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