src/src/dk.c

   1 /* $Cambridge: exim/src/src/dk.c,v 1.10 2006/07/06 14:28:04 ph10 Exp $ */
   2
   3 /*************************************************
   4 *     Exim - an Internet mail transport agent    *
   5 *************************************************/
   6
   7 /* Copyright (c) University of Cambridge 1995 - 2006 */
   8 /* See the file NOTICE for conditions of use and distribution. */
   9
  10 /* Code for DomainKeys support. Other DK relevant code is in
  11    receive.c, transport.c and transports/smtp.c */
  12
  13 #include "exim.h"
  14
  15 #ifdef EXPERIMENTAL_DOMAINKEYS
  16
  17 /* Globals related to the DK reference library. */
  18 DK                   *dk_context             = NULL;
  19 DK_LIB               *dk_lib                 = NULL;
  20 DK_FLAGS              dk_flags;
  21 DK_STAT               dk_internal_status;
  22
  23 /* Globals related to Exim DK implementation. */
  24 dk_exim_verify_block *dk_verify_block        = NULL;
  25
  26 /* Global char buffer for getc/ungetc functions. We need
  27    to accumulate some chars to be able to match EOD and
  28    doubled SMTP dots. Those must not be fed to the validation
  29    engine. */
  30 int dkbuff[6] = {256,256,256,256,256,256};
  31
  32 /* receive_getc() wrapper that feeds DK while Exim reads
  33    the message. */
  34 int dk_receive_getc(void) {
  35   int i;
  36   int c = receive_getc();
  37
  38   if (dk_context != NULL) {
  39     /* Send oldest byte */
  40     if ((dkbuff[0] < 256) && (dk_internal_status == DK_STAT_OK)) {
  41       dk_internal_status = dk_message(dk_context, CUS &dkbuff[0], 1);
  42       if (dk_internal_status != DK_STAT_OK)
  43         DEBUG(D_receive) debug_printf("DK: %s\n", DK_STAT_to_string(dk_internal_status));
  44     }
  45     /* rotate buffer */
  46     for (i=0;i<5;i++) dkbuff[i]=dkbuff[i+1];
  47     dkbuff[5]=c;
  48     /* look for our candidate patterns */
  49     if ( (dkbuff[1] == '\r') &&
  50          (dkbuff[2] == '\n') &&
  51          (dkbuff[3] == '.') &&
  52          (dkbuff[4] == '\r') &&
  53          (dkbuff[5] == '\n') ) {
  54       /* End of DATA */
  55       dkbuff[3] = 256;
  56       dkbuff[4] = 256;
  57       dkbuff[5] = 256;
  58     }
  59     if ( (dkbuff[2] == '\r') &&
  60          (dkbuff[3] == '\n') &&
  61          (dkbuff[4] == '.') &&
  62          (dkbuff[5] == '.') ) {
  63       /* doubled dot, skip this char */
  64       dkbuff[5] = 256;
  65     }
  66   }
  67 return c;
  68 }
  69
  70 /* When exim puts a char back in the fd, we
  71    must rotate our buffer back. */
  72 int dk_receive_ungetc(int c) {
  73   int i;
  74   if (dk_context != NULL) {
  75     /* rotate buffer back */
  76     for (i=5;i>0;i--) dkbuff[i]=dkbuff[i-1];
  77     dkbuff[0]=256;
  78   }
  79   return receive_ungetc(c);
  80 }
  81
  82
  83 void dk_exim_verify_init(void) {
  84   int old_pool = store_pool;
  85   store_pool = POOL_PERM;
  86
  87   /* Reset DK state in any case. */
  88   dk_context = NULL;
  89   dk_lib = NULL;
  90   dk_verify_block = NULL;
  91
  92   /* Set up DK context if DK was requested and input is SMTP. */
  93   if (smtp_input && !smtp_batched_input && dk_do_verify) {
  94     /* initialize library */
  95     dk_lib = dk_init(&dk_internal_status);
  96     if (dk_internal_status != DK_STAT_OK)
  97       debug_printf("DK: %s\n", DK_STAT_to_string(dk_internal_status));
  98     else {
  99       /* initialize verification context */
 100       dk_context = dk_verify(dk_lib, &dk_internal_status);
 101       if (dk_internal_status != DK_STAT_OK) {
 102         debug_printf("DK: %s\n", DK_STAT_to_string(dk_internal_status));
 103         dk_context = NULL;
 104       }
 105       else {
 106         /* Reserve some space for the verify block. */
 107         dk_verify_block = store_get(sizeof(dk_exim_verify_block));
 108         if (dk_verify_block == NULL) {
 109           debug_printf("DK: Can't allocate %d bytes.\n",sizeof(dk_exim_verify_block));
 110           dk_context = NULL;
 111         }
 112         else {
 113           memset(dk_verify_block, 0, sizeof(dk_exim_verify_block));
 114         }
 115       }
 116     }
 117   }
 118   store_pool = old_pool;
 119 }
 120
 121
 122 void dk_exim_verify_finish(void) {
 123   char *p,*q;
 124   int i;
 125   int old_pool = store_pool;
 126
 127   /* Bail out if context could not be set up earlier. */
 128   if (dk_context == NULL)
 129     return;
 130
 131   store_pool = POOL_PERM;
 132
 133   /* Send remaining bytes from input which are still in the buffer. */
 134   for (i=0;i<6;i++)
 135     if (dkbuff[i] < 256)
 136       dk_internal_status = dk_message(dk_context, CUS &dkbuff[i], 1);
 137
 138   /* Flag end-of-message. */
 139   dk_internal_status = dk_end(dk_context, &dk_flags);
 140
 141   /* dk_flags now has the selector flags (if there was one).
 142      It seems that currently only the "t=" flag is supported
 143      in selectors. */
 144   if (dk_flags & DK_FLAG_SET)
 145     if (dk_flags & DK_FLAG_TESTING)
 146       dk_verify_block->testing = TRUE;
 147
 148   /* Grab address/domain information. */
 149   p = dk_address(dk_context);
 150   if (p != NULL) {
 151     switch(p[0]) {
 152       case 'N':
 153         dk_verify_block->address_source = DK_EXIM_ADDRESS_NONE;
 154       break;
 155       case 'S':
 156         dk_verify_block->address_source = DK_EXIM_ADDRESS_FROM_SENDER;
 157       break;
 158       case 'F':
 159         dk_verify_block->address_source = DK_EXIM_ADDRESS_FROM_FROM;
 160       break;
 161     }
 162     p++;
 163     if (*p != '\0') {
 164       dk_verify_block->address = string_copy((uschar *)p);
 165       q = strrchr(p,'@');
 166       if ((q != NULL) && (*(q+1) != '\0')) {
 167         dk_verify_block->domain = string_copy((uschar *)(q+1));
 168         *q = '\0';
 169         dk_verify_block->local_part = string_copy((uschar *)p);
 170         *q = '@';
 171       }
 172     }
 173   }
 174
 175   /* Now grab the domain-wide DK policy */
 176   dk_flags = dk_policy(dk_context);
 177
 178   if (dk_flags & DK_FLAG_SET) {
 179     /* Selector "t=" flag has precedence, don't overwrite it if
 180        the selector has set it above. */
 181     if ((dk_flags & DK_FLAG_TESTING) && !dk_verify_block->testing)
 182       dk_verify_block->testing = TRUE;
 183     if (dk_flags & DK_FLAG_SIGNSALL)
 184       dk_verify_block->signsall = TRUE;
 185   }
 186
 187   /* Set up main result. */
 188   switch(dk_internal_status)
 189     {
 190     case DK_STAT_NOSIG:
 191       dk_verify_block->is_signed = FALSE;
 192       dk_verify_block->result = DK_EXIM_RESULT_NO_SIGNATURE;
 193     break;
 194     case DK_STAT_OK:
 195       dk_verify_block->is_signed = TRUE;
 196       dk_verify_block->result = DK_EXIM_RESULT_GOOD;
 197     break;
 198     case DK_STAT_BADSIG:
 199       dk_verify_block->is_signed = TRUE;
 200       dk_verify_block->result = DK_EXIM_RESULT_BAD;
 201     break;
 202     case DK_STAT_REVOKED:
 203       dk_verify_block->is_signed = TRUE;
 204       dk_verify_block->result = DK_EXIM_RESULT_REVOKED;
 205     break;
 206     case DK_STAT_BADKEY:
 207     case DK_STAT_SYNTAX:
 208       dk_verify_block->is_signed = TRUE;
 209       /* Syntax -> Bad format? */
 210       dk_verify_block->result = DK_EXIM_RESULT_BAD_FORMAT;
 211     break;
 212     case DK_STAT_NOKEY:
 213       dk_verify_block->is_signed = TRUE;
 214       dk_verify_block->result = DK_EXIM_RESULT_NO_KEY;
 215     break;
 216     case DK_STAT_NORESOURCE:
 217     case DK_STAT_INTERNAL:
 218     case DK_STAT_ARGS:
 219     case DK_STAT_CANTVRFY:
 220       dk_verify_block->result = DK_EXIM_RESULT_ERR;
 221     break;
 222     /* This is missing DK_EXIM_RESULT_NON_PARTICIPANT. The lib does not
 223        report such a status. */
 224     }
 225
 226   /* Set up human readable result string. */
 227   dk_verify_block->result_string = string_copy((uschar *)DK_STAT_to_string(dk_internal_status));
 228
 229   /* All done, reset dk_context. */
 230   dk_free(dk_context,1);
 231   dk_context = NULL;
 232
 233   store_pool = old_pool;
 234 }
 235
 236 uschar *dk_exim_sign(int dk_fd,
 237                      uschar *dk_private_key,
 238                      uschar *dk_domain,
 239                      uschar *dk_selector,
 240                      uschar *dk_canon) {
 241   uschar *rc = NULL;
 242   uschar *headers = NULL;
 243   int headers_len;
 244   int dk_canon_int = DK_CANON_SIMPLE;
 245   char c;
 246   int seen_lf = 0;
 247   int seen_lfdot = 0;
 248   uschar sig[1024];
 249   int save_errno = 0;
 250   int sread;
 251   int old_pool = store_pool;
 252   store_pool = POOL_PERM;
 253
 254   dk_lib = dk_init(&dk_internal_status);
 255   if (dk_internal_status != DK_STAT_OK) {
 256     debug_printf("DK: %s\n", DK_STAT_to_string(dk_internal_status));
 257     rc = NULL;
 258     goto CLEANUP;
 259   }
 260
 261   /* Figure out what canonicalization to use. Unfortunately
 262      we must do this BEFORE knowing which domain we sign for. */
 263   if ((dk_canon != NULL) && (Ustrcmp(dk_canon, "nofws") == 0)) dk_canon_int = DK_CANON_NOFWS;
 264   else dk_canon = US "simple";
 265
 266   /* Initialize signing context. */
 267   dk_context = dk_sign(dk_lib, &dk_internal_status, dk_canon_int);
 268   if (dk_internal_status != DK_STAT_OK) {
 269     debug_printf("DK: %s\n", DK_STAT_to_string(dk_internal_status));
 270     dk_context = NULL;
 271     goto CLEANUP;
 272   }
 273
 274   while((sread = read(dk_fd,&c,1)) > 0) {
 275
 276     if ((c == '.') && seen_lfdot) {
 277       /* escaped dot, write "\n.", continue */
 278       dk_message(dk_context, CUS "\n.", 2);
 279       seen_lf = 0;
 280       seen_lfdot = 0;
 281       continue;
 282     }
 283
 284     if (seen_lfdot) {
 285       /* EOM, write "\n" and break */
 286       dk_message(dk_context, CUS "\n", 1);
 287       break;
 288     }
 289
 290     if ((c == '.') && seen_lf) {
 291       seen_lfdot = 1;
 292       continue;
 293     }
 294
 295     if (seen_lf) {
 296       /* normal lf, just send it */
 297       dk_message(dk_context, CUS "\n", 1);
 298       seen_lf = 0;
 299     }
 300
 301     if (c == '\n') {
 302       seen_lf = 1;
 303       continue;
 304     }
 305
 306     /* write the char */
 307     dk_message(dk_context, CUS &c, 1);
 308   }
 309
 310   /* Handle failed read above. */
 311   if (sread == -1) {
 312     debug_printf("DK: Error reading -K file.\n");
 313     save_errno = errno;
 314     rc = NULL;
 315     goto CLEANUP;
 316   }
 317
 318   /* Flag end-of-message. */
 319   dk_internal_status = dk_end(dk_context, NULL);
 320   /* TODO: check status */
 321
 322
 323   /* Get domain to use, unless overridden. */
 324   if (dk_domain == NULL) {
 325     dk_domain = US dk_address(dk_context);
 326     switch(dk_domain[0]) {
 327       case 'N': dk_domain = NULL; break;
 328       case 'F':
 329       case 'S':
 330         dk_domain++;
 331         dk_domain = Ustrrchr(dk_domain,'@');
 332         if (dk_domain != NULL) {
 333           uschar *p;
 334           dk_domain++;
 335           p = dk_domain;
 336           while (*p != 0) { *p = tolower(*p); p++; }
 337         }
 338       break;
 339     }
 340     if (dk_domain == NULL) {
 341       debug_printf("DK: Could not determine domain to use for signing from message headers.\n");
 342       /* In this case, we return "OK" by sending up an empty string as the
 343          DomainKey-Signature header. If there is no domain to sign for, we
 344          can send the message anyway since the recipient has no policy to
 345          apply ... */
 346       rc = US"";
 347       goto CLEANUP;
 348     }
 349   }
 350   else {
 351     dk_domain = expand_string(dk_domain);
 352     if (dk_domain == NULL) {
 353       /* expansion error, do not send message. */
 354       debug_printf("DK: Error while expanding dk_domain option.\n");
 355       rc = NULL;
 356       goto CLEANUP;
 357     }
 358   }
 359
 360   /* Set up $dk_domain expansion variable. */
 361   dk_signing_domain = dk_domain;
 362
 363   /* Get selector to use. */
 364   dk_selector = expand_string(dk_selector);
 365   if (dk_selector == NULL) {
 366     log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand "
 367       "dk_selector: %s", expand_string_message);
 368     rc = NULL;
 369     goto CLEANUP;
 370   }
 371
 372   /* Set up $dk_selector expansion variable. */
 373   dk_signing_selector = dk_selector;
 374
 375   /* Get private key to use. */
 376   dk_private_key = expand_string(dk_private_key);
 377   if (dk_private_key == NULL) {
 378     log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand "
 379       "dk_private_key: %s", expand_string_message);
 380     rc = NULL;
 381     goto CLEANUP;
 382   }
 383
 384   if ( (Ustrlen(dk_private_key) == 0) ||
 385        (Ustrcmp(dk_private_key,"0") == 0) ||
 386        (Ustrcmp(dk_private_key,"false") == 0) ) {
 387     /* don't sign, but no error */
 388     rc = US"";
 389     goto CLEANUP;
 390   }
 391
 392   if (dk_private_key[0] == '/') {
 393     int privkey_fd = 0;
 394     /* Looks like a filename, load the private key. */
 395     memset(big_buffer,0,big_buffer_size);
 396     privkey_fd = open(CS dk_private_key,O_RDONLY);
 397     (void)read(privkey_fd,big_buffer,16383);
 398     (void)close(privkey_fd);
 399     dk_private_key = big_buffer;
 400   }
 401
 402   /* Get the signature. */
 403   dk_internal_status = dk_getsig(dk_context, dk_private_key, sig, 1024);
 404
 405   /* Check for unuseable key */
 406   if (dk_internal_status != DK_STAT_OK) {
 407     debug_printf("DK: %s\n", DK_STAT_to_string(dk_internal_status));
 408     rc = NULL;
 409     goto CLEANUP;
 410   }
 411
 412   headers_len = dk_headers(dk_context, NULL);
 413   rc = store_get(1024+256+headers_len);
 414   headers = store_malloc(headers_len);
 415   dk_headers(dk_context, CS headers);
 416   /* Build DomainKey-Signature header to return. */
 417   (void)string_format(rc, 1024+256+headers_len, "DomainKey-Signature: a=rsa-sha1; q=dns; c=%s; s=%s; d=%s;\r\n"
 418                      "\th=%s;\r\n"
 419                      "\tb=%s;\r\n", dk_canon, dk_selector, dk_domain, headers, sig);
 420
 421   log_write(0, LOG_MAIN, "DK: message signed using a=rsa-sha1; q=dns; c=%s; s=%s; d=%s; h=%s;", dk_canon, dk_selector, dk_domain, headers);
 422   store_free(headers);
 423
 424   CLEANUP:
 425   if (dk_context != NULL) {
 426     dk_free(dk_context,1);
 427     dk_context = NULL;
 428   }
 429   store_pool = old_pool;
 430   errno = save_errno;
 431   return rc;
 432 }
 433
 434 #endif