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