1/*
2 * Copyright (c) 2000 - 2004 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
39struct hdb_master_key_data {
40    krb5_keytab_entry keytab;
41    krb5_crypto crypto;
42    struct hdb_master_key_data *next;
43};
44
45void
46hdb_free_master_key(krb5_context context, hdb_master_key mkey)
47{
48    struct hdb_master_key_data *ptr;
49    while(mkey) {
50	krb5_kt_free_entry(context, &mkey->keytab);
51	if (mkey->crypto)
52	    krb5_crypto_destroy(context, mkey->crypto);
53	ptr = mkey;
54	mkey = mkey->next;
55	free(ptr);
56    }
57}
58
59krb5_error_code
60hdb_process_master_key(krb5_context context,
61		       int kvno, krb5_keyblock *key, krb5_enctype etype,
62		       hdb_master_key *mkey)
63{
64    krb5_error_code ret;
65
66    *mkey = calloc(1, sizeof(**mkey));
67    if(*mkey == NULL) {
68	krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
69	return ENOMEM;
70    }
71    (*mkey)->keytab.vno = kvno;
72    ret = krb5_parse_name(context, "K/M", &(*mkey)->keytab.principal);
73    if(ret)
74	goto fail;
75    ret = krb5_copy_keyblock_contents(context, key, &(*mkey)->keytab.keyblock);
76    if(ret)
77	goto fail;
78    if(etype != 0)
79	(*mkey)->keytab.keyblock.keytype = etype;
80    (*mkey)->keytab.timestamp = time(NULL);
81    ret = krb5_crypto_init(context, key, etype, &(*mkey)->crypto);
82    if(ret)
83	goto fail;
84    return 0;
85 fail:
86    hdb_free_master_key(context, *mkey);
87    *mkey = NULL;
88    return ret;
89}
90
91krb5_error_code
92hdb_add_master_key(krb5_context context, krb5_keyblock *key,
93		   hdb_master_key *inout)
94{
95    int vno = 0;
96    hdb_master_key p;
97    krb5_error_code ret;
98
99    for(p = *inout; p; p = p->next)
100	vno = max(vno, p->keytab.vno);
101    vno++;
102    ret = hdb_process_master_key(context, vno, key, 0, &p);
103    if(ret)
104	return ret;
105    p->next = *inout;
106    *inout = p;
107    return 0;
108}
109
110static krb5_error_code
111read_master_keytab(krb5_context context, const char *filename,
112		   hdb_master_key *mkey)
113{
114    krb5_error_code ret;
115    krb5_keytab id;
116    krb5_kt_cursor cursor;
117    krb5_keytab_entry entry;
118    hdb_master_key p;
119
120    ret = krb5_kt_resolve(context, filename, &id);
121    if(ret)
122	return ret;
123
124    ret = krb5_kt_start_seq_get(context, id, &cursor);
125    if(ret)
126	goto out;
127    *mkey = NULL;
128    while(krb5_kt_next_entry(context, id, &entry, &cursor) == 0) {
129	p = calloc(1, sizeof(*p));
130	if(p == NULL) {
131	    krb5_kt_end_seq_get(context, id, &cursor);
132	    ret = ENOMEM;
133	    goto out;
134	}
135	p->keytab = entry;
136	ret = krb5_crypto_init(context, &p->keytab.keyblock, 0, &p->crypto);
137	p->next = *mkey;
138	*mkey = p;
139    }
140    krb5_kt_end_seq_get(context, id, &cursor);
141  out:
142    krb5_kt_close(context, id);
143    return ret;
144}
145
146/* read a MIT master keyfile */
147static krb5_error_code
148read_master_mit(krb5_context context, const char *filename,
149		int byteorder, hdb_master_key *mkey)
150{
151    int fd;
152    krb5_error_code ret;
153    krb5_storage *sp;
154    int16_t enctype;
155    krb5_keyblock key;
156
157    fd = open(filename, O_RDONLY | O_BINARY);
158    if(fd < 0) {
159	int save_errno = errno;
160	krb5_set_error_message(context, save_errno, "failed to open %s: %s",
161			       filename, strerror(save_errno));
162	return save_errno;
163    }
164    sp = krb5_storage_from_fd(fd);
165    if(sp == NULL) {
166	close(fd);
167	return errno;
168    }
169    krb5_storage_set_flags(sp, byteorder);
170    /* could possibly use ret_keyblock here, but do it with more
171       checks for now */
172    {
173	ret = krb5_ret_int16(sp, &enctype);
174	if (ret)
175	    goto out;
176	ret = krb5_enctype_valid(context, enctype);
177	if (ret)
178	   goto out;
179	key.keytype = enctype;
180	ret = krb5_ret_data(sp, &key.keyvalue);
181	if(ret)
182	    goto out;
183    }
184    ret = hdb_process_master_key(context, 1, &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 */
193static krb5_error_code
194read_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_message(context, save_errno, "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_message(context, save_errno, "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 == ETYPE_DES_CBC_CRC || 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 */
240static krb5_error_code
241read_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_message(context, save_errno, "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_message(context, save_errno, "error reading %s: %s",
263			       filename, strerror(save_errno));
264	return save_errno;
265    }
266    if(len != 8) {
267	krb5_set_error_message(context, HEIM_ERR_EOF,
268			       "bad contents of %s", filename);
269	return HEIM_ERR_EOF; /* XXX file might be too large */
270    }
271
272    memset(&key, 0, sizeof(key));
273    key.keytype = ETYPE_DES_PCBC_NONE;
274    ret = krb5_data_copy(&key.keyvalue, buf, len);
275    memset(buf, 0, sizeof(buf));
276    if(ret)
277	return ret;
278
279    ret = hdb_process_master_key(context, 0, &key, 0, mkey);
280    krb5_free_keyblock_contents(context, &key);
281    return ret;
282}
283
284krb5_error_code
285hdb_read_master_key(krb5_context context, const char *filename,
286		    hdb_master_key *mkey)
287{
288    FILE *f;
289    unsigned char buf[16];
290    krb5_error_code ret;
291
292    off_t len;
293
294    *mkey = NULL;
295
296    if(filename == NULL)
297	filename = HDB_DB_DIR "/m-key";
298
299    f = fopen(filename, "r");
300    if(f == NULL) {
301	int save_errno = errno;
302	krb5_set_error_message(context, save_errno, "failed to open %s: %s",
303			       filename, strerror(save_errno));
304	return save_errno;
305    }
306
307    if(fread(buf, 1, 2, f) != 2) {
308	fclose(f);
309	krb5_set_error_message(context, HEIM_ERR_EOF, "end of file reading %s", filename);
310	return HEIM_ERR_EOF;
311    }
312
313    fseek(f, 0, SEEK_END);
314    len = ftell(f);
315
316    if(fclose(f) != 0)
317	return errno;
318
319    if(len < 0)
320	return errno;
321
322    if(len == 8) {
323	ret = read_master_krb4(context, filename, mkey);
324    } else if(buf[0] == 0x30 && len <= 127 && buf[1] == len - 2) {
325	ret = read_master_encryptionkey(context, filename, mkey);
326    } else if(buf[0] == 5 && buf[1] >= 1 && buf[1] <= 2) {
327	ret = read_master_keytab(context, filename, mkey);
328    } else {
329      /*
330       * Check both LittleEndian and BigEndian since they key file
331       * might be moved from a machine with diffrent byte order, or
332       * its running on MacOS X that always uses BE master keys.
333       */
334      ret = read_master_mit(context, filename, KRB5_STORAGE_BYTEORDER_LE, mkey);
335      if (ret)
336          ret = read_master_mit(context, filename, KRB5_STORAGE_BYTEORDER_BE, mkey);
337    }
338    return ret;
339}
340
341krb5_error_code
342hdb_write_master_key(krb5_context context, const char *filename,
343		     hdb_master_key mkey)
344{
345    krb5_error_code ret;
346    hdb_master_key p;
347    krb5_keytab kt;
348
349    if(filename == NULL)
350	filename = HDB_DB_DIR "/m-key";
351
352    ret = krb5_kt_resolve(context, filename, &kt);
353    if(ret)
354	return ret;
355
356    for(p = mkey; p; p = p->next) {
357	ret = krb5_kt_add_entry(context, kt, &p->keytab);
358    }
359
360    krb5_kt_close(context, kt);
361
362    return ret;
363}
364
365hdb_master_key
366_hdb_find_master_key(uint32_t *mkvno, hdb_master_key mkey)
367{
368    hdb_master_key ret = NULL;
369    while(mkey) {
370	if(ret == NULL && mkey->keytab.vno == 0)
371	    ret = mkey;
372	if(mkvno == NULL) {
373	    if(ret == NULL || mkey->keytab.vno > ret->keytab.vno)
374		ret = mkey;
375	} else if((uint32_t)mkey->keytab.vno == *mkvno)
376	    return mkey;
377	mkey = mkey->next;
378    }
379    return ret;
380}
381
382int
383_hdb_mkey_version(hdb_master_key mkey)
384{
385    return mkey->keytab.vno;
386}
387
388int
389_hdb_mkey_decrypt(krb5_context context, hdb_master_key key,
390		  krb5_key_usage usage,
391		  void *ptr, size_t size, krb5_data *res)
392{
393    return krb5_decrypt(context, key->crypto, usage,
394			ptr, size, res);
395}
396
397int
398_hdb_mkey_encrypt(krb5_context context, hdb_master_key key,
399		  krb5_key_usage usage,
400		  const void *ptr, size_t size, krb5_data *res)
401{
402    return krb5_encrypt(context, key->crypto, usage,
403			ptr, size, res);
404}
405
406krb5_error_code
407hdb_unseal_key_mkey(krb5_context context, Key *k, hdb_master_key mkey)
408{
409
410    krb5_error_code ret;
411    krb5_data res;
412    size_t keysize;
413
414    hdb_master_key key;
415
416    if(k->mkvno == NULL)
417	return 0;
418
419    key = _hdb_find_master_key(k->mkvno, mkey);
420
421    if (key == NULL)
422	return HDB_ERR_NO_MKEY;
423
424    ret = _hdb_mkey_decrypt(context, key, HDB_KU_MKEY,
425			    k->key.keyvalue.data,
426			    k->key.keyvalue.length,
427			    &res);
428    if(ret == KRB5KRB_AP_ERR_BAD_INTEGRITY) {
429	/* try to decrypt with MIT key usage */
430	ret = _hdb_mkey_decrypt(context, key, 0,
431				k->key.keyvalue.data,
432				k->key.keyvalue.length,
433				&res);
434    }
435    if (ret)
436	return ret;
437
438    /* fixup keylength if the key got padded when encrypting it */
439    ret = krb5_enctype_keysize(context, k->key.keytype, &keysize);
440    if (ret) {
441	krb5_data_free(&res);
442	return ret;
443    }
444    if (keysize > res.length) {
445	krb5_data_free(&res);
446	return KRB5_BAD_KEYSIZE;
447    }
448
449    memset(k->key.keyvalue.data, 0, k->key.keyvalue.length);
450    free(k->key.keyvalue.data);
451    k->key.keyvalue = res;
452    k->key.keyvalue.length = keysize;
453    free(k->mkvno);
454    k->mkvno = NULL;
455
456    return 0;
457}
458
459krb5_error_code
460hdb_unseal_keys_mkey(krb5_context context, hdb_entry *ent, hdb_master_key mkey)
461{
462    size_t i;
463
464    for(i = 0; i < ent->keys.len; i++){
465	krb5_error_code ret;
466
467	ret = hdb_unseal_key_mkey(context, &ent->keys.val[i], mkey);
468	if (ret)
469	    return ret;
470    }
471    return 0;
472}
473
474krb5_error_code
475hdb_unseal_keys(krb5_context context, HDB *db, hdb_entry *ent)
476{
477    if (db->hdb_master_key_set == 0)
478	return 0;
479    return hdb_unseal_keys_mkey(context, ent, db->hdb_master_key);
480}
481
482krb5_error_code
483hdb_unseal_key(krb5_context context, HDB *db, Key *k)
484{
485    if (db->hdb_master_key_set == 0)
486	return 0;
487    return hdb_unseal_key_mkey(context, k, db->hdb_master_key);
488}
489
490krb5_error_code
491hdb_seal_key_mkey(krb5_context context, Key *k, hdb_master_key mkey)
492{
493    krb5_error_code ret;
494    krb5_data res;
495    hdb_master_key key;
496
497    if(k->mkvno != NULL)
498	return 0;
499
500    key = _hdb_find_master_key(k->mkvno, mkey);
501
502    if (key == NULL)
503	return HDB_ERR_NO_MKEY;
504
505    ret = _hdb_mkey_encrypt(context, key, HDB_KU_MKEY,
506			    k->key.keyvalue.data,
507			    k->key.keyvalue.length,
508			    &res);
509    if (ret)
510	return ret;
511
512    memset(k->key.keyvalue.data, 0, k->key.keyvalue.length);
513    free(k->key.keyvalue.data);
514    k->key.keyvalue = res;
515
516    if (k->mkvno == NULL) {
517	k->mkvno = malloc(sizeof(*k->mkvno));
518	if (k->mkvno == NULL)
519	    return ENOMEM;
520    }
521    *k->mkvno = key->keytab.vno;
522
523    return 0;
524}
525
526krb5_error_code
527hdb_seal_keys_mkey(krb5_context context, hdb_entry *ent, hdb_master_key mkey)
528{
529    size_t i;
530    for(i = 0; i < ent->keys.len; i++){
531	krb5_error_code ret;
532
533	ret = hdb_seal_key_mkey(context, &ent->keys.val[i], mkey);
534	if (ret)
535	    return ret;
536    }
537    return 0;
538}
539
540krb5_error_code
541hdb_seal_keys(krb5_context context, HDB *db, hdb_entry *ent)
542{
543    if (db->hdb_master_key_set == 0)
544	return 0;
545
546    return hdb_seal_keys_mkey(context, ent, db->hdb_master_key);
547}
548
549krb5_error_code
550hdb_seal_key(krb5_context context, HDB *db, Key *k)
551{
552    if (db->hdb_master_key_set == 0)
553	return 0;
554
555    return hdb_seal_key_mkey(context, k, db->hdb_master_key);
556}
557
558krb5_error_code
559hdb_set_master_key (krb5_context context,
560		    HDB *db,
561		    krb5_keyblock *key)
562{
563    krb5_error_code ret;
564    hdb_master_key mkey;
565
566    ret = hdb_process_master_key(context, 0, key, 0, &mkey);
567    if (ret)
568	return ret;
569    db->hdb_master_key = mkey;
570#if 0 /* XXX - why? */
571    des_set_random_generator_seed(key.keyvalue.data);
572#endif
573    db->hdb_master_key_set = 1;
574    return 0;
575}
576
577krb5_error_code
578hdb_set_master_keyfile (krb5_context context,
579			HDB *db,
580			const char *keyfile)
581{
582    hdb_master_key key;
583    krb5_error_code ret;
584
585    ret = hdb_read_master_key(context, keyfile, &key);
586    if (ret) {
587	if (ret != ENOENT)
588	    return ret;
589	krb5_clear_error_message(context);
590	return 0;
591    }
592    db->hdb_master_key = key;
593    db->hdb_master_key_set = 1;
594    return ret;
595}
596
597krb5_error_code
598hdb_clear_master_key (krb5_context context,
599		      HDB *db)
600{
601    if (db->hdb_master_key_set) {
602	hdb_free_master_key(context, db->hdb_master_key);
603	db->hdb_master_key_set = 0;
604    }
605    return 0;
606}
607