lib/security.c

   1 /* This source code was modified by Martin Hedenfalk <mhe@stacken.kth.se> for
   2  * use in Curl. His latest changes were done 2000-09-18.
   3  *
   4  * It has since been patched and modified a lot by Daniel Stenberg
   5  * <daniel@haxx.se> to make it better applied to curl conditions, and to make
   6  * it not use globals, pollute name space and more. This source code awaits a
   7  * rewrite to work around the paragraph 2 in the BSD licenses as explained
   8  * below.
   9  *
  10  * Copyright (c) 1998, 1999 Kungliga Tekniska Högskolan
  11  * (Royal Institute of Technology, Stockholm, Sweden).
  12  * All rights reserved.
  13  *
  14  * Redistribution and use in source and binary forms, with or without
  15  * modification, are permitted provided that the following conditions
  16  * are met:
  17  *
  18  * 1. Redistributions of source code must retain the above copyright
  19  *    notice, this list of conditions and the following disclaimer.
  20  *
  21  * 2. Redistributions in binary form must reproduce the above copyright
  22  *    notice, this list of conditions and the following disclaimer in the
  23  *    documentation and/or other materials provided with the distribution.
  24  *
  25  * 3. Neither the name of the Institute nor the names of its contributors
  26  *    may be used to endorse or promote products derived from this software
  27  *    without specific prior written permission.
  28  *
  29  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  30  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  31  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  32  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  33  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  34  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  35  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  36  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  37  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  38  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  39  * SUCH DAMAGE.  */
  40
  41 #include "setup.h"
  42
  43 #ifdef KRB4
  44
  45 #define _MPRINTF_REPLACE /* we want curl-functions instead of native ones */
  46 #include <curl/mprintf.h>
  47
  48 #include "security.h"
  49 #include <stdlib.h>
  50 #include <string.h>
  51 #include <netdb.h>
  52
  53 #ifdef HAVE_UNISTD_H
  54 #include <unistd.h>
  55 #endif
  56
  57 #include "base64.h"
  58 #include "sendf.h"
  59 #include "ftp.h"
  60
  61 /* The last #include file should be: */
  62 #ifdef MALLOCDEBUG
  63 #include "memdebug.h"
  64 #endif
  65
  66 #define min(a, b)   ((a) < (b) ? (a) : (b))
  67
  68 static struct {
  69     enum protection_level level;
  70     const char *name;
  71 } level_names[] = {
  72     { prot_clear, "clear" },
  73     { prot_safe, "safe" },
  74     { prot_confidential, "confidential" },
  75     { prot_private, "private" }
  76 };
  77
  78 static enum protection_level
  79 name_to_level(const char *name)
  80 {
  81   int i;
  82   for(i = 0; i < (int)sizeof(level_names)/(int)sizeof(level_names[0]); i++)
  83     if(!strncasecmp(level_names[i].name, name, strlen(name)))
  84       return level_names[i].level;
  85   return (enum protection_level)-1;
  86 }
  87
  88 static struct Curl_sec_client_mech *mechs[] = {
  89 #ifdef KRB5
  90   /* not supported */
  91 #endif
  92 #ifdef KRB4
  93     &Curl_krb4_client_mech,
  94 #endif
  95     NULL
  96 };
  97
  98 int
  99 Curl_sec_getc(struct connectdata *conn, FILE *F)
 100 {
 101   if(conn->sec_complete && conn->data_prot) {
 102     char c;
 103     if(Curl_sec_read(conn, fileno(F), &c, 1) <= 0)
 104       return EOF;
 105     return c;
 106   }
 107   else
 108     return getc(F);
 109 }
 110
 111 static int
 112 block_read(int fd, void *buf, size_t len)
 113 {
 114   unsigned char *p = buf;
 115   int b;
 116   while(len) {
 117     b = read(fd, p, len);
 118     if (b == 0)
 119       return 0;
 120     else if (b < 0)
 121       return -1;
 122     len -= b;
 123     p += b;
 124   }
 125   return p - (unsigned char*)buf;
 126 }
 127
 128 static int
 129 block_write(int fd, void *buf, size_t len)
 130 {
 131   unsigned char *p = buf;
 132   int b;
 133   while(len) {
 134     b = write(fd, p, len);
 135     if(b < 0)
 136       return -1;
 137     len -= b;
 138     p += b;
 139   }
 140   return p - (unsigned char*)buf;
 141 }
 142
 143 static int
 144 sec_get_data(struct connectdata *conn,
 145              int fd, struct krb4buffer *buf)
 146 {
 147   int len;
 148   int b;
 149
 150   b = block_read(fd, &len, sizeof(len));
 151   if (b == 0)
 152     return 0;
 153   else if (b < 0)
 154     return -1;
 155   len = ntohl(len);
 156   buf->data = realloc(buf->data, len);
 157   b = block_read(fd, buf->data, len);
 158   if (b == 0)
 159     return 0;
 160   else if (b < 0)
 161     return -1;
 162   buf->size = (conn->mech->decode)(conn->app_data, buf->data, len,
 163                                    conn->data_prot, conn);
 164   buf->index = 0;
 165   return 0;
 166 }
 167
 168 static size_t
 169 buffer_read(struct krb4buffer *buf, void *data, size_t len)
 170 {
 171     len = min(len, buf->size - buf->index);
 172     memcpy(data, (char*)buf->data + buf->index, len);
 173     buf->index += len;
 174     return len;
 175 }
 176
 177 static size_t
 178 buffer_write(struct krb4buffer *buf, void *data, size_t len)
 179 {
 180     if(buf->index + len > buf->size) {
 181         void *tmp;
 182         if(buf->data == NULL)
 183             tmp = malloc(1024);
 184         else
 185             tmp = realloc(buf->data, buf->index + len);
 186         if(tmp == NULL)
 187             return -1;
 188         buf->data = tmp;
 189         buf->size = buf->index + len;
 190     }
 191     memcpy((char*)buf->data + buf->index, data, len);
 192     buf->index += len;
 193     return len;
 194 }
 195
 196 int
 197 Curl_sec_read(struct connectdata *conn, int fd, void *buffer, int length)
 198 {
 199     size_t len;
 200     int rx = 0;
 201
 202     if(conn->sec_complete == 0 || conn->data_prot == 0)
 203       return read(fd, buffer, length);
 204
 205     if(conn->in_buffer.eof_flag){
 206       conn->in_buffer.eof_flag = 0;
 207       return 0;
 208     }
 209
 210     len = buffer_read(&conn->in_buffer, buffer, length);
 211     length -= len;
 212     rx += len;
 213     buffer = (char*)buffer + len;
 214
 215     while(length) {
 216       if(sec_get_data(conn, fd, &conn->in_buffer) < 0)
 217         return -1;
 218       if(conn->in_buffer.size == 0) {
 219         if(rx)
 220           conn->in_buffer.eof_flag = 1;
 221         return rx;
 222       }
 223       len = buffer_read(&conn->in_buffer, buffer, length);
 224       length -= len;
 225       rx += len;
 226       buffer = (char*)buffer + len;
 227     }
 228     return rx;
 229 }
 230
 231 static int
 232 sec_send(struct connectdata *conn, int fd, char *from, int length)
 233 {
 234   int bytes;
 235   void *buf;
 236   bytes = (conn->mech->encode)(conn->app_data, from, length, conn->data_prot,
 237                                &buf, conn);
 238   bytes = htonl(bytes);
 239   block_write(fd, &bytes, sizeof(bytes));
 240   block_write(fd, buf, ntohl(bytes));
 241   free(buf);
 242   return length;
 243 }
 244
 245 int
 246 Curl_sec_fflush_fd(struct connectdata *conn, int fd)
 247 {
 248   if(conn->data_prot != prot_clear) {
 249     if(conn->out_buffer.index > 0){
 250       Curl_sec_write(conn, fd,
 251                 conn->out_buffer.data, conn->out_buffer.index);
 252       conn->out_buffer.index = 0;
 253     }
 254     sec_send(conn, fd, NULL, 0);
 255   }
 256   return 0;
 257 }
 258
 259 int
 260 Curl_sec_write(struct connectdata *conn, int fd, char *buffer, int length)
 261 {
 262   int len = conn->buffer_size;
 263   int tx = 0;
 264
 265   if(conn->data_prot == prot_clear)
 266     return write(fd, buffer, length);
 267
 268   len -= (conn->mech->overhead)(conn->app_data, conn->data_prot, len);
 269   while(length){
 270     if(length < len)
 271       len = length;
 272     sec_send(conn, fd, buffer, len);
 273     length -= len;
 274     buffer += len;
 275     tx += len;
 276   }
 277   return tx;
 278 }
 279
 280 int
 281 Curl_sec_vfprintf2(struct connectdata *conn, FILE *f, const char *fmt, va_list ap)
 282 {
 283   char *buf;
 284   int ret;
 285   if(conn->data_prot == prot_clear)
 286     return vfprintf(f, fmt, ap);
 287   else {
 288     buf = aprintf(fmt, ap);
 289     ret = buffer_write(&conn->out_buffer, buf, strlen(buf));
 290     free(buf);
 291     return ret;
 292   }
 293 }
 294
 295 int
 296 Curl_sec_fprintf2(struct connectdata *conn, FILE *f, const char *fmt, ...)
 297 {
 298     int ret;
 299     va_list ap;
 300     va_start(ap, fmt);
 301     ret = Curl_sec_vfprintf2(conn, f, fmt, ap);
 302     va_end(ap);
 303     return ret;
 304 }
 305
 306 int
 307 Curl_sec_putc(struct connectdata *conn, int c, FILE *F)
 308 {
 309   char ch = c;
 310   if(conn->data_prot == prot_clear)
 311     return putc(c, F);
 312
 313   buffer_write(&conn->out_buffer, &ch, 1);
 314   if(c == '\n' || conn->out_buffer.index >= 1024 /* XXX */) {
 315     Curl_sec_write(conn, fileno(F), conn->out_buffer.data, conn->out_buffer.index);
 316     conn->out_buffer.index = 0;
 317   }
 318   return c;
 319 }
 320
 321 int
 322 Curl_sec_read_msg(struct connectdata *conn, char *s, int level)
 323 {
 324     int len;
 325     char *buf;
 326     int code;
 327
 328     buf = malloc(strlen(s));
 329     len = Curl_base64_decode(s + 4, buf); /* XXX */
 330
 331     len = (conn->mech->decode)(conn->app_data, buf, len, level, conn);
 332     if(len < 0)
 333         return -1;
 334
 335     buf[len] = '\0';
 336
 337     if(buf[3] == '-')
 338         code = 0;
 339     else
 340         sscanf(buf, "%d", &code);
 341     if(buf[len-1] == '\n')
 342         buf[len-1] = '\0';
 343     strcpy(s, buf);
 344     free(buf);
 345     return code;
 346 }
 347
 348 /* modified to return how many bytes written, or -1 on error ***/
 349 int
 350 Curl_sec_vfprintf(struct connectdata *conn, FILE *f, const char *fmt, va_list ap)
 351 {
 352     int ret = 0;
 353     char *buf;
 354     void *enc;
 355     int len;
 356     if(!conn->sec_complete)
 357         return vfprintf(f, fmt, ap);
 358
 359     buf = aprintf(fmt, ap);
 360     len = (conn->mech->encode)(conn->app_data, buf, strlen(buf),
 361                                conn->command_prot, &enc,
 362                                conn);
 363     free(buf);
 364     if(len < 0) {
 365         failf(conn->data, "Failed to encode command.");
 366         return -1;
 367     }
 368     if(Curl_base64_encode(enc, len, &buf) < 0){
 369       failf(conn->data, "Out of memory base64-encoding.");
 370       return -1;
 371     }
 372     if(conn->command_prot == prot_safe)
 373         ret = fprintf(f, "MIC %s", buf);
 374     else if(conn->command_prot == prot_private)
 375         ret = fprintf(f, "ENC %s", buf);
 376     else if(conn->command_prot == prot_confidential)
 377         ret = fprintf(f, "CONF %s", buf);
 378
 379     free(buf);
 380     return ret;
 381 }
 382
 383 int
 384 Curl_sec_fprintf(struct connectdata *conn, FILE *f, const char *fmt, ...)
 385 {
 386     va_list ap;
 387     int ret;
 388     va_start(ap, fmt);
 389     ret = Curl_sec_vfprintf(conn, f, fmt, ap);
 390     va_end(ap);
 391     return ret;
 392 }
 393
 394
 395 enum protection_level
 396 Curl_set_command_prot(struct connectdata *conn, enum protection_level level)
 397 {
 398     enum protection_level old = conn->command_prot;
 399     conn->command_prot = level;
 400     return old;
 401 }
 402
 403 static int
 404 sec_prot_internal(struct connectdata *conn, int level)
 405 {
 406   char *p;
 407   unsigned int s = 1048576;
 408   ssize_t nread;
 409
 410   if(!conn->sec_complete){
 411     infof(conn->data, "No security data exchange has taken place.\n");
 412     return -1;
 413   }
 414
 415   if(level){
 416     if(Curl_ftpsendf(conn, "PBSZ %u", s))
 417       return -1;
 418
 419     nread = Curl_GetFTPResponse(conn->data->state.buffer, conn, NULL);
 420     if(nread < 0)
 421       return -1;
 422
 423     if(conn->data->state.buffer[0] != '2'){
 424       failf(conn->data, "Failed to set protection buffer size.");
 425       return -1;
 426     }
 427     conn->buffer_size = s;
 428
 429     p = strstr(conn->data->state.buffer, "PBSZ=");
 430     if(p)
 431       sscanf(p, "PBSZ=%u", &s);
 432     if(s < conn->buffer_size)
 433       conn->buffer_size = s;
 434   }
 435
 436   if(Curl_ftpsendf(conn, "PROT %c", level["CSEP"]))
 437     return -1;
 438
 439   nread = Curl_GetFTPResponse(conn->data->state.buffer, conn, NULL);
 440   if(nread < 0)
 441     return -1;
 442
 443   if(conn->data->state.buffer[0] != '2'){
 444     failf(conn->data, "Failed to set protection level.");
 445     return -1;
 446   }
 447
 448   conn->data_prot = (enum protection_level)level;
 449   return 0;
 450 }
 451
 452 void
 453 Curl_sec_set_protection_level(struct connectdata *conn)
 454 {
 455   if(conn->sec_complete && conn->data_prot != conn->request_data_prot)
 456     sec_prot_internal(conn, conn->request_data_prot);
 457 }
 458
 459
 460 int
 461 Curl_sec_request_prot(struct connectdata *conn, const char *level)
 462 {
 463   int l = name_to_level(level);
 464   if(l == -1)
 465     return -1;
 466   conn->request_data_prot = (enum protection_level)l;
 467   return 0;
 468 }
 469
 470 int
 471 Curl_sec_login(struct connectdata *conn)
 472 {
 473   int ret;
 474   struct Curl_sec_client_mech **m;
 475   ssize_t nread;
 476   struct SessionHandle *data=conn->data;
 477   int ftpcode;
 478
 479   for(m = mechs; *m && (*m)->name; m++) {
 480     void *tmp;
 481
 482     tmp = realloc(conn->app_data, (*m)->size);
 483     if (tmp == NULL) {
 484       failf (data, "realloc %u failed", (*m)->size);
 485       return -1;
 486     }
 487     conn->app_data = tmp;
 488
 489     if((*m)->init && (*(*m)->init)(conn->app_data) != 0) {
 490       infof(data, "Skipping %s...\n", (*m)->name);
 491       continue;
 492     }
 493     infof(data, "Trying %s...\n", (*m)->name);
 494
 495     if(Curl_ftpsendf(conn, "AUTH %s", (*m)->name))
 496       return -1;
 497
 498     nread = Curl_GetFTPResponse(conn->data->state.buffer, conn, &ftpcode);
 499     if(nread < 0)
 500       return -1;
 501
 502     if(conn->data->state.buffer[0] != '3'){
 503       switch(ftpcode) {
 504       case 504:
 505         infof(data,
 506               "%s is not supported by the server.\n", (*m)->name);
 507         break;
 508       case 534:
 509         infof(data, "%s rejected as security mechanism.\n", (*m)->name);
 510         break;
 511       default:
 512         if(conn->data->state.buffer[0] == '5') {
 513           infof(data, "The server doesn't support the FTP "
 514                 "security extensions.\n");
 515           return -1;
 516         }
 517         break;
 518       }
 519       continue;
 520     }
 521
 522     ret = (*(*m)->auth)(conn->app_data, conn);
 523
 524     if(ret == AUTH_CONTINUE)
 525       continue;
 526     else if(ret != AUTH_OK){
 527       /* mechanism is supposed to output error string */
 528       return -1;
 529     }
 530     conn->mech = *m;
 531     conn->sec_complete = 1;
 532     conn->command_prot = prot_safe;
 533     break;
 534   }
 535
 536   return *m == NULL;
 537 }
 538
 539 void
 540 Curl_sec_end(struct connectdata *conn)
 541 {
 542   if (conn->mech != NULL) {
 543     if(conn->mech->end)
 544       (conn->mech->end)(conn->app_data);
 545     memset(conn->app_data, 0, conn->mech->size);
 546     free(conn->app_data);
 547     conn->app_data = NULL;
 548   }
 549   conn->sec_complete = 0;
 550   conn->data_prot = (enum protection_level)0;
 551   conn->mech=NULL;
 552 }
 553
 554 #endif /* KRB4 */
 555
 556 /*
 557  * local variables:
 558  * eval: (load-file "../curl-mode.el")
 559  * end:
 560  * vim600: fdm=marker
 561  * vim: et sw=2 ts=2 sts=2 tw=78
 562  */