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