?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Rename and fix as/tgs-use-strongest-key config parameters
[heimdal.git] / kdc / krb5tgs.c
blob87e33930be15956b45c739897c51ece3823b2a83
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 "kdc_locl.h"
35
36 /*
37 * return the realm of a krbtgt-ticket or NULL
38 */
39
40 static Realm
41 get_krbtgt_realm(const PrincipalName *p)
42 {
43 if(p->name_string.len == 2
44 && strcmp(p->name_string.val[0], KRB5_TGS_NAME) == 0)
45 return p->name_string.val[1];
46 else
47 return NULL;
48 }
49
50 /*
51 * The KDC might add a signed path to the ticket authorization data
52 * field. This is to avoid server impersonating clients and the
53 * request constrained delegation.
54 *
55 * This is done by storing a KRB5_AUTHDATA_IF_RELEVANT with a single
56 * entry of type KRB5SignedPath.
57 */
58
59 static krb5_error_code
60 find_KRB5SignedPath(krb5_context context,
61 const AuthorizationData *ad,
62 krb5_data *data)
63 {
64 AuthorizationData child;
65 krb5_error_code ret;
66 int pos;
67
68 if (ad == NULL || ad->len == 0)
69 return KRB5KDC_ERR_PADATA_TYPE_NOSUPP;
70
71 pos = ad->len - 1;
72
73 if (ad->val[pos].ad_type != KRB5_AUTHDATA_IF_RELEVANT)
74 return KRB5KDC_ERR_PADATA_TYPE_NOSUPP;
75
76 ret = decode_AuthorizationData(ad->val[pos].ad_data.data,
77 ad->val[pos].ad_data.length,
78 &child,
79 NULL);
80 if (ret) {
81 krb5_set_error_message(context, ret, "Failed to decode "
82 "IF_RELEVANT with %d", ret);
83 return ret;
84 }
85
86 if (child.len != 1) {
87 free_AuthorizationData(&child);
88 return KRB5KDC_ERR_PADATA_TYPE_NOSUPP;
89 }
90
91 if (child.val[0].ad_type != KRB5_AUTHDATA_SIGNTICKET) {
92 free_AuthorizationData(&child);
93 return KRB5KDC_ERR_PADATA_TYPE_NOSUPP;
94 }
95
96 if (data)
97 ret = der_copy_octet_string(&child.val[0].ad_data, data);
98 free_AuthorizationData(&child);
99 return ret;
100 }
101
102 krb5_error_code
103 _kdc_add_KRB5SignedPath(krb5_context context,
104 krb5_kdc_configuration *config,
105 hdb_entry_ex *krbtgt,
106 krb5_enctype enctype,
107 krb5_principal client,
108 krb5_const_principal server,
109 krb5_principals principals,
110 EncTicketPart *tkt)
111 {
112 krb5_error_code ret;
113 KRB5SignedPath sp;
114 krb5_data data;
115 krb5_crypto crypto = NULL;
116 size_t size = 0;
117
118 if (server && principals) {
119 ret = add_Principals(principals, server);
120 if (ret)
121 return ret;
122 }
123
124 {
125 KRB5SignedPathData spd;
126
127 spd.client = client;
128 spd.authtime = tkt->authtime;
129 spd.delegated = principals;
130 spd.method_data = NULL;
131
132 ASN1_MALLOC_ENCODE(KRB5SignedPathData, data.data, data.length,
133 &spd, &size, ret);
134 if (ret)
135 return ret;
136 if (data.length != size)
137 krb5_abortx(context, "internal asn.1 encoder error");
138 }
139
140 {
141 Key *key;
142 ret = hdb_enctype2key(context, &krbtgt->entry, enctype, &key);
143 if (ret == 0)
144 ret = krb5_crypto_init(context, &key->key, 0, &crypto);
145 if (ret) {
146 free(data.data);
147 return ret;
148 }
149 }
150
151 /*
152 * Fill in KRB5SignedPath
153 */
154
155 sp.etype = enctype;
156 sp.delegated = principals;
157 sp.method_data = NULL;
158
159 ret = krb5_create_checksum(context, crypto, KRB5_KU_KRB5SIGNEDPATH, 0,
160 data.data, data.length, &sp.cksum);
161 krb5_crypto_destroy(context, crypto);
162 free(data.data);
163 if (ret)
164 return ret;
165
166 ASN1_MALLOC_ENCODE(KRB5SignedPath, data.data, data.length, &sp, &size, ret);
167 free_Checksum(&sp.cksum);
168 if (ret)
169 return ret;
170 if (data.length != size)
171 krb5_abortx(context, "internal asn.1 encoder error");
172
173
174 /*
175 * Add IF-RELEVANT(KRB5SignedPath) to the last slot in
176 * authorization data field.
177 */
178
179 ret = _kdc_tkt_add_if_relevant_ad(context, tkt,
180 KRB5_AUTHDATA_SIGNTICKET, &data);
181 krb5_data_free(&data);
182
183 return ret;
184 }
185
186 static krb5_error_code
187 check_KRB5SignedPath(krb5_context context,
188 krb5_kdc_configuration *config,
189 hdb_entry_ex *krbtgt,
190 krb5_principal cp,
191 EncTicketPart *tkt,
192 krb5_principals *delegated,
193 int *signedpath)
194 {
195 krb5_error_code ret;
196 krb5_data data;
197 krb5_crypto crypto = NULL;
198
199 if (delegated)
200 *delegated = NULL;
201
202 ret = find_KRB5SignedPath(context, tkt->authorization_data, &data);
203 if (ret == 0) {
204 KRB5SignedPathData spd;
205 KRB5SignedPath sp;
206 size_t size = 0;
207
208 ret = decode_KRB5SignedPath(data.data, data.length, &sp, NULL);
209 krb5_data_free(&data);
210 if (ret)
211 return ret;
212
213 spd.client = cp;
214 spd.authtime = tkt->authtime;
215 spd.delegated = sp.delegated;
216 spd.method_data = sp.method_data;
217
218 ASN1_MALLOC_ENCODE(KRB5SignedPathData, data.data, data.length,
219 &spd, &size, ret);
220 if (ret) {
221 free_KRB5SignedPath(&sp);
222 return ret;
223 }
224 if (data.length != size)
225 krb5_abortx(context, "internal asn.1 encoder error");
226
227 {
228 Key *key;
229 ret = hdb_enctype2key(context, &krbtgt->entry, sp.etype, &key);
230 if (ret == 0)
231 ret = krb5_crypto_init(context, &key->key, 0, &crypto);
232 if (ret) {
233 free(data.data);
234 free_KRB5SignedPath(&sp);
235 return ret;
236 }
237 }
238 ret = krb5_verify_checksum(context, crypto, KRB5_KU_KRB5SIGNEDPATH,
239 data.data, data.length,
240 &sp.cksum);
241 krb5_crypto_destroy(context, crypto);
242 free(data.data);
243 if (ret) {
244 free_KRB5SignedPath(&sp);
245 kdc_log(context, config, 5,
246 "KRB5SignedPath not signed correctly, not marking as signed");
247 return 0;
248 }
249
250 if (delegated && sp.delegated) {
251
252 *delegated = malloc(sizeof(*sp.delegated));
253 if (*delegated == NULL) {
254 free_KRB5SignedPath(&sp);
255 return ENOMEM;
256 }
257
258 ret = copy_Principals(*delegated, sp.delegated);
259 if (ret) {
260 free_KRB5SignedPath(&sp);
261 free(*delegated);
262 *delegated = NULL;
263 return ret;
264 }
265 }
266 free_KRB5SignedPath(&sp);
267
268 *signedpath = 1;
269 }
270
271 return 0;
272 }
273
274 /*
275 *
276 */
277
278 static krb5_error_code
279 check_PAC(krb5_context context,
280 krb5_kdc_configuration *config,
281 const krb5_principal client_principal,
282 const krb5_principal delegated_proxy_principal,
283 hdb_entry_ex *client,
284 hdb_entry_ex *server,
285 hdb_entry_ex *krbtgt,
286 const EncryptionKey *server_check_key,
287 const EncryptionKey *krbtgt_check_key,
288 const EncryptionKey *server_sign_key,
289 const EncryptionKey *krbtgt_sign_key,
290 EncTicketPart *tkt,
291 krb5_data *rspac,
292 int *signedpath)
293 {
294 AuthorizationData *ad = tkt->authorization_data;
295 unsigned i, j;
296 krb5_error_code ret;
297
298 if (ad == NULL || ad->len == 0)
299 return 0;
300
301 for (i = 0; i < ad->len; i++) {
302 AuthorizationData child;
303
304 if (ad->val[i].ad_type != KRB5_AUTHDATA_IF_RELEVANT)
305 continue;
306
307 ret = decode_AuthorizationData(ad->val[i].ad_data.data,
308 ad->val[i].ad_data.length,
309 &child,
310 NULL);
311 if (ret) {
312 krb5_set_error_message(context, ret, "Failed to decode "
313 "IF_RELEVANT with %d", ret);
314 return ret;
315 }
316 for (j = 0; j < child.len; j++) {
317
318 if (child.val[j].ad_type == KRB5_AUTHDATA_WIN2K_PAC) {
319 int signed_pac = 0;
320 krb5_pac pac;
321
322 /* Found PAC */
323 ret = krb5_pac_parse(context,
324 child.val[j].ad_data.data,
325 child.val[j].ad_data.length,
326 &pac);
327 free_AuthorizationData(&child);
328 if (ret)
329 return ret;
330
331 ret = krb5_pac_verify(context, pac, tkt->authtime,
332 client_principal,
333 server_check_key, krbtgt_check_key);
334 if (ret) {
335 krb5_pac_free(context, pac);
336 return ret;
337 }
338
339 ret = _kdc_pac_verify(context, client_principal,
340 delegated_proxy_principal,
341 client, server, krbtgt, &pac, &signed_pac);
342 if (ret) {
343 krb5_pac_free(context, pac);
344 return ret;
345 }
346
347 /*
348 * Only re-sign PAC if we could verify it with the PAC
349 * function. The no-verify case happens when we get in
350 * a PAC from cross realm from a Windows domain and
351 * that there is no PAC verification function.
352 */
353 if (signed_pac) {
354 *signedpath = 1;
355 ret = _krb5_pac_sign(context, pac, tkt->authtime,
356 client_principal,
357 server_sign_key, krbtgt_sign_key, rspac);
358 }
359 krb5_pac_free(context, pac);
360
361 return ret;
362 }
363 }
364 free_AuthorizationData(&child);
365 }
366 return 0;
367 }
368
369 /*
370 *
371 */
372
373 static krb5_error_code
374 check_tgs_flags(krb5_context context,
375 krb5_kdc_configuration *config,
376 KDC_REQ_BODY *b, const EncTicketPart *tgt, EncTicketPart *et)
377 {
378 KDCOptions f = b->kdc_options;
379
380 if(f.validate){
381 if(!tgt->flags.invalid || tgt->starttime == NULL){
382 kdc_log(context, config, 0,
383 "Bad request to validate ticket");
384 return KRB5KDC_ERR_BADOPTION;
385 }
386 if(*tgt->starttime > kdc_time){
387 kdc_log(context, config, 0,
388 "Early request to validate ticket");
389 return KRB5KRB_AP_ERR_TKT_NYV;
390 }
391 /* XXX tkt = tgt */
392 et->flags.invalid = 0;
393 }else if(tgt->flags.invalid){
394 kdc_log(context, config, 0,
395 "Ticket-granting ticket has INVALID flag set");
396 return KRB5KRB_AP_ERR_TKT_INVALID;
397 }
398
399 if(f.forwardable){
400 if(!tgt->flags.forwardable){
401 kdc_log(context, config, 0,
402 "Bad request for forwardable ticket");
403 return KRB5KDC_ERR_BADOPTION;
404 }
405 et->flags.forwardable = 1;
406 }
407 if(f.forwarded){
408 if(!tgt->flags.forwardable){
409 kdc_log(context, config, 0,
410 "Request to forward non-forwardable ticket");
411 return KRB5KDC_ERR_BADOPTION;
412 }
413 et->flags.forwarded = 1;
414 et->caddr = b->addresses;
415 }
416 if(tgt->flags.forwarded)
417 et->flags.forwarded = 1;
418
419 if(f.proxiable){
420 if(!tgt->flags.proxiable){
421 kdc_log(context, config, 0,
422 "Bad request for proxiable ticket");
423 return KRB5KDC_ERR_BADOPTION;
424 }
425 et->flags.proxiable = 1;
426 }
427 if(f.proxy){
428 if(!tgt->flags.proxiable){
429 kdc_log(context, config, 0,
430 "Request to proxy non-proxiable ticket");
431 return KRB5KDC_ERR_BADOPTION;
432 }
433 et->flags.proxy = 1;
434 et->caddr = b->addresses;
435 }
436 if(tgt->flags.proxy)
437 et->flags.proxy = 1;
438
439 if(f.allow_postdate){
440 if(!tgt->flags.may_postdate){
441 kdc_log(context, config, 0,
442 "Bad request for post-datable ticket");
443 return KRB5KDC_ERR_BADOPTION;
444 }
445 et->flags.may_postdate = 1;
446 }
447 if(f.postdated){
448 if(!tgt->flags.may_postdate){
449 kdc_log(context, config, 0,
450 "Bad request for postdated ticket");
451 return KRB5KDC_ERR_BADOPTION;
452 }
453 if(b->from)
454 *et->starttime = *b->from;
455 et->flags.postdated = 1;
456 et->flags.invalid = 1;
457 }else if(b->from && *b->from > kdc_time + context->max_skew){
458 kdc_log(context, config, 0, "Ticket cannot be postdated");
459 return KRB5KDC_ERR_CANNOT_POSTDATE;
460 }
461
462 if(f.renewable){
463 if(!tgt->flags.renewable || tgt->renew_till == NULL){
464 kdc_log(context, config, 0,
465 "Bad request for renewable ticket");
466 return KRB5KDC_ERR_BADOPTION;
467 }
468 et->flags.renewable = 1;
469 ALLOC(et->renew_till);
470 _kdc_fix_time(&b->rtime);
471 *et->renew_till = *b->rtime;
472 }
473 if(f.renew){
474 time_t old_life;
475 if(!tgt->flags.renewable || tgt->renew_till == NULL){
476 kdc_log(context, config, 0,
477 "Request to renew non-renewable ticket");
478 return KRB5KDC_ERR_BADOPTION;
479 }
480 old_life = tgt->endtime;
481 if(tgt->starttime)
482 old_life -= *tgt->starttime;
483 else
484 old_life -= tgt->authtime;
485 et->endtime = *et->starttime + old_life;
486 if (et->renew_till != NULL)
487 et->endtime = min(*et->renew_till, et->endtime);
488 }
489
490 #if 0
491 /* checks for excess flags */
492 if(f.request_anonymous && !config->allow_anonymous){
493 kdc_log(context, config, 0,
494 "Request for anonymous ticket");
495 return KRB5KDC_ERR_BADOPTION;
496 }
497 #endif
498 return 0;
499 }
500
501 /*
502 * Determine if constrained delegation is allowed from this client to this server
503 */
504
505 static krb5_error_code
506 check_constrained_delegation(krb5_context context,
507 krb5_kdc_configuration *config,
508 HDB *clientdb,
509 hdb_entry_ex *client,
510 hdb_entry_ex *server,
511 krb5_const_principal target)
512 {
513 const HDB_Ext_Constrained_delegation_acl *acl;
514 krb5_error_code ret;
515 size_t i;
516
517 /*
518 * constrained_delegation (S4U2Proxy) only works within
519 * the same realm. We use the already canonicalized version
520 * of the principals here, while "target" is the principal
521 * provided by the client.
522 */
523 if(!krb5_realm_compare(context, client->entry.principal, server->entry.principal)) {
524 ret = KRB5KDC_ERR_BADOPTION;
525 kdc_log(context, config, 0,
526 "Bad request for constrained delegation");
527 return ret;
528 }
529
530 if (clientdb->hdb_check_constrained_delegation) {
531 ret = clientdb->hdb_check_constrained_delegation(context, clientdb, client, target);
532 if (ret == 0)
533 return 0;
534 } else {
535 /* if client delegates to itself, that ok */
536 if (krb5_principal_compare(context, client->entry.principal, server->entry.principal) == TRUE)
537 return 0;
538
539 ret = hdb_entry_get_ConstrainedDelegACL(&client->entry, &acl);
540 if (ret) {
541 krb5_clear_error_message(context);
542 return ret;
543 }
544
545 if (acl) {
546 for (i = 0; i < acl->len; i++) {
547 if (krb5_principal_compare(context, target, &acl->val[i]) == TRUE)
548 return 0;
549 }
550 }
551 ret = KRB5KDC_ERR_BADOPTION;
552 }
553 kdc_log(context, config, 0,
554 "Bad request for constrained delegation");
555 return ret;
556 }
557
558 /*
559 * Determine if s4u2self is allowed from this client to this server
560 *
561 * For example, regardless of the principal being impersonated, if the
562 * 'client' and 'server' are the same, then it's safe.
563 */
564
565 static krb5_error_code
566 check_s4u2self(krb5_context context,
567 krb5_kdc_configuration *config,
568 HDB *clientdb,
569 hdb_entry_ex *client,
570 krb5_const_principal server)
571 {
572 krb5_error_code ret;
573
574 /* if client does a s4u2self to itself, that ok */
575 if (krb5_principal_compare(context, client->entry.principal, server) == TRUE)
576 return 0;
577
578 if (clientdb->hdb_check_s4u2self) {
579 ret = clientdb->hdb_check_s4u2self(context, clientdb, client, server);
580 if (ret == 0)
581 return 0;
582 } else {
583 ret = KRB5KDC_ERR_BADOPTION;
584 }
585 return ret;
586 }
587
588 /*
589 *
590 */
591
592 static krb5_error_code
593 verify_flags (krb5_context context,
594 krb5_kdc_configuration *config,
595 const EncTicketPart *et,
596 const char *pstr)
597 {
598 if(et->endtime < kdc_time){
599 kdc_log(context, config, 0, "Ticket expired (%s)", pstr);
600 return KRB5KRB_AP_ERR_TKT_EXPIRED;
601 }
602 if(et->flags.invalid){
603 kdc_log(context, config, 0, "Ticket not valid (%s)", pstr);
604 return KRB5KRB_AP_ERR_TKT_NYV;
605 }
606 return 0;
607 }
608
609 /*
610 *
611 */
612
613 static krb5_error_code
614 fix_transited_encoding(krb5_context context,
615 krb5_kdc_configuration *config,
616 krb5_boolean check_policy,
617 const TransitedEncoding *tr,
618 EncTicketPart *et,
619 const char *client_realm,
620 const char *server_realm,
621 const char *tgt_realm)
622 {
623 krb5_error_code ret = 0;
624 char **realms, **tmp;
625 unsigned int num_realms;
626 size_t i;
627
628 switch (tr->tr_type) {
629 case DOMAIN_X500_COMPRESS:
630 break;
631 case 0:
632 /*
633 * Allow empty content of type 0 because that is was Microsoft
634 * generates in their TGT.
635 */
636 if (tr->contents.length == 0)
637 break;
638 kdc_log(context, config, 0,
639 "Transited type 0 with non empty content");
640 return KRB5KDC_ERR_TRTYPE_NOSUPP;
641 default:
642 kdc_log(context, config, 0,
643 "Unknown transited type: %u", tr->tr_type);
644 return KRB5KDC_ERR_TRTYPE_NOSUPP;
645 }
646
647 ret = krb5_domain_x500_decode(context,
648 tr->contents,
649 &realms,
650 &num_realms,
651 client_realm,
652 server_realm);
653 if(ret){
654 krb5_warn(context, ret,
655 "Decoding transited encoding");
656 return ret;
657 }
658 if(strcmp(client_realm, tgt_realm) && strcmp(server_realm, tgt_realm)) {
659 /* not us, so add the previous realm to transited set */
660 if (num_realms + 1 > UINT_MAX/sizeof(*realms)) {
661 ret = ERANGE;
662 goto free_realms;
663 }
664 tmp = realloc(realms, (num_realms + 1) * sizeof(*realms));
665 if(tmp == NULL){
666 ret = ENOMEM;
667 goto free_realms;
668 }
669 realms = tmp;
670 realms[num_realms] = strdup(tgt_realm);
671 if(realms[num_realms] == NULL){
672 ret = ENOMEM;
673 goto free_realms;
674 }
675 num_realms++;
676 }
677 if(num_realms == 0) {
678 if(strcmp(client_realm, server_realm))
679 kdc_log(context, config, 0,
680 "cross-realm %s -> %s", client_realm, server_realm);
681 } else {
682 size_t l = 0;
683 char *rs;
684 for(i = 0; i < num_realms; i++)
685 l += strlen(realms[i]) + 2;
686 rs = malloc(l);
687 if(rs != NULL) {
688 *rs = '\0';
689 for(i = 0; i < num_realms; i++) {
690 if(i > 0)
691 strlcat(rs, ", ", l);
692 strlcat(rs, realms[i], l);
693 }
694 kdc_log(context, config, 0,
695 "cross-realm %s -> %s via [%s]",
696 client_realm, server_realm, rs);
697 free(rs);
698 }
699 }
700 if(check_policy) {
701 ret = krb5_check_transited(context, client_realm,
702 server_realm,
703 realms, num_realms, NULL);
704 if(ret) {
705 krb5_warn(context, ret, "cross-realm %s -> %s",
706 client_realm, server_realm);
707 goto free_realms;
708 }
709 et->flags.transited_policy_checked = 1;
710 }
711 et->transited.tr_type = DOMAIN_X500_COMPRESS;
712 ret = krb5_domain_x500_encode(realms, num_realms, &et->transited.contents);
713 if(ret)
714 krb5_warn(context, ret, "Encoding transited encoding");
715 free_realms:
716 for(i = 0; i < num_realms; i++)
717 free(realms[i]);
718 free(realms);
719 return ret;
720 }
721
722
723 static krb5_error_code
724 tgs_make_reply(krb5_context context,
725 krb5_kdc_configuration *config,
726 KDC_REQ_BODY *b,
727 krb5_const_principal tgt_name,
728 const EncTicketPart *tgt,
729 const krb5_keyblock *replykey,
730 int rk_is_subkey,
731 const EncryptionKey *serverkey,
732 const krb5_keyblock *sessionkey,
733 krb5_kvno kvno,
734 AuthorizationData *auth_data,
735 hdb_entry_ex *server,
736 krb5_principal server_principal,
737 const char *server_name,
738 hdb_entry_ex *client,
739 krb5_principal client_principal,
740 hdb_entry_ex *krbtgt,
741 krb5_enctype krbtgt_etype,
742 krb5_principals spp,
743 const krb5_data *rspac,
744 const METHOD_DATA *enc_pa_data,
745 const char **e_text,
746 krb5_data *reply)
747 {
748 KDC_REP rep;
749 EncKDCRepPart ek;
750 EncTicketPart et;
751 KDCOptions f = b->kdc_options;
752 krb5_error_code ret;
753 int is_weak = 0;
754
755 memset(&rep, 0, sizeof(rep));
756 memset(&et, 0, sizeof(et));
757 memset(&ek, 0, sizeof(ek));
758
759 rep.pvno = 5;
760 rep.msg_type = krb_tgs_rep;
761
762 et.authtime = tgt->authtime;
763 _kdc_fix_time(&b->till);
764 et.endtime = min(tgt->endtime, *b->till);
765 ALLOC(et.starttime);
766 *et.starttime = kdc_time;
767
768 ret = check_tgs_flags(context, config, b, tgt, &et);
769 if(ret)
770 goto out;
771
772 /* We should check the transited encoding if:
773 1) the request doesn't ask not to be checked
774 2) globally enforcing a check
775 3) principal requires checking
776 4) we allow non-check per-principal, but principal isn't marked as allowing this
777 5) we don't globally allow this
778 */
779
780 #define GLOBAL_FORCE_TRANSITED_CHECK \
781 (config->trpolicy == TRPOLICY_ALWAYS_CHECK)
782 #define GLOBAL_ALLOW_PER_PRINCIPAL \
783 (config->trpolicy == TRPOLICY_ALLOW_PER_PRINCIPAL)
784 #define GLOBAL_ALLOW_DISABLE_TRANSITED_CHECK \
785 (config->trpolicy == TRPOLICY_ALWAYS_HONOUR_REQUEST)
786
787 /* these will consult the database in future release */
788 #define PRINCIPAL_FORCE_TRANSITED_CHECK(P) 0
789 #define PRINCIPAL_ALLOW_DISABLE_TRANSITED_CHECK(P) 0
790
791 ret = fix_transited_encoding(context, config,
792 !f.disable_transited_check ||
793 GLOBAL_FORCE_TRANSITED_CHECK ||
794 PRINCIPAL_FORCE_TRANSITED_CHECK(server) ||
795 !((GLOBAL_ALLOW_PER_PRINCIPAL &&
796 PRINCIPAL_ALLOW_DISABLE_TRANSITED_CHECK(server)) ||
797 GLOBAL_ALLOW_DISABLE_TRANSITED_CHECK),
798 &tgt->transited, &et,
799 krb5_principal_get_realm(context, client_principal),
800 krb5_principal_get_realm(context, server->entry.principal),
801 krb5_principal_get_realm(context, krbtgt->entry.principal));
802 if(ret)
803 goto out;
804
805 copy_Realm(&server_principal->realm, &rep.ticket.realm);
806 _krb5_principal2principalname(&rep.ticket.sname, server_principal);
807 copy_Realm(&tgt_name->realm, &rep.crealm);
808 /*
809 if (f.request_anonymous)
810 _kdc_make_anonymous_principalname (&rep.cname);
811 else */
812
813 copy_PrincipalName(&tgt_name->name, &rep.cname);
814 rep.ticket.tkt_vno = 5;
815
816 ek.caddr = et.caddr;
817 if(et.caddr == NULL)
818 et.caddr = tgt->caddr;
819
820 {
821 time_t life;
822 life = et.endtime - *et.starttime;
823 if(client && client->entry.max_life)
824 life = min(life, *client->entry.max_life);
825 if(server->entry.max_life)
826 life = min(life, *server->entry.max_life);
827 et.endtime = *et.starttime + life;
828 }
829 if(f.renewable_ok && tgt->flags.renewable &&
830 et.renew_till == NULL && et.endtime < *b->till &&
831 tgt->renew_till != NULL)
832 {
833 et.flags.renewable = 1;
834 ALLOC(et.renew_till);
835 *et.renew_till = *b->till;
836 }
837 if(et.renew_till){
838 time_t renew;
839 renew = *et.renew_till - et.authtime;
840 if(client && client->entry.max_renew)
841 renew = min(renew, *client->entry.max_renew);
842 if(server->entry.max_renew)
843 renew = min(renew, *server->entry.max_renew);
844 *et.renew_till = et.authtime + renew;
845 }
846
847 if(et.renew_till){
848 *et.renew_till = min(*et.renew_till, *tgt->renew_till);
849 *et.starttime = min(*et.starttime, *et.renew_till);
850 et.endtime = min(et.endtime, *et.renew_till);
851 }
852
853 *et.starttime = min(*et.starttime, et.endtime);
854
855 if(*et.starttime == et.endtime){
856 ret = KRB5KDC_ERR_NEVER_VALID;
857 goto out;
858 }
859 if(et.renew_till && et.endtime == *et.renew_till){
860 free(et.renew_till);
861 et.renew_till = NULL;
862 et.flags.renewable = 0;
863 }
864
865 et.flags.pre_authent = tgt->flags.pre_authent;
866 et.flags.hw_authent = tgt->flags.hw_authent;
867 et.flags.anonymous = tgt->flags.anonymous;
868 et.flags.ok_as_delegate = server->entry.flags.ok_as_delegate;
869
870 if(rspac->length) {
871 /*
872 * No not need to filter out the any PAC from the
873 * auth_data since it's signed by the KDC.
874 */
875 ret = _kdc_tkt_add_if_relevant_ad(context, &et,
876 KRB5_AUTHDATA_WIN2K_PAC, rspac);
877 if (ret)
878 goto out;
879 }
880
881 if (auth_data) {
882 unsigned int i = 0;
883
884 /* XXX check authdata */
885
886 if (et.authorization_data == NULL) {
887 et.authorization_data = calloc(1, sizeof(*et.authorization_data));
888 if (et.authorization_data == NULL) {
889 ret = ENOMEM;
890 krb5_set_error_message(context, ret, "malloc: out of memory");
891 goto out;
892 }
893 }
894 for(i = 0; i < auth_data->len ; i++) {
895 ret = add_AuthorizationData(et.authorization_data, &auth_data->val[i]);
896 if (ret) {
897 krb5_set_error_message(context, ret, "malloc: out of memory");
898 goto out;
899 }
900 }
901
902 /* Filter out type KRB5SignedPath */
903 ret = find_KRB5SignedPath(context, et.authorization_data, NULL);
904 if (ret == 0) {
905 if (et.authorization_data->len == 1) {
906 free_AuthorizationData(et.authorization_data);
907 free(et.authorization_data);
908 et.authorization_data = NULL;
909 } else {
910 AuthorizationData *ad = et.authorization_data;
911 free_AuthorizationDataElement(&ad->val[ad->len - 1]);
912 ad->len--;
913 }
914 }
915 }
916
917 ret = krb5_copy_keyblock_contents(context, sessionkey, &et.key);
918 if (ret)
919 goto out;
920 et.crealm = tgt_name->realm;
921 et.cname = tgt_name->name;
922
923 ek.key = et.key;
924 /* MIT must have at least one last_req */
925 ek.last_req.len = 1;
926 ek.last_req.val = calloc(1, sizeof(*ek.last_req.val));
927 if (ek.last_req.val == NULL) {
928 ret = ENOMEM;
929 goto out;
930 }
931 ek.nonce = b->nonce;
932 ek.flags = et.flags;
933 ek.authtime = et.authtime;
934 ek.starttime = et.starttime;
935 ek.endtime = et.endtime;
936 ek.renew_till = et.renew_till;
937 ek.srealm = rep.ticket.realm;
938 ek.sname = rep.ticket.sname;
939
940 _kdc_log_timestamp(context, config, "TGS-REQ", et.authtime, et.starttime,
941 et.endtime, et.renew_till);
942
943 /* Don't sign cross realm tickets, they can't be checked anyway */
944 {
945 char *r = get_krbtgt_realm(&ek.sname);
946
947 if (r == NULL || strcmp(r, ek.srealm) == 0) {
948 ret = _kdc_add_KRB5SignedPath(context,
949 config,
950 krbtgt,
951 krbtgt_etype,
952 client_principal,
953 NULL,
954 spp,
955 &et);
956 if (ret)
957 goto out;
958 }
959 }
960
961 if (enc_pa_data->len) {
962 rep.padata = calloc(1, sizeof(*rep.padata));
963 if (rep.padata == NULL) {
964 ret = ENOMEM;
965 goto out;
966 }
967 ret = copy_METHOD_DATA(enc_pa_data, rep.padata);
968 if (ret)
969 goto out;
970 }
971
972 if (krb5_enctype_valid(context, et.key.keytype) != 0
973 && _kdc_is_weak_exception(server->entry.principal, et.key.keytype))
974 {
975 krb5_enctype_enable(context, et.key.keytype);
976 is_weak = 1;
977 }
978
979
980 /* It is somewhat unclear where the etype in the following
981 encryption should come from. What we have is a session
982 key in the passed tgt, and a list of preferred etypes
983 *for the new ticket*. Should we pick the best possible
984 etype, given the keytype in the tgt, or should we look
985 at the etype list here as well? What if the tgt
986 session key is DES3 and we want a ticket with a (say)
987 CAST session key. Should the DES3 etype be added to the
988 etype list, even if we don't want a session key with
989 DES3? */
990 ret = _kdc_encode_reply(context, config,
991 &rep, &et, &ek, et.key.keytype,
992 kvno,
993 serverkey, 0, replykey, rk_is_subkey,
994 e_text, reply);
995 if (is_weak)
996 krb5_enctype_disable(context, et.key.keytype);
997
998 out:
999 free_TGS_REP(&rep);
1000 free_TransitedEncoding(&et.transited);
1001 if(et.starttime)
1002 free(et.starttime);
1003 if(et.renew_till)
1004 free(et.renew_till);
1005 if(et.authorization_data) {
1006 free_AuthorizationData(et.authorization_data);
1007 free(et.authorization_data);
1008 }
1009 free_LastReq(&ek.last_req);
1010 memset(et.key.keyvalue.data, 0, et.key.keyvalue.length);
1011 free_EncryptionKey(&et.key);
1012 return ret;
1013 }
1014
1015 static krb5_error_code
1016 tgs_check_authenticator(krb5_context context,
1017 krb5_kdc_configuration *config,
1018 krb5_auth_context ac,
1019 KDC_REQ_BODY *b,
1020 const char **e_text,
1021 krb5_keyblock *key)
1022 {
1023 krb5_authenticator auth;
1024 size_t len = 0;
1025 unsigned char *buf;
1026 size_t buf_size;
1027 krb5_error_code ret;
1028 krb5_crypto crypto;
1029
1030 krb5_auth_con_getauthenticator(context, ac, &auth);
1031 if(auth->cksum == NULL){
1032 kdc_log(context, config, 0, "No authenticator in request");
1033 ret = KRB5KRB_AP_ERR_INAPP_CKSUM;
1034 goto out;
1035 }
1036 /*
1037 * according to RFC1510 it doesn't need to be keyed,
1038 * but according to the latest draft it needs to.
1039 */
1040 if (
1041 #if 0
1042 !krb5_checksum_is_keyed(context, auth->cksum->cksumtype)
1043 ||
1044 #endif
1045 !krb5_checksum_is_collision_proof(context, auth->cksum->cksumtype)) {
1046 kdc_log(context, config, 0, "Bad checksum type in authenticator: %d",
1047 auth->cksum->cksumtype);
1048 ret = KRB5KRB_AP_ERR_INAPP_CKSUM;
1049 goto out;
1050 }
1051
1052 /* XXX should not re-encode this */
1053 ASN1_MALLOC_ENCODE(KDC_REQ_BODY, buf, buf_size, b, &len, ret);
1054 if(ret){
1055 const char *msg = krb5_get_error_message(context, ret);
1056 kdc_log(context, config, 0, "Failed to encode KDC-REQ-BODY: %s", msg);
1057 krb5_free_error_message(context, msg);
1058 goto out;
1059 }
1060 if(buf_size != len) {
1061 free(buf);
1062 kdc_log(context, config, 0, "Internal error in ASN.1 encoder");
1063 *e_text = "KDC internal error";
1064 ret = KRB5KRB_ERR_GENERIC;
1065 goto out;
1066 }
1067 ret = krb5_crypto_init(context, key, 0, &crypto);
1068 if (ret) {
1069 const char *msg = krb5_get_error_message(context, ret);
1070 free(buf);
1071 kdc_log(context, config, 0, "krb5_crypto_init failed: %s", msg);
1072 krb5_free_error_message(context, msg);
1073 goto out;
1074 }
1075 ret = krb5_verify_checksum(context,
1076 crypto,
1077 KRB5_KU_TGS_REQ_AUTH_CKSUM,
1078 buf,
1079 len,
1080 auth->cksum);
1081 free(buf);
1082 krb5_crypto_destroy(context, crypto);
1083 if(ret){
1084 const char *msg = krb5_get_error_message(context, ret);
1085 kdc_log(context, config, 0,
1086 "Failed to verify authenticator checksum: %s", msg);
1087 krb5_free_error_message(context, msg);
1088 }
1089 out:
1090 free_Authenticator(auth);
1091 free(auth);
1092 return ret;
1093 }
1094
1095 /*
1096 *
1097 */
1098
1099 static const char *
1100 find_rpath(krb5_context context, Realm crealm, Realm srealm)
1101 {
1102 const char *new_realm = krb5_config_get_string(context,
1103 NULL,
1104 "capaths",
1105 crealm,
1106 srealm,
1107 NULL);
1108 return new_realm;
1109 }
1110
1111
1112 static krb5_boolean
1113 need_referral(krb5_context context, krb5_kdc_configuration *config,
1114 const KDCOptions * const options, krb5_principal server,
1115 krb5_realm **realms)
1116 {
1117 const char *name;
1118
1119 if(!options->canonicalize && server->name.name_type != KRB5_NT_SRV_INST)
1120 return FALSE;
1121
1122 if (server->name.name_string.len == 1)
1123 name = server->name.name_string.val[0];
1124 else if (server->name.name_string.len > 1)
1125 name = server->name.name_string.val[1];
1126 else
1127 return FALSE;
1128
1129 kdc_log(context, config, 0, "Searching referral for %s", name);
1130
1131 return _krb5_get_host_realm_int(context, name, FALSE, realms) == 0;
1132 }
1133
1134 static krb5_error_code
1135 tgs_parse_request(krb5_context context,
1136 krb5_kdc_configuration *config,
1137 KDC_REQ_BODY *b,
1138 const PA_DATA *tgs_req,
1139 hdb_entry_ex **krbtgt,
1140 krb5_enctype *krbtgt_etype,
1141 krb5_ticket **ticket,
1142 const char **e_text,
1143 const char *from,
1144 const struct sockaddr *from_addr,
1145 time_t **csec,
1146 int **cusec,
1147 AuthorizationData **auth_data,
1148 krb5_keyblock **replykey,
1149 int *rk_is_subkey)
1150 {
1151 static char failed[] = "<unparse_name failed>";
1152 krb5_ap_req ap_req;
1153 krb5_error_code ret;
1154 krb5_principal princ;
1155 krb5_auth_context ac = NULL;
1156 krb5_flags ap_req_options;
1157 krb5_flags verify_ap_req_flags;
1158 krb5_crypto crypto;
1159 Key *tkey;
1160 krb5_keyblock *subkey = NULL;
1161 unsigned usage;
1162
1163 *auth_data = NULL;
1164 *csec = NULL;
1165 *cusec = NULL;
1166 *replykey = NULL;
1167
1168 memset(&ap_req, 0, sizeof(ap_req));
1169 ret = krb5_decode_ap_req(context, &tgs_req->padata_value, &ap_req);
1170 if(ret){
1171 const char *msg = krb5_get_error_message(context, ret);
1172 kdc_log(context, config, 0, "Failed to decode AP-REQ: %s", msg);
1173 krb5_free_error_message(context, msg);
1174 goto out;
1175 }
1176
1177 if(!get_krbtgt_realm(&ap_req.ticket.sname)){
1178 /* XXX check for ticket.sname == req.sname */
1179 kdc_log(context, config, 0, "PA-DATA is not a ticket-granting ticket");
1180 ret = KRB5KDC_ERR_POLICY; /* ? */
1181 goto out;
1182 }
1183
1184 _krb5_principalname2krb5_principal(context,
1185 &princ,
1186 ap_req.ticket.sname,
1187 ap_req.ticket.realm);
1188
1189 ret = _kdc_db_fetch(context, config, princ, HDB_F_GET_KRBTGT, ap_req.ticket.enc_part.kvno, NULL, krbtgt);
1190
1191 if(ret == HDB_ERR_NOT_FOUND_HERE) {
1192 char *p;
1193 ret = krb5_unparse_name(context, princ, &p);
1194 if (ret != 0)
1195 p = failed;
1196 krb5_free_principal(context, princ);
1197 kdc_log(context, config, 5, "Ticket-granting ticket account %s does not have secrets at this KDC, need to proxy", p);
1198 if (ret == 0)
1199 free(p);
1200 ret = HDB_ERR_NOT_FOUND_HERE;
1201 goto out;
1202 } else if(ret){
1203 const char *msg = krb5_get_error_message(context, ret);
1204 char *p;
1205 ret = krb5_unparse_name(context, princ, &p);
1206 if (ret != 0)
1207 p = failed;
1208 krb5_free_principal(context, princ);
1209 kdc_log(context, config, 0,
1210 "Ticket-granting ticket not found in database: %s", msg);
1211 krb5_free_error_message(context, msg);
1212 if (ret == 0)
1213 free(p);
1214 ret = KRB5KRB_AP_ERR_NOT_US;
1215 goto out;
1216 }
1217
1218 if(ap_req.ticket.enc_part.kvno &&
1219 *ap_req.ticket.enc_part.kvno != (*krbtgt)->entry.kvno){
1220 char *p;
1221
1222 ret = krb5_unparse_name (context, princ, &p);
1223 krb5_free_principal(context, princ);
1224 if (ret != 0)
1225 p = failed;
1226 kdc_log(context, config, 0,
1227 "Ticket kvno = %d, DB kvno = %d (%s)",
1228 *ap_req.ticket.enc_part.kvno,
1229 (*krbtgt)->entry.kvno,
1230 p);
1231 if (ret == 0)
1232 free (p);
1233 ret = KRB5KRB_AP_ERR_BADKEYVER;
1234 goto out;
1235 }
1236
1237 *krbtgt_etype = ap_req.ticket.enc_part.etype;
1238
1239 ret = hdb_enctype2key(context, &(*krbtgt)->entry,
1240 ap_req.ticket.enc_part.etype, &tkey);
1241 if(ret){
1242 char *str = NULL, *p = NULL;
1243
1244 krb5_enctype_to_string(context, ap_req.ticket.enc_part.etype, &str);
1245 krb5_unparse_name(context, princ, &p);
1246 kdc_log(context, config, 0,
1247 "No server key with enctype %s found for %s",
1248 str ? str : "<unknown enctype>",
1249 p ? p : "<unparse_name failed>");
1250 free(str);
1251 free(p);
1252 ret = KRB5KRB_AP_ERR_BADKEYVER;
1253 goto out;
1254 }
1255
1256 if (b->kdc_options.validate)
1257 verify_ap_req_flags = KRB5_VERIFY_AP_REQ_IGNORE_INVALID;
1258 else
1259 verify_ap_req_flags = 0;
1260
1261 ret = krb5_verify_ap_req2(context,
1262 &ac,
1263 &ap_req,
1264 princ,
1265 &tkey->key,
1266 verify_ap_req_flags,
1267 &ap_req_options,
1268 ticket,
1269 KRB5_KU_TGS_REQ_AUTH);
1270
1271 krb5_free_principal(context, princ);
1272 if(ret) {
1273 const char *msg = krb5_get_error_message(context, ret);
1274 kdc_log(context, config, 0, "Failed to verify AP-REQ: %s", msg);
1275 krb5_free_error_message(context, msg);
1276 goto out;
1277 }
1278
1279 {
1280 krb5_authenticator auth;
1281
1282 ret = krb5_auth_con_getauthenticator(context, ac, &auth);
1283 if (ret == 0) {
1284 *csec = malloc(sizeof(**csec));
1285 if (*csec == NULL) {
1286 krb5_free_authenticator(context, &auth);
1287 kdc_log(context, config, 0, "malloc failed");
1288 goto out;
1289 }
1290 **csec = auth->ctime;
1291 *cusec = malloc(sizeof(**cusec));
1292 if (*cusec == NULL) {
1293 krb5_free_authenticator(context, &auth);
1294 kdc_log(context, config, 0, "malloc failed");
1295 goto out;
1296 }
1297 **cusec = auth->cusec;
1298 krb5_free_authenticator(context, &auth);
1299 }
1300 }
1301
1302 ret = tgs_check_authenticator(context, config,
1303 ac, b, e_text, &(*ticket)->ticket.key);
1304 if (ret) {
1305 krb5_auth_con_free(context, ac);
1306 goto out;
1307 }
1308
1309 usage = KRB5_KU_TGS_REQ_AUTH_DAT_SUBKEY;
1310 *rk_is_subkey = 1;
1311
1312 ret = krb5_auth_con_getremotesubkey(context, ac, &subkey);
1313 if(ret){
1314 const char *msg = krb5_get_error_message(context, ret);
1315 krb5_auth_con_free(context, ac);
1316 kdc_log(context, config, 0, "Failed to get remote subkey: %s", msg);
1317 krb5_free_error_message(context, msg);
1318 goto out;
1319 }
1320 if(subkey == NULL){
1321 usage = KRB5_KU_TGS_REQ_AUTH_DAT_SESSION;
1322 *rk_is_subkey = 0;
1323
1324 ret = krb5_auth_con_getkey(context, ac, &subkey);
1325 if(ret) {
1326 const char *msg = krb5_get_error_message(context, ret);
1327 krb5_auth_con_free(context, ac);
1328 kdc_log(context, config, 0, "Failed to get session key: %s", msg);
1329 krb5_free_error_message(context, msg);
1330 goto out;
1331 }
1332 }
1333 if(subkey == NULL){
1334 krb5_auth_con_free(context, ac);
1335 kdc_log(context, config, 0,
1336 "Failed to get key for enc-authorization-data");
1337 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY; /* ? */
1338 goto out;
1339 }
1340
1341 *replykey = subkey;
1342
1343 if (b->enc_authorization_data) {
1344 krb5_data ad;
1345
1346 ret = krb5_crypto_init(context, subkey, 0, &crypto);
1347 if (ret) {
1348 const char *msg = krb5_get_error_message(context, ret);
1349 krb5_auth_con_free(context, ac);
1350 kdc_log(context, config, 0, "krb5_crypto_init failed: %s", msg);
1351 krb5_free_error_message(context, msg);
1352 goto out;
1353 }
1354 ret = krb5_decrypt_EncryptedData (context,
1355 crypto,
1356 usage,
1357 b->enc_authorization_data,
1358 &ad);
1359 krb5_crypto_destroy(context, crypto);
1360 if(ret){
1361 krb5_auth_con_free(context, ac);
1362 kdc_log(context, config, 0,
1363 "Failed to decrypt enc-authorization-data");
1364 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY; /* ? */
1365 goto out;
1366 }
1367 ALLOC(*auth_data);
1368 if (*auth_data == NULL) {
1369 krb5_auth_con_free(context, ac);
1370 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY; /* ? */
1371 goto out;
1372 }
1373 ret = decode_AuthorizationData(ad.data, ad.length, *auth_data, NULL);
1374 if(ret){
1375 krb5_auth_con_free(context, ac);
1376 free(*auth_data);
1377 *auth_data = NULL;
1378 kdc_log(context, config, 0, "Failed to decode authorization data");
1379 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY; /* ? */
1380 goto out;
1381 }
1382 }
1383
1384 krb5_auth_con_free(context, ac);
1385
1386 out:
1387 free_AP_REQ(&ap_req);
1388
1389 return ret;
1390 }
1391
1392 static krb5_error_code
1393 build_server_referral(krb5_context context,
1394 krb5_kdc_configuration *config,
1395 krb5_crypto session,
1396 krb5_const_realm referred_realm,
1397 const PrincipalName *true_principal_name,
1398 const PrincipalName *requested_principal,
1399 krb5_data *outdata)
1400 {
1401 PA_ServerReferralData ref;
1402 krb5_error_code ret;
1403 EncryptedData ed;
1404 krb5_data data;
1405 size_t size = 0;
1406
1407 memset(&ref, 0, sizeof(ref));
1408
1409 if (referred_realm) {
1410 ALLOC(ref.referred_realm);
1411 if (ref.referred_realm == NULL)
1412 goto eout;
1413 *ref.referred_realm = strdup(referred_realm);
1414 if (*ref.referred_realm == NULL)
1415 goto eout;
1416 }
1417 if (true_principal_name) {
1418 ALLOC(ref.true_principal_name);
1419 if (ref.true_principal_name == NULL)
1420 goto eout;
1421 ret = copy_PrincipalName(true_principal_name, ref.true_principal_name);
1422 if (ret)
1423 goto eout;
1424 }
1425 if (requested_principal) {
1426 ALLOC(ref.requested_principal_name);
1427 if (ref.requested_principal_name == NULL)
1428 goto eout;
1429 ret = copy_PrincipalName(requested_principal,
1430 ref.requested_principal_name);
1431 if (ret)
1432 goto eout;
1433 }
1434
1435 ASN1_MALLOC_ENCODE(PA_ServerReferralData,
1436 data.data, data.length,
1437 &ref, &size, ret);
1438 free_PA_ServerReferralData(&ref);
1439 if (ret)
1440 return ret;
1441 if (data.length != size)
1442 krb5_abortx(context, "internal asn.1 encoder error");
1443
1444 ret = krb5_encrypt_EncryptedData(context, session,
1445 KRB5_KU_PA_SERVER_REFERRAL,
1446 data.data, data.length,
1447 0 /* kvno */, &ed);
1448 free(data.data);
1449 if (ret)
1450 return ret;
1451
1452 ASN1_MALLOC_ENCODE(EncryptedData,
1453 outdata->data, outdata->length,
1454 &ed, &size, ret);
1455 free_EncryptedData(&ed);
1456 if (ret)
1457 return ret;
1458 if (outdata->length != size)
1459 krb5_abortx(context, "internal asn.1 encoder error");
1460
1461 return 0;
1462 eout:
1463 free_PA_ServerReferralData(&ref);
1464 krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
1465 return ENOMEM;
1466 }
1467
1468 static krb5_error_code
1469 tgs_build_reply(krb5_context context,
1470 krb5_kdc_configuration *config,
1471 KDC_REQ *req,
1472 KDC_REQ_BODY *b,
1473 hdb_entry_ex *krbtgt,
1474 krb5_enctype krbtgt_etype,
1475 const krb5_keyblock *replykey,
1476 int rk_is_subkey,
1477 krb5_ticket *ticket,
1478 krb5_data *reply,
1479 const char *from,
1480 const char **e_text,
1481 AuthorizationData **auth_data,
1482 const struct sockaddr *from_addr)
1483 {
1484 krb5_error_code ret;
1485 krb5_principal cp = NULL, sp = NULL, rsp = NULL, tp = NULL, dp = NULL;
1486 krb5_principal krbtgt_principal = NULL;
1487 char *spn = NULL, *cpn = NULL, *tpn = NULL, *dpn = NULL;
1488 hdb_entry_ex *server = NULL, *client = NULL, *s4u2self_impersonated_client = NULL;
1489 HDB *clientdb, *s4u2self_impersonated_clientdb;
1490 krb5_realm ref_realm = NULL;
1491 EncTicketPart *tgt = &ticket->ticket;
1492 krb5_principals spp = NULL;
1493 const EncryptionKey *ekey;
1494 krb5_keyblock sessionkey;
1495 krb5_kvno kvno;
1496 krb5_data rspac;
1497
1498 hdb_entry_ex *krbtgt_out = NULL;
1499
1500 METHOD_DATA enc_pa_data;
1501
1502 PrincipalName *s;
1503 Realm r;
1504 int nloop = 0;
1505 EncTicketPart adtkt;
1506 char opt_str[128];
1507 int signedpath = 0;
1508
1509 Key *tkey_check;
1510 Key *tkey_sign;
1511 int flags = HDB_F_FOR_TGS_REQ;
1512
1513 memset(&sessionkey, 0, sizeof(sessionkey));
1514 memset(&adtkt, 0, sizeof(adtkt));
1515 krb5_data_zero(&rspac);
1516 memset(&enc_pa_data, 0, sizeof(enc_pa_data));
1517
1518 s = b->sname;
1519 r = b->realm;
1520
1521 /*
1522 * Always to do CANON, see comment below about returned server principal (rsp).
1523 */
1524 flags |= HDB_F_CANON;
1525
1526 if(b->kdc_options.enc_tkt_in_skey){
1527 Ticket *t;
1528 hdb_entry_ex *uu;
1529 krb5_principal p;
1530 Key *uukey;
1531
1532 if(b->additional_tickets == NULL ||
1533 b->additional_tickets->len == 0){
1534 ret = KRB5KDC_ERR_BADOPTION; /* ? */
1535 kdc_log(context, config, 0,
1536 "No second ticket present in request");
1537 goto out;
1538 }
1539 t = &b->additional_tickets->val[0];
1540 if(!get_krbtgt_realm(&t->sname)){
1541 kdc_log(context, config, 0,
1542 "Additional ticket is not a ticket-granting ticket");
1543 ret = KRB5KDC_ERR_POLICY;
1544 goto out;
1545 }
1546 _krb5_principalname2krb5_principal(context, &p, t->sname, t->realm);
1547 ret = _kdc_db_fetch(context, config, p,
1548 HDB_F_GET_KRBTGT, t->enc_part.kvno,
1549 NULL, &uu);
1550 krb5_free_principal(context, p);
1551 if(ret){
1552 if (ret == HDB_ERR_NOENTRY)
1553 ret = KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN;
1554 goto out;
1555 }
1556 ret = hdb_enctype2key(context, &uu->entry,
1557 t->enc_part.etype, &uukey);
1558 if(ret){
1559 _kdc_free_ent(context, uu);
1560 ret = KRB5KDC_ERR_ETYPE_NOSUPP; /* XXX */
1561 goto out;
1562 }
1563 ret = krb5_decrypt_ticket(context, t, &uukey->key, &adtkt, 0);
1564 _kdc_free_ent(context, uu);
1565 if(ret)
1566 goto out;
1567
1568 ret = verify_flags(context, config, &adtkt, spn);
1569 if (ret)
1570 goto out;
1571
1572 s = &adtkt.cname;
1573 r = adtkt.crealm;
1574 }
1575
1576 _krb5_principalname2krb5_principal(context, &sp, *s, r);
1577 ret = krb5_unparse_name(context, sp, &spn);
1578 if (ret)
1579 goto out;
1580 _krb5_principalname2krb5_principal(context, &cp, tgt->cname, tgt->crealm);
1581 ret = krb5_unparse_name(context, cp, &cpn);
1582 if (ret)
1583 goto out;
1584 unparse_flags (KDCOptions2int(b->kdc_options),
1585 asn1_KDCOptions_units(),
1586 opt_str, sizeof(opt_str));
1587 if(*opt_str)
1588 kdc_log(context, config, 0,
1589 "TGS-REQ %s from %s for %s [%s]",
1590 cpn, from, spn, opt_str);
1591 else
1592 kdc_log(context, config, 0,
1593 "TGS-REQ %s from %s for %s", cpn, from, spn);
1594
1595 /*
1596 * Fetch server
1597 */
1598
1599 server_lookup:
1600 ret = _kdc_db_fetch(context, config, sp, HDB_F_GET_SERVER | flags,
1601 NULL, NULL, &server);
1602
1603 if(ret == HDB_ERR_NOT_FOUND_HERE) {
1604 kdc_log(context, config, 5, "target %s does not have secrets at this KDC, need to proxy", sp);
1605 goto out;
1606 } else if(ret){
1607 const char *new_rlm, *msg;
1608 Realm req_rlm;
1609 krb5_realm *realms;
1610
1611 if ((req_rlm = get_krbtgt_realm(&sp->name)) != NULL) {
1612 if(nloop++ < 2) {
1613 new_rlm = find_rpath(context, tgt->crealm, req_rlm);
1614 if(new_rlm) {
1615 kdc_log(context, config, 5, "krbtgt for realm %s "
1616 "not found, trying %s",
1617 req_rlm, new_rlm);
1618 krb5_free_principal(context, sp);
1619 free(spn);
1620 krb5_make_principal(context, &sp, r,
1621 KRB5_TGS_NAME, new_rlm, NULL);
1622 ret = krb5_unparse_name(context, sp, &spn);
1623 if (ret)
1624 goto out;
1625
1626 if (ref_realm)
1627 free(ref_realm);
1628 ref_realm = strdup(new_rlm);
1629 goto server_lookup;
1630 }
1631 }
1632 } else if(need_referral(context, config, &b->kdc_options, sp, &realms)) {
1633 if (strcmp(realms[0], sp->realm) != 0) {
1634 kdc_log(context, config, 5,
1635 "Returning a referral to realm %s for "
1636 "server %s that was not found",
1637 realms[0], spn);
1638 krb5_free_principal(context, sp);
1639 free(spn);
1640 krb5_make_principal(context, &sp, r, KRB5_TGS_NAME,
1641 realms[0], NULL);
1642 ret = krb5_unparse_name(context, sp, &spn);
1643 if (ret)
1644 goto out;
1645
1646 if (ref_realm)
1647 free(ref_realm);
1648 ref_realm = strdup(realms[0]);
1649
1650 krb5_free_host_realm(context, realms);
1651 goto server_lookup;
1652 }
1653 krb5_free_host_realm(context, realms);
1654 }
1655 msg = krb5_get_error_message(context, ret);
1656 kdc_log(context, config, 0,
1657 "Server not found in database: %s: %s", spn, msg);
1658 krb5_free_error_message(context, msg);
1659 if (ret == HDB_ERR_NOENTRY)
1660 ret = KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN;
1661 goto out;
1662 }
1663
1664 /* the name returned to the client depend on what was asked for,
1665 * return canonical name if kdc_options.canonicalize was set, the
1666 * client wants the true name of the principal, if not it just
1667 * wants the name its asked for.
1668 */
1669
1670 if (b->kdc_options.canonicalize)
1671 rsp = server->entry.principal;
1672 else
1673 rsp = sp;
1674
1675
1676 /*
1677 * Select enctype, return key and kvno.
1678 */
1679
1680 {
1681 krb5_enctype etype;
1682
1683 if(b->kdc_options.enc_tkt_in_skey) {
1684 size_t i;
1685 ekey = &adtkt.key;
1686 for(i = 0; i < b->etype.len; i++)
1687 if (b->etype.val[i] == adtkt.key.keytype)
1688 break;
1689 if(i == b->etype.len) {
1690 kdc_log(context, config, 0,
1691 "Addition ticket have not matching etypes");
1692 krb5_clear_error_message(context);
1693 ret = KRB5KDC_ERR_ETYPE_NOSUPP;
1694 goto out;
1695 }
1696 etype = b->etype.val[i];
1697 kvno = 0;
1698 } else {
1699 Key *skey;
1700
1701 ret = _kdc_find_etype(context,
1702 krb5_principal_is_krbtgt(context, sp) ?
1703 config->tgt_use_strongest_session_key :
1704 config->svc_use_strongest_session_key, FALSE,
1705 server, b->etype.val, b->etype.len, NULL,
1706 &skey);
1707 if(ret) {
1708 kdc_log(context, config, 0,
1709 "Server (%s) has no support for etypes", spn);
1710 goto out;
1711 }
1712 ekey = &skey->key;
1713 etype = skey->key.keytype;
1714 kvno = server->entry.kvno;
1715 }
1716
1717 ret = krb5_generate_random_keyblock(context, etype, &sessionkey);
1718 if (ret)
1719 goto out;
1720 }
1721
1722 /*
1723 * Check that service is in the same realm as the krbtgt. If it's
1724 * not the same, it's someone that is using a uni-directional trust
1725 * backward.
1726 */
1727
1728 /*
1729 * Validate authoriation data
1730 */
1731
1732 ret = hdb_enctype2key(context, &krbtgt->entry,
1733 krbtgt_etype, &tkey_check);
1734 if(ret) {
1735 kdc_log(context, config, 0,
1736 "Failed to find key for krbtgt PAC check");
1737 goto out;
1738 }
1739
1740 /* Now refetch the primary krbtgt, and get the current kvno (the
1741 * sign check may have been on an old kvno, and the server may
1742 * have been an incoming trust) */
1743 ret = krb5_make_principal(context, &krbtgt_principal,
1744 krb5_principal_get_comp_string(context,
1745 krbtgt->entry.principal,
1746 1),
1747 KRB5_TGS_NAME,
1748 krb5_principal_get_comp_string(context,
1749 krbtgt->entry.principal,
1750 1), NULL);
1751 if(ret) {
1752 kdc_log(context, config, 0,
1753 "Failed to generate krbtgt principal");
1754 goto out;
1755 }
1756
1757 ret = _kdc_db_fetch(context, config, krbtgt_principal, HDB_F_GET_KRBTGT, NULL, NULL, &krbtgt_out);
1758 krb5_free_principal(context, krbtgt_principal);
1759 if (ret) {
1760 krb5_error_code ret2;
1761 char *ktpn, *ktpn2;
1762 ret = krb5_unparse_name(context, krbtgt->entry.principal, &ktpn);
1763 ret2 = krb5_unparse_name(context, krbtgt_principal, &ktpn2);
1764 kdc_log(context, config, 0,
1765 "Request with wrong krbtgt: %s, %s not found in our database",
1766 (ret == 0) ? ktpn : "<unknown>", (ret2 == 0) ? ktpn2 : "<unknown>");
1767 if(ret == 0)
1768 free(ktpn);
1769 if(ret2 == 0)
1770 free(ktpn2);
1771 ret = KRB5KRB_AP_ERR_NOT_US;
1772 goto out;
1773 }
1774
1775 /* The first realm is the realm of the service, the second is
1776 * krbtgt/<this>/@REALM component of the krbtgt DN the request was
1777 * encrypted to. The redirection via the krbtgt_out entry allows
1778 * the DB to possibly correct the case of the realm (Samba4 does
1779 * this) before the strcmp() */
1780 if (strcmp(krb5_principal_get_realm(context, server->entry.principal),
1781 krb5_principal_get_realm(context, krbtgt_out->entry.principal)) != 0) {
1782 char *ktpn;
1783 ret = krb5_unparse_name(context, krbtgt_out->entry.principal, &ktpn);
1784 kdc_log(context, config, 0,
1785 "Request with wrong krbtgt: %s",
1786 (ret == 0) ? ktpn : "<unknown>");
1787 if(ret == 0)
1788 free(ktpn);
1789 ret = KRB5KRB_AP_ERR_NOT_US;
1790 }
1791
1792 ret = hdb_enctype2key(context, &krbtgt_out->entry,
1793 krbtgt_etype, &tkey_sign);
1794 if(ret) {
1795 kdc_log(context, config, 0,
1796 "Failed to find key for krbtgt PAC signature");
1797 goto out;
1798 }
1799
1800 ret = _kdc_db_fetch(context, config, cp, HDB_F_GET_CLIENT | flags,
1801 NULL, &clientdb, &client);
1802 if(ret == HDB_ERR_NOT_FOUND_HERE) {
1803 /* This is OK, we are just trying to find out if they have
1804 * been disabled or deleted in the meantime, missing secrets
1805 * is OK */
1806 } else if(ret){
1807 const char *krbtgt_realm, *msg;
1808
1809 /*
1810 * If the client belongs to the same realm as our krbtgt, it
1811 * should exist in the local database.
1812 *
1813 */
1814
1815 krbtgt_realm = krb5_principal_get_realm(context, krbtgt_out->entry.principal);
1816
1817 if(strcmp(krb5_principal_get_realm(context, cp), krbtgt_realm) == 0) {
1818 if (ret == HDB_ERR_NOENTRY)
1819 ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
1820 kdc_log(context, config, 1, "Client no longer in database: %s",
1821 cpn);
1822 goto out;
1823 }
1824
1825 msg = krb5_get_error_message(context, ret);
1826 kdc_log(context, config, 1, "Client not found in database: %s", msg);
1827 krb5_free_error_message(context, msg);
1828 }
1829
1830 ret = check_PAC(context, config, cp, NULL,
1831 client, server, krbtgt,
1832 &tkey_check->key, &tkey_check->key,
1833 ekey, &tkey_sign->key,
1834 tgt, &rspac, &signedpath);
1835 if (ret) {
1836 const char *msg = krb5_get_error_message(context, ret);
1837 kdc_log(context, config, 0,
1838 "Verify PAC failed for %s (%s) from %s with %s",
1839 spn, cpn, from, msg);
1840 krb5_free_error_message(context, msg);
1841 goto out;
1842 }
1843
1844 /* also check the krbtgt for signature */
1845 ret = check_KRB5SignedPath(context,
1846 config,
1847 krbtgt,
1848 cp,
1849 tgt,
1850 &spp,
1851 &signedpath);
1852 if (ret) {
1853 const char *msg = krb5_get_error_message(context, ret);
1854 kdc_log(context, config, 0,
1855 "KRB5SignedPath check failed for %s (%s) from %s with %s",
1856 spn, cpn, from, msg);
1857 krb5_free_error_message(context, msg);
1858 goto out;
1859 }
1860
1861 /*
1862 * Process request
1863 */
1864
1865 /* by default the tgt principal matches the client principal */
1866 tp = cp;
1867 tpn = cpn;
1868
1869 if (client) {
1870 const PA_DATA *sdata;
1871 int i = 0;
1872
1873 sdata = _kdc_find_padata(req, &i, KRB5_PADATA_FOR_USER);
1874 if (sdata) {
1875 krb5_crypto crypto;
1876 krb5_data datack;
1877 PA_S4U2Self self;
1878 const char *str;
1879
1880 ret = decode_PA_S4U2Self(sdata->padata_value.data,
1881 sdata->padata_value.length,
1882 &self, NULL);
1883 if (ret) {
1884 kdc_log(context, config, 0, "Failed to decode PA-S4U2Self");
1885 goto out;
1886 }
1887
1888 ret = _krb5_s4u2self_to_checksumdata(context, &self, &datack);
1889 if (ret)
1890 goto out;
1891
1892 ret = krb5_crypto_init(context, &tgt->key, 0, &crypto);
1893 if (ret) {
1894 const char *msg = krb5_get_error_message(context, ret);
1895 free_PA_S4U2Self(&self);
1896 krb5_data_free(&datack);
1897 kdc_log(context, config, 0, "krb5_crypto_init failed: %s", msg);
1898 krb5_free_error_message(context, msg);
1899 goto out;
1900 }
1901
1902 ret = krb5_verify_checksum(context,
1903 crypto,
1904 KRB5_KU_OTHER_CKSUM,
1905 datack.data,
1906 datack.length,
1907 &self.cksum);
1908 krb5_data_free(&datack);
1909 krb5_crypto_destroy(context, crypto);
1910 if (ret) {
1911 const char *msg = krb5_get_error_message(context, ret);
1912 free_PA_S4U2Self(&self);
1913 kdc_log(context, config, 0,
1914 "krb5_verify_checksum failed for S4U2Self: %s", msg);
1915 krb5_free_error_message(context, msg);
1916 goto out;
1917 }
1918
1919 ret = _krb5_principalname2krb5_principal(context,
1920 &tp,
1921 self.name,
1922 self.realm);
1923 free_PA_S4U2Self(&self);
1924 if (ret)
1925 goto out;
1926
1927 ret = krb5_unparse_name(context, tp, &tpn);
1928 if (ret)
1929 goto out;
1930
1931 /* If we were about to put a PAC into the ticket, we better fix it to be the right PAC */
1932 if(rspac.data) {
1933 krb5_pac p = NULL;
1934 krb5_data_free(&rspac);
1935 ret = _kdc_db_fetch(context, config, tp, HDB_F_GET_CLIENT | flags,
1936 NULL, &s4u2self_impersonated_clientdb, &s4u2self_impersonated_client);
1937 if (ret) {
1938 const char *msg;
1939
1940 /*
1941 * If the client belongs to the same realm as our krbtgt, it
1942 * should exist in the local database.
1943 *
1944 */
1945
1946 if (ret == HDB_ERR_NOENTRY)
1947 ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
1948 msg = krb5_get_error_message(context, ret);
1949 kdc_log(context, config, 1,
1950 "S2U4Self principal to impersonate %s not found in database: %s",
1951 tpn, msg);
1952 krb5_free_error_message(context, msg);
1953 goto out;
1954 }
1955 ret = _kdc_pac_generate(context, s4u2self_impersonated_client, &p);
1956 if (ret) {
1957 kdc_log(context, config, 0, "PAC generation failed for -- %s",
1958 tpn);
1959 goto out;
1960 }
1961 if (p != NULL) {
1962 ret = _krb5_pac_sign(context, p, ticket->ticket.authtime,
1963 s4u2self_impersonated_client->entry.principal,
1964 ekey, &tkey_sign->key,
1965 &rspac);
1966 krb5_pac_free(context, p);
1967 if (ret) {
1968 kdc_log(context, config, 0, "PAC signing failed for -- %s",
1969 tpn);
1970 goto out;
1971 }
1972 }
1973 }
1974
1975 /*
1976 * Check that service doing the impersonating is
1977 * requesting a ticket to it-self.
1978 */
1979 ret = check_s4u2self(context, config, clientdb, client, sp);
1980 if (ret) {
1981 kdc_log(context, config, 0, "S4U2Self: %s is not allowed "
1982 "to impersonate to service "
1983 "(tried for user %s to service %s)",
1984 cpn, tpn, spn);
1985 goto out;
1986 }
1987
1988 /*
1989 * If the service isn't trusted for authentication to
1990 * delegation, remove the forward flag.
1991 */
1992
1993 if (client->entry.flags.trusted_for_delegation) {
1994 str = "[forwardable]";
1995 } else {
1996 b->kdc_options.forwardable = 0;
1997 str = "";
1998 }
1999 kdc_log(context, config, 0, "s4u2self %s impersonating %s to "
2000 "service %s %s", cpn, tpn, spn, str);
2001 }
2002 }
2003
2004 /*
2005 * Constrained delegation
2006 */
2007
2008 if (client != NULL
2009 && b->additional_tickets != NULL
2010 && b->additional_tickets->len != 0
2011 && b->kdc_options.enc_tkt_in_skey == 0)
2012 {
2013 int ad_signedpath = 0;
2014 Key *clientkey;
2015 Ticket *t;
2016
2017 /*
2018 * Require that the KDC have issued the service's krbtgt (not
2019 * self-issued ticket with kimpersonate(1).
2020 */
2021 if (!signedpath) {
2022 ret = KRB5KDC_ERR_BADOPTION;
2023 kdc_log(context, config, 0,
2024 "Constrained delegation done on service ticket %s/%s",
2025 cpn, spn);
2026 goto out;
2027 }
2028
2029 t = &b->additional_tickets->val[0];
2030
2031 ret = hdb_enctype2key(context, &client->entry,
2032 t->enc_part.etype, &clientkey);
2033 if(ret){
2034 ret = KRB5KDC_ERR_ETYPE_NOSUPP; /* XXX */
2035 goto out;
2036 }
2037
2038 ret = krb5_decrypt_ticket(context, t, &clientkey->key, &adtkt, 0);
2039 if (ret) {
2040 kdc_log(context, config, 0,
2041 "failed to decrypt ticket for "
2042 "constrained delegation from %s to %s ", cpn, spn);
2043 goto out;
2044 }
2045
2046 ret = _krb5_principalname2krb5_principal(context,
2047 &tp,
2048 adtkt.cname,
2049 adtkt.crealm);
2050 if (ret)
2051 goto out;
2052
2053 ret = krb5_unparse_name(context, tp, &tpn);
2054 if (ret)
2055 goto out;
2056
2057 ret = _krb5_principalname2krb5_principal(context,
2058 &dp,
2059 t->sname,
2060 t->realm);
2061 if (ret)
2062 goto out;
2063
2064 ret = krb5_unparse_name(context, dp, &dpn);
2065 if (ret)
2066 goto out;
2067
2068 /* check that ticket is valid */
2069 if (adtkt.flags.forwardable == 0) {
2070 kdc_log(context, config, 0,
2071 "Missing forwardable flag on ticket for "
2072 "constrained delegation from %s (%s) as %s to %s ",
2073 cpn, dpn, tpn, spn);
2074 ret = KRB5KDC_ERR_BADOPTION;
2075 goto out;
2076 }
2077
2078 ret = check_constrained_delegation(context, config, clientdb,
2079 client, server, sp);
2080 if (ret) {
2081 kdc_log(context, config, 0,
2082 "constrained delegation from %s (%s) as %s to %s not allowed",
2083 cpn, dpn, tpn, spn);
2084 goto out;
2085 }
2086
2087 ret = verify_flags(context, config, &adtkt, tpn);
2088 if (ret) {
2089 goto out;
2090 }
2091
2092 krb5_data_free(&rspac);
2093
2094 /*
2095 * generate the PAC for the user.
2096 *
2097 * TODO: pass in t->sname and t->realm and build
2098 * a S4U_DELEGATION_INFO blob to the PAC.
2099 */
2100 ret = check_PAC(context, config, tp, dp,
2101 client, server, krbtgt,
2102 &clientkey->key, &tkey_check->key,
2103 ekey, &tkey_sign->key,
2104 &adtkt, &rspac, &ad_signedpath);
2105 if (ret) {
2106 const char *msg = krb5_get_error_message(context, ret);
2107 kdc_log(context, config, 0,
2108 "Verify delegated PAC failed to %s for client"
2109 "%s (%s) as %s from %s with %s",
2110 spn, cpn, dpn, tpn, from, msg);
2111 krb5_free_error_message(context, msg);
2112 goto out;
2113 }
2114
2115 /*
2116 * Check that the KDC issued the user's ticket.
2117 */
2118 ret = check_KRB5SignedPath(context,
2119 config,
2120 krbtgt,
2121 cp,
2122 &adtkt,
2123 NULL,
2124 &ad_signedpath);
2125 if (ret) {
2126 const char *msg = krb5_get_error_message(context, ret);
2127 kdc_log(context, config, 0,
2128 "KRB5SignedPath check from service %s failed "
2129 "for delegation to %s for client %s (%s)"
2130 "from %s failed with %s",
2131 spn, tpn, dpn, cpn, from, msg);
2132 krb5_free_error_message(context, msg);
2133 goto out;
2134 }
2135
2136 if (!ad_signedpath) {
2137 ret = KRB5KDC_ERR_BADOPTION;
2138 kdc_log(context, config, 0,
2139 "Ticket not signed with PAC nor SignedPath service %s failed "
2140 "for delegation to %s for client %s (%s)"
2141 "from %s",
2142 spn, tpn, dpn, cpn, from);
2143 goto out;
2144 }
2145
2146 kdc_log(context, config, 0, "constrained delegation for %s "
2147 "from %s (%s) to %s", tpn, cpn, dpn, spn);
2148 }
2149
2150 /*
2151 * Check flags
2152 */
2153
2154 ret = kdc_check_flags(context, config,
2155 client, cpn,
2156 server, spn,
2157 FALSE);
2158 if(ret)
2159 goto out;
2160
2161 if((b->kdc_options.validate || b->kdc_options.renew) &&
2162 !krb5_principal_compare(context,
2163 krbtgt->entry.principal,
2164 server->entry.principal)){
2165 kdc_log(context, config, 0, "Inconsistent request.");
2166 ret = KRB5KDC_ERR_SERVER_NOMATCH;
2167 goto out;
2168 }
2169
2170 /* check for valid set of addresses */
2171 if(!_kdc_check_addresses(context, config, tgt->caddr, from_addr)) {
2172 ret = KRB5KRB_AP_ERR_BADADDR;
2173 kdc_log(context, config, 0, "Request from wrong address");
2174 goto out;
2175 }
2176
2177 /*
2178 * If this is an referral, add server referral data to the
2179 * auth_data reply .
2180 */
2181 if (ref_realm) {
2182 PA_DATA pa;
2183 krb5_crypto crypto;
2184
2185 kdc_log(context, config, 0,
2186 "Adding server referral to %s", ref_realm);
2187
2188 ret = krb5_crypto_init(context, &sessionkey, 0, &crypto);
2189 if (ret)
2190 goto out;
2191
2192 ret = build_server_referral(context, config, crypto, ref_realm,
2193 NULL, s, &pa.padata_value);
2194 krb5_crypto_destroy(context, crypto);
2195 if (ret) {
2196 kdc_log(context, config, 0,
2197 "Failed building server referral");
2198 goto out;
2199 }
2200 pa.padata_type = KRB5_PADATA_SERVER_REFERRAL;
2201
2202 ret = add_METHOD_DATA(&enc_pa_data, &pa);
2203 krb5_data_free(&pa.padata_value);
2204 if (ret) {
2205 kdc_log(context, config, 0,
2206 "Add server referral METHOD-DATA failed");
2207 goto out;
2208 }
2209 }
2210
2211 /*
2212 *
2213 */
2214
2215 ret = tgs_make_reply(context,
2216 config,
2217 b,
2218 tp,
2219 tgt,
2220 replykey,
2221 rk_is_subkey,
2222 ekey,
2223 &sessionkey,
2224 kvno,
2225 *auth_data,
2226 server,
2227 rsp,
2228 spn,
2229 client,
2230 cp,
2231 krbtgt_out,
2232 krbtgt_etype,
2233 spp,
2234 &rspac,
2235 &enc_pa_data,
2236 e_text,
2237 reply);
2238
2239 out:
2240 if (tpn != cpn)
2241 free(tpn);
2242 free(spn);
2243 free(cpn);
2244 if (dpn)
2245 free(dpn);
2246
2247 krb5_data_free(&rspac);
2248 krb5_free_keyblock_contents(context, &sessionkey);
2249 if(krbtgt_out)
2250 _kdc_free_ent(context, krbtgt_out);
2251 if(server)
2252 _kdc_free_ent(context, server);
2253 if(client)
2254 _kdc_free_ent(context, client);
2255 if(s4u2self_impersonated_client)
2256 _kdc_free_ent(context, s4u2self_impersonated_client);
2257
2258 if (tp && tp != cp)
2259 krb5_free_principal(context, tp);
2260 if (cp)
2261 krb5_free_principal(context, cp);
2262 if (dp)
2263 krb5_free_principal(context, dp);
2264 if (sp)
2265 krb5_free_principal(context, sp);
2266 if (ref_realm)
2267 free(ref_realm);
2268 free_METHOD_DATA(&enc_pa_data);
2269
2270 free_EncTicketPart(&adtkt);
2271
2272 return ret;
2273 }
2274
2275 /*
2276 *
2277 */
2278
2279 krb5_error_code
2280 _kdc_tgs_rep(krb5_context context,
2281 krb5_kdc_configuration *config,
2282 KDC_REQ *req,
2283 krb5_data *data,
2284 const char *from,
2285 struct sockaddr *from_addr,
2286 int datagram_reply)
2287 {
2288 AuthorizationData *auth_data = NULL;
2289 krb5_error_code ret;
2290 int i = 0;
2291 const PA_DATA *tgs_req;
2292
2293 hdb_entry_ex *krbtgt = NULL;
2294 krb5_ticket *ticket = NULL;
2295 const char *e_text = NULL;
2296 krb5_enctype krbtgt_etype = ETYPE_NULL;
2297
2298 krb5_keyblock *replykey = NULL;
2299 int rk_is_subkey = 0;
2300 time_t *csec = NULL;
2301 int *cusec = NULL;
2302
2303 if(req->padata == NULL){
2304 ret = KRB5KDC_ERR_PREAUTH_REQUIRED; /* XXX ??? */
2305 kdc_log(context, config, 0,
2306 "TGS-REQ from %s without PA-DATA", from);
2307 goto out;
2308 }
2309
2310 tgs_req = _kdc_find_padata(req, &i, KRB5_PADATA_TGS_REQ);
2311
2312 if(tgs_req == NULL){
2313 ret = KRB5KDC_ERR_PADATA_TYPE_NOSUPP;
2314
2315 kdc_log(context, config, 0,
2316 "TGS-REQ from %s without PA-TGS-REQ", from);
2317 goto out;
2318 }
2319 ret = tgs_parse_request(context, config,
2320 &req->req_body, tgs_req,
2321 &krbtgt,
2322 &krbtgt_etype,
2323 &ticket,
2324 &e_text,
2325 from, from_addr,
2326 &csec, &cusec,
2327 &auth_data,
2328 &replykey,
2329 &rk_is_subkey);
2330 if (ret == HDB_ERR_NOT_FOUND_HERE) {
2331 /* kdc_log() is called in tgs_parse_request() */
2332 goto out;
2333 }
2334 if (ret) {
2335 kdc_log(context, config, 0,
2336 "Failed parsing TGS-REQ from %s", from);
2337 goto out;
2338 }
2339
2340 ret = tgs_build_reply(context,
2341 config,
2342 req,
2343 &req->req_body,
2344 krbtgt,
2345 krbtgt_etype,
2346 replykey,
2347 rk_is_subkey,
2348 ticket,
2349 data,
2350 from,
2351 &e_text,
2352 &auth_data,
2353 from_addr);
2354 if (ret) {
2355 kdc_log(context, config, 0,
2356 "Failed building TGS-REP to %s", from);
2357 goto out;
2358 }
2359
2360 /* */
2361 if (datagram_reply && data->length > config->max_datagram_reply_length) {
2362 krb5_data_free(data);
2363 ret = KRB5KRB_ERR_RESPONSE_TOO_BIG;
2364 e_text = "Reply packet too large";
2365 }
2366
2367 out:
2368 if (replykey)
2369 krb5_free_keyblock(context, replykey);
2370 if(ret && ret != HDB_ERR_NOT_FOUND_HERE && data->data == NULL){
2371 krb5_mk_error(context,
2372 ret,
2373 NULL,
2374 NULL,
2375 NULL,
2376 NULL,
2377 csec,
2378 cusec,
2379 data);
2380 ret = 0;
2381 }
2382 free(csec);
2383 free(cusec);
2384 if (ticket)
2385 krb5_free_ticket(context, ticket);
2386 if(krbtgt)
2387 _kdc_free_ent(context, krbtgt);
2388
2389 if (auth_data) {
2390 free_AuthorizationData(auth_data);
2391 free(auth_data);
2392 }
2393
2394 return ret;
2395 }
Heimdal