Utilities/cmcurl/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 #ifndef CURL_DISABLE_FTP
  44 #ifdef HAVE_KRB4
  45
  46 #define _MPRINTF_REPLACE /* we want curl-functions instead of native ones */
  47 #include <curl/mprintf.h>
  48
  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 "urldata.h"
  58 #include "krb4.h"
  59 #include "base64.h"
  60 #include "sendf.h"
  61 #include "ftp.h"
  62 #include "memory.h"
  63
  64 /* The last #include file should be: */
  65 #include "memdebug.h"
  66
  67 #define min(a, b)   ((a) < (b) ? (a) : (b))
  68
  69 static const struct {
  70     enum protection_level level;
  71     const char *name;
  72 } level_names[] = {
  73     { prot_clear, "clear" },
  74     { prot_safe, "safe" },
  75     { prot_confidential, "confidential" },
  76     { prot_private, "private" }
  77 };
  78
  79 static enum protection_level
  80 name_to_level(const char *name)
  81 {
  82   int i;
  83   for(i = 0; i < (int)sizeof(level_names)/(int)sizeof(level_names[0]); i++)
  84     if(curl_strnequal(level_names[i].name, name, strlen(name)))
  85       return level_names[i].level;
  86   return (enum protection_level)-1;
  87 }
  88
  89 static const struct Curl_sec_client_mech * const mechs[] = {
  90 #ifdef KRB5
  91   /* not supported */
  92 #endif
  93 #ifdef HAVE_KRB4
  94     &Curl_krb4_client_mech,
  95 #endif
  96     NULL
  97 };
  98
  99 int
 100 Curl_sec_getc(struct connectdata *conn, FILE *F)
 101 {
 102   if(conn->sec_complete && conn->data_prot) {
 103     char c;
 104     if(Curl_sec_read(conn, fileno(F), &c, 1) <= 0)
 105       return EOF;
 106     return c;
 107   }
 108   else
 109     return getc(F);
 110 }
 111
 112 static int
 113 block_read(int fd, void *buf, size_t len)
 114 {
 115   unsigned char *p = buf;
 116   int b;
 117   while(len) {
 118     b = read(fd, p, len);
 119     if (b == 0)
 120       return 0;
 121     else if (b < 0)
 122       return -1;
 123     len -= b;
 124     p += b;
 125   }
 126   return p - (unsigned char*)buf;
 127 }
 128
 129 static int
 130 block_write(int fd, void *buf, size_t len)
 131 {
 132   unsigned char *p = buf;
 133   int b;
 134   while(len) {
 135     b = write(fd, p, len);
 136     if(b < 0)
 137       return -1;
 138     len -= b;
 139     p += b;
 140   }
 141   return p - (unsigned char*)buf;
 142 }
 143
 144 static int
 145 sec_get_data(struct connectdata *conn,
 146              int fd, struct krb4buffer *buf)
 147 {
 148   int len;
 149   int b;
 150
 151   b = block_read(fd, &len, sizeof(len));
 152   if (b == 0)
 153     return 0;
 154   else if (b < 0)
 155     return -1;
 156   len = ntohl(len);
 157   buf->data = realloc(buf->data, len);
 158   b = block_read(fd, buf->data, len);
 159   if (b == 0)
 160     return 0;
 161   else if (b < 0)
 162     return -1;
 163   buf->size = (conn->mech->decode)(conn->app_data, buf->data, len,
 164                                    conn->data_prot, conn);
 165   buf->index = 0;
 166   return 0;
 167 }
 168
 169 static size_t
 170 buffer_read(struct krb4buffer *buf, void *data, size_t len)
 171 {
 172     len = min(len, buf->size - buf->index);
 173     memcpy(data, (char*)buf->data + buf->index, len);
 174     buf->index += len;
 175     return len;
 176 }
 177
 178 static size_t
 179 buffer_write(struct krb4buffer *buf, void *data, size_t len)
 180 {
 181     if(buf->index + len > buf->size) {
 182         void *tmp;
 183         if(buf->data == NULL)
 184             tmp = malloc(1024);
 185         else
 186             tmp = realloc(buf->data, buf->index + len);
 187         if(tmp == NULL)
 188             return -1;
 189         buf->data = tmp;
 190         buf->size = buf->index + len;
 191     }
 192     memcpy((char*)buf->data + buf->index, data, len);
 193     buf->index += len;
 194     return len;
 195 }
 196
 197 int
 198 Curl_sec_read(struct connectdata *conn, int fd, void *buffer, int length)
 199 {
 200     size_t len;
 201     int rx = 0;
 202
 203     if(conn->sec_complete == 0 || conn->data_prot == 0)
 204       return read(fd, buffer, length);
 205
 206     if(conn->in_buffer.eof_flag){
 207       conn->in_buffer.eof_flag = 0;
 208       return 0;
 209     }
 210
 211     len = buffer_read(&conn->in_buffer, buffer, length);
 212     length -= len;
 213     rx += len;
 214     buffer = (char*)buffer + len;
 215
 216     while(length) {
 217       if(sec_get_data(conn, fd, &conn->in_buffer) < 0)
 218         return -1;
 219       if(conn->in_buffer.size == 0) {
 220         if(rx)
 221           conn->in_buffer.eof_flag = 1;
 222         return rx;
 223       }
 224       len = buffer_read(&conn->in_buffer, buffer, length);
 225       length -= len;
 226       rx += len;
 227       buffer = (char*)buffer + len;
 228     }
 229     return rx;
 230 }
 231
 232 static int
 233 sec_send(struct connectdata *conn, int fd, char *from, int length)
 234 {
 235   int bytes;
 236   void *buf;
 237   bytes = (conn->mech->encode)(conn->app_data, from, length, conn->data_prot,
 238                                &buf, conn);
 239   bytes = htonl(bytes);
 240   block_write(fd, &bytes, sizeof(bytes));
 241   block_write(fd, buf, ntohl(bytes));
 242   free(buf);
 243   return length;
 244 }
 245
 246 int
 247 Curl_sec_fflush_fd(struct connectdata *conn, int fd)
 248 {
 249   if(conn->data_prot != prot_clear) {
 250     if(conn->out_buffer.index > 0){
 251       Curl_sec_write(conn, fd,
 252                 conn->out_buffer.data, conn->out_buffer.index);
 253       conn->out_buffer.index = 0;
 254     }
 255     sec_send(conn, fd, NULL, 0);
 256   }
 257   return 0;
 258 }
 259
 260 int
 261 Curl_sec_write(struct connectdata *conn, int fd, char *buffer, int length)
 262 {
 263   int len = conn->buffer_size;
 264   int tx = 0;
 265
 266   if(conn->data_prot == prot_clear)
 267     return write(fd, buffer, length);
 268
 269   len -= (conn->mech->overhead)(conn->app_data, conn->data_prot, len);
 270   while(length){
 271     if(length < len)
 272       len = length;
 273     sec_send(conn, fd, buffer, len);
 274     length -= len;
 275     buffer += len;
 276     tx += len;
 277   }
 278   return tx;
 279 }
 280
 281 ssize_t
 282 Curl_sec_send(struct connectdata *conn, int num, char *buffer, int length)
 283 {
 284   curl_socket_t fd = conn->sock[num];
 285   return (ssize_t)Curl_sec_write(conn, fd, buffer, length);
 286 }
 287
 288 int
 289 Curl_sec_putc(struct connectdata *conn, int c, FILE *F)
 290 {
 291   char ch = c;
 292   if(conn->data_prot == prot_clear)
 293     return putc(c, F);
 294
 295   buffer_write(&conn->out_buffer, &ch, 1);
 296   if(c == '\n' || conn->out_buffer.index >= 1024 /* XXX */) {
 297     Curl_sec_write(conn, fileno(F), conn->out_buffer.data,
 298                    conn->out_buffer.index);
 299     conn->out_buffer.index = 0;
 300   }
 301   return c;
 302 }
 303
 304 int
 305 Curl_sec_read_msg(struct connectdata *conn, char *s, int level)
 306 {
 307   int len;
 308   unsigned char *buf;
 309   int code;
 310
 311   len = Curl_base64_decode(s + 4, &buf); /* XXX */
 312   if(len > 0)
 313     len = (conn->mech->decode)(conn->app_data, buf, len, level, conn);
 314   else
 315     return -1;
 316
 317   if(len < 0) {
 318     free(buf);
 319     return -1;
 320   }
 321
 322   buf[len] = '\0';
 323
 324   if(buf[3] == '-')
 325     code = 0;
 326   else
 327     sscanf((char *)buf, "%d", &code);
 328   if(buf[len-1] == '\n')
 329     buf[len-1] = '\0';
 330   strcpy(s, (char *)buf);
 331   free(buf);
 332   return code;
 333 }
 334
 335 enum protection_level
 336 Curl_set_command_prot(struct connectdata *conn, enum protection_level level)
 337 {
 338   enum protection_level old = conn->command_prot;
 339   conn->command_prot = level;
 340   return old;
 341 }
 342
 343 static int
 344 sec_prot_internal(struct connectdata *conn, int level)
 345 {
 346   char *p;
 347   unsigned int s = 1048576;
 348   ssize_t nread;
 349
 350   if(!conn->sec_complete){
 351     infof(conn->data, "No security data exchange has taken place.\n");
 352     return -1;
 353   }
 354
 355   if(level){
 356     int code;
 357     if(Curl_ftpsendf(conn, "PBSZ %u", s))
 358       return -1;
 359
 360     if(Curl_GetFTPResponse(&nread, conn, &code))
 361       return -1;
 362
 363     if(code/100 != '2'){
 364       failf(conn->data, "Failed to set protection buffer size.");
 365       return -1;
 366     }
 367     conn->buffer_size = s;
 368
 369     p = strstr(conn->data->state.buffer, "PBSZ=");
 370     if(p)
 371       sscanf(p, "PBSZ=%u", &s);
 372     if(s < conn->buffer_size)
 373       conn->buffer_size = s;
 374   }
 375
 376   if(Curl_ftpsendf(conn, "PROT %c", level["CSEP"]))
 377     return -1;
 378
 379   if(Curl_GetFTPResponse(&nread, conn, NULL))
 380     return -1;
 381
 382   if(conn->data->state.buffer[0] != '2'){
 383     failf(conn->data, "Failed to set protection level.");
 384     return -1;
 385   }
 386
 387   conn->data_prot = (enum protection_level)level;
 388   return 0;
 389 }
 390
 391 void
 392 Curl_sec_set_protection_level(struct connectdata *conn)
 393 {
 394   if(conn->sec_complete && conn->data_prot != conn->request_data_prot)
 395     sec_prot_internal(conn, conn->request_data_prot);
 396 }
 397
 398
 399 int
 400 Curl_sec_request_prot(struct connectdata *conn, const char *level)
 401 {
 402   int l = name_to_level(level);
 403   if(l == -1)
 404     return -1;
 405   conn->request_data_prot = (enum protection_level)l;
 406   return 0;
 407 }
 408
 409 int
 410 Curl_sec_login(struct connectdata *conn)
 411 {
 412   int ret;
 413   const struct Curl_sec_client_mech * const *m;
 414   ssize_t nread;
 415   struct SessionHandle *data=conn->data;
 416   int ftpcode;
 417
 418   for(m = mechs; *m && (*m)->name; m++) {
 419     void *tmp;
 420
 421     tmp = realloc(conn->app_data, (*m)->size);
 422     if (tmp == NULL) {
 423       failf (data, "realloc %u failed", (*m)->size);
 424       return -1;
 425     }
 426     conn->app_data = tmp;
 427
 428     if((*m)->init && (*(*m)->init)(conn->app_data) != 0) {
 429       infof(data, "Skipping %s...\n", (*m)->name);
 430       continue;
 431     }
 432     infof(data, "Trying %s...\n", (*m)->name);
 433
 434     if(Curl_ftpsendf(conn, "AUTH %s", (*m)->name))
 435       return -1;
 436
 437     if(Curl_GetFTPResponse(&nread, conn, &ftpcode))
 438       return -1;
 439
 440     if(conn->data->state.buffer[0] != '3'){
 441       switch(ftpcode) {
 442       case 504:
 443         infof(data,
 444               "%s is not supported by the server.\n", (*m)->name);
 445         break;
 446       case 534:
 447         infof(data, "%s rejected as security mechanism.\n", (*m)->name);
 448         break;
 449       default:
 450         if(conn->data->state.buffer[0] == '5') {
 451           infof(data, "The server doesn't support the FTP "
 452                 "security extensions.\n");
 453           return -1;
 454         }
 455         break;
 456       }
 457       continue;
 458     }
 459
 460     ret = (*(*m)->auth)(conn->app_data, conn);
 461
 462     if(ret == AUTH_CONTINUE)
 463       continue;
 464     else if(ret != AUTH_OK){
 465       /* mechanism is supposed to output error string */
 466       return -1;
 467     }
 468     conn->mech = *m;
 469     conn->sec_complete = 1;
 470     conn->command_prot = prot_safe;
 471     break;
 472   }
 473
 474   return *m == NULL;
 475 }
 476
 477 void
 478 Curl_sec_end(struct connectdata *conn)
 479 {
 480   if (conn->mech != NULL) {
 481     if(conn->mech->end)
 482       (conn->mech->end)(conn->app_data);
 483     memset(conn->app_data, 0, conn->mech->size);
 484     free(conn->app_data);
 485     conn->app_data = NULL;
 486   }
 487   conn->sec_complete = 0;
 488   conn->data_prot = (enum protection_level)0;
 489   conn->mech=NULL;
 490 }
 491
 492 #endif /* HAVE_KRB4 */
 493 #endif /* CURL_DISABLE_FTP */