res/res_crypto.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 1999 - 2006, Digium, Inc.
   5  *
   6  * Mark Spencer <markster@digium.com>
   7  *
   8  * See http://www.asterisk.org for more information about
   9  * the Asterisk project. Please do not directly contact
  10  * any of the maintainers of this project for assistance;
  11  * the project provides a web site, mailing lists and IRC
  12  * channels for your use.
  13  *
  14  * This program is free software, distributed under the terms of
  15  * the GNU General Public License Version 2. See the LICENSE file
  16  * at the top of the source tree.
  17  */
  18
  19 /*! \file
  20  *
  21  * \brief Provide Cryptographic Signature capability
  22  *
  23  * \author Mark Spencer <markster@digium.com>
  24  *
  25  * \extref Uses the OpenSSL library, available at
  26  *      http://www.openssl.org/
  27  */
  28
  29 /*** MODULEINFO
  30         <depend>ssl</depend>
  31  ***/
  32
  33 #include "asterisk.h"
  34
  35 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  36
  37 #include <sys/types.h>
  38 #include <openssl/ssl.h>
  39 #include <openssl/err.h>
  40 #include <stdio.h>
  41 #include <dirent.h>
  42 #include <string.h>
  43 #include <errno.h>
  44 #include <unistd.h>
  45 #include <fcntl.h>
  46
  47 #include "asterisk/file.h"
  48 #include "asterisk/channel.h"
  49 #include "asterisk/logger.h"
  50 #include "asterisk/say.h"
  51 #include "asterisk/module.h"
  52 #include "asterisk/options.h"
  53 #include "asterisk/crypto.h"
  54 #include "asterisk/md5.h"
  55 #include "asterisk/cli.h"
  56 #include "asterisk/io.h"
  57 #include "asterisk/lock.h"
  58 #include "asterisk/utils.h"
  59
  60 /*
  61  * Asterisk uses RSA keys with SHA-1 message digests for its
  62  * digital signatures.  The choice of RSA is due to its higher
  63  * throughput on verification, and the choice of SHA-1 based
  64  * on the recently discovered collisions in MD5's compression
  65  * algorithm and recommendations of avoiding MD5 in new schemes
  66  * from various industry experts.
  67  *
  68  * We use OpenSSL to provide our crypto routines, although we never
  69  * actually use full-up SSL
  70  *
  71  */
  72
  73 /*
  74  * XXX This module is not very thread-safe.  It is for everyday stuff
  75  *     like reading keys and stuff, but there are all kinds of weird
  76  *     races with people running reload and key init at the same time
  77  *     for example
  78  *
  79  * XXXX
  80  */
  81
  82 AST_MUTEX_DEFINE_STATIC(keylock);
  83
  84 #define KEY_NEEDS_PASSCODE (1 << 16)
  85
  86 struct ast_key {
  87         /* Name of entity */
  88         char name[80];
  89         /* File name */
  90         char fn[256];
  91         /* Key type (AST_KEY_PUB or AST_KEY_PRIV, along with flags from above) */
  92         int ktype;
  93         /* RSA structure (if successfully loaded) */
  94         RSA *rsa;
  95         /* Whether we should be deleted */
  96         int delme;
  97         /* FD for input (or -1 if no input allowed, or -2 if we needed input) */
  98         int infd;
  99         /* FD for output */
 100         int outfd;
 101         /* Last MD5 Digest */
 102         unsigned char digest[16];
 103         struct ast_key *next;
 104 };
 105
 106 static struct ast_key *keys = NULL;
 107
 108
 109 #if 0
 110 static int fdprint(int fd, char *s)
 111 {
 112         return write(fd, s, strlen(s) + 1);
 113 }
 114 #endif
 115 static int pw_cb(char *buf, int size, int rwflag, void *userdata)
 116 {
 117         struct ast_key *key = (struct ast_key *)userdata;
 118         char prompt[256];
 119         int res;
 120         int tmp;
 121         if (key->infd > -1) {
 122                 snprintf(prompt, sizeof(prompt), ">>>> passcode for %s key '%s': ",
 123                          key->ktype == AST_KEY_PRIVATE ? "PRIVATE" : "PUBLIC", key->name);
 124                 write(key->outfd, prompt, strlen(prompt));
 125                 memset(buf, 0, sizeof(buf));
 126                 tmp = ast_hide_password(key->infd);
 127                 memset(buf, 0, size);
 128                 res = read(key->infd, buf, size);
 129                 ast_restore_tty(key->infd, tmp);
 130                 if (buf[strlen(buf) -1] == '\n')
 131                         buf[strlen(buf) - 1] = '\0';
 132                 return strlen(buf);
 133         } else {
 134                 /* Note that we were at least called */
 135                 key->infd = -2;
 136         }
 137         return -1;
 138 }
 139
 140 static struct ast_key *__ast_key_get(const char *kname, int ktype)
 141 {
 142         struct ast_key *key;
 143         ast_mutex_lock(&keylock);
 144         key = keys;
 145         while(key) {
 146                 if (!strcmp(kname, key->name) &&
 147                     (ktype == key->ktype))
 148                         break;
 149                 key = key->next;
 150         }
 151         ast_mutex_unlock(&keylock);
 152         return key;
 153 }
 154
 155 static struct ast_key *try_load_key (char *dir, char *fname, int ifd, int ofd, int *not2)
 156 {
 157         int ktype = 0;
 158         char *c = NULL;
 159         char ffname[256];
 160         unsigned char digest[16];
 161         FILE *f;
 162         struct MD5Context md5;
 163         struct ast_key *key;
 164         static int notice = 0;
 165         int found = 0;
 166
 167         /* Make sure its name is a public or private key */
 168
 169         if ((c = strstr(fname, ".pub")) && !strcmp(c, ".pub")) {
 170                 ktype = AST_KEY_PUBLIC;
 171         } else if ((c = strstr(fname, ".key")) && !strcmp(c, ".key")) {
 172                 ktype = AST_KEY_PRIVATE;
 173         } else
 174                 return NULL;
 175
 176         /* Get actual filename */
 177         snprintf(ffname, sizeof(ffname), "%s/%s", dir, fname);
 178
 179         ast_mutex_lock(&keylock);
 180         key = keys;
 181         while(key) {
 182                 /* Look for an existing version already */
 183                 if (!strcasecmp(key->fn, ffname))
 184                         break;
 185                 key = key->next;
 186         }
 187         ast_mutex_unlock(&keylock);
 188
 189         /* Open file */
 190         f = fopen(ffname, "r");
 191         if (!f) {
 192                 ast_log(LOG_WARNING, "Unable to open key file %s: %s\n", ffname, strerror(errno));
 193                 return NULL;
 194         }
 195         MD5Init(&md5);
 196         while(!feof(f)) {
 197                 /* Calculate a "whatever" quality md5sum of the key */
 198                 char buf[256];
 199                 memset(buf, 0, 256);
 200                 fgets(buf, sizeof(buf), f);
 201                 if (!feof(f)) {
 202                         MD5Update(&md5, (unsigned char *) buf, strlen(buf));
 203                 }
 204         }
 205         MD5Final(digest, &md5);
 206         if (key) {
 207                 /* If the MD5 sum is the same, and it isn't awaiting a passcode
 208                    then this is far enough */
 209                 if (!memcmp(digest, key->digest, 16) &&
 210                     !(key->ktype & KEY_NEEDS_PASSCODE)) {
 211                         fclose(f);
 212                         key->delme = 0;
 213                         return NULL;
 214                 } else {
 215                         /* Preserve keytype */
 216                         ktype = key->ktype;
 217                         /* Recycle the same structure */
 218                         found++;
 219                 }
 220         }
 221
 222         /* Make fname just be the normal name now */
 223         *c = '\0';
 224         if (!key) {
 225                 if (!(key = ast_calloc(1, sizeof(*key)))) {
 226                         fclose(f);
 227                         return NULL;
 228                 }
 229         }
 230         /* At this point we have a key structure (old or new).  Time to
 231            fill it with what we know */
 232         /* Gotta lock if this one already exists */
 233         if (found)
 234                 ast_mutex_lock(&keylock);
 235         /* First the filename */
 236         ast_copy_string(key->fn, ffname, sizeof(key->fn));
 237         /* Then the name */
 238         ast_copy_string(key->name, fname, sizeof(key->name));
 239         key->ktype = ktype;
 240         /* Yes, assume we're going to be deleted */
 241         key->delme = 1;
 242         /* Keep the key type */
 243         memcpy(key->digest, digest, 16);
 244         /* Can I/O takes the FD we're given */
 245         key->infd = ifd;
 246         key->outfd = ofd;
 247         /* Reset the file back to the beginning */
 248         rewind(f);
 249         /* Now load the key with the right method */
 250         if (ktype == AST_KEY_PUBLIC)
 251                 key->rsa = PEM_read_RSA_PUBKEY(f, NULL, pw_cb, key);
 252         else
 253                 key->rsa = PEM_read_RSAPrivateKey(f, NULL, pw_cb, key);
 254         fclose(f);
 255         if (key->rsa) {
 256                 if (RSA_size(key->rsa) == 128) {
 257                         /* Key loaded okay */
 258                         key->ktype &= ~KEY_NEEDS_PASSCODE;
 259                         if (option_verbose > 2)
 260                                 ast_verbose(VERBOSE_PREFIX_3 "Loaded %s key '%s'\n", key->ktype == AST_KEY_PUBLIC ? "PUBLIC" : "PRIVATE", key->name);
 261                         ast_debug(1, "Key '%s' loaded OK\n", key->name);
 262                         key->delme = 0;
 263                 } else
 264                         ast_log(LOG_NOTICE, "Key '%s' is not expected size.\n", key->name);
 265         } else if (key->infd != -2) {
 266                 ast_log(LOG_WARNING, "Key load %s '%s' failed\n",key->ktype == AST_KEY_PUBLIC ? "PUBLIC" : "PRIVATE", key->name);
 267                 if (ofd > -1) {
 268                         ERR_print_errors_fp(stderr);
 269                 } else
 270                         ERR_print_errors_fp(stderr);
 271         } else {
 272                 ast_log(LOG_NOTICE, "Key '%s' needs passcode.\n", key->name);
 273                 key->ktype |= KEY_NEEDS_PASSCODE;
 274                 if (!notice) {
 275                         if (!ast_opt_init_keys)
 276                                 ast_log(LOG_NOTICE, "Add the '-i' flag to the asterisk command line if you want to automatically initialize passcodes at launch.\n");
 277                         notice++;
 278                 }
 279                 /* Keep it anyway */
 280                 key->delme = 0;
 281                 /* Print final notice about "init keys" when done */
 282                 *not2 = 1;
 283         }
 284         if (found)
 285                 ast_mutex_unlock(&keylock);
 286         if (!found) {
 287                 ast_mutex_lock(&keylock);
 288                 key->next = keys;
 289                 keys = key;
 290                 ast_mutex_unlock(&keylock);
 291         }
 292         return key;
 293 }
 294
 295 #if 0
 296
 297 static void dump(unsigned char *src, int len)
 298 {
 299         int x;
 300         for (x=0;x<len;x++)
 301                 printf("%02x", *(src++));
 302         printf("\n");
 303 }
 304
 305 static char *binary(int y, int len)
 306 {
 307         static char res[80];
 308         int x;
 309         memset(res, 0, sizeof(res));
 310         for (x=0;x<len;x++) {
 311                 if (y & (1 << x))
 312                         res[(len - x - 1)] = '1';
 313                 else
 314                         res[(len - x - 1)] = '0';
 315         }
 316         return res;
 317 }
 318
 319 #endif
 320
 321 static int __ast_sign_bin(struct ast_key *key, const char *msg, int msglen, unsigned char *dsig)
 322 {
 323         unsigned char digest[20];
 324         unsigned int siglen = 128;
 325         int res;
 326
 327         if (key->ktype != AST_KEY_PRIVATE) {
 328                 ast_log(LOG_WARNING, "Cannot sign with a public key\n");
 329                 return -1;
 330         }
 331
 332         /* Calculate digest of message */
 333         SHA1((unsigned char *)msg, msglen, digest);
 334
 335         /* Verify signature */
 336         res = RSA_sign(NID_sha1, digest, sizeof(digest), dsig, &siglen, key->rsa);
 337
 338         if (!res) {
 339                 ast_log(LOG_WARNING, "RSA Signature (key %s) failed\n", key->name);
 340                 return -1;
 341         }
 342
 343         if (siglen != 128) {
 344                 ast_log(LOG_WARNING, "Unexpected signature length %d, expecting %d\n", (int)siglen, (int)128);
 345                 return -1;
 346         }
 347
 348         return 0;
 349
 350 }
 351
 352 static int __ast_decrypt_bin(unsigned char *dst, const unsigned char *src, int srclen, struct ast_key *key)
 353 {
 354         int res;
 355         int pos = 0;
 356         if (key->ktype != AST_KEY_PRIVATE) {
 357                 ast_log(LOG_WARNING, "Cannot decrypt with a public key\n");
 358                 return -1;
 359         }
 360
 361         if (srclen % 128) {
 362                 ast_log(LOG_NOTICE, "Tried to decrypt something not a multiple of 128 bytes\n");
 363                 return -1;
 364         }
 365         while(srclen) {
 366                 /* Process chunks 128 bytes at a time */
 367                 res = RSA_private_decrypt(128, src, dst, key->rsa, RSA_PKCS1_OAEP_PADDING);
 368                 if (res < 0)
 369                         return -1;
 370                 pos += res;
 371                 src += 128;
 372                 srclen -= 128;
 373                 dst += res;
 374         }
 375         return pos;
 376 }
 377
 378 static int __ast_encrypt_bin(unsigned char *dst, const unsigned char *src, int srclen, struct ast_key *key)
 379 {
 380         int res;
 381         int bytes;
 382         int pos = 0;
 383         if (key->ktype != AST_KEY_PUBLIC) {
 384                 ast_log(LOG_WARNING, "Cannot encrypt with a private key\n");
 385                 return -1;
 386         }
 387
 388         while(srclen) {
 389                 bytes = srclen;
 390                 if (bytes > 128 - 41)
 391                         bytes = 128 - 41;
 392                 /* Process chunks 128-41 bytes at a time */
 393                 res = RSA_public_encrypt(bytes, src, dst, key->rsa, RSA_PKCS1_OAEP_PADDING);
 394                 if (res != 128) {
 395                         ast_log(LOG_NOTICE, "How odd, encrypted size is %d\n", res);
 396                         return -1;
 397                 }
 398                 src += bytes;
 399                 srclen -= bytes;
 400                 pos += res;
 401                 dst += res;
 402         }
 403         return pos;
 404 }
 405
 406 static int __ast_sign(struct ast_key *key, char *msg, char *sig)
 407 {
 408         unsigned char dsig[128];
 409         int siglen = sizeof(dsig);
 410         int res;
 411         res = ast_sign_bin(key, msg, strlen(msg), dsig);
 412         if (!res)
 413                 /* Success -- encode (256 bytes max as documented) */
 414                 ast_base64encode(sig, dsig, siglen, 256);
 415         return res;
 416
 417 }
 418
 419 static int __ast_check_signature_bin(struct ast_key *key, const char *msg, int msglen, const unsigned char *dsig)
 420 {
 421         unsigned char digest[20];
 422         int res;
 423
 424         if (key->ktype != AST_KEY_PUBLIC) {
 425                 /* Okay, so of course you really *can* but for our purposes
 426                    we're going to say you can't */
 427                 ast_log(LOG_WARNING, "Cannot check message signature with a private key\n");
 428                 return -1;
 429         }
 430
 431         /* Calculate digest of message */
 432         SHA1((unsigned char *)msg, msglen, digest);
 433
 434         /* Verify signature */
 435         res = RSA_verify(NID_sha1, digest, sizeof(digest), (unsigned char *)dsig, 128, key->rsa);
 436
 437         if (!res) {
 438                 ast_debug(1, "Key failed verification: %s\n", key->name);
 439                 return -1;
 440         }
 441         /* Pass */
 442         return 0;
 443 }
 444
 445 static int __ast_check_signature(struct ast_key *key, const char *msg, const char *sig)
 446 {
 447         unsigned char dsig[128];
 448         int res;
 449
 450         /* Decode signature */
 451         res = ast_base64decode(dsig, sig, sizeof(dsig));
 452         if (res != sizeof(dsig)) {
 453                 ast_log(LOG_WARNING, "Signature improper length (expect %d, got %d)\n", (int)sizeof(dsig), (int)res);
 454                 return -1;
 455         }
 456         res = ast_check_signature_bin(key, msg, strlen(msg), dsig);
 457         return res;
 458 }
 459
 460 static void crypto_load(int ifd, int ofd)
 461 {
 462         struct ast_key *key, *nkey, *last;
 463         DIR *dir = NULL;
 464         struct dirent *ent;
 465         int note = 0;
 466         /* Mark all keys for deletion */
 467         ast_mutex_lock(&keylock);
 468         key = keys;
 469         while(key) {
 470                 key->delme = 1;
 471                 key = key->next;
 472         }
 473         ast_mutex_unlock(&keylock);
 474         /* Load new keys */
 475         dir = opendir((char *)ast_config_AST_KEY_DIR);
 476         if (dir) {
 477                 while((ent = readdir(dir))) {
 478                         try_load_key((char *)ast_config_AST_KEY_DIR, ent->d_name, ifd, ofd, &note);
 479                 }
 480                 closedir(dir);
 481         } else
 482                 ast_log(LOG_WARNING, "Unable to open key directory '%s'\n", (char *)ast_config_AST_KEY_DIR);
 483         if (note) {
 484                 ast_log(LOG_NOTICE, "Please run the command 'init keys' to enter the passcodes for the keys\n");
 485         }
 486         ast_mutex_lock(&keylock);
 487         key = keys;
 488         last = NULL;
 489         while(key) {
 490                 nkey = key->next;
 491                 if (key->delme) {
 492                         ast_debug(1, "Deleting key %s type %d\n", key->name, key->ktype);
 493                         /* Do the delete */
 494                         if (last)
 495                                 last->next = nkey;
 496                         else
 497                                 keys = nkey;
 498                         if (key->rsa)
 499                                 RSA_free(key->rsa);
 500                         free(key);
 501                 } else
 502                         last = key;
 503                 key = nkey;
 504         }
 505         ast_mutex_unlock(&keylock);
 506 }
 507
 508 static void md52sum(char *sum, unsigned char *md5)
 509 {
 510         int x;
 511         for (x=0;x<16;x++)
 512                 sum += sprintf(sum, "%02x", *(md5++));
 513 }
 514
 515 static int show_keys(int fd, int argc, char *argv[])
 516 {
 517         struct ast_key *key;
 518         char sum[16 * 2 + 1];
 519         int count_keys = 0;
 520
 521         ast_mutex_lock(&keylock);
 522         key = keys;
 523         ast_cli(fd, "%-18s %-8s %-16s %-33s\n", "Key Name", "Type", "Status", "Sum");
 524         while(key) {
 525                 md52sum(sum, key->digest);
 526                 ast_cli(fd, "%-18s %-8s %-16s %-33s\n", key->name,
 527                         (key->ktype & 0xf) == AST_KEY_PUBLIC ? "PUBLIC" : "PRIVATE",
 528                         key->ktype & KEY_NEEDS_PASSCODE ? "[Needs Passcode]" : "[Loaded]", sum);
 529
 530                 key = key->next;
 531                 count_keys++;
 532         }
 533         ast_mutex_unlock(&keylock);
 534         ast_cli(fd, "%d known RSA keys.\n", count_keys);
 535         return RESULT_SUCCESS;
 536 }
 537
 538 static int init_keys(int fd, int argc, char *argv[])
 539 {
 540         struct ast_key *key;
 541         int ign;
 542         char *kn;
 543         char tmp[256] = "";
 544
 545         key = keys;
 546         while(key) {
 547                 /* Reload keys that need pass codes now */
 548                 if (key->ktype & KEY_NEEDS_PASSCODE) {
 549                         kn = key->fn + strlen(ast_config_AST_KEY_DIR) + 1;
 550                         ast_copy_string(tmp, kn, sizeof(tmp));
 551                         try_load_key((char *)ast_config_AST_KEY_DIR, tmp, fd, fd, &ign);
 552                 }
 553                 key = key->next;
 554         }
 555         return RESULT_SUCCESS;
 556 }
 557
 558 static const char show_key_usage[] =
 559 "Usage: keys show\n"
 560 "       Displays information about RSA keys known by Asterisk\n";
 561
 562 static const char init_keys_usage[] =
 563 "Usage: keys init\n"
 564 "       Initializes private keys (by reading in pass code from the user)\n";
 565
 566 static struct ast_cli_entry cli_crypto[] = {
 567         { { "keys", "show", NULL },
 568         show_keys, "Displays RSA key information",
 569         show_key_usage },
 570
 571         { { "keys", "init", NULL },
 572         init_keys, "Initialize RSA key passcodes",
 573         init_keys_usage },
 574 };
 575
 576 static int crypto_init(void)
 577 {
 578         SSL_library_init();
 579         ERR_load_crypto_strings();
 580         ast_cli_register_multiple(cli_crypto, sizeof(cli_crypto) / sizeof(struct ast_cli_entry));
 581
 582         /* Install ourselves into stubs */
 583         ast_key_get = __ast_key_get;
 584         ast_check_signature = __ast_check_signature;
 585         ast_check_signature_bin = __ast_check_signature_bin;
 586         ast_sign = __ast_sign;
 587         ast_sign_bin = __ast_sign_bin;
 588         ast_encrypt_bin = __ast_encrypt_bin;
 589         ast_decrypt_bin = __ast_decrypt_bin;
 590         return 0;
 591 }
 592
 593 static int reload(void)
 594 {
 595         crypto_load(-1, -1);
 596         return 0;
 597 }
 598
 599 static int load_module(void)
 600 {
 601         crypto_init();
 602         if (ast_opt_init_keys)
 603                 crypto_load(STDIN_FILENO, STDOUT_FILENO);
 604         else
 605                 crypto_load(-1, -1);
 606         return 0;
 607 }
 608
 609 static int unload_module(void)
 610 {
 611         /* Can't unload this once we're loaded */
 612         return -1;
 613 }
 614
 615 /* needs usecount semantics defined */
 616 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Cryptographic Digital Signatures",
 617                 .load = load_module,
 618                 .unload = unload_module,
 619                 .reload = reload
 620         );