Restructure Makefiles to accomodate multiple archs
[dragonfly.git] / crypto / heimdal-0.6.3 / lib / hdb / mkey.c
1 /*
2  * Copyright (c) 2000 - 2002 Kungliga Tekniska Högskolan
3  * (Royal Institute of Technology, Stockholm, Sweden). 
4  * All rights reserved. 
5  *
6  * Redistribution and use in source and binary forms, with or without 
7  * modification, are permitted provided that the following conditions 
8  * are met: 
9  *
10  * 1. Redistributions of source code must retain the above copyright 
11  *    notice, this list of conditions and the following disclaimer. 
12  *
13  * 2. Redistributions in binary form must reproduce the above copyright 
14  *    notice, this list of conditions and the following disclaimer in the 
15  *    documentation and/or other materials provided with the distribution. 
16  *
17  * 3. Neither the name of the Institute nor the names of its contributors 
18  *    may be used to endorse or promote products derived from this software 
19  *    without specific prior written permission. 
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
31  * SUCH DAMAGE. 
32  */
33
34 #include "hdb_locl.h"
35 #ifndef O_BINARY
36 #define O_BINARY 0
37 #endif
38
39 RCSID("$Id: mkey.c,v 1.15 2003/03/28 02:01:33 lha Exp $");
40
41 struct hdb_master_key_data {
42     krb5_keytab_entry keytab;
43     krb5_crypto crypto;
44     struct hdb_master_key_data *next;
45 };
46
47 void
48 hdb_free_master_key(krb5_context context, hdb_master_key mkey)
49 {
50     struct hdb_master_key_data *ptr;
51     while(mkey) {
52         krb5_kt_free_entry(context, &mkey->keytab);
53         if (mkey->crypto)
54             krb5_crypto_destroy(context, mkey->crypto);
55         ptr = mkey;
56         mkey = mkey->next;
57         free(ptr);
58     }
59 }
60
61 krb5_error_code
62 hdb_process_master_key(krb5_context context,
63                        int kvno, krb5_keyblock *key, krb5_enctype etype,
64                        hdb_master_key *mkey)
65 {
66     krb5_error_code ret;
67
68     *mkey = calloc(1, sizeof(**mkey));
69     if(*mkey == NULL) {
70         krb5_set_error_string(context, "malloc: out of memory");
71         return ENOMEM;
72     }
73     (*mkey)->keytab.vno = kvno;
74     ret = krb5_parse_name(context, "K/M", &(*mkey)->keytab.principal);
75     if(ret)
76         goto fail;
77     ret = krb5_copy_keyblock_contents(context, key, &(*mkey)->keytab.keyblock);
78     if(ret)
79         goto fail;
80     if(etype != 0)
81         (*mkey)->keytab.keyblock.keytype = etype;
82     (*mkey)->keytab.timestamp = time(NULL);
83     ret = krb5_crypto_init(context, key, etype, &(*mkey)->crypto);
84     if(ret)
85         goto fail;
86     return 0;
87  fail:
88     hdb_free_master_key(context, *mkey);
89     *mkey = NULL;
90     return ret;
91 }
92
93 krb5_error_code
94 hdb_add_master_key(krb5_context context, krb5_keyblock *key,
95                    hdb_master_key *inout)
96 {
97     int vno = 0;
98     hdb_master_key p;
99     krb5_error_code ret;
100
101     for(p = *inout; p; p = p->next)
102         vno = max(vno, p->keytab.vno);
103     vno++;
104     ret = hdb_process_master_key(context, vno, key, 0, &p);
105     if(ret)
106         return ret;
107     p->next = *inout;
108     *inout = p;
109     return 0;
110 }
111
112 static krb5_error_code
113 read_master_keytab(krb5_context context, const char *filename, 
114                    hdb_master_key *mkey)
115 {
116     krb5_error_code ret;
117     krb5_keytab id;
118     krb5_kt_cursor cursor;
119     krb5_keytab_entry entry;
120     hdb_master_key p;
121     
122     ret = krb5_kt_resolve(context, filename, &id);
123     if(ret)
124         return ret;
125
126     ret = krb5_kt_start_seq_get(context, id, &cursor);
127     if(ret)
128         goto out;
129     *mkey = NULL;
130     while(krb5_kt_next_entry(context, id, &entry, &cursor) == 0) {
131         p = calloc(1, sizeof(*p));
132         p->keytab = entry;
133         ret = krb5_crypto_init(context, &p->keytab.keyblock, 0, &p->crypto);
134         p->next = *mkey;
135         *mkey = p;
136     }
137     krb5_kt_end_seq_get(context, id, &cursor);
138   out:
139     krb5_kt_close(context, id);
140     return ret;
141 }
142
143 /* read a MIT master keyfile */
144 static krb5_error_code
145 read_master_mit(krb5_context context, const char *filename, 
146                 hdb_master_key *mkey)
147 {
148     int fd;
149     krb5_error_code ret;
150     krb5_storage *sp;
151     u_int16_t enctype;
152     krb5_keyblock key;
153                
154     fd = open(filename, O_RDONLY | O_BINARY);
155     if(fd < 0) {
156         int save_errno = errno;
157         krb5_set_error_string(context, "failed to open %s: %s", filename,
158                               strerror(save_errno));
159         return save_errno;
160     }
161     sp = krb5_storage_from_fd(fd);
162     if(sp == NULL) {
163         close(fd);
164         return errno;
165     }
166     krb5_storage_set_flags(sp, KRB5_STORAGE_HOST_BYTEORDER);
167 #if 0
168     /* could possibly use ret_keyblock here, but do it with more
169        checks for now */
170     ret = krb5_ret_keyblock(sp, &key);
171 #else
172     ret = krb5_ret_int16(sp, &enctype);
173     if((htons(enctype) & 0xff00) == 0x3000) {
174         krb5_set_error_string(context, "unknown keytype in %s: %#x, expected %#x", 
175                               filename, htons(enctype), 0x3000);
176         ret = HEIM_ERR_BAD_MKEY;
177         goto out;
178     }
179     key.keytype = enctype;
180     ret = krb5_ret_data(sp, &key.keyvalue);
181     if(ret)
182         goto out;
183 #endif
184     ret = hdb_process_master_key(context, 0, &key, 0, mkey);
185     krb5_free_keyblock_contents(context, &key);
186   out:
187     krb5_storage_free(sp);
188     close(fd);
189     return ret;
190 }
191
192 /* read an old master key file */
193 static krb5_error_code
194 read_master_encryptionkey(krb5_context context, const char *filename, 
195                           hdb_master_key *mkey)
196 {
197     int fd;
198     krb5_keyblock key;
199     krb5_error_code ret;
200     unsigned char buf[256];
201     ssize_t len;
202     size_t ret_len;
203                
204     fd = open(filename, O_RDONLY | O_BINARY);
205     if(fd < 0) {
206         int save_errno = errno;
207         krb5_set_error_string(context, "failed to open %s: %s", 
208                               filename, strerror(save_errno));
209         return save_errno;
210     }
211     
212     len = read(fd, buf, sizeof(buf));
213     close(fd);
214     if(len < 0) {
215         int save_errno = errno;
216         krb5_set_error_string(context, "error reading %s: %s", 
217                               filename, strerror(save_errno));
218         return save_errno;
219     }
220
221     ret = decode_EncryptionKey(buf, len, &key, &ret_len);
222     memset(buf, 0, sizeof(buf));
223     if(ret)
224         return ret;
225
226     /* Originally, the keytype was just that, and later it got changed
227        to des-cbc-md5, but we always used des in cfb64 mode. This
228        should cover all cases, but will break if someone has hacked
229        this code to really use des-cbc-md5 -- but then that's not my
230        problem. */
231     if(key.keytype == KEYTYPE_DES || key.keytype == ETYPE_DES_CBC_MD5)
232         key.keytype = ETYPE_DES_CFB64_NONE;
233     
234     ret = hdb_process_master_key(context, 0, &key, 0, mkey);
235     krb5_free_keyblock_contents(context, &key);
236     return ret;
237 }
238
239 /* read a krb4 /.k style file */
240 static krb5_error_code
241 read_master_krb4(krb5_context context, const char *filename, 
242                  hdb_master_key *mkey)
243 {
244     int fd;
245     krb5_keyblock key;
246     krb5_error_code ret;
247     unsigned char buf[256];
248     ssize_t len;
249                
250     fd = open(filename, O_RDONLY | O_BINARY);
251     if(fd < 0) {
252         int save_errno = errno;
253         krb5_set_error_string(context, "failed to open %s: %s", 
254                               filename, strerror(save_errno));
255         return save_errno;
256     }
257     
258     len = read(fd, buf, sizeof(buf));
259     close(fd);
260     if(len < 0) {
261         int save_errno = errno;
262         krb5_set_error_string(context, "error reading %s: %s", 
263                               filename, strerror(save_errno));
264         return save_errno;
265     }
266     if(len != 8) {
267         krb5_set_error_string(context, "bad contents of %s", filename);
268         return HEIM_ERR_EOF; /* XXX file might be too large */
269     }
270
271     memset(&key, 0, sizeof(key));
272     key.keytype = ETYPE_DES_PCBC_NONE;
273     ret = krb5_data_copy(&key.keyvalue, buf, len);
274     memset(buf, 0, sizeof(buf));
275     if(ret) 
276         return ret;
277
278     ret = hdb_process_master_key(context, 0, &key, 0, mkey);
279     krb5_free_keyblock_contents(context, &key);
280     return ret;
281 }
282
283 krb5_error_code
284 hdb_read_master_key(krb5_context context, const char *filename, 
285                     hdb_master_key *mkey)
286 {
287     FILE *f;
288     unsigned char buf[16];
289     krb5_error_code ret;
290
291     off_t len;
292
293     *mkey = NULL;
294
295     if(filename == NULL)
296         filename = HDB_DB_DIR "/m-key";
297
298     f = fopen(filename, "r");
299     if(f == NULL) {
300         int save_errno = errno;
301         krb5_set_error_string(context, "failed to open %s: %s", 
302                               filename, strerror(save_errno));
303         return save_errno;
304     }
305     
306     if(fread(buf, 1, 2, f) != 2) {
307         krb5_set_error_string(context, "end of file reading %s", filename);
308         fclose(f);
309         return HEIM_ERR_EOF;
310     }
311     
312     fseek(f, 0, SEEK_END);
313     len = ftell(f);
314
315     if(fclose(f) != 0)
316         return errno;
317     
318     if(len < 0)
319         return errno;
320     
321     if(len == 8) {
322         ret = read_master_krb4(context, filename, mkey);
323     } else if(buf[0] == 0x30 && len <= 127 && buf[1] == len - 2) {
324         ret = read_master_encryptionkey(context, filename, mkey);
325     } else if(buf[0] == 5 && buf[1] >= 1 && buf[1] <= 2) {
326         ret = read_master_keytab(context, filename, mkey);
327     } else {
328         ret = read_master_mit(context, filename, mkey);
329     }
330     return ret;
331 }
332
333 krb5_error_code
334 hdb_write_master_key(krb5_context context, const char *filename, 
335                      hdb_master_key mkey)
336 {
337     krb5_error_code ret;
338     hdb_master_key p;
339     krb5_keytab kt;
340
341     if(filename == NULL)
342         filename = HDB_DB_DIR "/m-key";
343
344     ret = krb5_kt_resolve(context, filename, &kt);
345     if(ret)
346         return ret;
347
348     for(p = mkey; p; p = p->next) {
349         ret = krb5_kt_add_entry(context, kt, &p->keytab);
350     }
351
352     krb5_kt_close(context, kt);
353
354     return ret;
355 }
356
357 static hdb_master_key
358 find_master_key(Key *key, hdb_master_key mkey)
359 {
360     hdb_master_key ret = NULL;
361     while(mkey) {
362         if(ret == NULL && mkey->keytab.vno == 0)
363             ret = mkey;
364         if(key->mkvno == NULL) {
365             if(ret == NULL || mkey->keytab.vno > ret->keytab.vno)
366                 ret = mkey;
367         } else if(mkey->keytab.vno == *key->mkvno)
368             return mkey;
369         mkey = mkey->next;
370     }
371     return ret;
372 }
373
374 krb5_error_code
375 hdb_unseal_keys_mkey(krb5_context context, hdb_entry *ent, hdb_master_key mkey)
376 {
377     int i;
378     krb5_error_code ret;
379     krb5_data res;
380     size_t keysize;
381     Key *k;
382
383     for(i = 0; i < ent->keys.len; i++){
384         hdb_master_key key;
385
386         k = &ent->keys.val[i];
387         if(k->mkvno == NULL)
388             continue;
389
390         key = find_master_key(&ent->keys.val[i], mkey);
391
392         if (key == NULL)
393             return HDB_ERR_NO_MKEY;
394
395         ret = krb5_decrypt(context, key->crypto, HDB_KU_MKEY,
396                            k->key.keyvalue.data,
397                            k->key.keyvalue.length,
398                            &res);
399         if (ret)
400             return ret;
401
402         /* fixup keylength if the key got padded when encrypting it */
403         ret = krb5_enctype_keysize(context, k->key.keytype, &keysize);
404         if (ret) {
405             krb5_data_free(&res);
406             return ret;
407         }
408         if (keysize > res.length) {
409             krb5_data_free(&res);
410             return KRB5_BAD_KEYSIZE;
411         }
412
413         memset(k->key.keyvalue.data, 0, k->key.keyvalue.length);
414         free(k->key.keyvalue.data);
415         k->key.keyvalue = res;
416         k->key.keyvalue.length = keysize;
417         free(k->mkvno);
418         k->mkvno = NULL;
419     }
420     return 0;
421 }
422
423 krb5_error_code
424 hdb_unseal_keys(krb5_context context, HDB *db, hdb_entry *ent)
425 {
426     if (db->master_key_set == 0)
427         return 0;
428     return hdb_unseal_keys_mkey(context, ent, db->master_key);
429 }
430
431 krb5_error_code
432 hdb_seal_keys_mkey(krb5_context context, hdb_entry *ent, hdb_master_key mkey)
433 {
434     int i;
435     krb5_error_code ret;
436     krb5_data res;
437     for(i = 0; i < ent->keys.len; i++){
438         Key *k = &ent->keys.val[i];
439         hdb_master_key key;
440
441         if(k->mkvno != NULL)
442             continue;
443
444         key = find_master_key(k, mkey);
445
446         if (key == NULL)
447             return HDB_ERR_NO_MKEY;
448
449         ret = krb5_encrypt(context, key->crypto, HDB_KU_MKEY,
450                            k->key.keyvalue.data,
451                            k->key.keyvalue.length,
452                            &res);
453         if (ret)
454             return ret;
455
456         memset(k->key.keyvalue.data, 0, k->key.keyvalue.length);
457         free(k->key.keyvalue.data);
458         k->key.keyvalue = res;
459
460         k->mkvno = malloc(sizeof(*k->mkvno));
461         if (k->mkvno == NULL)
462             return ENOMEM;
463         *k->mkvno = key->keytab.vno;
464     }
465     return 0;
466 }
467
468 krb5_error_code
469 hdb_seal_keys(krb5_context context, HDB *db, hdb_entry *ent)
470 {
471     if (db->master_key_set == 0)
472         return 0;
473     
474     return hdb_seal_keys_mkey(context, ent, db->master_key);
475 }
476
477 krb5_error_code
478 hdb_set_master_key (krb5_context context,
479                     HDB *db,
480                     krb5_keyblock *key)
481 {
482     krb5_error_code ret;
483     hdb_master_key mkey;
484
485     ret = hdb_process_master_key(context, 0, key, 0, &mkey);
486     if (ret)
487         return ret;
488     db->master_key = mkey;
489 #if 0 /* XXX - why? */
490     des_set_random_generator_seed(key.keyvalue.data);
491 #endif
492     db->master_key_set = 1;
493     return 0;
494 }
495
496 krb5_error_code
497 hdb_set_master_keyfile (krb5_context context,
498                         HDB *db,
499                         const char *keyfile)
500 {
501     hdb_master_key key;
502     krb5_error_code ret;
503
504     ret = hdb_read_master_key(context, keyfile, &key);
505     if (ret) {
506         if (ret != ENOENT)
507             return ret;
508         krb5_clear_error_string(context);
509         return 0;
510     }
511     db->master_key = key;
512     db->master_key_set = 1;
513     return ret;
514 }
515
516 krb5_error_code
517 hdb_clear_master_key (krb5_context context,
518                       HDB *db)
519 {
520     if (db->master_key_set) {
521         hdb_free_master_key(context, db->master_key);
522         db->master_key_set = 0;
523     }
524     return 0;
525 }