Debian Codegraph @

lib/krb5/pac.c

raw
1 /*
2 * Copyright (c) 2006 - 2007 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 #include <wind.h>
36
37 struct PAC_INFO_BUFFER {
38 uint32_t type;
39 uint32_t buffersize;
40 uint32_t offset_hi;
41 uint32_t offset_lo;
42 };
43
44 struct PACTYPE {
45 uint32_t numbuffers;
46 uint32_t version;
47 struct PAC_INFO_BUFFER buffers[1];
48 };
49
50 struct krb5_pac_data {
51 struct PACTYPE *pac;
52 krb5_data data;
53 struct PAC_INFO_BUFFER *server_checksum;
54 struct PAC_INFO_BUFFER *privsvr_checksum;
55 struct PAC_INFO_BUFFER *logon_name;
56 };
57
58 #define PAC_ALIGNMENT 8
59
60 #define PACTYPE_SIZE 8
61 #define PAC_INFO_BUFFER_SIZE 16
62
63 #define PAC_SERVER_CHECKSUM 6
64 #define PAC_PRIVSVR_CHECKSUM 7
65 #define PAC_LOGON_NAME 10
66 #define PAC_CONSTRAINED_DELEGATION 11
67
68 #define CHECK(r,f,l) \
69 do { \
70 if (((r) = f ) != 0) { \
71 krb5_clear_error_message(context); \
72 goto l; \
73 } \
74 } while(0)
75
76 static const char zeros[PAC_ALIGNMENT] = { 0 };
77
78 /*
79 * HMAC-MD5 checksum over any key (needed for the PAC routines)
80 */
81
82 static krb5_error_code
83 HMAC_MD5_any_checksum(krb5_context context,
84 const krb5_keyblock *key,
85 const void *data,
86 size_t len,
87 unsigned usage,
88 Checksum *result)
89 {
90 struct _krb5_key_data local_key;
91 krb5_error_code ret;
92
93 memset(&local_key, 0, sizeof(local_key));
94
95 ret = krb5_copy_keyblock(context, key, &local_key.key);
96 if (ret)
97 return ret;
98
99 ret = krb5_data_alloc (&result->checksum, 16);
100 if (ret) {
101 krb5_free_keyblock(context, local_key.key);
102 return ret;
103 }
104
105 result->cksumtype = CKSUMTYPE_HMAC_MD5;
106 ret = _krb5_HMAC_MD5_checksum(context, &local_key, data, len, usage, result);
107 if (ret)
108 krb5_data_free(&result->checksum);
109
110 krb5_free_keyblock(context, local_key.key);
111 return ret;
112 }
113
114
115 static krb5_error_code pac_header_size(krb5_context context,
116 uint32_t num_buffers,
117 uint32_t *result)
118 {
119 krb5_error_code ret;
120 uint32_t header_size;
121
122 /* Guard against integer overflow on 32-bit systems. */
123 if (num_buffers > UINT32_MAX / PAC_INFO_BUFFER_SIZE) {
124 ret = EINVAL;
125 krb5_set_error_message(context, ret, "PAC has too many buffers");
126 return ret;
127 }
128 header_size = PAC_INFO_BUFFER_SIZE * num_buffers;
129
130 /* Guard against integer overflow on 32-bit systems. */
131 if (header_size > UINT32_MAX - PACTYPE_SIZE) {
132 ret = EINVAL;
133 krb5_set_error_message(context, ret, "PAC has too many buffers");
134 return ret;
135 }
136 header_size += PACTYPE_SIZE;
137
138 *result = header_size;
139
140 return 0;
141 }
142
143 static krb5_error_code pac_aligned_size(krb5_context context,
144 uint32_t size,
145 uint32_t *aligned_size)
146 {
147 krb5_error_code ret;
148
149 /* Guard against integer overflow on 32-bit systems. */
150 if (size > UINT32_MAX - (PAC_ALIGNMENT - 1)) {
151 ret = EINVAL;
152 krb5_set_error_message(context, ret, "integer overrun");
153 return ret;
154 }
155 size += PAC_ALIGNMENT - 1;
156
157 /* align to PAC_ALIGNMENT */
158 size = (size / PAC_ALIGNMENT) * PAC_ALIGNMENT;
159
160 *aligned_size = size;
161
162 return 0;
163 }
164
165 /*
166 *
167 */
168
169 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
170 krb5_pac_parse(krb5_context context, const void *ptr, size_t len,
171 krb5_pac *pac)
172 {
173 krb5_error_code ret;
174 krb5_pac p;
175 krb5_storage *sp = NULL;
176 uint32_t i, tmp, tmp2, header_end;
177
178 p = calloc(1, sizeof(*p));
179 if (p == NULL) {
180 ret = krb5_enomem(context);
181 goto out;
182 }
183
184 sp = krb5_storage_from_readonly_mem(ptr, len);
185 if (sp == NULL) {
186 ret = krb5_enomem(context);
187 goto out;
188 }
189 krb5_storage_set_flags(sp, KRB5_STORAGE_BYTEORDER_LE);
190
191 CHECK(ret, krb5_ret_uint32(sp, &tmp), out);
192 CHECK(ret, krb5_ret_uint32(sp, &tmp2), out);
193 if (tmp < 1) {
194 ret = EINVAL; /* Too few buffers */
195 krb5_set_error_message(context, ret, N_("PAC have too few buffer", ""));
196 goto out;
197 }
198 if (tmp2 != 0) {
199 ret = EINVAL; /* Wrong version */
200 krb5_set_error_message(context, ret,
201 N_("PAC have wrong version %d", ""),
202 (int)tmp2);
203 goto out;
204 }
205
206 ret = pac_header_size(context, tmp, &header_end);
207 if (ret)
208 goto out;
209
210 p->pac = calloc(1, header_end);
211 if (p->pac == NULL) {
212 ret = krb5_enomem(context);
213 goto out;
214 }
215
216 p->pac->numbuffers = tmp;
217 p->pac->version = tmp2;
218
219 if (header_end > len) {
220 ret = EINVAL;
221 goto out;
222 }
223
224 for (i = 0; i < p->pac->numbuffers; i++) {
225 CHECK(ret, krb5_ret_uint32(sp, &p->pac->buffers[i].type), out);
226 CHECK(ret, krb5_ret_uint32(sp, &p->pac->buffers[i].buffersize), out);
227 CHECK(ret, krb5_ret_uint32(sp, &p->pac->buffers[i].offset_lo), out);
228 CHECK(ret, krb5_ret_uint32(sp, &p->pac->buffers[i].offset_hi), out);
229
230 /* consistency checks */
231 if (p->pac->buffers[i].offset_lo & (PAC_ALIGNMENT - 1)) {
232 ret = EINVAL;
233 krb5_set_error_message(context, ret,
234 N_("PAC out of allignment", ""));
235 goto out;
236 }
237 if (p->pac->buffers[i].offset_hi) {
238 ret = EINVAL;
239 krb5_set_error_message(context, ret,
240 N_("PAC high offset set", ""));
241 goto out;
242 }
243 if (p->pac->buffers[i].offset_lo > len) {
244 ret = EINVAL;
245 krb5_set_error_message(context, ret,
246 N_("PAC offset off end", ""));
247 goto out;
248 }
249 if (p->pac->buffers[i].offset_lo < header_end) {
250 ret = EINVAL;
251 krb5_set_error_message(context, ret,
252 N_("PAC offset inside header: %lu %lu", ""),
253 (unsigned long)p->pac->buffers[i].offset_lo,
254 (unsigned long)header_end);
255 goto out;
256 }
257 if (p->pac->buffers[i].buffersize > len - p->pac->buffers[i].offset_lo){
258 ret = EINVAL;
259 krb5_set_error_message(context, ret, N_("PAC length off end", ""));
260 goto out;
261 }
262
263 /* let save pointer to data we need later */
264 if (p->pac->buffers[i].type == PAC_SERVER_CHECKSUM) {
265 if (p->server_checksum) {
266 ret = EINVAL;
267 krb5_set_error_message(context, ret,
268 N_("PAC have two server checksums", ""));
269 goto out;
270 }
271 p->server_checksum = &p->pac->buffers[i];
272 } else if (p->pac->buffers[i].type == PAC_PRIVSVR_CHECKSUM) {
273 if (p->privsvr_checksum) {
274 ret = EINVAL;
275 krb5_set_error_message(context, ret,
276 N_("PAC have two KDC checksums", ""));
277 goto out;
278 }
279 p->privsvr_checksum = &p->pac->buffers[i];
280 } else if (p->pac->buffers[i].type == PAC_LOGON_NAME) {
281 if (p->logon_name) {
282 ret = EINVAL;
283 krb5_set_error_message(context, ret,
284 N_("PAC have two logon names", ""));
285 goto out;
286 }
287 p->logon_name = &p->pac->buffers[i];
288 }
289 }
290
291 ret = krb5_data_copy(&p->data, ptr, len);
292 if (ret)
293 goto out;
294
295 krb5_storage_free(sp);
296
297 *pac = p;
298 return 0;
299
300 out:
301 if (sp)
302 krb5_storage_free(sp);
303 if (p) {
304 if (p->pac)
305 free(p->pac);
306 free(p);
307 }
308 *pac = NULL;
309
310 return ret;
311 }
312
313 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
314 krb5_pac_init(krb5_context context, krb5_pac *pac)
315 {
316 krb5_error_code ret;
317 krb5_pac p;
318
319 p = calloc(1, sizeof(*p));
320 if (p == NULL) {
321 return krb5_enomem(context);
322 }
323
324 p->pac = calloc(1, sizeof(*p->pac));
325 if (p->pac == NULL) {
326 free(p);
327 return krb5_enomem(context);
328 }
329
330 ret = krb5_data_alloc(&p->data, PACTYPE_SIZE);
331 if (ret) {
332 free (p->pac);
333 free(p);
334 return krb5_enomem(context);
335 }
336
337 *pac = p;
338 return 0;
339 }
340
341 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
342 krb5_pac_add_buffer(krb5_context context, krb5_pac p,
343 uint32_t type, const krb5_data *data)
344 {
345 krb5_error_code ret;
346 void *ptr;
347 uint32_t unaligned_len, num_buffers, len, offset, header_end, old_end;
348 uint32_t i;
349
350 if (data->length > UINT32_MAX) {
351 ret = EINVAL;
352 krb5_set_error_message(context, ret, "integer overrun");
353 return ret;
354 }
355
356 num_buffers = p->pac->numbuffers;
357
358 if (num_buffers >= UINT32_MAX) {
359 ret = EINVAL;
360 krb5_set_error_message(context, ret, "integer overrun");
361 return ret;
362 }
363 ret = pac_header_size(context, num_buffers + 1, &header_end);
364 if (ret) {
365 return ret;
366 }
367
368 ptr = realloc(p->pac, header_end);
369 if (ptr == NULL)
370 return krb5_enomem(context);
371
372 p->pac = ptr;
373
374 for (i = 0; i < num_buffers; i++) {
375 if (p->pac->buffers[i].offset_lo > UINT32_MAX - PAC_INFO_BUFFER_SIZE) {
376 ret = EINVAL;
377 krb5_set_error_message(context, ret, "integer overrun");
378 return ret;
379 }
380
381 p->pac->buffers[i].offset_lo += PAC_INFO_BUFFER_SIZE;
382 }
383
384 if (p->data.length > UINT32_MAX - PAC_INFO_BUFFER_SIZE) {
385 ret = EINVAL;
386 krb5_set_error_message(context, ret, "integer overrun");
387 return ret;
388 }
389 offset = p->data.length + PAC_INFO_BUFFER_SIZE;
390
391 p->pac->buffers[num_buffers].type = type;
392 p->pac->buffers[num_buffers].buffersize = data->length;
393 p->pac->buffers[num_buffers].offset_lo = offset;
394 p->pac->buffers[num_buffers].offset_hi = 0;
395
396 old_end = p->data.length;
397 if (offset > UINT32_MAX - data->length) {
398 krb5_set_error_message(context, EINVAL, "integer overrun");
399 return EINVAL;
400 }
401 unaligned_len = offset + data->length;
402
403 ret = pac_aligned_size(context, unaligned_len, &len);
404 if (ret)
405 return ret;
406
407 ret = krb5_data_realloc(&p->data, len);
408 if (ret) {
409 krb5_set_error_message(context, ret, N_("malloc: out of memory", ""));
410 return ret;
411 }
412
413 /*
414 * make place for new PAC INFO BUFFER header
415 */
416 header_end -= PAC_INFO_BUFFER_SIZE;
417 memmove((unsigned char *)p->data.data + header_end + PAC_INFO_BUFFER_SIZE,
418 (unsigned char *)p->data.data + header_end ,
419 old_end - header_end);
420 memset((unsigned char *)p->data.data + header_end, 0, PAC_INFO_BUFFER_SIZE);
421
422 /*
423 * copy in new data part
424 */
425
426 memcpy((unsigned char *)p->data.data + offset,
427 data->data, data->length);
428 memset((unsigned char *)p->data.data + offset + data->length,
429 0, p->data.length - unaligned_len);
430
431 p->pac->numbuffers += 1;
432
433 return 0;
434 }
435
436 /**
437 * Get the PAC buffer of specific type from the pac.
438 *
439 * @param context Kerberos 5 context.
440 * @param p the pac structure returned by krb5_pac_parse().
441 * @param type type of buffer to get
442 * @param data return data, free with krb5_data_free().
443 *
444 * @return Returns 0 to indicate success. Otherwise an kerberos et
445 * error code is returned, see krb5_get_error_message().
446 *
447 * @ingroup krb5_pac
448 */
449
450 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
451 krb5_pac_get_buffer(krb5_context context, krb5_pac p,
452 uint32_t type, krb5_data *data)
453 {
454 krb5_error_code ret;
455 uint32_t i;
456
457 for (i = 0; i < p->pac->numbuffers; i++) {
458 const uint32_t len = p->pac->buffers[i].buffersize;
459 const uint32_t offset = p->pac->buffers[i].offset_lo;
460
461 if (p->pac->buffers[i].type != type)
462 continue;
463
464 ret = krb5_data_copy(data, (unsigned char *)p->data.data + offset, len);
465 if (ret) {
466 krb5_set_error_message(context, ret, N_("malloc: out of memory", ""));
467 return ret;
468 }
469 return 0;
470 }
471 krb5_set_error_message(context, ENOENT, "No PAC buffer of type %lu was found",
472 (unsigned long)type);
473 return ENOENT;
474 }
475
476 /*
477 *
478 */
479
480 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
481 krb5_pac_get_types(krb5_context context,
482 krb5_pac p,
483 size_t *len,
484 uint32_t **types)
485 {
486 size_t i;
487
488 *types = calloc(p->pac->numbuffers, sizeof(**types));
489 if (*types == NULL) {
490 *len = 0;
491 return krb5_enomem(context);
492 }
493 for (i = 0; i < p->pac->numbuffers; i++)
494 (*types)[i] = p->pac->buffers[i].type;
495 *len = p->pac->numbuffers;
496
497 return 0;
498 }
499
500 /*
501 *
502 */
503
504 KRB5_LIB_FUNCTION void KRB5_LIB_CALL
505 krb5_pac_free(krb5_context context, krb5_pac pac)
506 {
507 krb5_data_free(&pac->data);
508 free(pac->pac);
509 free(pac);
510 }
511
512 /*
513 *
514 */
515
516 static krb5_error_code
517 verify_checksum(krb5_context context,
518 const struct PAC_INFO_BUFFER *sig,
519 const krb5_data *data,
520 void *ptr, size_t len,
521 const krb5_keyblock *key)
522 {
523 krb5_storage *sp = NULL;
524 uint32_t type;
525 krb5_error_code ret;
526 Checksum cksum;
527
528 memset(&cksum, 0, sizeof(cksum));
529
530 sp = krb5_storage_from_mem((char *)data->data + sig->offset_lo,
531 sig->buffersize);
532 if (sp == NULL)
533 return krb5_enomem(context);
534
535 krb5_storage_set_flags(sp, KRB5_STORAGE_BYTEORDER_LE);
536
537 CHECK(ret, krb5_ret_uint32(sp, &type), out);
538 cksum.cksumtype = type;
539 cksum.checksum.length =
540 sig->buffersize - krb5_storage_seek(sp, 0, SEEK_CUR);
541 cksum.checksum.data = malloc(cksum.checksum.length);
542 if (cksum.checksum.data == NULL) {
543 ret = krb5_enomem(context);
544 goto out;
545 }
546 ret = krb5_storage_read(sp, cksum.checksum.data, cksum.checksum.length);
547 if (ret != (int)cksum.checksum.length) {
548 ret = EINVAL;
549 krb5_set_error_message(context, ret, "PAC checksum missing checksum");
550 goto out;
551 }
552
553 if (!krb5_checksum_is_keyed(context, cksum.cksumtype)) {
554 ret = EINVAL;
555 krb5_set_error_message(context, ret, "Checksum type %d not keyed",
556 cksum.cksumtype);
557 goto out;
558 }
559
560 /* If the checksum is HMAC-MD5, the checksum type is not tied to
561 * the key type, instead the HMAC-MD5 checksum is applied blindly
562 * on whatever key is used for this connection, avoiding issues
563 * with unkeyed checksums on des-cbc-md5 and des-cbc-crc. See
564 * http://comments.gmane.org/gmane.comp.encryption.kerberos.devel/8743
565 * for the same issue in MIT, and
566 * http://blogs.msdn.com/b/openspecification/archive/2010/01/01/verifying-the-server-signature-in-kerberos-privilege-account-certificate.aspx
567 * for Microsoft's explaination */
568
569 if (cksum.cksumtype == CKSUMTYPE_HMAC_MD5) {
570 Checksum local_checksum;
571
572 memset(&local_checksum, 0, sizeof(local_checksum));
573
574 ret = HMAC_MD5_any_checksum(context, key, ptr, len,
575 KRB5_KU_OTHER_CKSUM, &local_checksum);
576
577 if (ret != 0 || krb5_data_ct_cmp(&local_checksum.checksum, &cksum.checksum) != 0) {
578 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
579 krb5_set_error_message(context, ret,
580 N_("PAC integrity check failed for "
581 "hmac-md5 checksum", ""));
582 }
583 krb5_data_free(&local_checksum.checksum);
584
585 } else {
586 krb5_crypto crypto = NULL;
587
588 ret = krb5_crypto_init(context, key, 0, &crypto);
589 if (ret)
590 goto out;
591
592 ret = krb5_verify_checksum(context, crypto, KRB5_KU_OTHER_CKSUM,
593 ptr, len, &cksum);
594 krb5_crypto_destroy(context, crypto);
595 }
596 free(cksum.checksum.data);
597 krb5_storage_free(sp);
598
599 return ret;
600
601 out:
602 if (cksum.checksum.data)
603 free(cksum.checksum.data);
604 if (sp)
605 krb5_storage_free(sp);
606 return ret;
607 }
608
609 static krb5_error_code
610 create_checksum(krb5_context context,
611 const krb5_keyblock *key,
612 uint32_t cksumtype,
613 void *data, size_t datalen,
614 void *sig, size_t siglen)
615 {
616 krb5_crypto crypto = NULL;
617 krb5_error_code ret;
618 Checksum cksum;
619
620 /* If the checksum is HMAC-MD5, the checksum type is not tied to
621 * the key type, instead the HMAC-MD5 checksum is applied blindly
622 * on whatever key is used for this connection, avoiding issues
623 * with unkeyed checksums on des-cbc-md5 and des-cbc-crc. See
624 * http://comments.gmane.org/gmane.comp.encryption.kerberos.devel/8743
625 * for the same issue in MIT, and
626 * http://blogs.msdn.com/b/openspecification/archive/2010/01/01/verifying-the-server-signature-in-kerberos-privilege-account-certificate.aspx
627 * for Microsoft's explaination */
628
629 if (cksumtype == (uint32_t)CKSUMTYPE_HMAC_MD5) {
630 ret = HMAC_MD5_any_checksum(context, key, data, datalen,
631 KRB5_KU_OTHER_CKSUM, &cksum);
632 if (ret)
633 return ret;
634 } else {
635 ret = krb5_crypto_init(context, key, 0, &crypto);
636 if (ret)
637 return ret;
638
639 ret = krb5_create_checksum(context, crypto, KRB5_KU_OTHER_CKSUM, 0,
640 data, datalen, &cksum);
641 krb5_crypto_destroy(context, crypto);
642 if (ret)
643 return ret;
644 }
645 if (cksum.checksum.length != siglen) {
646 krb5_set_error_message(context, EINVAL, "pac checksum wrong length");
647 free_Checksum(&cksum);
648 return EINVAL;
649 }
650
651 memcpy(sig, cksum.checksum.data, siglen);
652 free_Checksum(&cksum);
653
654 return 0;
655 }
656
657
658 /*
659 *
660 */
661
662 #define NTTIME_EPOCH 0x019DB1DED53E8000LL
663
664 static uint64_t
665 unix2nttime(time_t unix_time)
666 {
667 long long wt;
668 wt = unix_time * (uint64_t)10000000 + (uint64_t)NTTIME_EPOCH;
669 return wt;
670 }
671
672 static krb5_error_code
673 verify_logonname(krb5_context context,
674 const struct PAC_INFO_BUFFER *logon_name,
675 const krb5_data *data,
676 time_t authtime,
677 krb5_const_principal principal)
678 {
679 krb5_error_code ret;
680 uint32_t time1, time2;
681 krb5_storage *sp;
682 uint16_t len;
683 char *s = NULL;
684 char *principal_string = NULL;
685 char *logon_string = NULL;
686
687 sp = krb5_storage_from_readonly_mem((const char *)data->data + logon_name->offset_lo,
688 logon_name->buffersize);
689 if (sp == NULL)
690 return krb5_enomem(context);
691
692 krb5_storage_set_flags(sp, KRB5_STORAGE_BYTEORDER_LE);
693
694 CHECK(ret, krb5_ret_uint32(sp, &time1), out);
695 CHECK(ret, krb5_ret_uint32(sp, &time2), out);
696
697 {
698 uint64_t t1, t2;
699 t1 = unix2nttime(authtime);
700 t2 = ((uint64_t)time2 << 32) | time1;
701 /*
702 * When neither the ticket nor the PAC set an explicit authtime,
703 * both times are zero, but relative to different time scales.
704 * So we must compare "not set" values without converting to a
705 * common time reference.
706 */
707 if (t1 != t2 && (t2 != 0 && authtime != 0)) {
708 krb5_storage_free(sp);
709 krb5_set_error_message(context, EINVAL, "PAC timestamp mismatch");
710 return EINVAL;
711 }
712 }
713 CHECK(ret, krb5_ret_uint16(sp, &len), out);
714 if (len == 0) {
715 krb5_storage_free(sp);
716 krb5_set_error_message(context, EINVAL, "PAC logon name length missing");
717 return EINVAL;
718 }
719
720 s = malloc(len);
721 if (s == NULL) {
722 krb5_storage_free(sp);
723 return krb5_enomem(context);
724 }
725 ret = krb5_storage_read(sp, s, len);
726 if (ret != len) {
727 krb5_storage_free(sp);
728 krb5_set_error_message(context, EINVAL, "Failed to read PAC logon name");
729 return EINVAL;
730 }
731 krb5_storage_free(sp);
732 {
733 size_t ucs2len = len / 2;
734 uint16_t *ucs2;
735 size_t u8len;
736 unsigned int flags = WIND_RW_LE;
737
738 ucs2 = malloc(sizeof(ucs2[0]) * ucs2len);
739 if (ucs2 == NULL)
740 return krb5_enomem(context);
741
742 ret = wind_ucs2read(s, len, &flags, ucs2, &ucs2len);
743 free(s);
744 if (ret) {
745 free(ucs2);
746 krb5_set_error_message(context, ret, "Failed to convert string to UCS-2");
747 return ret;
748 }
749 ret = wind_ucs2utf8_length(ucs2, ucs2len, &u8len);
750 if (ret) {
751 free(ucs2);
752 krb5_set_error_message(context, ret, "Failed to count length of UCS-2 string");
753 return ret;
754 }
755 u8len += 1; /* Add space for NUL */
756 logon_string = malloc(u8len);
757 if (logon_string == NULL) {
758 free(ucs2);
759 return krb5_enomem(context);
760 }
761 ret = wind_ucs2utf8(ucs2, ucs2len, logon_string, &u8len);
762 free(ucs2);
763 if (ret) {
764 free(logon_string);
765 krb5_set_error_message(context, ret, "Failed to convert to UTF-8");
766 return ret;
767 }
768 }
769 ret = krb5_unparse_name_flags(context, principal,
770 KRB5_PRINCIPAL_UNPARSE_NO_REALM |
771 KRB5_PRINCIPAL_UNPARSE_DISPLAY,
772 &principal_string);
773 if (ret) {
774 free(logon_string);
775 return ret;
776 }
777
778 ret = strcmp(logon_string, principal_string);
779 if (ret != 0) {
780 ret = EINVAL;
781 krb5_set_error_message(context, ret, "PAC logon name [%s] mismatch principal name [%s]",
782 logon_string, principal_string);
783 }
784 free(logon_string);
785 free(principal_string);
786 return ret;
787 out:
788 return ret;
789 }
790
791 /*
792 *
793 */
794
795 static krb5_error_code
796 build_logon_name(krb5_context context,
797 time_t authtime,
798 krb5_const_principal principal,
799 krb5_data *logon)
800 {
801 krb5_error_code ret;
802 krb5_storage *sp;
803 uint64_t t;
804 char *s, *s2;
805 size_t s2_len;
806
807 t = unix2nttime(authtime);
808
809 krb5_data_zero(logon);
810
811 sp = krb5_storage_emem();
812 if (sp == NULL)
813 return krb5_enomem(context);
814
815 krb5_storage_set_flags(sp, KRB5_STORAGE_BYTEORDER_LE);
816
817 CHECK(ret, krb5_store_uint32(sp, t & 0xffffffff), out);
818 CHECK(ret, krb5_store_uint32(sp, t >> 32), out);
819
820 ret = krb5_unparse_name_flags(context, principal,
821 KRB5_PRINCIPAL_UNPARSE_NO_REALM |
822 KRB5_PRINCIPAL_UNPARSE_DISPLAY,
823 &s);
824 if (ret)
825 goto out;
826
827 {
828 size_t ucs2_len;
829 uint16_t *ucs2;
830 unsigned int flags;
831
832 ret = wind_utf8ucs2_length(s, &ucs2_len);
833 if (ret) {
834 krb5_set_error_message(context, ret, "Principal %s is not valid UTF-8", s);
835 free(s);
836 return ret;
837 }
838
839 ucs2 = malloc(sizeof(ucs2[0]) * ucs2_len);
840 if (ucs2 == NULL) {
841 free(s);
842 return krb5_enomem(context);
843 }
844
845 ret = wind_utf8ucs2(s, ucs2, &ucs2_len);
846 if (ret) {
847 free(ucs2);
848 krb5_set_error_message(context, ret, "Principal %s is not valid UTF-8", s);
849 free(s);
850 return ret;
851 } else
852 free(s);
853
854 s2_len = (ucs2_len + 1) * 2;
855 s2 = malloc(s2_len);
856 if (s2 == NULL) {
857 free(ucs2);
858 return krb5_enomem(context);
859 }
860
861 flags = WIND_RW_LE;
862 ret = wind_ucs2write(ucs2, ucs2_len,
863 &flags, s2, &s2_len);
864 free(ucs2);
865 if (ret) {
866 free(s2);
867 krb5_set_error_message(context, ret, "Failed to write to UCS-2 buffer");
868 return ret;
869 }
870
871 /*
872 * we do not want zero termination
873 */
874 s2_len = ucs2_len * 2;
875 }
876
877 CHECK(ret, krb5_store_uint16(sp, s2_len), out);
878
879 ret = krb5_storage_write(sp, s2, s2_len);
880 free(s2);
881 if (ret != (int)s2_len) {
882 ret = krb5_enomem(context);
883 goto out;
884 }
885 ret = krb5_storage_to_data(sp, logon);
886 if (ret)
887 goto out;
888 krb5_storage_free(sp);
889
890 return 0;
891 out:
892 krb5_storage_free(sp);
893 return ret;
894 }
895
896
897 /**
898 * Verify the PAC.
899 *
900 * @param context Kerberos 5 context.
901 * @param pac the pac structure returned by krb5_pac_parse().
902 * @param authtime The time of the ticket the PAC belongs to.
903 * @param principal the principal to verify.
904 * @param server The service key, most always be given.
905 * @param privsvr The KDC key, may be given.
906
907 * @return Returns 0 to indicate success. Otherwise an kerberos et
908 * error code is returned, see krb5_get_error_message().
909 *
910 * @ingroup krb5_pac
911 */
912
913 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
914 krb5_pac_verify(krb5_context context,
915 const krb5_pac pac,
916 time_t authtime,
917 krb5_const_principal principal,
918 const krb5_keyblock *server,
919 const krb5_keyblock *privsvr)
920 {
921 krb5_error_code ret;
922
923 if (pac->server_checksum == NULL) {
924 krb5_set_error_message(context, EINVAL, "PAC missing server checksum");
925 return EINVAL;
926 }
927 if (pac->privsvr_checksum == NULL) {
928 krb5_set_error_message(context, EINVAL, "PAC missing kdc checksum");
929 return EINVAL;
930 }
931 if (pac->logon_name == NULL) {
932 krb5_set_error_message(context, EINVAL, "PAC missing logon name");
933 return EINVAL;
934 }
935
936 ret = verify_logonname(context,
937 pac->logon_name,
938 &pac->data,
939 authtime,
940 principal);
941 if (ret)
942 return ret;
943
944 /*
945 * in the service case, clean out data option of the privsvr and
946 * server checksum before checking the checksum.
947 */
948 {
949 krb5_data *copy;
950
951 if (pac->server_checksum->buffersize < 4 ||
952 pac->privsvr_checksum->buffersize < 4)
953 return EINVAL;
954
955 ret = krb5_copy_data(context, &pac->data, &copy);
956 if (ret)
957 return ret;
958
959 memset((char *)copy->data + pac->server_checksum->offset_lo + 4,
960 0,
961 pac->server_checksum->buffersize - 4);
962
963 memset((char *)copy->data + pac->privsvr_checksum->offset_lo + 4,
964 0,
965 pac->privsvr_checksum->buffersize - 4);
966
967 ret = verify_checksum(context,
968 pac->server_checksum,
969 &pac->data,
970 copy->data,
971 copy->length,
972 server);
973 krb5_free_data(context, copy);
974 if (ret)
975 return ret;
976 }
977 if (privsvr) {
978 /* The priv checksum covers the server checksum */
979 ret = verify_checksum(context,
980 pac->privsvr_checksum,
981 &pac->data,
982 (char *)pac->data.data
983 + pac->server_checksum->offset_lo + 4,
984 pac->server_checksum->buffersize - 4,
985 privsvr);
986 if (ret)
987 return ret;
988 }
989
990 return 0;
991 }
992
993 /*
994 *
995 */
996
997 static krb5_error_code
998 fill_zeros(krb5_context context, krb5_storage *sp, size_t len)
999 {
1000 ssize_t sret;
1001 size_t l;
1002
1003 while (len) {
1004 l = len;
1005 if (l > sizeof(zeros))
1006 l = sizeof(zeros);
1007 sret = krb5_storage_write(sp, zeros, l);
1008 if (sret <= 0)
1009 return krb5_enomem(context);
1010
1011 len -= sret;
1012 }
1013 return 0;
1014 }
1015
1016 static krb5_error_code
1017 pac_checksum(krb5_context context,
1018 const krb5_keyblock *key,
1019 uint32_t *cksumtype,
1020 size_t *cksumsize)
1021 {
1022 krb5_cksumtype cktype;
1023 krb5_error_code ret;
1024 krb5_crypto crypto = NULL;
1025
1026 ret = krb5_crypto_init(context, key, 0, &crypto);
1027 if (ret)
1028 return ret;
1029
1030 ret = krb5_crypto_get_checksum_type(context, crypto, &cktype);
1031 krb5_crypto_destroy(context, crypto);
1032 if (ret)
1033 return ret;
1034
1035 if (krb5_checksum_is_keyed(context, cktype) == FALSE) {
1036 *cksumtype = CKSUMTYPE_HMAC_MD5;
1037 *cksumsize = 16;
1038 }
1039
1040 ret = krb5_checksumsize(context, cktype, cksumsize);
1041 if (ret)
1042 return ret;
1043
1044 *cksumtype = (uint32_t)cktype;
1045
1046 return 0;
1047 }
1048
1049 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1050 _krb5_pac_sign(krb5_context context,
1051 krb5_pac p,
1052 time_t authtime,
1053 krb5_principal principal,
1054 const krb5_keyblock *server_key,
1055 const krb5_keyblock *priv_key,
1056 krb5_data *data)
1057 {
1058 krb5_error_code ret;
1059 krb5_storage *sp = NULL, *spdata = NULL;
1060 uint32_t end;
1061 size_t server_size, priv_size;
1062 uint32_t server_offset = 0, priv_offset = 0;
1063 uint32_t server_cksumtype = 0, priv_cksumtype = 0;
1064 uint32_t num = 0;
1065 uint32_t i;
1066 krb5_data logon, d;
1067
1068 krb5_data_zero(&logon);
1069
1070 for (i = 0; i < p->pac->numbuffers; i++) {
1071 if (p->pac->buffers[i].type == PAC_SERVER_CHECKSUM) {
1072 if (p->server_checksum == NULL) {
1073 p->server_checksum = &p->pac->buffers[i];
1074 }
1075 if (p->server_checksum != &p->pac->buffers[i]) {
1076 ret = EINVAL;
1077 krb5_set_error_message(context, ret,
1078 N_("PAC have two server checksums", ""));
1079 goto out;
1080 }
1081 } else if (p->pac->buffers[i].type == PAC_PRIVSVR_CHECKSUM) {
1082 if (p->privsvr_checksum == NULL) {
1083 p->privsvr_checksum = &p->pac->buffers[i];
1084 }
1085 if (p->privsvr_checksum != &p->pac->buffers[i]) {
1086 ret = EINVAL;
1087 krb5_set_error_message(context, ret,
1088 N_("PAC have two KDC checksums", ""));
1089 goto out;
1090 }
1091 } else if (p->pac->buffers[i].type == PAC_LOGON_NAME) {
1092 if (p->logon_name == NULL) {
1093 p->logon_name = &p->pac->buffers[i];
1094 }
1095 if (p->logon_name != &p->pac->buffers[i]) {
1096 ret = EINVAL;
1097 krb5_set_error_message(context, ret,
1098 N_("PAC have two logon names", ""));
1099 goto out;
1100 }
1101 }
1102 }
1103
1104 if (p->logon_name == NULL)
1105 num++;
1106 if (p->server_checksum == NULL)
1107 num++;
1108 if (p->privsvr_checksum == NULL)
1109 num++;
1110
1111 if (num) {
1112 void *ptr;
1113 uint32_t len;
1114
1115 if (p->pac->numbuffers > UINT32_MAX - num) {
1116 ret = EINVAL;
1117 krb5_set_error_message(context, ret, "integer overrun");
1118 goto out;
1119 }
1120 ret = pac_header_size(context, p->pac->numbuffers + num, &len);
1121 if (ret)
1122 goto out;
1123
1124 ptr = realloc(p->pac, len);
1125 if (ptr == NULL)
1126 return krb5_enomem(context);
1127
1128 p->pac = ptr;
1129
1130 if (p->logon_name == NULL) {
1131 p->logon_name = &p->pac->buffers[p->pac->numbuffers++];
1132 memset(p->logon_name, 0, sizeof(*p->logon_name));
1133 p->logon_name->type = PAC_LOGON_NAME;
1134 }
1135 if (p->server_checksum == NULL) {
1136 p->server_checksum = &p->pac->buffers[p->pac->numbuffers++];
1137 memset(p->server_checksum, 0, sizeof(*p->server_checksum));
1138 p->server_checksum->type = PAC_SERVER_CHECKSUM;
1139 }
1140 if (p->privsvr_checksum == NULL) {
1141 p->privsvr_checksum = &p->pac->buffers[p->pac->numbuffers++];
1142 memset(p->privsvr_checksum, 0, sizeof(*p->privsvr_checksum));
1143 p->privsvr_checksum->type = PAC_PRIVSVR_CHECKSUM;
1144 }
1145 }
1146
1147 /* Calculate LOGON NAME */
1148 ret = build_logon_name(context, authtime, principal, &logon);
1149 if (ret)
1150 goto out;
1151
1152 /* Set lengths for checksum */
1153 ret = pac_checksum(context, server_key, &server_cksumtype, &server_size);
1154 if (ret)
1155 goto out;
1156 ret = pac_checksum(context, priv_key, &priv_cksumtype, &priv_size);
1157 if (ret)
1158 goto out;
1159
1160 /* Encode PAC */
1161 sp = krb5_storage_emem();
1162 if (sp == NULL)
1163 return krb5_enomem(context);
1164
1165 krb5_storage_set_flags(sp, KRB5_STORAGE_BYTEORDER_LE);
1166
1167 spdata = krb5_storage_emem();
1168 if (spdata == NULL) {
1169 krb5_storage_free(sp);
1170 return krb5_enomem(context);
1171 }
1172 krb5_storage_set_flags(spdata, KRB5_STORAGE_BYTEORDER_LE);
1173
1174 CHECK(ret, krb5_store_uint32(sp, p->pac->numbuffers), out);
1175 CHECK(ret, krb5_store_uint32(sp, p->pac->version), out);
1176
1177 ret = pac_header_size(context, p->pac->numbuffers, &end);
1178 if (ret)
1179 goto out;
1180
1181 for (i = 0; i < p->pac->numbuffers; i++) {
1182 uint32_t len;
1183 size_t sret;
1184 void *ptr = NULL;
1185
1186 /* store data */
1187
1188 if (p->pac->buffers[i].type == PAC_SERVER_CHECKSUM) {
1189 if (server_size > UINT32_MAX - 4) {
1190 ret = EINVAL;
1191 krb5_set_error_message(context, ret, "integer overrun");
1192 goto out;
1193 }
1194 if (end > UINT32_MAX - 4) {
1195 ret = EINVAL;
1196 krb5_set_error_message(context, ret, "integer overrun");
1197 goto out;
1198 }
1199 len = server_size + 4;
1200 server_offset = end + 4;
1201 CHECK(ret, krb5_store_uint32(spdata, server_cksumtype), out);
1202 CHECK(ret, fill_zeros(context, spdata, server_size), out);
1203 } else if (p->pac->buffers[i].type == PAC_PRIVSVR_CHECKSUM) {
1204 if (priv_size > UINT32_MAX - 4) {
1205 ret = EINVAL;
1206 krb5_set_error_message(context, ret, "integer overrun");
1207 goto out;
1208 }
1209 if (end > UINT32_MAX - 4) {
1210 ret = EINVAL;
1211 krb5_set_error_message(context, ret, "integer overrun");
1212 goto out;
1213 }
1214 len = priv_size + 4;
1215 priv_offset = end + 4;
1216 CHECK(ret, krb5_store_uint32(spdata, priv_cksumtype), out);
1217 CHECK(ret, fill_zeros(context, spdata, priv_size), out);
1218 } else if (p->pac->buffers[i].type == PAC_LOGON_NAME) {
1219 len = krb5_storage_write(spdata, logon.data, logon.length);
1220 if (logon.length != len) {
1221 ret = EINVAL;
1222 goto out;
1223 }
1224 } else {
1225 len = p->pac->buffers[i].buffersize;
1226 ptr = (char *)p->data.data + p->pac->buffers[i].offset_lo;
1227
1228 sret = krb5_storage_write(spdata, ptr, len);
1229 if (sret != len) {
1230 ret = krb5_enomem(context);
1231 goto out;
1232 }
1233 /* XXX if not aligned, fill_zeros */
1234 }
1235
1236 /* write header */
1237 CHECK(ret, krb5_store_uint32(sp, p->pac->buffers[i].type), out);
1238 CHECK(ret, krb5_store_uint32(sp, len), out);
1239 CHECK(ret, krb5_store_uint32(sp, end), out);
1240 CHECK(ret, krb5_store_uint32(sp, 0), out);
1241
1242 /* advance data endpointer and align */
1243 {
1244 uint32_t e;
1245
1246 if (end > UINT32_MAX - len) {
1247 ret = EINVAL;
1248 krb5_set_error_message(context, ret, "integer overrun");
1249 goto out;
1250 }
1251 end += len;
1252
1253 ret = pac_aligned_size(context, end, &e);
1254 if (ret)
1255 goto out;
1256
1257 if (end != e) {
1258 CHECK(ret, fill_zeros(context, spdata, e - end), out);
1259 }
1260 end = e;
1261 }
1262
1263 }
1264
1265 /* assert (server_offset != 0 && priv_offset != 0); */
1266
1267 /* export PAC */
1268 ret = krb5_storage_to_data(spdata, &d);
1269 if (ret) {
1270 krb5_set_error_message(context, ret, N_("malloc: out of memory", ""));
1271 goto out;
1272 }
1273 ret = krb5_storage_write(sp, d.data, d.length);
1274 if (ret != (int)d.length) {
1275 krb5_data_free(&d);
1276 ret = krb5_enomem(context);
1277 goto out;
1278 }
1279 krb5_data_free(&d);
1280
1281 ret = krb5_storage_to_data(sp, &d);
1282 if (ret) {
1283 ret = krb5_enomem(context);
1284 goto out;
1285 }
1286
1287 /* sign */
1288 ret = create_checksum(context, server_key, server_cksumtype,
1289 d.data, d.length,
1290 (char *)d.data + server_offset, server_size);
1291 if (ret) {
1292 krb5_data_free(&d);
1293 goto out;
1294 }
1295 ret = create_checksum(context, priv_key, priv_cksumtype,
1296 (char *)d.data + server_offset, server_size,
1297 (char *)d.data + priv_offset, priv_size);
1298 if (ret) {
1299 krb5_data_free(&d);
1300 goto out;
1301 }
1302
1303 /* done */
1304 *data = d;
1305
1306 krb5_data_free(&logon);
1307 krb5_storage_free(sp);
1308 krb5_storage_free(spdata);
1309
1310 return 0;
1311 out:
1312 krb5_data_free(&logon);
1313 if (sp)
1314 krb5_storage_free(sp);
1315 if (spdata)
1316 krb5_storage_free(spdata);
1317 return ret;
1318 }