Debian Codegraph @

lib/krb5/crypto.c

raw
1 /*
2 * Copyright (c) 1997 - 2008 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 "krb5_locl.h"
35
36 struct _krb5_key_usage {
37 unsigned usage;
38 struct _krb5_key_data key;
39 };
40
41
42 #ifndef HEIMDAL_SMALLER
43 #define DES3_OLD_ENCTYPE 1
44 #endif
45
46 static krb5_error_code _get_derived_key(krb5_context, krb5_crypto,
47 unsigned, struct _krb5_key_data**);
48 static struct _krb5_key_data *_new_derived_key(krb5_crypto crypto, unsigned usage);
49
50 static void free_key_schedule(krb5_context,
51 struct _krb5_key_data *,
52 struct _krb5_encryption_type *);
53
54 /*
55 * Converts etype to a user readable string and sets as a side effect
56 * the krb5_error_message containing this string. Returns
57 * KRB5_PROG_ETYPE_NOSUPP in not the conversion of the etype failed in
58 * which case the error code of the etype convesion is returned.
59 */
60
61 static krb5_error_code
62 unsupported_enctype(krb5_context context, krb5_enctype etype)
63 {
64 krb5_error_code ret;
65 char *name;
66
67 ret = krb5_enctype_to_string(context, etype, &name);
68 if (ret)
69 return ret;
70
71 krb5_set_error_message(context, KRB5_PROG_ETYPE_NOSUPP,
72 N_("Encryption type %s not supported", ""),
73 name);
74 free(name);
75 return KRB5_PROG_ETYPE_NOSUPP;
76 }
77
78 /*
79 *
80 */
81
82 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
83 krb5_enctype_keysize(krb5_context context,
84 krb5_enctype type,
85 size_t *keysize)
86 {
87 struct _krb5_encryption_type *et = _krb5_find_enctype(type);
88 if(et == NULL) {
89 return unsupported_enctype (context, type);
90 }
91 *keysize = et->keytype->size;
92 return 0;
93 }
94
95 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
96 krb5_enctype_keybits(krb5_context context,
97 krb5_enctype type,
98 size_t *keybits)
99 {
100 struct _krb5_encryption_type *et = _krb5_find_enctype(type);
101 if(et == NULL) {
102 return unsupported_enctype (context, type);
103 }
104 *keybits = et->keytype->bits;
105 return 0;
106 }
107
108 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
109 krb5_generate_random_keyblock(krb5_context context,
110 krb5_enctype type,
111 krb5_keyblock *key)
112 {
113 krb5_error_code ret;
114 struct _krb5_encryption_type *et = _krb5_find_enctype(type);
115 if(et == NULL) {
116 return unsupported_enctype (context, type);
117 }
118 ret = krb5_data_alloc(&key->keyvalue, et->keytype->size);
119 if(ret)
120 return ret;
121 key->keytype = type;
122 if(et->keytype->random_key)
123 (*et->keytype->random_key)(context, key);
124 else
125 krb5_generate_random_block(key->keyvalue.data,
126 key->keyvalue.length);
127 return 0;
128 }
129
130 static krb5_error_code
131 _key_schedule(krb5_context context,
132 struct _krb5_key_data *key)
133 {
134 krb5_error_code ret;
135 struct _krb5_encryption_type *et = _krb5_find_enctype(key->key->keytype);
136 struct _krb5_key_type *kt;
137
138 if (et == NULL) {
139 return unsupported_enctype (context,
140 key->key->keytype);
141 }
142
143 kt = et->keytype;
144
145 if(kt->schedule == NULL)
146 return 0;
147 if (key->schedule != NULL)
148 return 0;
149 ALLOC(key->schedule, 1);
150 if (key->schedule == NULL)
151 return krb5_enomem(context);
152 ret = krb5_data_alloc(key->schedule, kt->schedule_size);
153 if(ret) {
154 free(key->schedule);
155 key->schedule = NULL;
156 return ret;
157 }
158 (*kt->schedule)(context, kt, key);
159 return 0;
160 }
161
162 /************************************************************
163 * *
164 ************************************************************/
165
166 static krb5_error_code
167 SHA1_checksum(krb5_context context,
168 struct _krb5_key_data *key,
169 const void *data,
170 size_t len,
171 unsigned usage,
172 Checksum *C)
173 {
174 if (EVP_Digest(data, len, C->checksum.data, NULL, EVP_sha1(), NULL) != 1)
175 krb5_abortx(context, "sha1 checksum failed");
176 return 0;
177 }
178
179 /* HMAC according to RFC2104 */
180 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
181 _krb5_internal_hmac(krb5_context context,
182 struct _krb5_checksum_type *cm,
183 const void *data,
184 size_t len,
185 unsigned usage,
186 struct _krb5_key_data *keyblock,
187 Checksum *result)
188 {
189 unsigned char *ipad, *opad;
190 unsigned char *key;
191 size_t key_len;
192 size_t i;
193
194 ipad = malloc(cm->blocksize + len);
195 if (ipad == NULL)
196 return ENOMEM;
197 opad = malloc(cm->blocksize + cm->checksumsize);
198 if (opad == NULL) {
199 free(ipad);
200 return ENOMEM;
201 }
202 memset(ipad, 0x36, cm->blocksize);
203 memset(opad, 0x5c, cm->blocksize);
204
205 if(keyblock->key->keyvalue.length > cm->blocksize){
206 (*cm->checksum)(context,
207 keyblock,
208 keyblock->key->keyvalue.data,
209 keyblock->key->keyvalue.length,
210 usage,
211 result);
212 key = result->checksum.data;
213 key_len = result->checksum.length;
214 } else {
215 key = keyblock->key->keyvalue.data;
216 key_len = keyblock->key->keyvalue.length;
217 }
218 for(i = 0; i < key_len; i++){
219 ipad[i] ^= key[i];
220 opad[i] ^= key[i];
221 }
222 memcpy(ipad + cm->blocksize, data, len);
223 (*cm->checksum)(context, keyblock, ipad, cm->blocksize + len,
224 usage, result);
225 memcpy(opad + cm->blocksize, result->checksum.data,
226 result->checksum.length);
227 (*cm->checksum)(context, keyblock, opad,
228 cm->blocksize + cm->checksumsize, usage, result);
229 memset(ipad, 0, cm->blocksize + len);
230 free(ipad);
231 memset(opad, 0, cm->blocksize + cm->checksumsize);
232 free(opad);
233
234 return 0;
235 }
236
237 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
238 krb5_hmac(krb5_context context,
239 krb5_cksumtype cktype,
240 const void *data,
241 size_t len,
242 unsigned usage,
243 krb5_keyblock *key,
244 Checksum *result)
245 {
246 struct _krb5_checksum_type *c = _krb5_find_checksum(cktype);
247 struct _krb5_key_data kd;
248 krb5_error_code ret;
249
250 if (c == NULL) {
251 krb5_set_error_message (context, KRB5_PROG_SUMTYPE_NOSUPP,
252 N_("checksum type %d not supported", ""),
253 cktype);
254 return KRB5_PROG_SUMTYPE_NOSUPP;
255 }
256
257 kd.key = key;
258 kd.schedule = NULL;
259
260 ret = _krb5_internal_hmac(context, c, data, len, usage, &kd, result);
261
262 if (kd.schedule)
263 krb5_free_data(context, kd.schedule);
264
265 return ret;
266 }
267
268 krb5_error_code
269 _krb5_SP_HMAC_SHA1_checksum(krb5_context context,
270 struct _krb5_key_data *key,
271 const void *data,
272 size_t len,
273 unsigned usage,
274 Checksum *result)
275 {
276 struct _krb5_checksum_type *c = _krb5_find_checksum(CKSUMTYPE_SHA1);
277 Checksum res;
278 char sha1_data[20];
279 krb5_error_code ret;
280
281 res.checksum.data = sha1_data;
282 res.checksum.length = sizeof(sha1_data);
283
284 ret = _krb5_internal_hmac(context, c, data, len, usage, key, &res);
285 if (ret)
286 krb5_abortx(context, "hmac failed");
287 memcpy(result->checksum.data, res.checksum.data, result->checksum.length);
288 return 0;
289 }
290
291 struct _krb5_checksum_type _krb5_checksum_sha1 = {
292 CKSUMTYPE_SHA1,
293 "sha1",
294 64,
295 20,
296 F_CPROOF,
297 SHA1_checksum,
298 NULL
299 };
300
301 KRB5_LIB_FUNCTION struct _krb5_checksum_type * KRB5_LIB_CALL
302 _krb5_find_checksum(krb5_cksumtype type)
303 {
304 int i;
305 for(i = 0; i < _krb5_num_checksums; i++)
306 if(_krb5_checksum_types[i]->type == type)
307 return _krb5_checksum_types[i];
308 return NULL;
309 }
310
311 static krb5_error_code
312 get_checksum_key(krb5_context context,
313 krb5_crypto crypto,
314 unsigned usage, /* not krb5_key_usage */
315 struct _krb5_checksum_type *ct,
316 struct _krb5_key_data **key)
317 {
318 krb5_error_code ret = 0;
319
320 if(ct->flags & F_DERIVED)
321 ret = _get_derived_key(context, crypto, usage, key);
322 else if(ct->flags & F_VARIANT) {
323 size_t i;
324
325 *key = _new_derived_key(crypto, 0xff/* KRB5_KU_RFC1510_VARIANT */);
326 if (*key == NULL)
327 return krb5_enomem(context);
328 ret = krb5_copy_keyblock(context, crypto->key.key, &(*key)->key);
329 if(ret)
330 return ret;
331 for(i = 0; i < (*key)->key->keyvalue.length; i++)
332 ((unsigned char*)(*key)->key->keyvalue.data)[i] ^= 0xF0;
333 } else {
334 *key = &crypto->key;
335 }
336 if(ret == 0)
337 ret = _key_schedule(context, *key);
338 return ret;
339 }
340
341 static krb5_error_code
342 create_checksum (krb5_context context,
343 struct _krb5_checksum_type *ct,
344 krb5_crypto crypto,
345 unsigned usage,
346 void *data,
347 size_t len,
348 Checksum *result)
349 {
350 krb5_error_code ret;
351 struct _krb5_key_data *dkey;
352 int keyed_checksum;
353
354 if (ct->flags & F_DISABLED) {
355 krb5_clear_error_message (context);
356 return KRB5_PROG_SUMTYPE_NOSUPP;
357 }
358 keyed_checksum = (ct->flags & F_KEYED) != 0;
359 if(keyed_checksum && crypto == NULL) {
360 krb5_set_error_message (context, KRB5_PROG_SUMTYPE_NOSUPP,
361 N_("Checksum type %s is keyed but no "
362 "crypto context (key) was passed in", ""),
363 ct->name);
364 return KRB5_PROG_SUMTYPE_NOSUPP; /* XXX */
365 }
366 if(keyed_checksum) {
367 ret = get_checksum_key(context, crypto, usage, ct, &dkey);
368 if (ret)
369 return ret;
370 } else
371 dkey = NULL;
372 result->cksumtype = ct->type;
373 ret = krb5_data_alloc(&result->checksum, ct->checksumsize);
374 if (ret)
375 return (ret);
376 return (*ct->checksum)(context, dkey, data, len, usage, result);
377 }
378
379 static int
380 arcfour_checksum_p(struct _krb5_checksum_type *ct, krb5_crypto crypto)
381 {
382 return (ct->type == CKSUMTYPE_HMAC_MD5) &&
383 (crypto->key.key->keytype == KEYTYPE_ARCFOUR);
384 }
385
386 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
387 krb5_create_checksum(krb5_context context,
388 krb5_crypto crypto,
389 krb5_key_usage usage,
390 int type,
391 void *data,
392 size_t len,
393 Checksum *result)
394 {
395 struct _krb5_checksum_type *ct = NULL;
396 unsigned keyusage;
397
398 /* type 0 -> pick from crypto */
399 if (type) {
400 ct = _krb5_find_checksum(type);
401 } else if (crypto) {
402 ct = crypto->et->keyed_checksum;
403 if (ct == NULL)
404 ct = crypto->et->checksum;
405 }
406
407 if(ct == NULL) {
408 krb5_set_error_message (context, KRB5_PROG_SUMTYPE_NOSUPP,
409 N_("checksum type %d not supported", ""),
410 type);
411 return KRB5_PROG_SUMTYPE_NOSUPP;
412 }
413
414 if (arcfour_checksum_p(ct, crypto)) {
415 keyusage = usage;
416 _krb5_usage2arcfour(context, &keyusage);
417 } else
418 keyusage = CHECKSUM_USAGE(usage);
419
420 return create_checksum(context, ct, crypto, keyusage,
421 data, len, result);
422 }
423
424 static krb5_error_code
425 verify_checksum(krb5_context context,
426 krb5_crypto crypto,
427 unsigned usage, /* not krb5_key_usage */
428 void *data,
429 size_t len,
430 Checksum *cksum)
431 {
432 krb5_error_code ret;
433 struct _krb5_key_data *dkey;
434 int keyed_checksum;
435 Checksum c;
436 struct _krb5_checksum_type *ct;
437
438 ct = _krb5_find_checksum(cksum->cksumtype);
439 if (ct == NULL || (ct->flags & F_DISABLED)) {
440 krb5_set_error_message (context, KRB5_PROG_SUMTYPE_NOSUPP,
441 N_("checksum type %d not supported", ""),
442 cksum->cksumtype);
443 return KRB5_PROG_SUMTYPE_NOSUPP;
444 }
445 if(ct->checksumsize != cksum->checksum.length) {
446 krb5_clear_error_message (context);
447 krb5_set_error_message(context, KRB5KRB_AP_ERR_BAD_INTEGRITY,
448 N_("Decrypt integrity check failed for checksum type %s, "
449 "length was %u, expected %u", ""),
450 ct->name, (unsigned)cksum->checksum.length,
451 (unsigned)ct->checksumsize);
452
453 return KRB5KRB_AP_ERR_BAD_INTEGRITY; /* XXX */
454 }
455 keyed_checksum = (ct->flags & F_KEYED) != 0;
456 if(keyed_checksum) {
457 struct _krb5_checksum_type *kct;
458 if (crypto == NULL) {
459 krb5_set_error_message(context, KRB5_PROG_SUMTYPE_NOSUPP,
460 N_("Checksum type %s is keyed but no "
461 "crypto context (key) was passed in", ""),
462 ct->name);
463 return KRB5_PROG_SUMTYPE_NOSUPP; /* XXX */
464 }
465 kct = crypto->et->keyed_checksum;
466 if (kct == NULL || kct->type != ct->type) {
467 krb5_set_error_message(context, KRB5_PROG_SUMTYPE_NOSUPP,
468 N_("Checksum type %s is keyed, but "
469 "the key type %s passed didnt have that checksum "
470 "type as the keyed type", ""),
471 ct->name, crypto->et->name);
472 return KRB5_PROG_SUMTYPE_NOSUPP; /* XXX */
473 }
474
475 ret = get_checksum_key(context, crypto, usage, ct, &dkey);
476 if (ret)
477 return ret;
478 } else
479 dkey = NULL;
480
481 /*
482 * If checksum have a verify function, lets use that instead of
483 * calling ->checksum and then compare result.
484 */
485
486 if(ct->verify) {
487 ret = (*ct->verify)(context, dkey, data, len, usage, cksum);
488 if (ret)
489 krb5_set_error_message(context, ret,
490 N_("Decrypt integrity check failed for checksum "
491 "type %s, key type %s", ""),
492 ct->name, (crypto != NULL)? crypto->et->name : "(none)");
493 return ret;
494 }
495
496 ret = krb5_data_alloc (&c.checksum, ct->checksumsize);
497 if (ret)
498 return ret;
499
500 ret = (*ct->checksum)(context, dkey, data, len, usage, &c);
501 if (ret) {
502 krb5_data_free(&c.checksum);
503 return ret;
504 }
505
506 if(krb5_data_ct_cmp(&c.checksum, &cksum->checksum) != 0) {
507 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
508 krb5_set_error_message(context, ret,
509 N_("Decrypt integrity check failed for checksum "
510 "type %s, key type %s", ""),
511 ct->name, crypto ? crypto->et->name : "(unkeyed)");
512 } else {
513 ret = 0;
514 }
515 krb5_data_free (&c.checksum);
516 return ret;
517 }
518
519 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
520 krb5_verify_checksum(krb5_context context,
521 krb5_crypto crypto,
522 krb5_key_usage usage,
523 void *data,
524 size_t len,
525 Checksum *cksum)
526 {
527 struct _krb5_checksum_type *ct;
528 unsigned keyusage;
529
530 ct = _krb5_find_checksum(cksum->cksumtype);
531 if(ct == NULL) {
532 krb5_set_error_message (context, KRB5_PROG_SUMTYPE_NOSUPP,
533 N_("checksum type %d not supported", ""),
534 cksum->cksumtype);
535 return KRB5_PROG_SUMTYPE_NOSUPP;
536 }
537
538 if (arcfour_checksum_p(ct, crypto)) {
539 keyusage = usage;
540 _krb5_usage2arcfour(context, &keyusage);
541 } else
542 keyusage = CHECKSUM_USAGE(usage);
543
544 return verify_checksum(context, crypto, keyusage,
545 data, len, cksum);
546 }
547
548 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
549 krb5_crypto_get_checksum_type(krb5_context context,
550 krb5_crypto crypto,
551 krb5_cksumtype *type)
552 {
553 struct _krb5_checksum_type *ct = NULL;
554
555 if (crypto != NULL) {
556 ct = crypto->et->keyed_checksum;
557 if (ct == NULL)
558 ct = crypto->et->checksum;
559 }
560
561 if (ct == NULL) {
562 krb5_set_error_message (context, KRB5_PROG_SUMTYPE_NOSUPP,
563 N_("checksum type not found", ""));
564 return KRB5_PROG_SUMTYPE_NOSUPP;
565 }
566
567 *type = ct->type;
568
569 return 0;
570 }
571
572
573 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
574 krb5_checksumsize(krb5_context context,
575 krb5_cksumtype type,
576 size_t *size)
577 {
578 struct _krb5_checksum_type *ct = _krb5_find_checksum(type);
579 if(ct == NULL) {
580 krb5_set_error_message (context, KRB5_PROG_SUMTYPE_NOSUPP,
581 N_("checksum type %d not supported", ""),
582 type);
583 return KRB5_PROG_SUMTYPE_NOSUPP;
584 }
585 *size = ct->checksumsize;
586 return 0;
587 }
588
589 KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
590 krb5_checksum_is_keyed(krb5_context context,
591 krb5_cksumtype type)
592 {
593 struct _krb5_checksum_type *ct = _krb5_find_checksum(type);
594 if(ct == NULL) {
595 if (context)
596 krb5_set_error_message (context, KRB5_PROG_SUMTYPE_NOSUPP,
597 N_("checksum type %d not supported", ""),
598 type);
599 return KRB5_PROG_SUMTYPE_NOSUPP;
600 }
601 return ct->flags & F_KEYED;
602 }
603
604 KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
605 krb5_checksum_is_collision_proof(krb5_context context,
606 krb5_cksumtype type)
607 {
608 struct _krb5_checksum_type *ct = _krb5_find_checksum(type);
609 if(ct == NULL) {
610 if (context)
611 krb5_set_error_message (context, KRB5_PROG_SUMTYPE_NOSUPP,
612 N_("checksum type %d not supported", ""),
613 type);
614 return KRB5_PROG_SUMTYPE_NOSUPP;
615 }
616 return ct->flags & F_CPROOF;
617 }
618
619 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
620 krb5_checksum_disable(krb5_context context,
621 krb5_cksumtype type)
622 {
623 struct _krb5_checksum_type *ct = _krb5_find_checksum(type);
624 if(ct == NULL) {
625 if (context)
626 krb5_set_error_message (context, KRB5_PROG_SUMTYPE_NOSUPP,
627 N_("checksum type %d not supported", ""),
628 type);
629 return KRB5_PROG_SUMTYPE_NOSUPP;
630 }
631 ct->flags |= F_DISABLED;
632 return 0;
633 }
634
635 /************************************************************
636 * *
637 ************************************************************/
638
639 KRB5_LIB_FUNCTION struct _krb5_encryption_type * KRB5_LIB_CALL
640 _krb5_find_enctype(krb5_enctype type)
641 {
642 int i;
643 for(i = 0; i < _krb5_num_etypes; i++)
644 if(_krb5_etypes[i]->type == type)
645 return _krb5_etypes[i];
646 return NULL;
647 }
648
649
650 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
651 krb5_enctype_to_string(krb5_context context,
652 krb5_enctype etype,
653 char **string)
654 {
655 struct _krb5_encryption_type *e;
656 e = _krb5_find_enctype(etype);
657 if(e == NULL) {
658 krb5_set_error_message (context, KRB5_PROG_ETYPE_NOSUPP,
659 N_("encryption type %d not supported", ""),
660 etype);
661 *string = NULL;
662 return KRB5_PROG_ETYPE_NOSUPP;
663 }
664 *string = strdup(e->name);
665 if (*string == NULL)
666 return krb5_enomem(context);
667 return 0;
668 }
669
670 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
671 krb5_string_to_enctype(krb5_context context,
672 const char *string,
673 krb5_enctype *etype)
674 {
675 int i;
676 for(i = 0; i < _krb5_num_etypes; i++) {
677 if(strcasecmp(_krb5_etypes[i]->name, string) == 0){
678 *etype = _krb5_etypes[i]->type;
679 return 0;
680 }
681 if(_krb5_etypes[i]->alias != NULL &&
682 strcasecmp(_krb5_etypes[i]->alias, string) == 0){
683 *etype = _krb5_etypes[i]->type;
684 return 0;
685 }
686 }
687 krb5_set_error_message (context, KRB5_PROG_ETYPE_NOSUPP,
688 N_("encryption type %s not supported", ""),
689 string);
690 return KRB5_PROG_ETYPE_NOSUPP;
691 }
692
693 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
694 krb5_enctype_to_keytype(krb5_context context,
695 krb5_enctype etype,
696 krb5_keytype *keytype)
697 {
698 struct _krb5_encryption_type *e = _krb5_find_enctype(etype);
699 if(e == NULL) {
700 return unsupported_enctype (context, etype);
701 }
702 *keytype = e->keytype->type; /* XXX */
703 return 0;
704 }
705
706 /**
707 * Check if a enctype is valid, return 0 if it is.
708 *
709 * @param context Kerberos context
710 * @param etype enctype to check if its valid or not
711 *
712 * @return Return an error code for an failure or 0 on success (enctype valid).
713 * @ingroup krb5_crypto
714 */
715
716 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
717 krb5_enctype_valid(krb5_context context,
718 krb5_enctype etype)
719 {
720 struct _krb5_encryption_type *e = _krb5_find_enctype(etype);
721 if(e && (e->flags & F_DISABLED) == 0)
722 return 0;
723 if (context == NULL)
724 return KRB5_PROG_ETYPE_NOSUPP;
725 if(e == NULL) {
726 return unsupported_enctype (context, etype);
727 }
728 /* Must be (e->flags & F_DISABLED) */
729 krb5_set_error_message (context, KRB5_PROG_ETYPE_NOSUPP,
730 N_("encryption type %s is disabled", ""),
731 e->name);
732 return KRB5_PROG_ETYPE_NOSUPP;
733 }
734
735 /**
736 * Return the coresponding encryption type for a checksum type.
737 *
738 * @param context Kerberos context
739 * @param ctype The checksum type to get the result enctype for
740 * @param etype The returned encryption, when the matching etype is
741 * not found, etype is set to ETYPE_NULL.
742 *
743 * @return Return an error code for an failure or 0 on success.
744 * @ingroup krb5_crypto
745 */
746
747
748 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
749 krb5_cksumtype_to_enctype(krb5_context context,
750 krb5_cksumtype ctype,
751 krb5_enctype *etype)
752 {
753 int i;
754
755 *etype = ETYPE_NULL;
756
757 for(i = 0; i < _krb5_num_etypes; i++) {
758 if(_krb5_etypes[i]->keyed_checksum &&
759 _krb5_etypes[i]->keyed_checksum->type == ctype)
760 {
761 *etype = _krb5_etypes[i]->type;
762 return 0;
763 }
764 }
765
766 krb5_set_error_message (context, KRB5_PROG_SUMTYPE_NOSUPP,
767 N_("checksum type %d not supported", ""),
768 (int)ctype);
769 return KRB5_PROG_SUMTYPE_NOSUPP;
770 }
771
772
773 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
774 krb5_cksumtype_valid(krb5_context context,
775 krb5_cksumtype ctype)
776 {
777 struct _krb5_checksum_type *c = _krb5_find_checksum(ctype);
778 if (c == NULL) {
779 krb5_set_error_message (context, KRB5_PROG_SUMTYPE_NOSUPP,
780 N_("checksum type %d not supported", ""),
781 ctype);
782 return KRB5_PROG_SUMTYPE_NOSUPP;
783 }
784 if (c->flags & F_DISABLED) {
785 krb5_set_error_message (context, KRB5_PROG_SUMTYPE_NOSUPP,
786 N_("checksum type %s is disabled", ""),
787 c->name);
788 return KRB5_PROG_SUMTYPE_NOSUPP;
789 }
790 return 0;
791 }
792
793 static krb5_boolean
794 derived_crypto(krb5_context context,
795 krb5_crypto crypto)
796 {
797 return (crypto->et->flags & F_DERIVED) != 0;
798 }
799
800 #define CHECKSUMSIZE(C) ((C)->checksumsize)
801 #define CHECKSUMTYPE(C) ((C)->type)
802
803 static krb5_error_code
804 encrypt_internal_derived(krb5_context context,
805 krb5_crypto crypto,
806 unsigned usage,
807 const void *data,
808 size_t len,
809 krb5_data *result,
810 void *ivec)
811 {
812 size_t sz, block_sz, checksum_sz, total_sz;
813 Checksum cksum;
814 unsigned char *p, *q;
815 krb5_error_code ret;
816 struct _krb5_key_data *dkey;
817 const struct _krb5_encryption_type *et = crypto->et;
818
819 checksum_sz = CHECKSUMSIZE(et->keyed_checksum);
820
821 sz = et->confoundersize + len;
822 block_sz = (sz + et->padsize - 1) &~ (et->padsize - 1); /* pad */
823 total_sz = block_sz + checksum_sz;
824 p = calloc(1, total_sz);
825 if (p == NULL)
826 return krb5_enomem(context);
827
828 q = p;
829 krb5_generate_random_block(q, et->confoundersize); /* XXX */
830 q += et->confoundersize;
831 memcpy(q, data, len);
832
833 ret = create_checksum(context,
834 et->keyed_checksum,
835 crypto,
836 INTEGRITY_USAGE(usage),
837 p,
838 block_sz,
839 &cksum);
840 if(ret == 0 && cksum.checksum.length != checksum_sz) {
841 free_Checksum (&cksum);
842 krb5_clear_error_message (context);
843 ret = KRB5_CRYPTO_INTERNAL;
844 }
845 if(ret)
846 goto fail;
847 memcpy(p + block_sz, cksum.checksum.data, cksum.checksum.length);
848 free_Checksum (&cksum);
849 ret = _get_derived_key(context, crypto, ENCRYPTION_USAGE(usage), &dkey);
850 if(ret)
851 goto fail;
852 ret = _key_schedule(context, dkey);
853 if(ret)
854 goto fail;
855 ret = (*et->encrypt)(context, dkey, p, block_sz, 1, usage, ivec);
856 if (ret)
857 goto fail;
858 result->data = p;
859 result->length = total_sz;
860 return 0;
861 fail:
862 memset(p, 0, total_sz);
863 free(p);
864 return ret;
865 }
866
867 static krb5_error_code
868 encrypt_internal_enc_then_cksum(krb5_context context,
869 krb5_crypto crypto,
870 unsigned usage,
871 const void *data,
872 size_t len,
873 krb5_data *result,
874 void *ivec)
875 {
876 size_t sz, block_sz, checksum_sz, total_sz;
877 Checksum cksum;
878 unsigned char *p, *q, *ivc = NULL;
879 krb5_error_code ret;
880 struct _krb5_key_data *dkey;
881 const struct _krb5_encryption_type *et = crypto->et;
882
883 checksum_sz = CHECKSUMSIZE(et->keyed_checksum);
884
885 sz = et->confoundersize + len;
886 block_sz = (sz + et->padsize - 1) &~ (et->padsize - 1); /* pad */
887 total_sz = block_sz + checksum_sz;
888 p = calloc(1, total_sz);
889 if (p == NULL)
890 return krb5_enomem(context);
891
892 q = p;
893 krb5_generate_random_block(q, et->confoundersize); /* XXX */
894 q += et->confoundersize;
895 memcpy(q, data, len);
896
897 ret = _get_derived_key(context, crypto, ENCRYPTION_USAGE(usage), &dkey);
898 if(ret)
899 goto fail;
900 ret = _key_schedule(context, dkey);
901 if(ret)
902 goto fail;
903
904 /* XXX EVP style update API would avoid needing to allocate here */
905 ivc = malloc(et->blocksize + block_sz);
906 if (ivc == NULL) {
907 ret = krb5_enomem(context);
908 goto fail;
909 }
910 if (ivec)
911 memcpy(ivc, ivec, et->blocksize);
912 else
913 memset(ivc, 0, et->blocksize);
914
915 ret = (*et->encrypt)(context, dkey, p, block_sz, 1, usage, ivec);
916 if (ret)
917 goto fail;
918 memcpy(&ivc[et->blocksize], p, block_sz);
919
920 ret = create_checksum(context,
921 et->keyed_checksum,
922 crypto,
923 INTEGRITY_USAGE(usage),
924 ivc,
925 et->blocksize + block_sz,
926 &cksum);
927 if(ret == 0 && cksum.checksum.length != checksum_sz) {
928 free_Checksum (&cksum);
929 krb5_clear_error_message (context);
930 ret = KRB5_CRYPTO_INTERNAL;
931 }
932 if(ret)
933 goto fail;
934 memcpy(p + block_sz, cksum.checksum.data, cksum.checksum.length);
935 free_Checksum (&cksum);
936 result->data = p;
937 result->length = total_sz;
938 free(ivc);
939 return 0;
940 fail:
941 memset_s(p, total_sz, 0, total_sz);
942 free(p);
943 free(ivc);
944 return ret;
945 }
946
947 static krb5_error_code
948 encrypt_internal(krb5_context context,
949 krb5_crypto crypto,
950 const void *data,
951 size_t len,
952 krb5_data *result,
953 void *ivec)
954 {
955 size_t sz, block_sz, checksum_sz;
956 Checksum cksum;
957 unsigned char *p, *q;
958 krb5_error_code ret;
959 const struct _krb5_encryption_type *et = crypto->et;
960
961 checksum_sz = CHECKSUMSIZE(et->checksum);
962
963 sz = et->confoundersize + checksum_sz + len;
964 block_sz = (sz + et->padsize - 1) &~ (et->padsize - 1); /* pad */
965 p = calloc(1, block_sz);
966 if (p == NULL)
967 return krb5_enomem(context);
968
969 q = p;
970 krb5_generate_random_block(q, et->confoundersize); /* XXX */
971 q += et->confoundersize;
972 memset(q, 0, checksum_sz);
973 q += checksum_sz;
974 memcpy(q, data, len);
975
976 ret = create_checksum(context,
977 et->checksum,
978 crypto,
979 0,
980 p,
981 block_sz,
982 &cksum);
983 if(ret == 0 && cksum.checksum.length != checksum_sz) {
984 krb5_clear_error_message (context);
985 free_Checksum(&cksum);
986 ret = KRB5_CRYPTO_INTERNAL;
987 }
988 if(ret)
989 goto fail;
990 memcpy(p + et->confoundersize, cksum.checksum.data, cksum.checksum.length);
991 free_Checksum(&cksum);
992 ret = _key_schedule(context, &crypto->key);
993 if(ret)
994 goto fail;
995 ret = (*et->encrypt)(context, &crypto->key, p, block_sz, 1, 0, ivec);
996 if (ret) {
997 memset(p, 0, block_sz);
998 free(p);
999 return ret;
1000 }
1001 result->data = p;
1002 result->length = block_sz;
1003 return 0;
1004 fail:
1005 memset(p, 0, block_sz);
1006 free(p);
1007 return ret;
1008 }
1009
1010 static krb5_error_code
1011 encrypt_internal_special(krb5_context context,
1012 krb5_crypto crypto,
1013 int usage,
1014 const void *data,
1015 size_t len,
1016 krb5_data *result,
1017 void *ivec)
1018 {
1019 struct _krb5_encryption_type *et = crypto->et;
1020 size_t cksum_sz = CHECKSUMSIZE(et->checksum);
1021 size_t sz = len + cksum_sz + et->confoundersize;
1022 char *tmp, *p;
1023 krb5_error_code ret;
1024
1025 tmp = malloc (sz);
1026 if (tmp == NULL)
1027 return krb5_enomem(context);
1028 p = tmp;
1029 memset (p, 0, cksum_sz);
1030 p += cksum_sz;
1031 krb5_generate_random_block(p, et->confoundersize);
1032 p += et->confoundersize;
1033 memcpy (p, data, len);
1034 ret = (*et->encrypt)(context, &crypto->key, tmp, sz, TRUE, usage, ivec);
1035 if (ret) {
1036 memset(tmp, 0, sz);
1037 free(tmp);
1038 return ret;
1039 }
1040 result->data = tmp;
1041 result->length = sz;
1042 return 0;
1043 }
1044
1045 static krb5_error_code
1046 decrypt_internal_derived(krb5_context context,
1047 krb5_crypto crypto,
1048 unsigned usage,
1049 void *data,
1050 size_t len,
1051 krb5_data *result,
1052 void *ivec)
1053 {
1054 size_t checksum_sz;
1055 Checksum cksum;
1056 unsigned char *p;
1057 krb5_error_code ret;
1058 struct _krb5_key_data *dkey;
1059 struct _krb5_encryption_type *et = crypto->et;
1060 unsigned long l;
1061
1062 checksum_sz = CHECKSUMSIZE(et->keyed_checksum);
1063 if (len < checksum_sz + et->confoundersize) {
1064 krb5_set_error_message(context, KRB5_BAD_MSIZE,
1065 N_("Encrypted data shorter then "
1066 "checksum + confunder", ""));
1067 return KRB5_BAD_MSIZE;
1068 }
1069
1070 if (((len - checksum_sz) % et->padsize) != 0) {
1071 krb5_clear_error_message(context);
1072 return KRB5_BAD_MSIZE;
1073 }
1074
1075 p = malloc(len);
1076 if (len != 0 && p == NULL)
1077 return krb5_enomem(context);
1078 memcpy(p, data, len);
1079
1080 len -= checksum_sz;
1081
1082 ret = _get_derived_key(context, crypto, ENCRYPTION_USAGE(usage), &dkey);
1083 if(ret) {
1084 free(p);
1085 return ret;
1086 }
1087 ret = _key_schedule(context, dkey);
1088 if(ret) {
1089 free(p);
1090 return ret;
1091 }
1092 ret = (*et->encrypt)(context, dkey, p, len, 0, usage, ivec);
1093 if (ret) {
1094 free(p);
1095 return ret;
1096 }
1097
1098 cksum.checksum.data = p + len;
1099 cksum.checksum.length = checksum_sz;
1100 cksum.cksumtype = CHECKSUMTYPE(et->keyed_checksum);
1101
1102 ret = verify_checksum(context,
1103 crypto,
1104 INTEGRITY_USAGE(usage),
1105 p,
1106 len,
1107 &cksum);
1108 if(ret) {
1109 free(p);
1110 return ret;
1111 }
1112 l = len - et->confoundersize;
1113 memmove(p, p + et->confoundersize, l);
1114 result->data = realloc(p, l);
1115 if(result->data == NULL && l != 0) {
1116 free(p);
1117 return krb5_enomem(context);
1118 }
1119 result->length = l;
1120 return 0;
1121 }
1122
1123 static krb5_error_code
1124 decrypt_internal_enc_then_cksum(krb5_context context,
1125 krb5_crypto crypto,
1126 unsigned usage,
1127 void *data,
1128 size_t len,
1129 krb5_data *result,
1130 void *ivec)
1131 {
1132 size_t checksum_sz;
1133 Checksum cksum;
1134 unsigned char *p;
1135 krb5_error_code ret;
1136 struct _krb5_key_data *dkey;
1137 struct _krb5_encryption_type *et = crypto->et;
1138 unsigned long l;
1139
1140 checksum_sz = CHECKSUMSIZE(et->keyed_checksum);
1141 if (len < checksum_sz + et->confoundersize) {
1142 krb5_set_error_message(context, KRB5_BAD_MSIZE,
1143 N_("Encrypted data shorter then "
1144 "checksum + confunder", ""));
1145 return KRB5_BAD_MSIZE;
1146 }
1147
1148 if (((len - checksum_sz) % et->padsize) != 0) {
1149 krb5_clear_error_message(context);
1150 return KRB5_BAD_MSIZE;
1151 }
1152
1153 len -= checksum_sz;
1154
1155 p = malloc(et->blocksize + len);
1156 if (p == NULL)
1157 return krb5_enomem(context);
1158
1159 if (ivec)
1160 memcpy(p, ivec, et->blocksize);
1161 else
1162 memset(p, 0, et->blocksize);
1163 memcpy(&p[et->blocksize], data, len);
1164
1165 cksum.checksum.data = (unsigned char *)data + len;
1166 cksum.checksum.length = checksum_sz;
1167 cksum.cksumtype = CHECKSUMTYPE(et->keyed_checksum);
1168
1169 ret = verify_checksum(context,
1170 crypto,
1171 INTEGRITY_USAGE(usage),
1172 p,
1173 et->blocksize + len,
1174 &cksum);
1175 if(ret) {
1176 free(p);
1177 return ret;
1178 }
1179
1180 ret = _get_derived_key(context, crypto, ENCRYPTION_USAGE(usage), &dkey);
1181 if(ret) {
1182 free(p);
1183 return ret;
1184 }
1185 ret = _key_schedule(context, dkey);
1186 if(ret) {
1187 free(p);
1188 return ret;
1189 }
1190 ret = (*et->encrypt)(context, dkey, &p[et->blocksize], len, 0, usage, ivec);
1191 if (ret) {
1192 free(p);
1193 return ret;
1194 }
1195
1196 l = len - et->confoundersize;
1197 memmove(p, p + et->blocksize + et->confoundersize, l);
1198 result->data = realloc(p, l);
1199 if(result->data == NULL && l != 0) {
1200 free(p);
1201 return krb5_enomem(context);
1202 }
1203 result->length = l;
1204 return 0;
1205 }
1206
1207 static krb5_error_code
1208 decrypt_internal(krb5_context context,
1209 krb5_crypto crypto,
1210 void *data,
1211 size_t len,
1212 krb5_data *result,
1213 void *ivec)
1214 {
1215 krb5_error_code ret;
1216 unsigned char *p;
1217 Checksum cksum;
1218 size_t checksum_sz, l;
1219 struct _krb5_encryption_type *et = crypto->et;
1220
1221 if ((len % et->padsize) != 0) {
1222 krb5_clear_error_message(context);
1223 return KRB5_BAD_MSIZE;
1224 }
1225 checksum_sz = CHECKSUMSIZE(et->checksum);
1226 if (len < checksum_sz + et->confoundersize) {
1227 krb5_set_error_message(context, KRB5_BAD_MSIZE,
1228 N_("Encrypted data shorter then "
1229 "checksum + confunder", ""));
1230 return KRB5_BAD_MSIZE;
1231 }
1232
1233 p = malloc(len);
1234 if (len != 0 && p == NULL)
1235 return krb5_enomem(context);
1236 memcpy(p, data, len);
1237
1238 ret = _key_schedule(context, &crypto->key);
1239 if(ret) {
1240 free(p);
1241 return ret;
1242 }
1243 ret = (*et->encrypt)(context, &crypto->key, p, len, 0, 0, ivec);
1244 if (ret) {
1245 free(p);
1246 return ret;
1247 }
1248 ret = krb5_data_copy(&cksum.checksum, p + et->confoundersize, checksum_sz);
1249 if(ret) {
1250 free(p);
1251 return ret;
1252 }
1253 memset(p + et->confoundersize, 0, checksum_sz);
1254 cksum.cksumtype = CHECKSUMTYPE(et->checksum);
1255 ret = verify_checksum(context, NULL, 0, p, len, &cksum);
1256 free_Checksum(&cksum);
1257 if(ret) {
1258 free(p);
1259 return ret;
1260 }
1261 l = len - et->confoundersize - checksum_sz;
1262 memmove(p, p + et->confoundersize + checksum_sz, l);
1263 result->data = realloc(p, l);
1264 if(result->data == NULL && l != 0) {
1265 free(p);
1266 return krb5_enomem(context);
1267 }
1268 result->length = l;
1269 return 0;
1270 }
1271
1272 static krb5_error_code
1273 decrypt_internal_special(krb5_context context,
1274 krb5_crypto crypto,
1275 int usage,
1276 void *data,
1277 size_t len,
1278 krb5_data *result,
1279 void *ivec)
1280 {
1281 struct _krb5_encryption_type *et = crypto->et;
1282 size_t cksum_sz = CHECKSUMSIZE(et->checksum);
1283 size_t sz = len - cksum_sz - et->confoundersize;
1284 unsigned char *p;
1285 krb5_error_code ret;
1286
1287 if ((len % et->padsize) != 0) {
1288 krb5_clear_error_message(context);
1289 return KRB5_BAD_MSIZE;
1290 }
1291 if (len < cksum_sz + et->confoundersize) {
1292 krb5_set_error_message(context, KRB5_BAD_MSIZE,
1293 N_("Encrypted data shorter then "
1294 "checksum + confunder", ""));
1295 return KRB5_BAD_MSIZE;
1296 }
1297
1298 p = malloc (len);
1299 if (p == NULL)
1300 return krb5_enomem(context);
1301 memcpy(p, data, len);
1302
1303 ret = (*et->encrypt)(context, &crypto->key, p, len, FALSE, usage, ivec);
1304 if (ret) {
1305 free(p);
1306 return ret;
1307 }
1308
1309 memmove (p, p + cksum_sz + et->confoundersize, sz);
1310 result->data = realloc(p, sz);
1311 if(result->data == NULL && sz != 0) {
1312 free(p);
1313 return krb5_enomem(context);
1314 }
1315 result->length = sz;
1316 return 0;
1317 }
1318
1319 static krb5_crypto_iov *
1320 iov_find(krb5_crypto_iov *data, size_t num_data, unsigned type)
1321 {
1322 size_t i;
1323 for (i = 0; i < num_data; i++)
1324 if (data[i].flags == type)
1325 return &data[i];
1326 return NULL;
1327 }
1328
1329 static size_t
1330 iov_enc_data_len(krb5_crypto_iov *data, int num_data)
1331 {
1332 size_t i, len;
1333
1334 for (len = 0, i = 0; i < num_data; i++) {
1335 if (data[i].flags != KRB5_CRYPTO_TYPE_DATA)
1336 continue;
1337 len += data[i].data.length;
1338 }
1339
1340 return len;
1341 }
1342
1343 static size_t
1344 iov_sign_data_len(krb5_crypto_iov *data, int num_data)
1345 {
1346 size_t i, len;
1347
1348 for (len = 0, i = 0; i < num_data; i++) {
1349 if (data[i].flags != KRB5_CRYPTO_TYPE_DATA &&
1350 data[i].flags != KRB5_CRYPTO_TYPE_SIGN_ONLY)
1351 continue;
1352 len += data[i].data.length;
1353 }
1354
1355 return len;
1356 }
1357
1358 static krb5_error_code
1359 iov_coalesce(krb5_context context,
1360 krb5_data *prefix,
1361 krb5_crypto_iov *data,
1362 int num_data,
1363 krb5_boolean inc_sign_data,
1364 krb5_data *out)
1365 {
1366 unsigned char *p, *q;
1367 krb5_crypto_iov *hiv, *piv;
1368 size_t len;
1369 unsigned int i;
1370
1371 hiv = iov_find(data, num_data, KRB5_CRYPTO_TYPE_HEADER);
1372
1373 piv = iov_find(data, num_data, KRB5_CRYPTO_TYPE_PADDING);
1374
1375 len = 0;
1376 if (prefix)
1377 len += prefix->length;
1378 len += hiv->data.length;
1379 if (inc_sign_data)
1380 len += iov_sign_data_len(data, num_data);
1381 else
1382 len += iov_enc_data_len(data, num_data);
1383 if (piv)
1384 len += piv->data.length;
1385
1386 p = q = malloc(len);
1387 if (p == NULL)
1388 return krb5_enomem(context);
1389
1390 if (prefix) {
1391 memcpy(q, prefix->data, prefix->length);
1392 q += prefix->length;
1393 }
1394 memcpy(q, hiv->data.data, hiv->data.length);
1395 q += hiv->data.length;
1396 for (i = 0; i < num_data; i++) {
1397 if (data[i].flags == KRB5_CRYPTO_TYPE_DATA ||
1398 (inc_sign_data && data[i].flags == KRB5_CRYPTO_TYPE_SIGN_ONLY)) {
1399 memcpy(q, data[i].data.data, data[i].data.length);
1400 q += data[i].data.length;
1401 }
1402 }
1403 if (piv)
1404 memset(q, 0, piv->data.length);
1405
1406 out->length = len;
1407 out->data = p;
1408
1409 return 0;
1410 }
1411
1412 static krb5_error_code
1413 iov_uncoalesce(krb5_context context,
1414 krb5_data *enc_data,
1415 krb5_crypto_iov *data,
1416 int num_data)
1417 {
1418 unsigned char *q = enc_data->data;
1419 krb5_crypto_iov *hiv, *piv;
1420 unsigned int i;
1421
1422 hiv = iov_find(data, num_data, KRB5_CRYPTO_TYPE_HEADER);
1423
1424 piv = iov_find(data, num_data, KRB5_CRYPTO_TYPE_PADDING);
1425
1426 memcpy(hiv->data.data, q, hiv->data.length);
1427 q += hiv->data.length;
1428
1429 for (i = 0; i < num_data; i++) {
1430 if (data[i].flags != KRB5_CRYPTO_TYPE_DATA)
1431 continue;
1432 memcpy(data[i].data.data, q, data[i].data.length);
1433 q += data[i].data.length;
1434 }
1435 if (piv)
1436 memcpy(piv->data.data, q, piv->data.length);
1437
1438 return 0;
1439 }
1440
1441 static krb5_error_code
1442 iov_pad_validate(const struct _krb5_encryption_type *et,
1443 krb5_crypto_iov *data,
1444 int num_data,
1445 krb5_crypto_iov **ppiv)
1446 {
1447 krb5_crypto_iov *piv;
1448 size_t sz, headersz, block_sz, pad_sz, len;
1449
1450 len = iov_enc_data_len(data, num_data);
1451
1452 headersz = et->confoundersize;
1453
1454 sz = headersz + len;
1455 block_sz = (sz + et->padsize - 1) &~ (et->padsize - 1); /* pad */
1456
1457 pad_sz = block_sz - sz;
1458
1459 piv = iov_find(data, num_data, KRB5_CRYPTO_TYPE_PADDING);
1460 /* its ok to have no TYPE_PADDING if there is no padding */
1461 if (piv == NULL && pad_sz != 0)
1462 return KRB5_BAD_MSIZE;
1463 if (piv) {
1464 if (piv->data.length < pad_sz)
1465 return KRB5_BAD_MSIZE;
1466 piv->data.length = pad_sz;
1467 if (pad_sz)
1468 memset(piv->data.data, pad_sz, pad_sz);
1469 else
1470 piv = NULL;
1471 }
1472
1473 *ppiv = piv;
1474 return 0;
1475 }
1476
1477 /**
1478 * Inline encrypt a kerberos message
1479 *
1480 * @param context Kerberos context
1481 * @param crypto Kerberos crypto context
1482 * @param usage Key usage for this buffer
1483 * @param data array of buffers to process
1484 * @param num_data length of array
1485 * @param ivec initial cbc/cts vector
1486 *
1487 * @return Return an error code or 0.
1488 * @ingroup krb5_crypto
1489 *
1490 * Kerberos encrypted data look like this:
1491 *
1492 * 1. KRB5_CRYPTO_TYPE_HEADER
1493 * 2. array [1,...] KRB5_CRYPTO_TYPE_DATA and array [0,...]
1494 * KRB5_CRYPTO_TYPE_SIGN_ONLY in any order, however the receiver
1495 * have to aware of the order. KRB5_CRYPTO_TYPE_SIGN_ONLY is
1496 * commonly used headers and trailers.
1497 * 3. KRB5_CRYPTO_TYPE_PADDING, at least on padsize long if padsize > 1
1498 * 4. KRB5_CRYPTO_TYPE_TRAILER
1499 */
1500
1501 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1502 krb5_encrypt_iov_ivec(krb5_context context,
1503 krb5_crypto crypto,
1504 unsigned usage,
1505 krb5_crypto_iov *data,
1506 int num_data,
1507 void *ivec)
1508 {
1509 size_t headersz, trailersz;
1510 Checksum cksum;
1511 krb5_data enc_data, sign_data;
1512 krb5_error_code ret;
1513 struct _krb5_key_data *dkey;
1514 const struct _krb5_encryption_type *et = crypto->et;
1515 krb5_crypto_iov *tiv, *piv, *hiv;
1516
1517 if (num_data < 0) {
1518 krb5_clear_error_message(context);
1519 return KRB5_CRYPTO_INTERNAL;
1520 }
1521
1522 if(!derived_crypto(context, crypto)) {
1523 krb5_clear_error_message(context);
1524 return KRB5_CRYPTO_INTERNAL;
1525 }
1526
1527 krb5_data_zero(&enc_data);
1528 krb5_data_zero(&sign_data);
1529
1530 headersz = et->confoundersize;
1531 trailersz = CHECKSUMSIZE(et->keyed_checksum);
1532
1533 /* header */
1534 hiv = iov_find(data, num_data, KRB5_CRYPTO_TYPE_HEADER);
1535 if (hiv == NULL || hiv->data.length != headersz)
1536 return KRB5_BAD_MSIZE;
1537 krb5_generate_random_block(hiv->data.data, hiv->data.length);
1538
1539 /* padding */
1540 ret = iov_pad_validate(et, data, num_data, &piv);
1541 if(ret)
1542 goto cleanup;
1543
1544 /* trailer */
1545 tiv = iov_find(data, num_data, KRB5_CRYPTO_TYPE_TRAILER);
1546 if (tiv == NULL || tiv->data.length != trailersz) {
1547 ret = KRB5_BAD_MSIZE;
1548 goto cleanup;
1549 }
1550
1551 if (et->flags & F_ENC_THEN_CKSUM) {
1552 unsigned char old_ivec[EVP_MAX_IV_LENGTH];
1553 krb5_data ivec_data;
1554
1555 ret = iov_coalesce(context, NULL, data, num_data, FALSE, &enc_data);
1556 if(ret)
1557 goto cleanup;
1558
1559 ret = _get_derived_key(context, crypto, ENCRYPTION_USAGE(usage), &dkey);
1560 if(ret)
1561 goto cleanup;
1562
1563 ret = _key_schedule(context, dkey);
1564 if(ret)
1565 goto cleanup;
1566
1567 heim_assert(et->blocksize <= sizeof(old_ivec),
1568 "blocksize too big for ivec buffer");
1569
1570 if (ivec)
1571 memcpy(old_ivec, ivec, et->blocksize);
1572 else
1573 memset(old_ivec, 0, et->blocksize);
1574
1575 ret = (*et->encrypt)(context, dkey, enc_data.data, enc_data.length,
1576 1, usage, ivec);
1577 if(ret)
1578 goto cleanup;
1579
1580 ret = iov_uncoalesce(context, &enc_data, data, num_data);
1581 if(ret)
1582 goto cleanup;
1583
1584 ivec_data.length = et->blocksize;
1585 ivec_data.data = old_ivec;
1586
1587 ret = iov_coalesce(context, &ivec_data, data, num_data, TRUE, &sign_data);
1588 if(ret)
1589 goto cleanup;
1590 } else {
1591 ret = iov_coalesce(context, NULL, data, num_data, TRUE, &sign_data);
1592 if(ret)
1593 goto cleanup;
1594 }
1595
1596 ret = create_checksum(context,
1597 et->keyed_checksum,
1598 crypto,
1599 INTEGRITY_USAGE(usage),
1600 sign_data.data,
1601 sign_data.length,
1602 &cksum);
1603 if(ret == 0 && cksum.checksum.length != trailersz) {
1604 free_Checksum (&cksum);
1605 krb5_clear_error_message (context);
1606 ret = KRB5_CRYPTO_INTERNAL;
1607 }
1608 if(ret)
1609 goto cleanup;
1610
1611 /* save cksum at end */
1612 memcpy(tiv->data.data, cksum.checksum.data, cksum.checksum.length);
1613 free_Checksum (&cksum);
1614
1615 if (!(et->flags & F_ENC_THEN_CKSUM)) {
1616 ret = iov_coalesce(context, NULL, data, num_data, FALSE, &enc_data);
1617 if(ret)
1618 goto cleanup;
1619
1620 ret = _get_derived_key(context, crypto, ENCRYPTION_USAGE(usage), &dkey);
1621 if(ret)
1622 goto cleanup;
1623
1624 ret = _key_schedule(context, dkey);
1625 if(ret)
1626 goto cleanup;
1627
1628 ret = (*et->encrypt)(context, dkey, enc_data.data, enc_data.length,
1629 1, usage, ivec);
1630 if(ret)
1631 goto cleanup;
1632
1633 ret = iov_uncoalesce(context, &enc_data, data, num_data);
1634 if(ret)
1635 goto cleanup;
1636 }
1637
1638 cleanup:
1639 if (enc_data.data) {
1640 memset_s(enc_data.data, enc_data.length, 0, enc_data.length);
1641 krb5_data_free(&enc_data);
1642 }
1643 if (sign_data.data) {
1644 memset_s(sign_data.data, sign_data.length, 0, sign_data.length);
1645 krb5_data_free(&sign_data);
1646 }
1647 return ret;
1648 }
1649
1650 /**
1651 * Inline decrypt a Kerberos message.
1652 *
1653 * @param context Kerberos context
1654 * @param crypto Kerberos crypto context
1655 * @param usage Key usage for this buffer
1656 * @param data array of buffers to process
1657 * @param num_data length of array
1658 * @param ivec initial cbc/cts vector
1659 *
1660 * @return Return an error code or 0.
1661 * @ingroup krb5_crypto
1662 *
1663 * 1. KRB5_CRYPTO_TYPE_HEADER
1664 * 2. one KRB5_CRYPTO_TYPE_DATA and array [0,...] of KRB5_CRYPTO_TYPE_SIGN_ONLY in
1665 * any order, however the receiver have to aware of the
1666 * order. KRB5_CRYPTO_TYPE_SIGN_ONLY is commonly used unencrypoted
1667 * protocol headers and trailers. The output data will be of same
1668 * size as the input data or shorter.
1669 */
1670
1671 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1672 krb5_decrypt_iov_ivec(krb5_context context,
1673 krb5_crypto crypto,
1674 unsigned usage,
1675 krb5_crypto_iov *data,
1676 unsigned int num_data,
1677 void *ivec)
1678 {
1679 Checksum cksum;
1680 krb5_data enc_data, sign_data;
1681 krb5_error_code ret;
1682 struct _krb5_key_data *dkey;
1683 struct _krb5_encryption_type *et = crypto->et;
1684 krb5_crypto_iov *tiv, *hiv;
1685
1686 if(!derived_crypto(context, crypto)) {
1687 krb5_clear_error_message(context);
1688 return KRB5_CRYPTO_INTERNAL;
1689 }
1690
1691 /* header */
1692 hiv = iov_find(data, num_data, KRB5_CRYPTO_TYPE_HEADER);
1693 if (hiv == NULL || hiv->data.length != et->confoundersize)
1694 return KRB5_BAD_MSIZE;
1695
1696 /* trailer */
1697 tiv = iov_find(data, num_data, KRB5_CRYPTO_TYPE_TRAILER);
1698 if (tiv->data.length != CHECKSUMSIZE(et->keyed_checksum))
1699 return KRB5_BAD_MSIZE;
1700
1701 /* padding */
1702 if ((iov_enc_data_len(data, num_data) % et->padsize) != 0) {
1703 krb5_clear_error_message(context);
1704 return KRB5_BAD_MSIZE;
1705 }
1706
1707 krb5_data_zero(&enc_data);
1708 krb5_data_zero(&sign_data);
1709
1710 if (!(et->flags & F_ENC_THEN_CKSUM)) {
1711 ret = iov_coalesce(context, NULL, data, num_data, FALSE, &enc_data);
1712 if(ret)
1713 goto cleanup;
1714
1715 ret = _get_derived_key(context, crypto, ENCRYPTION_USAGE(usage), &dkey);
1716 if(ret)
1717 goto cleanup;
1718
1719 ret = _key_schedule(context, dkey);
1720 if(ret)
1721 goto cleanup;
1722
1723 ret = (*et->encrypt)(context, dkey, enc_data.data, enc_data.length,
1724 0, usage, ivec);
1725 if(ret)
1726 goto cleanup;
1727
1728 ret = iov_uncoalesce(context, &enc_data, data, num_data);
1729 if(ret)
1730 goto cleanup;
1731
1732 ret = iov_coalesce(context, NULL, data, num_data, TRUE, &sign_data);
1733 if(ret)
1734 goto cleanup;
1735 } else {
1736 krb5_data ivec_data;
1737 static unsigned char zero_ivec[EVP_MAX_IV_LENGTH];
1738
1739 heim_assert(et->blocksize <= sizeof(zero_ivec),
1740 "blocksize too big for ivec buffer");
1741
1742 ivec_data.length = et->blocksize;
1743 ivec_data.data = ivec ? ivec : zero_ivec;
1744
1745 ret = iov_coalesce(context, &ivec_data, data, num_data, TRUE, &sign_data);
1746 if(ret)
1747 goto cleanup;
1748 }
1749
1750 cksum.checksum.data = tiv->data.data;
1751 cksum.checksum.length = tiv->data.length;
1752 cksum.cksumtype = CHECKSUMTYPE(et->keyed_checksum);
1753
1754 ret = verify_checksum(context,
1755 crypto,
1756 INTEGRITY_USAGE(usage),
1757 sign_data.data,
1758 sign_data.length,
1759 &cksum);
1760 if(ret)
1761 goto cleanup;
1762
1763 if (et->flags & F_ENC_THEN_CKSUM) {
1764 ret = iov_coalesce(context, NULL, data, num_data, FALSE, &enc_data);
1765 if(ret)
1766 goto cleanup;
1767
1768 ret = _get_derived_key(context, crypto, ENCRYPTION_USAGE(usage), &dkey);
1769 if(ret)
1770 goto cleanup;
1771
1772 ret = _key_schedule(context, dkey);
1773 if(ret)
1774 goto cleanup;
1775
1776 ret = (*et->encrypt)(context, dkey, enc_data.data, enc_data.length,
1777 0, usage, ivec);
1778 if(ret)
1779 goto cleanup;
1780
1781 ret = iov_uncoalesce(context, &enc_data, data, num_data);
1782 if(ret)
1783 goto cleanup;
1784 }
1785
1786 cleanup:
1787 if (enc_data.data) {
1788 memset_s(enc_data.data, enc_data.length, 0, enc_data.length);
1789 krb5_data_free(&enc_data);
1790 }
1791 if (sign_data.data) {
1792 memset_s(sign_data.data, sign_data.length, 0, sign_data.length);
1793 krb5_data_free(&sign_data);
1794 }
1795 return ret;
1796 }
1797
1798 /**
1799 * Create a Kerberos message checksum.
1800 *
1801 * @param context Kerberos context
1802 * @param crypto Kerberos crypto context
1803 * @param usage Key usage for this buffer
1804 * @param data array of buffers to process
1805 * @param num_data length of array
1806 * @param type output data
1807 *
1808 * @return Return an error code or 0.
1809 * @ingroup krb5_crypto
1810 */
1811
1812 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1813 krb5_create_checksum_iov(krb5_context context,
1814 krb5_crypto crypto,
1815 unsigned usage,
1816 krb5_crypto_iov *data,
1817 unsigned int num_data,
1818 krb5_cksumtype *type)
1819 {
1820 Checksum cksum;
1821 krb5_crypto_iov *civ;
1822 krb5_error_code ret;
1823 size_t i;
1824 size_t len;
1825 char *p, *q;
1826
1827 if(!derived_crypto(context, crypto)) {
1828 krb5_clear_error_message(context);
1829 return KRB5_CRYPTO_INTERNAL;
1830 }
1831
1832 civ = iov_find(data, num_data, KRB5_CRYPTO_TYPE_CHECKSUM);
1833 if (civ == NULL)
1834 return KRB5_BAD_MSIZE;
1835
1836 len = 0;
1837 for (i = 0; i < num_data; i++) {
1838 if (data[i].flags != KRB5_CRYPTO_TYPE_DATA &&
1839 data[i].flags != KRB5_CRYPTO_TYPE_SIGN_ONLY)
1840 continue;
1841 len += data[i].data.length;
1842 }
1843
1844 p = q = malloc(len);
1845
1846 for (i = 0; i < num_data; i++) {
1847 if (data[i].flags != KRB5_CRYPTO_TYPE_DATA &&
1848 data[i].flags != KRB5_CRYPTO_TYPE_SIGN_ONLY)
1849 continue;
1850 memcpy(q, data[i].data.data, data[i].data.length);
1851 q += data[i].data.length;
1852 }
1853
1854 ret = krb5_create_checksum(context, crypto, usage, 0, p, len, &cksum);
1855 free(p);
1856 if (ret)
1857 return ret;
1858
1859 if (type)
1860 *type = cksum.cksumtype;
1861
1862 if (cksum.checksum.length > civ->data.length) {
1863 krb5_set_error_message(context, KRB5_BAD_MSIZE,
1864 N_("Checksum larger then input buffer", ""));
1865 free_Checksum(&cksum);
1866 return KRB5_BAD_MSIZE;
1867 }
1868
1869 civ->data.length = cksum.checksum.length;
1870 memcpy(civ->data.data, cksum.checksum.data, civ->data.length);
1871 free_Checksum(&cksum);
1872
1873 return 0;
1874 }
1875
1876 /**
1877 * Verify a Kerberos message checksum.
1878 *
1879 * @param context Kerberos context
1880 * @param crypto Kerberos crypto context
1881 * @param usage Key usage for this buffer
1882 * @param data array of buffers to process
1883 * @param num_data length of array
1884 * @param type return checksum type if not NULL
1885 *
1886 * @return Return an error code or 0.
1887 * @ingroup krb5_crypto
1888 */
1889
1890 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1891 krb5_verify_checksum_iov(krb5_context context,
1892 krb5_crypto crypto,
1893 unsigned usage,
1894 krb5_crypto_iov *data,
1895 unsigned int num_data,
1896 krb5_cksumtype *type)
1897 {
1898 struct _krb5_encryption_type *et = crypto->et;
1899 Checksum cksum;
1900 krb5_crypto_iov *civ;
1901 krb5_error_code ret;
1902 size_t i;
1903 size_t len;
1904 char *p, *q;
1905
1906 if(!derived_crypto(context, crypto)) {
1907 krb5_clear_error_message(context);
1908 return KRB5_CRYPTO_INTERNAL;
1909 }
1910
1911 civ = iov_find(data, num_data, KRB5_CRYPTO_TYPE_CHECKSUM);
1912 if (civ == NULL)
1913 return KRB5_BAD_MSIZE;
1914
1915 len = 0;
1916 for (i = 0; i < num_data; i++) {
1917 if (data[i].flags != KRB5_CRYPTO_TYPE_DATA &&
1918 data[i].flags != KRB5_CRYPTO_TYPE_SIGN_ONLY)
1919 continue;
1920 len += data[i].data.length;
1921 }
1922
1923 p = q = malloc(len);
1924
1925 for (i = 0; i < num_data; i++) {
1926 if (data[i].flags != KRB5_CRYPTO_TYPE_DATA &&
1927 data[i].flags != KRB5_CRYPTO_TYPE_SIGN_ONLY)
1928 continue;
1929 memcpy(q, data[i].data.data, data[i].data.length);
1930 q += data[i].data.length;
1931 }
1932
1933 cksum.cksumtype = CHECKSUMTYPE(et->keyed_checksum);
1934 cksum.checksum.length = civ->data.length;
1935 cksum.checksum.data = civ->data.data;
1936
1937 ret = krb5_verify_checksum(context, crypto, usage, p, len, &cksum);
1938 free(p);
1939
1940 if (ret == 0 && type)
1941 *type = cksum.cksumtype;
1942
1943 return ret;
1944 }
1945
1946
1947 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1948 krb5_crypto_length(krb5_context context,
1949 krb5_crypto crypto,
1950 int type,
1951 size_t *len)
1952 {
1953 if (!derived_crypto(context, crypto)) {
1954 krb5_set_error_message(context, EINVAL, "not a derived crypto");
1955 return EINVAL;
1956 }
1957
1958 switch(type) {
1959 case KRB5_CRYPTO_TYPE_EMPTY:
1960 *len = 0;
1961 return 0;
1962 case KRB5_CRYPTO_TYPE_HEADER:
1963 *len = crypto->et->blocksize;
1964 return 0;
1965 case KRB5_CRYPTO_TYPE_DATA:
1966 case KRB5_CRYPTO_TYPE_SIGN_ONLY:
1967 /* len must already been filled in */
1968 return 0;
1969 case KRB5_CRYPTO_TYPE_PADDING:
1970 if (crypto->et->padsize > 1)
1971 *len = crypto->et->padsize;
1972 else
1973 *len = 0;
1974 return 0;
1975 case KRB5_CRYPTO_TYPE_TRAILER:
1976 *len = CHECKSUMSIZE(crypto->et->keyed_checksum);
1977 return 0;
1978 case KRB5_CRYPTO_TYPE_CHECKSUM:
1979 if (crypto->et->keyed_checksum)
1980 *len = CHECKSUMSIZE(crypto->et->keyed_checksum);
1981 else
1982 *len = CHECKSUMSIZE(crypto->et->checksum);
1983 return 0;
1984 }
1985 krb5_set_error_message(context, EINVAL,
1986 "%d not a supported type", type);
1987 return EINVAL;
1988 }
1989
1990
1991 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1992 krb5_crypto_length_iov(krb5_context context,
1993 krb5_crypto crypto,
1994 krb5_crypto_iov *data,
1995 unsigned int num_data)
1996 {
1997 krb5_error_code ret;
1998 size_t i;
1999
2000 for (i = 0; i < num_data; i++) {
2001 ret = krb5_crypto_length(context, crypto,
2002 data[i].flags,
2003 &data[i].data.length);
2004 if (ret)
2005 return ret;
2006 }
2007 return 0;
2008 }
2009
2010
2011 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2012 krb5_encrypt_ivec(krb5_context context,
2013 krb5_crypto crypto,
2014 unsigned usage,
2015 const void *data,
2016 size_t len,
2017 krb5_data *result,
2018 void *ivec)
2019 {
2020 krb5_error_code ret;
2021
2022 switch (crypto->et->flags & F_CRYPTO_MASK) {
2023 case F_RFC3961_ENC:
2024 ret = encrypt_internal_derived(context, crypto, usage,
2025 data, len, result, ivec);
2026 break;
2027 case F_SPECIAL:
2028 ret = encrypt_internal_special (context, crypto, usage,
2029 data, len, result, ivec);
2030 break;
2031 case F_ENC_THEN_CKSUM:
2032 ret = encrypt_internal_enc_then_cksum(context, crypto, usage,
2033 data, len, result, ivec);
2034 break;
2035 default:
2036 ret = encrypt_internal(context, crypto, data, len, result, ivec);
2037 break;
2038 }
2039
2040 return ret;
2041 }
2042
2043 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2044 krb5_encrypt(krb5_context context,
2045 krb5_crypto crypto,
2046 unsigned usage,
2047 const void *data,
2048 size_t len,
2049 krb5_data *result)
2050 {
2051 return krb5_encrypt_ivec(context, crypto, usage, data, len, result, NULL);
2052 }
2053
2054 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2055 krb5_encrypt_EncryptedData(krb5_context context,
2056 krb5_crypto crypto,
2057 unsigned usage,
2058 void *data,
2059 size_t len,
2060 int kvno,
2061 EncryptedData *result)
2062 {
2063 result->etype = CRYPTO_ETYPE(crypto);
2064 if(kvno){
2065 ALLOC(result->kvno, 1);
2066 *result->kvno = kvno;
2067 }else
2068 result->kvno = NULL;
2069 return krb5_encrypt(context, crypto, usage, data, len, &result->cipher);
2070 }
2071
2072 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2073 krb5_decrypt_ivec(krb5_context context,
2074 krb5_crypto crypto,
2075 unsigned usage,
2076 void *data,
2077 size_t len,
2078 krb5_data *result,
2079 void *ivec)
2080 {
2081 krb5_error_code ret;
2082
2083 switch (crypto->et->flags & F_CRYPTO_MASK) {
2084 case F_RFC3961_ENC:
2085 ret = decrypt_internal_derived(context, crypto, usage,
2086 data, len, result, ivec);
2087 break;
2088 case F_SPECIAL:
2089 ret = decrypt_internal_special(context, crypto, usage,
2090 data, len, result, ivec);
2091 break;
2092 case F_ENC_THEN_CKSUM:
2093 ret = decrypt_internal_enc_then_cksum(context, crypto, usage,
2094 data, len, result, ivec);
2095 break;
2096 default:
2097 ret = decrypt_internal(context, crypto, data, len, result, ivec);
2098 break;
2099 }
2100
2101 return ret;
2102 }
2103
2104 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2105 krb5_decrypt(krb5_context context,
2106 krb5_crypto crypto,
2107 unsigned usage,
2108 void *data,
2109 size_t len,
2110 krb5_data *result)
2111 {
2112 return krb5_decrypt_ivec (context, crypto, usage, data, len, result,
2113 NULL);
2114 }
2115
2116 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2117 krb5_decrypt_EncryptedData(krb5_context context,
2118 krb5_crypto crypto,
2119 unsigned usage,
2120 const EncryptedData *e,
2121 krb5_data *result)
2122 {
2123 return krb5_decrypt(context, crypto, usage,
2124 e->cipher.data, e->cipher.length, result);
2125 }
2126
2127 /************************************************************
2128 * *
2129 ************************************************************/
2130
2131 static krb5_error_code
2132 derive_key_rfc3961(krb5_context context,
2133 struct _krb5_encryption_type *et,
2134 struct _krb5_key_data *key,
2135 const void *constant,
2136 size_t len)
2137 {
2138
2139 unsigned char *k = NULL;
2140 unsigned int nblocks = 0, i;
2141 krb5_error_code ret = 0;
2142 struct _krb5_key_type *kt = et->keytype;
2143
2144 if(et->blocksize * 8 < kt->bits || len != et->blocksize) {
2145 nblocks = (kt->bits + et->blocksize * 8 - 1) / (et->blocksize * 8);
2146 k = malloc(nblocks * et->blocksize);
2147 if(k == NULL) {
2148 ret = krb5_enomem(context);
2149 goto out;
2150 }
2151 ret = _krb5_n_fold(constant, len, k, et->blocksize);
2152 if (ret) {
2153 krb5_enomem(context);
2154 goto out;
2155 }
2156
2157 for(i = 0; i < nblocks; i++) {
2158 if(i > 0)
2159 memcpy(k + i * et->blocksize,
2160 k + (i - 1) * et->blocksize,
2161 et->blocksize);
2162 (*et->encrypt)(context, key, k + i * et->blocksize, et->blocksize,
2163 1, 0, NULL);
2164 }
2165 } else {
2166 /* this case is probably broken, but won't be run anyway */
2167 void *c = malloc(len);
2168 size_t res_len = (kt->bits + 7) / 8;
2169
2170 if(len != 0 && c == NULL) {
2171 ret = krb5_enomem(context);
2172 goto out;
2173 }
2174 memcpy(c, constant, len);
2175 (*et->encrypt)(context, key, c, len, 1, 0, NULL);
2176 k = malloc(res_len);
2177 if(res_len != 0 && k == NULL) {
2178 free(c);
2179 ret = krb5_enomem(context);
2180 goto out;
2181 }
2182 ret = _krb5_n_fold(c, len, k, res_len);
2183 free(c);
2184 if (ret) {
2185 krb5_enomem(context);
2186 goto out;
2187 }
2188 }
2189
2190 if (kt->type == KRB5_ENCTYPE_OLD_DES3_CBC_SHA1)
2191 _krb5_DES3_random_to_key(context, key->key, k, nblocks * et->blocksize);
2192 else
2193 memcpy(key->key->keyvalue.data, k, key->key->keyvalue.length);
2194
2195 out:
2196 if (k) {
2197 memset_s(k, nblocks * et->blocksize, 0, nblocks * et->blocksize);
2198 free(k);
2199 }
2200 return ret;
2201 }
2202
2203 static krb5_error_code
2204 derive_key_sp800_hmac(krb5_context context,
2205 struct _krb5_encryption_type *et,
2206 struct _krb5_key_data *key,
2207 const void *constant,
2208 size_t len)
2209 {
2210 krb5_error_code ret;
2211 struct _krb5_key_type *kt = et->keytype;
2212 krb5_data label;
2213 const EVP_MD *md = NULL;
2214 const unsigned char *c = constant;
2215 size_t key_len;
2216 krb5_data K1;
2217
2218 ret = _krb5_aes_sha2_md_for_enctype(context, kt->type, &md);
2219 if (ret)
2220 return ret;
2221
2222 /*
2223 * PRF usage: not handled here (output cannot be longer)
2224 * Integrity usage: truncated hash (half length)
2225 * Encryption usage: base key length
2226 */
2227 if (len == 5 && (c[4] == 0x99 || c[4] == 0x55))
2228 key_len = EVP_MD_size(md) / 2;
2229 else
2230 key_len = kt->size;
2231
2232 ret = krb5_data_alloc(&K1, key_len);
2233 if (ret)
2234 return ret;
2235
2236 label.data = (void *)constant;
2237 label.length = len;
2238
2239 ret = _krb5_SP800_108_HMAC_KDF(context, &key->key->keyvalue,
2240 &label, NULL, md, &K1);
2241 if (ret == 0) {
2242 if (key->key->keyvalue.length > key_len)
2243 key->key->keyvalue.length = key_len;
2244 memcpy(key->key->keyvalue.data, K1.data, key_len);
2245 }
2246
2247 memset_s(K1.data, K1.length, 0, K1.length);
2248 krb5_data_free(&K1);
2249
2250 return ret;
2251 }
2252
2253 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2254 _krb5_derive_key(krb5_context context,
2255 struct _krb5_encryption_type *et,
2256 struct _krb5_key_data *key,
2257 const void *constant,
2258 size_t len)
2259 {
2260 krb5_error_code ret;
2261
2262 ret = _key_schedule(context, key);
2263 if(ret)
2264 return ret;
2265
2266 switch (et->flags & F_KDF_MASK) {
2267 case F_RFC3961_KDF:
2268 ret = derive_key_rfc3961(context, et, key, constant, len);
2269 break;
2270 case F_SP800_108_HMAC_KDF:
2271 ret = derive_key_sp800_hmac(context, et, key, constant, len);
2272 break;
2273 default:
2274 ret = KRB5_CRYPTO_INTERNAL;
2275 krb5_set_error_message(context, ret,
2276 N_("derive_key() called with unknown keytype (%u)", ""),
2277 et->keytype->type);
2278 break;
2279 }
2280
2281 if (key->schedule) {
2282 free_key_schedule(context, key, et);
2283 key->schedule = NULL;
2284 }
2285
2286 return ret;
2287 }
2288
2289 static struct _krb5_key_data *
2290 _new_derived_key(krb5_crypto crypto, unsigned usage)
2291 {
2292 struct _krb5_key_usage *d = crypto->key_usage;
2293 d = realloc(d, (crypto->num_key_usage + 1) * sizeof(*d));
2294 if(d == NULL)
2295 return NULL;
2296 crypto->key_usage = d;
2297 d += crypto->num_key_usage++;
2298 memset(d, 0, sizeof(*d));
2299 d->usage = usage;
2300 return &d->key;
2301 }
2302
2303 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2304 krb5_derive_key(krb5_context context,
2305 const krb5_keyblock *key,
2306 krb5_enctype etype,
2307 const void *constant,
2308 size_t constant_len,
2309 krb5_keyblock **derived_key)
2310 {
2311 krb5_error_code ret;
2312 struct _krb5_encryption_type *et;
2313 struct _krb5_key_data d;
2314
2315 *derived_key = NULL;
2316
2317 et = _krb5_find_enctype (etype);
2318 if (et == NULL) {
2319 return unsupported_enctype (context, etype);
2320 }
2321
2322 ret = krb5_copy_keyblock(context, key, &d.key);
2323 if (ret)
2324 return ret;
2325
2326 d.schedule = NULL;
2327 ret = _krb5_derive_key(context, et, &d, constant, constant_len);
2328 if (ret == 0)
2329 ret = krb5_copy_keyblock(context, d.key, derived_key);
2330 _krb5_free_key_data(context, &d, et);
2331 return ret;
2332 }
2333
2334 static krb5_error_code
2335 _get_derived_key(krb5_context context,
2336 krb5_crypto crypto,
2337 unsigned usage,
2338 struct _krb5_key_data **key)
2339 {
2340 int i;
2341 struct _krb5_key_data *d;
2342 unsigned char constant[5];
2343
2344 *key = NULL;
2345 for(i = 0; i < crypto->num_key_usage; i++)
2346 if(crypto->key_usage[i].usage == usage) {
2347 *key = &crypto->key_usage[i].key;
2348 return 0;
2349 }
2350 d = _new_derived_key(crypto, usage);
2351 if (d == NULL)
2352 return krb5_enomem(context);
2353 *key = d;
2354 krb5_copy_keyblock(context, crypto->key.key, &d->key);
2355 _krb5_put_int(constant, usage, sizeof(constant));
2356 return _krb5_derive_key(context, crypto->et, d, constant, sizeof(constant));
2357 }
2358
2359 /**
2360 * Create a crypto context used for all encryption and signature
2361 * operation. The encryption type to use is taken from the key, but
2362 * can be overridden with the enctype parameter. This can be useful
2363 * for encryptions types which is compatiable (DES for example).
2364 *
2365 * To free the crypto context, use krb5_crypto_destroy().
2366 *
2367 * @param context Kerberos context
2368 * @param key the key block information with all key data
2369 * @param etype the encryption type
2370 * @param crypto the resulting crypto context
2371 *
2372 * @return Return an error code or 0.
2373 *
2374 * @ingroup krb5_crypto
2375 */
2376
2377 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2378 krb5_crypto_init(krb5_context context,
2379 const krb5_keyblock *key,
2380 krb5_enctype etype,
2381 krb5_crypto *crypto)
2382 {
2383 krb5_error_code ret;
2384 ALLOC(*crypto, 1);
2385 if (*crypto == NULL)
2386 return krb5_enomem(context);
2387 if(etype == (krb5_enctype)ETYPE_NULL)
2388 etype = key->keytype;
2389 (*crypto)->et = _krb5_find_enctype(etype);
2390 if((*crypto)->et == NULL || ((*crypto)->et->flags & F_DISABLED)) {
2391 free(*crypto);
2392 *crypto = NULL;
2393 return unsupported_enctype(context, etype);
2394 }
2395 if((*crypto)->et->keytype->size != key->keyvalue.length) {
2396 free(*crypto);
2397 *crypto = NULL;
2398 krb5_set_error_message (context, KRB5_BAD_KEYSIZE,
2399 "encryption key has bad length");
2400 return KRB5_BAD_KEYSIZE;
2401 }
2402 ret = krb5_copy_keyblock(context, key, &(*crypto)->key.key);
2403 if(ret) {
2404 free(*crypto);
2405 *crypto = NULL;
2406 return ret;
2407 }
2408 (*crypto)->key.schedule = NULL;
2409 (*crypto)->num_key_usage = 0;
2410 (*crypto)->key_usage = NULL;
2411 return 0;
2412 }
2413
2414 static void
2415 free_key_schedule(krb5_context context,
2416 struct _krb5_key_data *key,
2417 struct _krb5_encryption_type *et)
2418 {
2419 if (et->keytype->cleanup)
2420 (*et->keytype->cleanup)(context, key);
2421 memset(key->schedule->data, 0, key->schedule->length);
2422 krb5_free_data(context, key->schedule);
2423 }
2424
2425 KRB5_LIB_FUNCTION void KRB5_LIB_CALL
2426 _krb5_free_key_data(krb5_context context, struct _krb5_key_data *key,
2427 struct _krb5_encryption_type *et)
2428 {
2429 krb5_free_keyblock(context, key->key);
2430 if(key->schedule) {
2431 free_key_schedule(context, key, et);
2432 key->schedule = NULL;
2433 }
2434 }
2435
2436 static void
2437 free_key_usage(krb5_context context, struct _krb5_key_usage *ku,
2438 struct _krb5_encryption_type *et)
2439 {
2440 _krb5_free_key_data(context, &ku->key, et);
2441 }
2442
2443 /**
2444 * Free a crypto context created by krb5_crypto_init().
2445 *
2446 * @param context Kerberos context
2447 * @param crypto crypto context to free
2448 *
2449 * @return Return an error code or 0.
2450 *
2451 * @ingroup krb5_crypto
2452 */
2453
2454 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2455 krb5_crypto_destroy(krb5_context context,
2456 krb5_crypto crypto)
2457 {
2458 int i;
2459
2460 for(i = 0; i < crypto->num_key_usage; i++)
2461 free_key_usage(context, &crypto->key_usage[i], crypto->et);
2462 free(crypto->key_usage);
2463 _krb5_free_key_data(context, &crypto->key, crypto->et);
2464 free (crypto);
2465 return 0;
2466 }
2467
2468 /**
2469 * Return the blocksize used algorithm referenced by the crypto context
2470 *
2471 * @param context Kerberos context
2472 * @param crypto crypto context to query
2473 * @param blocksize the resulting blocksize
2474 *
2475 * @return Return an error code or 0.
2476 *
2477 * @ingroup krb5_crypto
2478 */
2479
2480 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2481 krb5_crypto_getblocksize(krb5_context context,
2482 krb5_crypto crypto,
2483 size_t *blocksize)
2484 {
2485 *blocksize = crypto->et->blocksize;
2486 return 0;
2487 }
2488
2489 /**
2490 * Return the encryption type used by the crypto context
2491 *
2492 * @param context Kerberos context
2493 * @param crypto crypto context to query
2494 * @param enctype the resulting encryption type
2495 *
2496 * @return Return an error code or 0.
2497 *
2498 * @ingroup krb5_crypto
2499 */
2500
2501 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2502 krb5_crypto_getenctype(krb5_context context,
2503 krb5_crypto crypto,
2504 krb5_enctype *enctype)
2505 {
2506 *enctype = crypto->et->type;
2507 return 0;
2508 }
2509
2510 /**
2511 * Return the padding size used by the crypto context
2512 *
2513 * @param context Kerberos context
2514 * @param crypto crypto context to query
2515 * @param padsize the return padding size
2516 *
2517 * @return Return an error code or 0.
2518 *
2519 * @ingroup krb5_crypto
2520 */
2521
2522 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2523 krb5_crypto_getpadsize(krb5_context context,
2524 krb5_crypto crypto,
2525 size_t *padsize)
2526 {
2527 *padsize = crypto->et->padsize;
2528 return 0;
2529 }
2530
2531 /**
2532 * Return the confounder size used by the crypto context
2533 *
2534 * @param context Kerberos context
2535 * @param crypto crypto context to query
2536 * @param confoundersize the returned confounder size
2537 *
2538 * @return Return an error code or 0.
2539 *
2540 * @ingroup krb5_crypto
2541 */
2542
2543 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2544 krb5_crypto_getconfoundersize(krb5_context context,
2545 krb5_crypto crypto,
2546 size_t *confoundersize)
2547 {
2548 *confoundersize = crypto->et->confoundersize;
2549 return 0;
2550 }
2551
2552
2553 /**
2554 * Disable encryption type
2555 *
2556 * @param context Kerberos 5 context
2557 * @param enctype encryption type to disable
2558 *
2559 * @return Return an error code or 0.
2560 *
2561 * @ingroup krb5_crypto
2562 */
2563
2564 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2565 krb5_enctype_disable(krb5_context context,
2566 krb5_enctype enctype)
2567 {
2568 struct _krb5_encryption_type *et = _krb5_find_enctype(enctype);
2569 if(et == NULL) {
2570 if (context)
2571 krb5_set_error_message (context, KRB5_PROG_ETYPE_NOSUPP,
2572 N_("encryption type %d not supported", ""),
2573 enctype);
2574 return KRB5_PROG_ETYPE_NOSUPP;
2575 }
2576 et->flags |= F_DISABLED;
2577 return 0;
2578 }
2579
2580 /**
2581 * Enable encryption type
2582 *
2583 * @param context Kerberos 5 context
2584 * @param enctype encryption type to enable
2585 *
2586 * @return Return an error code or 0.
2587 *
2588 * @ingroup krb5_crypto
2589 */
2590
2591 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2592 krb5_enctype_enable(krb5_context context,
2593 krb5_enctype enctype)
2594 {
2595 struct _krb5_encryption_type *et = _krb5_find_enctype(enctype);
2596 if(et == NULL) {
2597 if (context)
2598 krb5_set_error_message (context, KRB5_PROG_ETYPE_NOSUPP,
2599 N_("encryption type %d not supported", ""),
2600 enctype);
2601 return KRB5_PROG_ETYPE_NOSUPP;
2602 }
2603 et->flags &= ~F_DISABLED;
2604 return 0;
2605 }
2606
2607 /**
2608 * Enable or disable all weak encryption types
2609 *
2610 * @param context Kerberos 5 context
2611 * @param enable true to enable, false to disable
2612 *
2613 * @return Return an error code or 0.
2614 *
2615 * @ingroup krb5_crypto
2616 */
2617
2618 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2619 krb5_allow_weak_crypto(krb5_context context,
2620 krb5_boolean enable)
2621 {
2622 int i;
2623
2624 for(i = 0; i < _krb5_num_etypes; i++)
2625 if(_krb5_etypes[i]->flags & F_WEAK) {
2626 if(enable)
2627 _krb5_etypes[i]->flags &= ~F_DISABLED;
2628 else
2629 _krb5_etypes[i]->flags |= F_DISABLED;
2630 }
2631 return 0;
2632 }
2633
2634 /**
2635 * Returns is the encryption is strong or weak
2636 *
2637 * @param context Kerberos 5 context
2638 * @param enctype encryption type to probe
2639 *
2640 * @return Returns true if encryption type is weak or is not supported.
2641 *
2642 * @ingroup krb5_crypto
2643 */
2644
2645 KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
2646 krb5_is_enctype_weak(krb5_context context, krb5_enctype enctype)
2647 {
2648 struct _krb5_encryption_type *et = _krb5_find_enctype(enctype);
2649 if(et == NULL || (et->flags & F_WEAK))
2650 return TRUE;
2651 return FALSE;
2652 }
2653
2654 /**
2655 * Returns whether the encryption type should use randomly generated salts
2656 *
2657 * @param context Kerberos 5 context
2658 * @param enctype encryption type to probe
2659 *
2660 * @return Returns true if generated salts should have random component
2661 *
2662 * @ingroup krb5_crypto
2663 */
2664 KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
2665 _krb5_enctype_requires_random_salt(krb5_context context,
2666 krb5_enctype enctype)
2667 {
2668 struct _krb5_encryption_type *et;
2669
2670 et = _krb5_find_enctype (enctype);
2671
2672 return et && (et->flags & F_SP800_108_HMAC_KDF);
2673 }
2674
2675 static size_t
2676 wrapped_length (krb5_context context,
2677 krb5_crypto crypto,
2678 size_t data_len)
2679 {
2680 struct _krb5_encryption_type *et = crypto->et;
2681 size_t padsize = et->padsize;
2682 size_t checksumsize = CHECKSUMSIZE(et->checksum);
2683 size_t res;
2684
2685 res = et->confoundersize + checksumsize + data_len;
2686 res = (res + padsize - 1) / padsize * padsize;
2687 return res;
2688 }
2689
2690 static size_t
2691 wrapped_length_dervied (krb5_context context,
2692 krb5_crypto crypto,
2693 size_t data_len)
2694 {
2695 struct _krb5_encryption_type *et = crypto->et;
2696 size_t padsize = et->padsize;
2697 size_t res;
2698
2699 res = et->confoundersize + data_len;
2700 res = (res + padsize - 1) / padsize * padsize;
2701 if (et->keyed_checksum)
2702 res += et->keyed_checksum->checksumsize;
2703 else
2704 res += et->checksum->checksumsize;
2705 return res;
2706 }
2707
2708 /*
2709 * Return the size of an encrypted packet of length `data_len'
2710 */
2711
2712 KRB5_LIB_FUNCTION size_t KRB5_LIB_CALL
2713 krb5_get_wrapped_length (krb5_context context,
2714 krb5_crypto crypto,
2715 size_t data_len)
2716 {
2717 if (derived_crypto (context, crypto))
2718 return wrapped_length_dervied (context, crypto, data_len);
2719 else
2720 return wrapped_length (context, crypto, data_len);
2721 }
2722
2723 /*
2724 * Return the size of an encrypted packet of length `data_len'
2725 */
2726
2727 static size_t
2728 crypto_overhead (krb5_context context,
2729 krb5_crypto crypto)
2730 {
2731 struct _krb5_encryption_type *et = crypto->et;
2732 size_t res;
2733
2734 res = CHECKSUMSIZE(et->checksum);
2735 res += et->confoundersize;
2736 if (et->padsize > 1)
2737 res += et->padsize;
2738 return res;
2739 }
2740
2741 static size_t
2742 crypto_overhead_dervied (krb5_context context,
2743 krb5_crypto crypto)
2744 {
2745 struct _krb5_encryption_type *et = crypto->et;
2746 size_t res;
2747
2748 if (et->keyed_checksum)
2749 res = CHECKSUMSIZE(et->keyed_checksum);
2750 else
2751 res = CHECKSUMSIZE(et->checksum);
2752 res += et->confoundersize;
2753 if (et->padsize > 1)
2754 res += et->padsize;
2755 return res;
2756 }
2757
2758 KRB5_LIB_FUNCTION size_t KRB5_LIB_CALL
2759 krb5_crypto_overhead (krb5_context context, krb5_crypto crypto)
2760 {
2761 if (derived_crypto (context, crypto))
2762 return crypto_overhead_dervied (context, crypto);
2763 else
2764 return crypto_overhead (context, crypto);
2765 }
2766
2767 /**
2768 * Converts the random bytestring to a protocol key according to
2769 * Kerberos crypto frame work. It may be assumed that all the bits of
2770 * the input string are equally random, even though the entropy
2771 * present in the random source may be limited.
2772 *
2773 * @param context Kerberos 5 context
2774 * @param type the enctype resulting key will be of
2775 * @param data input random data to convert to a key
2776 * @param size size of input random data, at least krb5_enctype_keysize() long
2777 * @param key key, output key, free with krb5_free_keyblock_contents()
2778 *
2779 * @return Return an error code or 0.
2780 *
2781 * @ingroup krb5_crypto
2782 */
2783
2784 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2785 krb5_random_to_key(krb5_context context,
2786 krb5_enctype type,
2787 const void *data,
2788 size_t size,
2789 krb5_keyblock *key)
2790 {
2791 krb5_error_code ret;
2792 struct _krb5_encryption_type *et = _krb5_find_enctype(type);
2793 if(et == NULL) {
2794 krb5_set_error_message(context, KRB5_PROG_ETYPE_NOSUPP,
2795 N_("encryption type %d not supported", ""),
2796 type);
2797 return KRB5_PROG_ETYPE_NOSUPP;
2798 }
2799 if ((et->keytype->bits + 7) / 8 > size) {
2800 krb5_set_error_message(context, KRB5_PROG_ETYPE_NOSUPP,
2801 N_("encryption key %s needs %d bytes "
2802 "of random to make an encryption key "
2803 "out of it", ""),
2804 et->name, (int)et->keytype->size);
2805 return KRB5_PROG_ETYPE_NOSUPP;
2806 }
2807 ret = krb5_data_alloc(&key->keyvalue, et->keytype->size);
2808 if(ret)
2809 return ret;
2810 key->keytype = type;
2811 if (et->keytype->random_to_key)
2812 (*et->keytype->random_to_key)(context, key, data, size);
2813 else
2814 memcpy(key->keyvalue.data, data, et->keytype->size);
2815
2816 return 0;
2817 }
2818
2819
2820
2821 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2822 krb5_crypto_prf_length(krb5_context context,
2823 krb5_enctype type,
2824 size_t *length)
2825 {
2826 struct _krb5_encryption_type *et = _krb5_find_enctype(type);
2827
2828 if(et == NULL || et->prf_length == 0) {
2829 krb5_set_error_message(context, KRB5_PROG_ETYPE_NOSUPP,
2830 N_("encryption type %d not supported", ""),
2831 type);
2832 return KRB5_PROG_ETYPE_NOSUPP;
2833 }
2834
2835 *length = et->prf_length;
2836 return 0;
2837 }
2838
2839 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2840 krb5_crypto_prf(krb5_context context,
2841 const krb5_crypto crypto,
2842 const krb5_data *input,
2843 krb5_data *output)
2844 {
2845 struct _krb5_encryption_type *et = crypto->et;
2846
2847 krb5_data_zero(output);
2848
2849 if(et->prf == NULL) {
2850 krb5_set_error_message(context, KRB5_PROG_ETYPE_NOSUPP,
2851 "kerberos prf for %s not supported",
2852 et->name);
2853 return KRB5_PROG_ETYPE_NOSUPP;
2854 }
2855
2856 return (*et->prf)(context, crypto, input, output);
2857 }
2858
2859 static krb5_error_code
2860 krb5_crypto_prfplus(krb5_context context,
2861 const krb5_crypto crypto,
2862 const krb5_data *input,
2863 size_t length,
2864 krb5_data *output)
2865 {
2866 krb5_error_code ret;
2867 krb5_data input2;
2868 unsigned char i = 1;
2869 unsigned char *p;
2870
2871 krb5_data_zero(&input2);
2872 krb5_data_zero(output);
2873
2874 krb5_clear_error_message(context);
2875
2876 ret = krb5_data_alloc(output, length);
2877 if (ret) goto out;
2878 ret = krb5_data_alloc(&input2, input->length + 1);
2879 if (ret) goto out;
2880
2881 krb5_clear_error_message(context);
2882
2883 memcpy(((unsigned char *)input2.data) + 1, input->data, input->length);
2884
2885 p = output->data;
2886
2887 while (length) {
2888 krb5_data block;
2889
2890 ((unsigned char *)input2.data)[0] = i++;
2891
2892 ret = krb5_crypto_prf(context, crypto, &input2, &block);
2893 if (ret)
2894 goto out;
2895
2896 if (block.length < length) {
2897 memcpy(p, block.data, block.length);
2898 length -= block.length;
2899 } else {
2900 memcpy(p, block.data, length);
2901 length = 0;
2902 }
2903 p += block.length;
2904 krb5_data_free(&block);
2905 }
2906
2907 out:
2908 krb5_data_free(&input2);
2909 if (ret)
2910 krb5_data_free(output);
2911 return ret;
2912 }
2913
2914 /**
2915 * The FX-CF2 key derivation function, used in FAST and preauth framework.
2916 *
2917 * @param context Kerberos 5 context
2918 * @param crypto1 first key to combine
2919 * @param crypto2 second key to combine
2920 * @param pepper1 factor to combine with first key to garante uniqueness
2921 * @param pepper2 factor to combine with second key to garante uniqueness
2922 * @param enctype the encryption type of the resulting key
2923 * @param res allocated key, free with krb5_free_keyblock_contents()
2924 *
2925 * @return Return an error code or 0.
2926 *
2927 * @ingroup krb5_crypto
2928 */
2929
2930 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2931 krb5_crypto_fx_cf2(krb5_context context,
2932 const krb5_crypto crypto1,
2933 const krb5_crypto crypto2,
2934 krb5_data *pepper1,
2935 krb5_data *pepper2,
2936 krb5_enctype enctype,
2937 krb5_keyblock *res)
2938 {
2939 krb5_error_code ret;
2940 krb5_data os1, os2;
2941 size_t i, keysize;
2942
2943 memset(res, 0, sizeof(*res));
2944 krb5_data_zero(&os1);
2945 krb5_data_zero(&os2);
2946
2947 ret = krb5_enctype_keybits(context, enctype, &keysize);
2948 if (ret)
2949 return ret;
2950 keysize = (keysize + 7) / 8;
2951
2952 ret = krb5_crypto_prfplus(context, crypto1, pepper1, keysize, &os1);
2953 if (ret)
2954 goto out;
2955 ret = krb5_crypto_prfplus(context, crypto2, pepper2, keysize, &os2);
2956 if (ret)
2957 goto out;
2958
2959 res->keytype = enctype;
2960 {
2961 unsigned char *p1 = os1.data, *p2 = os2.data;
2962 for (i = 0; i < keysize; i++)
2963 p1[i] ^= p2[i];
2964 }
2965 ret = krb5_random_to_key(context, enctype, os1.data, keysize, res);
2966 out:
2967 krb5_data_free(&os1);
2968 krb5_data_free(&os2);
2969
2970 return ret;
2971 }
2972
2973
2974
2975 #ifndef HEIMDAL_SMALLER
2976
2977 /**
2978 * Deprecated: keytypes doesn't exists, they are really enctypes.
2979 *
2980 * @ingroup krb5_deprecated
2981 */
2982
2983 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2984 krb5_keytype_to_enctypes (krb5_context context,
2985 krb5_keytype keytype,
2986 unsigned *len,
2987 krb5_enctype **val)
2988 KRB5_DEPRECATED_FUNCTION("Use X instead")
2989 {
2990 int i;
2991 unsigned n = 0;
2992 krb5_enctype *ret;
2993
2994 for (i = _krb5_num_etypes - 1; i >= 0; --i) {
2995 if (_krb5_etypes[i]->keytype->type == keytype
2996 && !(_krb5_etypes[i]->flags & F_PSEUDO)
2997 && krb5_enctype_valid(context, _krb5_etypes[i]->type) == 0)
2998 ++n;
2999 }
3000 if (n == 0) {
3001 krb5_set_error_message(context, KRB5_PROG_KEYTYPE_NOSUPP,
3002 "Keytype have no mapping");
3003 return KRB5_PROG_KEYTYPE_NOSUPP;
3004 }
3005
3006 ret = malloc(n * sizeof(*ret));
3007 if (ret == NULL && n != 0)
3008 return krb5_enomem(context);
3009 n = 0;
3010 for (i = _krb5_num_etypes - 1; i >= 0; --i) {
3011 if (_krb5_etypes[i]->keytype->type == keytype
3012 && !(_krb5_etypes[i]->flags & F_PSEUDO)
3013 && krb5_enctype_valid(context, _krb5_etypes[i]->type) == 0)
3014 ret[n++] = _krb5_etypes[i]->type;
3015 }
3016 *len = n;
3017 *val = ret;
3018 return 0;
3019 }
3020
3021 /**
3022 * Deprecated: keytypes doesn't exists, they are really enctypes.
3023 *
3024 * @ingroup krb5_deprecated
3025 */
3026
3027 /* if two enctypes have compatible keys */
3028 KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
3029 krb5_enctypes_compatible_keys(krb5_context context,
3030 krb5_enctype etype1,
3031 krb5_enctype etype2)
3032 KRB5_DEPRECATED_FUNCTION("Use X instead")
3033 {
3034 struct _krb5_encryption_type *e1 = _krb5_find_enctype(etype1);
3035 struct _krb5_encryption_type *e2 = _krb5_find_enctype(etype2);
3036 return e1 != NULL && e2 != NULL && e1->keytype == e2->keytype;
3037 }
3038
3039 #endif /* HEIMDAL_SMALLER */