Debian Codegraph @

lib/krb5/ticket.c

raw
1 /*
2 * Copyright (c) 1997 - 2001 Kungliga Tekniska Högskolan
3 * (Royal Institute of Technology, Stockholm, Sweden).
4 * All rights reserved.
5 *
6 * Portions Copyright (c) 2009 Apple Inc. All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 *
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * 3. Neither the name of the Institute nor the names of its contributors
20 * may be used to endorse or promote products derived from this software
21 * without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 */
35
36 #include "krb5_locl.h"
37
38 /**
39 * Free ticket and content
40 *
41 * @param context a Kerberos 5 context
42 * @param ticket ticket to free
43 *
44 * @return Returns 0 to indicate success. Otherwise an kerberos et
45 * error code is returned, see krb5_get_error_message().
46 *
47 * @ingroup krb5
48 */
49
50 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
51 krb5_free_ticket(krb5_context context,
52 krb5_ticket *ticket)
53 {
54 free_EncTicketPart(&ticket->ticket);
55 krb5_free_principal(context, ticket->client);
56 krb5_free_principal(context, ticket->server);
57 free(ticket);
58 return 0;
59 }
60
61 /**
62 * Copy ticket and content
63 *
64 * @param context a Kerberos 5 context
65 * @param from ticket to copy
66 * @param to new copy of ticket, free with krb5_free_ticket()
67 *
68 * @return Returns 0 to indicate success. Otherwise an kerberos et
69 * error code is returned, see krb5_get_error_message().
70 *
71 * @ingroup krb5
72 */
73
74 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
75 krb5_copy_ticket(krb5_context context,
76 const krb5_ticket *from,
77 krb5_ticket **to)
78 {
79 krb5_error_code ret;
80 krb5_ticket *tmp;
81
82 *to = NULL;
83 tmp = malloc(sizeof(*tmp));
84 if (tmp == NULL)
85 return krb5_enomem(context);
86 if((ret = copy_EncTicketPart(&from->ticket, &tmp->ticket))){
87 free(tmp);
88 return ret;
89 }
90 ret = krb5_copy_principal(context, from->client, &tmp->client);
91 if(ret){
92 free_EncTicketPart(&tmp->ticket);
93 free(tmp);
94 return ret;
95 }
96 ret = krb5_copy_principal(context, from->server, &tmp->server);
97 if(ret){
98 krb5_free_principal(context, tmp->client);
99 free_EncTicketPart(&tmp->ticket);
100 free(tmp);
101 return ret;
102 }
103 *to = tmp;
104 return 0;
105 }
106
107 /**
108 * Return client principal in ticket
109 *
110 * @param context a Kerberos 5 context
111 * @param ticket ticket to copy
112 * @param client client principal, free with krb5_free_principal()
113 *
114 * @return Returns 0 to indicate success. Otherwise an kerberos et
115 * error code is returned, see krb5_get_error_message().
116 *
117 * @ingroup krb5
118 */
119
120 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
121 krb5_ticket_get_client(krb5_context context,
122 const krb5_ticket *ticket,
123 krb5_principal *client)
124 {
125 return krb5_copy_principal(context, ticket->client, client);
126 }
127
128 /**
129 * Return server principal in ticket
130 *
131 * @param context a Kerberos 5 context
132 * @param ticket ticket to copy
133 * @param server server principal, free with krb5_free_principal()
134 *
135 * @return Returns 0 to indicate success. Otherwise an kerberos et
136 * error code is returned, see krb5_get_error_message().
137 *
138 * @ingroup krb5
139 */
140
141 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
142 krb5_ticket_get_server(krb5_context context,
143 const krb5_ticket *ticket,
144 krb5_principal *server)
145 {
146 return krb5_copy_principal(context, ticket->server, server);
147 }
148
149 /**
150 * Return end time of ticket
151 *
152 * @param context a Kerberos 5 context
153 * @param ticket ticket to copy
154 *
155 * @return end time of ticket
156 *
157 * @ingroup krb5
158 */
159
160 KRB5_LIB_FUNCTION time_t KRB5_LIB_CALL
161 krb5_ticket_get_endtime(krb5_context context,
162 const krb5_ticket *ticket)
163 {
164 return ticket->ticket.endtime;
165 }
166
167 /**
168 * Get the flags from the Kerberos ticket
169 *
170 * @param context Kerberos context
171 * @param ticket Kerberos ticket
172 *
173 * @return ticket flags
174 *
175 * @ingroup krb5_ticket
176 */
177 KRB5_LIB_FUNCTION unsigned long KRB5_LIB_CALL
178 krb5_ticket_get_flags(krb5_context context,
179 const krb5_ticket *ticket)
180 {
181 return TicketFlags2int(ticket->ticket.flags);
182 }
183
184 static int
185 find_type_in_ad(krb5_context context,
186 int type,
187 krb5_data *data,
188 krb5_boolean *found,
189 krb5_boolean failp,
190 krb5_keyblock *sessionkey,
191 const AuthorizationData *ad,
192 int level)
193 {
194 krb5_error_code ret = 0;
195 size_t i;
196
197 if (level > 9) {
198 ret = ENOENT; /* XXX */
199 krb5_set_error_message(context, ret,
200 N_("Authorization data nested deeper "
201 "then %d levels, stop searching", ""),
202 level);
203 goto out;
204 }
205
206 /*
207 * Only copy out the element the first time we get to it, we need
208 * to run over the whole authorization data fields to check if
209 * there are any container clases we need to care about.
210 */
211 for (i = 0; i < ad->len; i++) {
212 if (!*found && ad->val[i].ad_type == type) {
213 ret = der_copy_octet_string(&ad->val[i].ad_data, data);
214 if (ret) {
215 krb5_set_error_message(context, ret,
216 N_("malloc: out of memory", ""));
217 goto out;
218 }
219 *found = TRUE;
220 continue;
221 }
222 switch (ad->val[i].ad_type) {
223 case KRB5_AUTHDATA_IF_RELEVANT: {
224 AuthorizationData child;
225 ret = decode_AuthorizationData(ad->val[i].ad_data.data,
226 ad->val[i].ad_data.length,
227 &child,
228 NULL);
229 if (ret) {
230 krb5_set_error_message(context, ret,
231 N_("Failed to decode "
232 "IF_RELEVANT with %d", ""),
233 (int)ret);
234 goto out;
235 }
236 ret = find_type_in_ad(context, type, data, found, FALSE,
237 sessionkey, &child, level + 1);
238 free_AuthorizationData(&child);
239 if (ret)
240 goto out;
241 break;
242 }
243 #if 0 /* XXX test */
244 case KRB5_AUTHDATA_KDC_ISSUED: {
245 AD_KDCIssued child;
246
247 ret = decode_AD_KDCIssued(ad->val[i].ad_data.data,
248 ad->val[i].ad_data.length,
249 &child,
250 NULL);
251 if (ret) {
252 krb5_set_error_message(context, ret,
253 N_("Failed to decode "
254 "AD_KDCIssued with %d", ""),
255 ret);
256 goto out;
257 }
258 if (failp) {
259 krb5_boolean valid;
260 krb5_data buf;
261 size_t len;
262
263 ASN1_MALLOC_ENCODE(AuthorizationData, buf.data, buf.length,
264 &child.elements, &len, ret);
265 if (ret) {
266 free_AD_KDCIssued(&child);
267 krb5_clear_error_message(context);
268 goto out;
269 }
270 if(buf.length != len)
271 krb5_abortx(context, "internal error in ASN.1 encoder");
272
273 ret = krb5_c_verify_checksum(context, sessionkey, 19, &buf,
274 &child.ad_checksum, &valid);
275 krb5_data_free(&buf);
276 if (ret) {
277 free_AD_KDCIssued(&child);
278 goto out;
279 }
280 if (!valid) {
281 krb5_clear_error_message(context);
282 ret = ENOENT;
283 free_AD_KDCIssued(&child);
284 goto out;
285 }
286 }
287 ret = find_type_in_ad(context, type, data, found, failp, sessionkey,
288 &child.elements, level + 1);
289 free_AD_KDCIssued(&child);
290 if (ret)
291 goto out;
292 break;
293 }
294 #endif
295 case KRB5_AUTHDATA_AND_OR:
296 if (!failp)
297 break;
298 ret = ENOENT; /* XXX */
299 krb5_set_error_message(context, ret,
300 N_("Authorization data contains "
301 "AND-OR element that is unknown to the "
302 "application", ""));
303 goto out;
304 default:
305 if (!failp)
306 break;
307 ret = ENOENT; /* XXX */
308 krb5_set_error_message(context, ret,
309 N_("Authorization data contains "
310 "unknown type (%d) ", ""),
311 ad->val[i].ad_type);
312 goto out;
313 }
314 }
315 out:
316 if (ret) {
317 if (*found) {
318 krb5_data_free(data);
319 *found = 0;
320 }
321 }
322 return ret;
323 }
324
325 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
326 _krb5_get_ad(krb5_context context,
327 const AuthorizationData *ad,
328 krb5_keyblock *sessionkey,
329 int type,
330 krb5_data *data)
331 {
332 krb5_boolean found = FALSE;
333 krb5_error_code ret;
334
335 krb5_data_zero(data);
336
337 if (ad == NULL) {
338 krb5_set_error_message(context, ENOENT,
339 N_("No authorization data", ""));
340 return ENOENT; /* XXX */
341 }
342
343 ret = find_type_in_ad(context, type, data, &found, TRUE, sessionkey, ad, 0);
344 if (ret)
345 return ret;
346 if (!found) {
347 krb5_set_error_message(context, ENOENT,
348 N_("Have no authorization data of type %d", ""),
349 type);
350 return ENOENT; /* XXX */
351 }
352 return 0;
353 }
354
355
356 /**
357 * Extract the authorization data type of type from the ticket. Store
358 * the field in data. This function is to use for kerberos
359 * applications.
360 *
361 * @param context a Kerberos 5 context
362 * @param ticket Kerberos ticket
363 * @param type type to fetch
364 * @param data returned data, free with krb5_data_free()
365 *
366 * @ingroup krb5
367 */
368
369 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
370 krb5_ticket_get_authorization_data_type(krb5_context context,
371 krb5_ticket *ticket,
372 int type,
373 krb5_data *data)
374 {
375 AuthorizationData *ad;
376 krb5_error_code ret;
377 krb5_boolean found = FALSE;
378
379 krb5_data_zero(data);
380
381 ad = ticket->ticket.authorization_data;
382 if (ticket->ticket.authorization_data == NULL) {
383 krb5_set_error_message(context, ENOENT,
384 N_("Ticket have not authorization data", ""));
385 return ENOENT; /* XXX */
386 }
387
388 ret = find_type_in_ad(context, type, data, &found, TRUE,
389 &ticket->ticket.key, ad, 0);
390 if (ret)
391 return ret;
392 if (!found) {
393 krb5_set_error_message(context, ENOENT,
394 N_("Ticket have not "
395 "authorization data of type %d", ""),
396 type);
397 return ENOENT; /* XXX */
398 }
399 return 0;
400 }
401
402 static krb5_error_code
403 check_server_referral(krb5_context context,
404 krb5_kdc_rep *rep,
405 unsigned flags,
406 krb5_const_principal requested,
407 krb5_const_principal returned,
408 krb5_keyblock * key)
409 {
410 krb5_error_code ret;
411 PA_ServerReferralData ref;
412 krb5_crypto session;
413 EncryptedData ed;
414 size_t len;
415 krb5_data data;
416 PA_DATA *pa;
417 int i = 0, cmp;
418
419 if (rep->kdc_rep.padata == NULL)
420 goto noreferral;
421
422 pa = krb5_find_padata(rep->kdc_rep.padata->val,
423 rep->kdc_rep.padata->len,
424 KRB5_PADATA_SERVER_REFERRAL, &i);
425 if (pa == NULL)
426 goto noreferral;
427
428 memset(&ed, 0, sizeof(ed));
429 memset(&ref, 0, sizeof(ref));
430
431 ret = decode_EncryptedData(pa->padata_value.data,
432 pa->padata_value.length,
433 &ed, &len);
434 if (ret)
435 return ret;
436 if (len != pa->padata_value.length) {
437 free_EncryptedData(&ed);
438 krb5_set_error_message(context, KRB5KRB_AP_ERR_MODIFIED,
439 N_("Referral EncryptedData wrong for realm %s",
440 "realm"), requested->realm);
441 return KRB5KRB_AP_ERR_MODIFIED;
442 }
443
444 ret = krb5_crypto_init(context, key, 0, &session);
445 if (ret) {
446 free_EncryptedData(&ed);
447 return ret;
448 }
449
450 ret = krb5_decrypt_EncryptedData(context, session,
451 KRB5_KU_PA_SERVER_REFERRAL,
452 &ed, &data);
453 free_EncryptedData(&ed);
454 krb5_crypto_destroy(context, session);
455 if (ret)
456 return ret;
457
458 ret = decode_PA_ServerReferralData(data.data, data.length, &ref, &len);
459 if (ret) {
460 krb5_data_free(&data);
461 return ret;
462 }
463 krb5_data_free(&data);
464
465 if (strcmp(requested->realm, returned->realm) != 0) {
466 free_PA_ServerReferralData(&ref);
467 krb5_set_error_message(context, KRB5KRB_AP_ERR_MODIFIED,
468 N_("server ref realm mismatch, "
469 "requested realm %s got back %s", ""),
470 requested->realm, returned->realm);
471 return KRB5KRB_AP_ERR_MODIFIED;
472 }
473
474 if (krb5_principal_is_krbtgt(context, returned)) {
475 const char *realm = returned->name.name_string.val[1];
476
477 if (ref.referred_realm == NULL
478 || strcmp(*ref.referred_realm, realm) != 0)
479 {
480 free_PA_ServerReferralData(&ref);
481 krb5_set_error_message(context, KRB5KRB_AP_ERR_MODIFIED,
482 N_("tgt returned with wrong ref", ""));
483 return KRB5KRB_AP_ERR_MODIFIED;
484 }
485 } else if (krb5_principal_compare(context, returned, requested) == 0) {
486 free_PA_ServerReferralData(&ref);
487 krb5_set_error_message(context, KRB5KRB_AP_ERR_MODIFIED,
488 N_("req princ no same as returned", ""));
489 return KRB5KRB_AP_ERR_MODIFIED;
490 }
491
492 if (ref.requested_principal_name) {
493 cmp = _krb5_principal_compare_PrincipalName(context,
494 requested,
495 ref.requested_principal_name);
496 if (!cmp) {
497 free_PA_ServerReferralData(&ref);
498 krb5_set_error_message(context, KRB5KRB_AP_ERR_MODIFIED,
499 N_("referred principal not same "
500 "as requested", ""));
501 return KRB5KRB_AP_ERR_MODIFIED;
502 }
503 } else if (flags & EXTRACT_TICKET_AS_REQ) {
504 free_PA_ServerReferralData(&ref);
505 krb5_set_error_message(context, KRB5KRB_AP_ERR_MODIFIED,
506 N_("Requested principal missing on AS-REQ", ""));
507 return KRB5KRB_AP_ERR_MODIFIED;
508 }
509
510 free_PA_ServerReferralData(&ref);
511
512 return ret;
513 noreferral:
514 /*
515 * Expect excact match or that we got a krbtgt
516 */
517 if (krb5_principal_compare(context, requested, returned) != TRUE &&
518 (krb5_realm_compare(context, requested, returned) != TRUE &&
519 krb5_principal_is_krbtgt(context, returned) != TRUE))
520 {
521 krb5_set_error_message(context, KRB5KRB_AP_ERR_MODIFIED,
522 N_("Not same server principal returned "
523 "as requested", ""));
524 return KRB5KRB_AP_ERR_MODIFIED;
525 }
526 return 0;
527 }
528
529 /*
530 * Verify KDC supported anonymous if requested
531 */
532 static krb5_error_code
533 check_client_anonymous(krb5_context context,
534 krb5_kdc_rep *rep,
535 krb5_const_principal requested,
536 krb5_const_principal mapped,
537 krb5_boolean is_tgs_rep)
538 {
539 int flags;
540
541 if (!rep->enc_part.flags.anonymous)
542 return KRB5KDC_ERR_BADOPTION;
543
544 /*
545 * Here we must validate that the AS returned a ticket of the expected type
546 * for either a fully anonymous request, or authenticated request for an
547 * anonymous ticket. If this is a TGS request, we're done. Then if the
548 * 'requested' principal was anonymous, we'll check the 'mapped' principal
549 * accordingly (without enforcing the name type and perhaps the realm).
550 * Finally, if the 'requested' principal was not anonymous, well check
551 * that the 'mapped' principal has an anonymous name and type, in a
552 * non-anonymous realm. (Should we also be checking for a realm match
553 * between the request and the mapped name in this case?)
554 */
555 if (is_tgs_rep)
556 flags = KRB5_ANON_MATCH_ANY_NONT;
557 else if (krb5_principal_is_anonymous(context, requested,
558 KRB5_ANON_MATCH_ANY_NONT))
559 flags = KRB5_ANON_MATCH_UNAUTHENTICATED | KRB5_ANON_IGNORE_NAME_TYPE;
560 else
561 flags = KRB5_ANON_MATCH_AUTHENTICATED;
562
563 if (!krb5_principal_is_anonymous(context, mapped, flags))
564 return KRB5KRB_AP_ERR_MODIFIED;
565
566 return 0;
567 }
568
569 /*
570 * Verify returned client principal name in anonymous/referral case
571 */
572
573 static krb5_error_code
574 check_client_mismatch(krb5_context context,
575 krb5_kdc_rep *rep,
576 krb5_const_principal requested,
577 krb5_const_principal mapped,
578 krb5_keyblock const * key)
579 {
580 if (rep->enc_part.flags.anonymous) {
581 if (!krb5_principal_is_anonymous(context, mapped,
582 KRB5_ANON_MATCH_ANY_NONT)) {
583 krb5_set_error_message(context, KRB5KRB_AP_ERR_MODIFIED,
584 N_("Anonymous ticket does not contain anonymous "
585 "principal", ""));
586 return KRB5KRB_AP_ERR_MODIFIED;
587 }
588 } else {
589 if (krb5_principal_compare(context, requested, mapped) == FALSE &&
590 !rep->enc_part.flags.enc_pa_rep) {
591 krb5_set_error_message(context, KRB5KRB_AP_ERR_MODIFIED,
592 N_("Not same client principal returned "
593 "as requested", ""));
594 return KRB5KRB_AP_ERR_MODIFIED;
595 }
596 }
597
598 return 0;
599 }
600
601
602 static krb5_error_code KRB5_CALLCONV
603 decrypt_tkt (krb5_context context,
604 krb5_keyblock *key,
605 krb5_key_usage usage,
606 krb5_const_pointer decrypt_arg,
607 krb5_kdc_rep *dec_rep)
608 {
609 krb5_error_code ret;
610 krb5_data data;
611 size_t size;
612 krb5_crypto crypto;
613
614 ret = krb5_crypto_init(context, key, 0, &crypto);
615 if (ret)
616 return ret;
617
618 ret = krb5_decrypt_EncryptedData (context,
619 crypto,
620 usage,
621 &dec_rep->kdc_rep.enc_part,
622 &data);
623 krb5_crypto_destroy(context, crypto);
624
625 if (ret)
626 return ret;
627
628 ret = decode_EncASRepPart(data.data,
629 data.length,
630 &dec_rep->enc_part,
631 &size);
632 if (ret)
633 ret = decode_EncTGSRepPart(data.data,
634 data.length,
635 &dec_rep->enc_part,
636 &size);
637 krb5_data_free (&data);
638 if (ret) {
639 krb5_set_error_message(context, ret,
640 N_("Failed to decode encpart in ticket", ""));
641 return ret;
642 }
643 return 0;
644 }
645
646 KRB5_LIB_FUNCTION int KRB5_LIB_CALL
647 _krb5_extract_ticket(krb5_context context,
648 krb5_kdc_rep *rep,
649 krb5_creds *creds,
650 krb5_keyblock *key,
651 krb5_const_pointer keyseed,
652 krb5_key_usage key_usage,
653 krb5_addresses *addrs,
654 unsigned nonce,
655 unsigned flags,
656 krb5_data *request,
657 krb5_decrypt_proc decrypt_proc,
658 krb5_const_pointer decryptarg)
659 {
660 krb5_error_code ret;
661 krb5_principal tmp_principal;
662 size_t len = 0;
663 time_t tmp_time;
664 krb5_timestamp sec_now;
665
666 /* decrypt */
667
668 if (decrypt_proc == NULL)
669 decrypt_proc = decrypt_tkt;
670
671 ret = (*decrypt_proc)(context, key, key_usage, decryptarg, rep);
672 if (ret)
673 goto out;
674
675 if (rep->enc_part.flags.enc_pa_rep && request) {
676 krb5_crypto crypto = NULL;
677 Checksum cksum;
678 PA_DATA *pa = NULL;
679 int idx = 0;
680
681 _krb5_debug(context, 5, "processing enc-ap-rep");
682
683 if (rep->enc_part.encrypted_pa_data == NULL ||
684 (pa = krb5_find_padata(rep->enc_part.encrypted_pa_data->val,
685 rep->enc_part.encrypted_pa_data->len,
686 KRB5_PADATA_REQ_ENC_PA_REP,
687 &idx)) == NULL)
688 {
689 _krb5_debug(context, 5, "KRB5_PADATA_REQ_ENC_PA_REP missing");
690 ret = KRB5KRB_AP_ERR_MODIFIED;
691 goto out;
692 }
693
694 ret = krb5_crypto_init(context, key, 0, &crypto);
695 if (ret)
696 goto out;
697
698 ret = decode_Checksum(pa->padata_value.data,
699 pa->padata_value.length,
700 &cksum, NULL);
701 if (ret) {
702 krb5_crypto_destroy(context, crypto);
703 goto out;
704 }
705
706 ret = krb5_verify_checksum(context, crypto,
707 KRB5_KU_AS_REQ,
708 request->data, request->length,
709 &cksum);
710 krb5_crypto_destroy(context, crypto);
711 free_Checksum(&cksum);
712 _krb5_debug(context, 5, "enc-ap-rep: %svalid", (ret == 0) ? "" : "in");
713 if (ret)
714 goto out;
715 }
716
717 /* save session key */
718
719 creds->session.keyvalue.length = 0;
720 creds->session.keyvalue.data = NULL;
721 creds->session.keytype = rep->enc_part.key.keytype;
722 ret = krb5_data_copy (&creds->session.keyvalue,
723 rep->enc_part.key.keyvalue.data,
724 rep->enc_part.key.keyvalue.length);
725 if (ret) {
726 krb5_clear_error_message(context);
727 goto out;
728 }
729
730 /* compare client and save */
731 ret = _krb5_principalname2krb5_principal(context,
732 &tmp_principal,
733 rep->kdc_rep.cname,
734 rep->kdc_rep.crealm);
735 if (ret)
736 goto out;
737
738 /* check KDC supported anonymous if it was requested */
739 if (flags & EXTRACT_TICKET_MATCH_ANON) {
740 ret = check_client_anonymous(context,rep,
741 creds->client,
742 tmp_principal,
743 request == NULL); /* is TGS */
744 if (ret) {
745 krb5_free_principal(context, tmp_principal);
746 goto out;
747 }
748 }
749
750 /* check client referral and save principal */
751 if((flags & EXTRACT_TICKET_ALLOW_CNAME_MISMATCH) == 0) {
752 ret = check_client_mismatch(context, rep,
753 creds->client,
754 tmp_principal,
755 &creds->session);
756 if (ret) {
757 krb5_free_principal (context, tmp_principal);
758 goto out;
759 }
760 }
761 krb5_free_principal (context, creds->client);
762 creds->client = tmp_principal;
763
764 /* check server referral and save principal */
765 ret = _krb5_principalname2krb5_principal (context,
766 &tmp_principal,
767 rep->enc_part.sname,
768 rep->enc_part.srealm);
769 if (ret)
770 goto out;
771 if((flags & EXTRACT_TICKET_ALLOW_SERVER_MISMATCH) == 0){
772 ret = check_server_referral(context,
773 rep,
774 flags,
775 creds->server,
776 tmp_principal,
777 &creds->session);
778 if (ret) {
779 krb5_free_principal (context, tmp_principal);
780 goto out;
781 }
782 }
783 krb5_free_principal(context, creds->server);
784 creds->server = tmp_principal;
785
786 /* verify names */
787 if(flags & EXTRACT_TICKET_MATCH_REALM){
788 const char *srealm = krb5_principal_get_realm(context, creds->server);
789 const char *crealm = krb5_principal_get_realm(context, creds->client);
790
791 if (strcmp(rep->enc_part.srealm, srealm) != 0 ||
792 strcmp(rep->enc_part.srealm, crealm) != 0)
793 {
794 ret = KRB5KRB_AP_ERR_MODIFIED;
795 krb5_clear_error_message(context);
796 goto out;
797 }
798 }
799
800 /* compare nonces */
801
802 if (nonce != (unsigned)rep->enc_part.nonce) {
803 ret = KRB5KRB_AP_ERR_MODIFIED;
804 krb5_set_error_message(context, ret, N_("malloc: out of memory", ""));
805 goto out;
806 }
807
808 /* set kdc-offset */
809
810 krb5_timeofday (context, &sec_now);
811 if (rep->enc_part.flags.initial
812 && (flags & EXTRACT_TICKET_TIMESYNC)
813 && context->kdc_sec_offset == 0
814 && krb5_config_get_bool (context, NULL,
815 "libdefaults",
816 "kdc_timesync",
817 NULL)) {
818 context->kdc_sec_offset = rep->enc_part.authtime - sec_now;
819 krb5_timeofday (context, &sec_now);
820 }
821
822 /* check all times */
823
824 if (rep->enc_part.starttime) {
825 tmp_time = *rep->enc_part.starttime;
826 } else
827 tmp_time = rep->enc_part.authtime;
828
829 if (creds->times.starttime == 0
830 && labs(tmp_time - sec_now) > context->max_skew) {
831 ret = KRB5KRB_AP_ERR_SKEW;
832 krb5_set_error_message (context, ret,
833 N_("time skew (%ld) larger than max (%ld)", ""),
834 labs(tmp_time - sec_now),
835 (long)context->max_skew);
836 goto out;
837 }
838
839 if (creds->times.starttime != 0
840 && tmp_time != creds->times.starttime) {
841 krb5_clear_error_message (context);
842 ret = KRB5KRB_AP_ERR_MODIFIED;
843 goto out;
844 }
845
846 creds->times.starttime = tmp_time;
847
848 if (rep->enc_part.renew_till) {
849 tmp_time = *rep->enc_part.renew_till;
850 } else
851 tmp_time = 0;
852
853 if (creds->times.renew_till != 0
854 && tmp_time > creds->times.renew_till) {
855 krb5_clear_error_message (context);
856 ret = KRB5KRB_AP_ERR_MODIFIED;
857 goto out;
858 }
859
860 creds->times.renew_till = tmp_time;
861
862 creds->times.authtime = rep->enc_part.authtime;
863
864 if (creds->times.endtime != 0
865 && rep->enc_part.endtime > creds->times.endtime) {
866 krb5_clear_error_message (context);
867 ret = KRB5KRB_AP_ERR_MODIFIED;
868 goto out;
869 }
870
871 creds->times.endtime = rep->enc_part.endtime;
872
873 if(rep->enc_part.caddr)
874 krb5_copy_addresses (context, rep->enc_part.caddr, &creds->addresses);
875 else if(addrs)
876 krb5_copy_addresses (context, addrs, &creds->addresses);
877 else {
878 creds->addresses.len = 0;
879 creds->addresses.val = NULL;
880 }
881 creds->flags.b = rep->enc_part.flags;
882
883 creds->authdata.len = 0;
884 creds->authdata.val = NULL;
885
886 /* extract ticket */
887 ASN1_MALLOC_ENCODE(Ticket, creds->ticket.data, creds->ticket.length,
888 &rep->kdc_rep.ticket, &len, ret);
889 if(ret)
890 goto out;
891 if (creds->ticket.length != len)
892 krb5_abortx(context, "internal error in ASN.1 encoder");
893 creds->second_ticket.length = 0;
894 creds->second_ticket.data = NULL;
895
896
897 out:
898 memset (rep->enc_part.key.keyvalue.data, 0,
899 rep->enc_part.key.keyvalue.length);
900 return ret;
901 }