crypto/heimdal-0.6.3/appl/ftp/ftp/security.c

   1 /*
   2  * Copyright (c) 1998-2002 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * 3. Neither the name of the Institute nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #ifdef FTP_SERVER
  35 #include "ftpd_locl.h"
  36 #else
  37 #include "ftp_locl.h"
  38 #endif
  39
  40 RCSID("$Id: security.c,v 1.19 2002/09/04 22:01:28 joda Exp $");
  41
  42 static enum protection_level command_prot;
  43 static enum protection_level data_prot;
  44 static size_t buffer_size;
  45
  46 struct buffer {
  47     void *data;
  48     size_t size;
  49     size_t index;
  50     int eof_flag;
  51 };
  52
  53 static struct buffer in_buffer, out_buffer;
  54 int sec_complete;
  55
  56 static struct {
  57     enum protection_level level;
  58     const char *name;
  59 } level_names[] = {
  60     { prot_clear, "clear" },
  61     { prot_safe, "safe" },
  62     { prot_confidential, "confidential" },
  63     { prot_private, "private" }
  64 };
  65
  66 static const char *
  67 level_to_name(enum protection_level level)
  68 {
  69     int i;
  70     for(i = 0; i < sizeof(level_names) / sizeof(level_names[0]); i++)
  71         if(level_names[i].level == level)
  72             return level_names[i].name;
  73     return "unknown";
  74 }
  75
  76 #ifndef FTP_SERVER /* not used in server */
  77 static enum protection_level
  78 name_to_level(const char *name)
  79 {
  80     int i;
  81     for(i = 0; i < sizeof(level_names) / sizeof(level_names[0]); i++)
  82         if(!strncasecmp(level_names[i].name, name, strlen(name)))
  83             return level_names[i].level;
  84     return (enum protection_level)-1;
  85 }
  86 #endif
  87
  88 #ifdef FTP_SERVER
  89
  90 static struct sec_server_mech *mechs[] = {
  91 #ifdef KRB5
  92     &gss_server_mech,
  93 #endif
  94 #ifdef KRB4
  95     &krb4_server_mech,
  96 #endif
  97     NULL
  98 };
  99
 100 static struct sec_server_mech *mech;
 101
 102 #else
 103
 104 static struct sec_client_mech *mechs[] = {
 105 #ifdef KRB5
 106     &gss_client_mech,
 107 #endif
 108 #ifdef KRB4
 109     &krb4_client_mech,
 110 #endif
 111     NULL
 112 };
 113
 114 static struct sec_client_mech *mech;
 115
 116 #endif
 117
 118 static void *app_data;
 119
 120 int
 121 sec_getc(FILE *F)
 122 {
 123     if(sec_complete && data_prot) {
 124         char c;
 125         if(sec_read(fileno(F), &c, 1) <= 0)
 126             return EOF;
 127         return c;
 128     } else
 129         return getc(F);
 130 }
 131
 132 static int
 133 block_read(int fd, void *buf, size_t len)
 134 {
 135     unsigned char *p = buf;
 136     int b;
 137     while(len) {
 138         b = read(fd, p, len);
 139         if (b == 0)
 140             return 0;
 141         else if (b < 0)
 142             return -1;
 143         len -= b;
 144         p += b;
 145     }
 146     return p - (unsigned char*)buf;
 147 }
 148
 149 static int
 150 block_write(int fd, void *buf, size_t len)
 151 {
 152     unsigned char *p = buf;
 153     int b;
 154     while(len) {
 155         b = write(fd, p, len);
 156         if(b < 0)
 157             return -1;
 158         len -= b;
 159         p += b;
 160     }
 161     return p - (unsigned char*)buf;
 162 }
 163
 164 static int
 165 sec_get_data(int fd, struct buffer *buf, int level)
 166 {
 167     int len;
 168     int b;
 169     void *tmp;
 170
 171     b = block_read(fd, &len, sizeof(len));
 172     if (b == 0)
 173         return 0;
 174     else if (b < 0)
 175         return -1;
 176     len = ntohl(len);
 177     tmp = realloc(buf->data, len);
 178     if (tmp == NULL)
 179         return -1;
 180     buf->data = tmp;
 181     b = block_read(fd, buf->data, len);
 182     if (b == 0)
 183         return 0;
 184     else if (b < 0)
 185         return -1;
 186     buf->size = (*mech->decode)(app_data, buf->data, len, data_prot);
 187     buf->index = 0;
 188     return 0;
 189 }
 190
 191 static size_t
 192 buffer_read(struct buffer *buf, void *data, size_t len)
 193 {
 194     len = min(len, buf->size - buf->index);
 195     memcpy(data, (char*)buf->data + buf->index, len);
 196     buf->index += len;
 197     return len;
 198 }
 199
 200 static size_t
 201 buffer_write(struct buffer *buf, void *data, size_t len)
 202 {
 203     if(buf->index + len > buf->size) {
 204         void *tmp;
 205         if(buf->data == NULL)
 206             tmp = malloc(1024);
 207         else
 208             tmp = realloc(buf->data, buf->index + len);
 209         if(tmp == NULL)
 210             return -1;
 211         buf->data = tmp;
 212         buf->size = buf->index + len;
 213     }
 214     memcpy((char*)buf->data + buf->index, data, len);
 215     buf->index += len;
 216     return len;
 217 }
 218
 219 int
 220 sec_read(int fd, void *data, int length)
 221 {
 222     size_t len;
 223     int rx = 0;
 224
 225     if(sec_complete == 0 || data_prot == 0)
 226         return read(fd, data, length);
 227
 228     if(in_buffer.eof_flag){
 229         in_buffer.eof_flag = 0;
 230         return 0;
 231     }
 232
 233     len = buffer_read(&in_buffer, data, length);
 234     length -= len;
 235     rx += len;
 236     data = (char*)data + len;
 237
 238     while(length){
 239         int ret;
 240
 241         ret = sec_get_data(fd, &in_buffer, data_prot);
 242         if (ret < 0)
 243             return -1;
 244         if(ret == 0 && in_buffer.size == 0) {
 245             if(rx)
 246                 in_buffer.eof_flag = 1;
 247             return rx;
 248         }
 249         len = buffer_read(&in_buffer, data, length);
 250         length -= len;
 251         rx += len;
 252         data = (char*)data + len;
 253     }
 254     return rx;
 255 }
 256
 257 static int
 258 sec_send(int fd, char *from, int length)
 259 {
 260     int bytes;
 261     void *buf;
 262     bytes = (*mech->encode)(app_data, from, length, data_prot, &buf);
 263     bytes = htonl(bytes);
 264     block_write(fd, &bytes, sizeof(bytes));
 265     block_write(fd, buf, ntohl(bytes));
 266     free(buf);
 267     return length;
 268 }
 269
 270 int
 271 sec_fflush(FILE *F)
 272 {
 273     if(data_prot != prot_clear) {
 274         if(out_buffer.index > 0){
 275             sec_write(fileno(F), out_buffer.data, out_buffer.index);
 276             out_buffer.index = 0;
 277         }
 278         sec_send(fileno(F), NULL, 0);
 279     }
 280     fflush(F);
 281     return 0;
 282 }
 283
 284 int
 285 sec_write(int fd, char *data, int length)
 286 {
 287     int len = buffer_size;
 288     int tx = 0;
 289
 290     if(data_prot == prot_clear)
 291         return write(fd, data, length);
 292
 293     len -= (*mech->overhead)(app_data, data_prot, len);
 294     while(length){
 295         if(length < len)
 296             len = length;
 297         sec_send(fd, data, len);
 298         length -= len;
 299         data += len;
 300         tx += len;
 301     }
 302     return tx;
 303 }
 304
 305 int
 306 sec_vfprintf2(FILE *f, const char *fmt, va_list ap)
 307 {
 308     char *buf;
 309     int ret;
 310     if(data_prot == prot_clear)
 311         return vfprintf(f, fmt, ap);
 312     else {
 313         vasprintf(&buf, fmt, ap);
 314         ret = buffer_write(&out_buffer, buf, strlen(buf));
 315         free(buf);
 316         return ret;
 317     }
 318 }
 319
 320 int
 321 sec_fprintf2(FILE *f, const char *fmt, ...)
 322 {
 323     int ret;
 324     va_list ap;
 325     va_start(ap, fmt);
 326     ret = sec_vfprintf2(f, fmt, ap);
 327     va_end(ap);
 328     return ret;
 329 }
 330
 331 int
 332 sec_putc(int c, FILE *F)
 333 {
 334     char ch = c;
 335     if(data_prot == prot_clear)
 336         return putc(c, F);
 337
 338     buffer_write(&out_buffer, &ch, 1);
 339     if(c == '\n' || out_buffer.index >= 1024 /* XXX */) {
 340         sec_write(fileno(F), out_buffer.data, out_buffer.index);
 341         out_buffer.index = 0;
 342     }
 343     return c;
 344 }
 345
 346 int
 347 sec_read_msg(char *s, int level)
 348 {
 349     int len;
 350     char *buf;
 351     int code;
 352
 353     buf = malloc(strlen(s));
 354     len = base64_decode(s + 4, buf); /* XXX */
 355
 356     len = (*mech->decode)(app_data, buf, len, level);
 357     if(len < 0)
 358         return -1;
 359
 360     buf[len] = '\0';
 361
 362     if(buf[3] == '-')
 363         code = 0;
 364     else
 365         sscanf(buf, "%d", &code);
 366     if(buf[len-1] == '\n')
 367         buf[len-1] = '\0';
 368     strcpy(s, buf);
 369     free(buf);
 370     return code;
 371 }
 372
 373 int
 374 sec_vfprintf(FILE *f, const char *fmt, va_list ap)
 375 {
 376     char *buf;
 377     void *enc;
 378     int len;
 379     if(!sec_complete)
 380         return vfprintf(f, fmt, ap);
 381
 382     vasprintf(&buf, fmt, ap);
 383     len = (*mech->encode)(app_data, buf, strlen(buf), command_prot, &enc);
 384     free(buf);
 385     if(len < 0) {
 386         printf("Failed to encode command.\n");
 387         return -1;
 388     }
 389     if(base64_encode(enc, len, &buf) < 0){
 390         free(enc);
 391         printf("Out of memory base64-encoding.\n");
 392         return -1;
 393     }
 394     free(enc);
 395 #ifdef FTP_SERVER
 396     if(command_prot == prot_safe)
 397         fprintf(f, "631 %s\r\n", buf);
 398     else if(command_prot == prot_private)
 399         fprintf(f, "632 %s\r\n", buf);
 400     else if(command_prot == prot_confidential)
 401         fprintf(f, "633 %s\r\n", buf);
 402 #else
 403     if(command_prot == prot_safe)
 404         fprintf(f, "MIC %s", buf);
 405     else if(command_prot == prot_private)
 406         fprintf(f, "ENC %s", buf);
 407     else if(command_prot == prot_confidential)
 408         fprintf(f, "CONF %s", buf);
 409 #endif
 410     free(buf);
 411     return 0;
 412 }
 413
 414 int
 415 sec_fprintf(FILE *f, const char *fmt, ...)
 416 {
 417     va_list ap;
 418     int ret;
 419     va_start(ap, fmt);
 420     ret = sec_vfprintf(f, fmt, ap);
 421     va_end(ap);
 422     return ret;
 423 }
 424
 425 /* end common stuff */
 426
 427 #ifdef FTP_SERVER
 428
 429 void
 430 auth(char *auth_name)
 431 {
 432     int i;
 433     void *tmp;
 434
 435     for(i = 0; (mech = mechs[i]) != NULL; i++){
 436         if(!strcasecmp(auth_name, mech->name)){
 437             tmp = realloc(app_data, mech->size);
 438             if (tmp == NULL) {
 439                 reply(431, "Unable to accept %s at this time", mech->name);
 440                 return;
 441             }
 442             app_data = tmp;
 443
 444             if(mech->init && (*mech->init)(app_data) != 0) {
 445                 reply(431, "Unable to accept %s at this time", mech->name);
 446                 return;
 447             }
 448             if(mech->auth) {
 449                 (*mech->auth)(app_data);
 450                 return;
 451             }
 452             if(mech->adat)
 453                 reply(334, "Send authorization data.");
 454             else
 455                 reply(234, "Authorization complete.");
 456             return;
 457         }
 458     }
 459     free (app_data);
 460     app_data = NULL;
 461     reply(504, "%s is unknown to me", auth_name);
 462 }
 463
 464 void
 465 adat(char *auth_data)
 466 {
 467     if(mech && !sec_complete) {
 468         void *buf = malloc(strlen(auth_data));
 469         size_t len;
 470         len = base64_decode(auth_data, buf);
 471         (*mech->adat)(app_data, buf, len);
 472         free(buf);
 473     } else
 474         reply(503, "You must %sissue an AUTH first.", mech ? "re-" : "");
 475 }
 476
 477 void pbsz(int size)
 478 {
 479     size_t new = size;
 480     if(!sec_complete)
 481         reply(503, "Incomplete security data exchange.");
 482     if(mech->pbsz)
 483         new = (*mech->pbsz)(app_data, size);
 484     if(buffer_size != new){
 485         buffer_size = size;
 486     }
 487     if(new != size)
 488         reply(200, "PBSZ=%lu", (unsigned long)new);
 489     else
 490         reply(200, "OK");
 491 }
 492
 493 void
 494 prot(char *pl)
 495 {
 496     int p = -1;
 497
 498     if(buffer_size == 0){
 499         reply(503, "No protection buffer size negotiated.");
 500         return;
 501     }
 502
 503     if(!strcasecmp(pl, "C"))
 504         p = prot_clear;
 505     else if(!strcasecmp(pl, "S"))
 506         p = prot_safe;
 507     else if(!strcasecmp(pl, "E"))
 508         p = prot_confidential;
 509     else if(!strcasecmp(pl, "P"))
 510         p = prot_private;
 511     else {
 512         reply(504, "Unrecognized protection level.");
 513         return;
 514     }
 515
 516     if(sec_complete){
 517         if((*mech->check_prot)(app_data, p)){
 518             reply(536, "%s does not support %s protection.",
 519                   mech->name, level_to_name(p));
 520         }else{
 521             data_prot = (enum protection_level)p;
 522             reply(200, "Data protection is %s.", level_to_name(p));
 523         }
 524     }else{
 525         reply(503, "Incomplete security data exchange.");
 526     }
 527 }
 528
 529 void ccc(void)
 530 {
 531     if(sec_complete){
 532         if(mech->ccc && (*mech->ccc)(app_data) == 0)
 533             command_prot = data_prot = prot_clear;
 534         else
 535             reply(534, "You must be joking.");
 536     }else
 537         reply(503, "Incomplete security data exchange.");
 538 }
 539
 540 void mec(char *msg, enum protection_level level)
 541 {
 542     void *buf;
 543     size_t len;
 544     if(!sec_complete) {
 545         reply(503, "Incomplete security data exchange.");
 546         return;
 547     }
 548     buf = malloc(strlen(msg) + 2); /* XXX go figure out where that 2
 549                                       comes from :-) */
 550     len = base64_decode(msg, buf);
 551     command_prot = level;
 552     if(len == (size_t)-1) {
 553         reply(501, "Failed to base64-decode command");
 554         return;
 555     }
 556     len = (*mech->decode)(app_data, buf, len, level);
 557     if(len == (size_t)-1) {
 558         reply(535, "Failed to decode command");
 559         return;
 560     }
 561     ((char*)buf)[len] = '\0';
 562     if(strstr((char*)buf, "\r\n") == NULL)
 563         strcat((char*)buf, "\r\n");
 564     new_ftp_command(buf);
 565 }
 566
 567 /* ------------------------------------------------------------ */
 568
 569 int
 570 sec_userok(char *user)
 571 {
 572     if(sec_complete)
 573         return (*mech->userok)(app_data, user);
 574     return 0;
 575 }
 576
 577 char *ftp_command;
 578
 579 void
 580 new_ftp_command(char *command)
 581 {
 582     ftp_command = command;
 583 }
 584
 585 void
 586 delete_ftp_command(void)
 587 {
 588     free(ftp_command);
 589     ftp_command = NULL;
 590 }
 591
 592 int
 593 secure_command(void)
 594 {
 595     return ftp_command != NULL;
 596 }
 597
 598 enum protection_level
 599 get_command_prot(void)
 600 {
 601     return command_prot;
 602 }
 603
 604 #else /* FTP_SERVER */
 605
 606 void
 607 sec_status(void)
 608 {
 609     if(sec_complete){
 610         printf("Using %s for authentication.\n", mech->name);
 611         printf("Using %s command channel.\n", level_to_name(command_prot));
 612         printf("Using %s data channel.\n", level_to_name(data_prot));
 613         if(buffer_size > 0)
 614             printf("Protection buffer size: %lu.\n",
 615                    (unsigned long)buffer_size);
 616     }else{
 617         printf("Not using any security mechanism.\n");
 618     }
 619 }
 620
 621 static int
 622 sec_prot_internal(int level)
 623 {
 624     int ret;
 625     char *p;
 626     unsigned int s = 1048576;
 627
 628     int old_verbose = verbose;
 629     verbose = 0;
 630
 631     if(!sec_complete){
 632         printf("No security data exchange has taken place.\n");
 633         return -1;
 634     }
 635
 636     if(level){
 637         ret = command("PBSZ %u", s);
 638         if(ret != COMPLETE){
 639             printf("Failed to set protection buffer size.\n");
 640             return -1;
 641         }
 642         buffer_size = s;
 643         p = strstr(reply_string, "PBSZ=");
 644         if(p)
 645             sscanf(p, "PBSZ=%u", &s);
 646         if(s < buffer_size)
 647             buffer_size = s;
 648     }
 649     verbose = old_verbose;
 650     ret = command("PROT %c", level["CSEP"]); /* XXX :-) */
 651     if(ret != COMPLETE){
 652         printf("Failed to set protection level.\n");
 653         return -1;
 654     }
 655
 656     data_prot = (enum protection_level)level;
 657     return 0;
 658 }
 659
 660 enum protection_level
 661 set_command_prot(enum protection_level level)
 662 {
 663     enum protection_level old = command_prot;
 664     command_prot = level;
 665     return old;
 666 }
 667
 668 void
 669 sec_prot(int argc, char **argv)
 670 {
 671     int level = -1;
 672
 673     if(argc < 2 || argc > 3)
 674         goto usage;
 675     if(!sec_complete) {
 676         printf("No security data exchange has taken place.\n");
 677         code = -1;
 678         return;
 679     }
 680     level = name_to_level(argv[argc - 1]);
 681
 682     if(level == -1)
 683         goto usage;
 684
 685     if((*mech->check_prot)(app_data, level)) {
 686         printf("%s does not implement %s protection.\n",
 687                mech->name, level_to_name(level));
 688         code = -1;
 689         return;
 690     }
 691
 692     if(argc == 2 || strncasecmp(argv[1], "data", strlen(argv[1])) == 0) {
 693         if(sec_prot_internal(level) < 0){
 694             code = -1;
 695             return;
 696         }
 697     } else if(strncasecmp(argv[1], "command", strlen(argv[1])) == 0)
 698         set_command_prot(level);
 699     else
 700         goto usage;
 701     code = 0;
 702     return;
 703  usage:
 704     printf("usage: %s [command|data] [clear|safe|confidential|private]\n",
 705            argv[0]);
 706     code = -1;
 707 }
 708
 709 static enum protection_level request_data_prot;
 710
 711 void
 712 sec_set_protection_level(void)
 713 {
 714     if(sec_complete && data_prot != request_data_prot)
 715         sec_prot_internal(request_data_prot);
 716 }
 717
 718
 719 int
 720 sec_request_prot(char *level)
 721 {
 722     int l = name_to_level(level);
 723     if(l == -1)
 724         return -1;
 725     request_data_prot = (enum protection_level)l;
 726     return 0;
 727 }
 728
 729 int
 730 sec_login(char *host)
 731 {
 732     int ret;
 733     struct sec_client_mech **m;
 734     int old_verbose = verbose;
 735
 736     verbose = -1; /* shut up all messages this will produce (they
 737                      are usually not very user friendly) */
 738
 739     for(m = mechs; *m && (*m)->name; m++) {
 740         void *tmp;
 741
 742         tmp = realloc(app_data, (*m)->size);
 743         if (tmp == NULL) {
 744             warnx ("realloc %u failed", (*m)->size);
 745             return -1;
 746         }
 747         app_data = tmp;
 748
 749         if((*m)->init && (*(*m)->init)(app_data) != 0) {
 750             printf("Skipping %s...\n", (*m)->name);
 751             continue;
 752         }
 753         printf("Trying %s...\n", (*m)->name);
 754         ret = command("AUTH %s", (*m)->name);
 755         if(ret != CONTINUE){
 756             if(code == 504){
 757                 printf("%s is not supported by the server.\n", (*m)->name);
 758             }else if(code == 534){
 759                 printf("%s rejected as security mechanism.\n", (*m)->name);
 760             }else if(ret == ERROR) {
 761                 printf("The server doesn't support the FTP "
 762                        "security extensions.\n");
 763                 verbose = old_verbose;
 764                 return -1;
 765             }
 766             continue;
 767         }
 768
 769         ret = (*(*m)->auth)(app_data, host);
 770
 771         if(ret == AUTH_CONTINUE)
 772             continue;
 773         else if(ret != AUTH_OK){
 774             /* mechanism is supposed to output error string */
 775             verbose = old_verbose;
 776             return -1;
 777         }
 778         mech = *m;
 779         sec_complete = 1;
 780         command_prot = prot_safe;
 781         break;
 782     }
 783
 784     verbose = old_verbose;
 785     return *m == NULL;
 786 }
 787
 788 void
 789 sec_end(void)
 790 {
 791     if (mech != NULL) {
 792         if(mech->end)
 793             (*mech->end)(app_data);
 794         if (app_data != NULL) {
 795             memset(app_data, 0, mech->size);
 796             free(app_data);
 797             app_data = NULL;
 798         }
 799     }
 800     sec_complete = 0;
 801     data_prot = (enum protection_level)0;
 802 }
 803
 804 #endif /* FTP_SERVER */
 805