?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Allow KDC to always return the salt in the PA-ETYPE-INFO[2]
[heimdal.git] / kdc / krb5tgs.c
blobe8a3d1b3722d2fb349587ca1a0b2bace38bd253b
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_const_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 = rk_UNCONST(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, NULL, 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, NULL, /* XXX use correct kvno! */
230 sp.etype, &key);
231 if (ret == 0)
232 ret = krb5_crypto_init(context, &key->key, 0, &crypto);
233 if (ret) {
234 free(data.data);
235 free_KRB5SignedPath(&sp);
236 return ret;
237 }
238 }
239 ret = krb5_verify_checksum(context, crypto, KRB5_KU_KRB5SIGNEDPATH,
240 data.data, data.length,
241 &sp.cksum);
242 krb5_crypto_destroy(context, crypto);
243 free(data.data);
244 if (ret) {
245 free_KRB5SignedPath(&sp);
246 kdc_log(context, config, 4,
247 "KRB5SignedPath not signed correctly, not marking as signed");
248 return 0;
249 }
250
251 if (delegated && sp.delegated) {
252
253 *delegated = malloc(sizeof(*sp.delegated));
254 if (*delegated == NULL) {
255 free_KRB5SignedPath(&sp);
256 return ENOMEM;
257 }
258
259 ret = copy_Principals(*delegated, sp.delegated);
260 if (ret) {
261 free_KRB5SignedPath(&sp);
262 free(*delegated);
263 *delegated = NULL;
264 return ret;
265 }
266 }
267 free_KRB5SignedPath(&sp);
268
269 *signedpath = 1;
270 }
271
272 return 0;
273 }
274
275 /*
276 *
277 */
278
279 static krb5_error_code
280 check_PAC(krb5_context context,
281 krb5_kdc_configuration *config,
282 const krb5_principal client_principal,
283 const krb5_principal delegated_proxy_principal,
284 hdb_entry_ex *client,
285 hdb_entry_ex *server,
286 hdb_entry_ex *krbtgt,
287 const EncryptionKey *server_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, NULL);
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 static krb5_boolean
370 is_anon_tgs_request_p(const KDC_REQ_BODY *b,
371 const EncTicketPart *tgt)
372 {
373 KDCOptions f = b->kdc_options;
374
375 /*
376 * Versions of Heimdal from 1.0 to 7.6, inclusive, send both the
377 * request-anonymous and cname-in-addl-tkt flags for constrained
378 * delegation requests. A true anonymous TGS request will only
379 * have the request-anonymous flag set. (A corollary of this is
380 * that it is not possible to support anonymous constrained
381 * delegation requests, although they would be of limited utility.)
382 */
383 return tgt->flags.anonymous ||
384 (f.request_anonymous && !f.cname_in_addl_tkt && !b->additional_tickets);
385 }
386
387 /*
388 *
389 */
390
391 static krb5_error_code
392 check_tgs_flags(astgs_request_t r, KDC_REQ_BODY *b,
393 krb5_const_principal tgt_name,
394 const EncTicketPart *tgt, EncTicketPart *et)
395 {
396 krb5_context context = r->context;
397 KDCOptions f = b->kdc_options;
398
399 if(f.validate){
400 if (!tgt->flags.invalid || tgt->starttime == NULL) {
401 _kdc_audit_addreason((kdc_request_t)r,
402 "Bad request to validate ticket");
403 return KRB5KDC_ERR_BADOPTION;
404 }
405 if(*tgt->starttime > kdc_time){
406 _kdc_audit_addreason((kdc_request_t)r,
407 "Early request to validate ticket");
408 return KRB5KRB_AP_ERR_TKT_NYV;
409 }
410 /* XXX tkt = tgt */
411 et->flags.invalid = 0;
412 } else if (tgt->flags.invalid) {
413 _kdc_audit_addreason((kdc_request_t)r,
414 "Ticket-granting ticket has INVALID flag set");
415 return KRB5KRB_AP_ERR_TKT_INVALID;
416 }
417
418 if(f.forwardable){
419 if (!tgt->flags.forwardable) {
420 _kdc_audit_addreason((kdc_request_t)r,
421 "Bad request for forwardable ticket");
422 return KRB5KDC_ERR_BADOPTION;
423 }
424 et->flags.forwardable = 1;
425 }
426 if(f.forwarded){
427 if (!tgt->flags.forwardable) {
428 _kdc_audit_addreason((kdc_request_t)r,
429 "Request to forward non-forwardable ticket");
430 return KRB5KDC_ERR_BADOPTION;
431 }
432 et->flags.forwarded = 1;
433 et->caddr = b->addresses;
434 }
435 if(tgt->flags.forwarded)
436 et->flags.forwarded = 1;
437
438 if(f.proxiable){
439 if (!tgt->flags.proxiable) {
440 _kdc_audit_addreason((kdc_request_t)r,
441 "Bad request for proxiable ticket");
442 return KRB5KDC_ERR_BADOPTION;
443 }
444 et->flags.proxiable = 1;
445 }
446 if(f.proxy){
447 if (!tgt->flags.proxiable) {
448 _kdc_audit_addreason((kdc_request_t)r,
449 "Request to proxy non-proxiable ticket");
450 return KRB5KDC_ERR_BADOPTION;
451 }
452 et->flags.proxy = 1;
453 et->caddr = b->addresses;
454 }
455 if(tgt->flags.proxy)
456 et->flags.proxy = 1;
457
458 if(f.allow_postdate){
459 if (!tgt->flags.may_postdate) {
460 _kdc_audit_addreason((kdc_request_t)r,
461 "Bad request for post-datable ticket");
462 return KRB5KDC_ERR_BADOPTION;
463 }
464 et->flags.may_postdate = 1;
465 }
466 if(f.postdated){
467 if (!tgt->flags.may_postdate) {
468 _kdc_audit_addreason((kdc_request_t)r,
469 "Bad request for postdated ticket");
470 return KRB5KDC_ERR_BADOPTION;
471 }
472 if(b->from)
473 *et->starttime = *b->from;
474 et->flags.postdated = 1;
475 et->flags.invalid = 1;
476 } else if (b->from && *b->from > kdc_time + context->max_skew) {
477 _kdc_audit_addreason((kdc_request_t)r,
478 "Ticket cannot be postdated");
479 return KRB5KDC_ERR_CANNOT_POSTDATE;
480 }
481
482 if(f.renewable){
483 if (!tgt->flags.renewable || tgt->renew_till == NULL) {
484 _kdc_audit_addreason((kdc_request_t)r,
485 "Bad request for renewable ticket");
486 return KRB5KDC_ERR_BADOPTION;
487 }
488 et->flags.renewable = 1;
489 ALLOC(et->renew_till);
490 _kdc_fix_time(&b->rtime);
491 *et->renew_till = *b->rtime;
492 }
493 if(f.renew){
494 time_t old_life;
495 if (!tgt->flags.renewable || tgt->renew_till == NULL) {
496 _kdc_audit_addreason((kdc_request_t)r,
497 "Request to renew non-renewable ticket");
498 return KRB5KDC_ERR_BADOPTION;
499 }
500 old_life = tgt->endtime;
501 if(tgt->starttime)
502 old_life -= *tgt->starttime;
503 else
504 old_life -= tgt->authtime;
505 et->endtime = *et->starttime + old_life;
506 if (et->renew_till != NULL)
507 et->endtime = min(*et->renew_till, et->endtime);
508 }
509
510 /*
511 * RFC 8062 section 3 defines an anonymous ticket as one containing
512 * the anonymous principal and the anonymous ticket flag.
513 */
514 if (tgt->flags.anonymous &&
515 !_kdc_is_anonymous(context, tgt_name)) {
516 _kdc_audit_addreason((kdc_request_t)r,
517 "Anonymous ticket flag set without "
518 "anonymous principal");
519 return KRB5KDC_ERR_BADOPTION;
520 }
521
522 /*
523 * RFC 8062 section 4.2 states that if the TGT is anonymous, the
524 * anonymous KDC option SHOULD be set, but it is not required.
525 * Treat an anonymous TGT as if the anonymous flag was set.
526 */
527 if (is_anon_tgs_request_p(b, tgt))
528 et->flags.anonymous = 1;
529
530 return 0;
531 }
532
533 /*
534 * Determine if constrained delegation is allowed from this client to this server
535 */
536
537 static krb5_error_code
538 check_constrained_delegation(krb5_context context,
539 krb5_kdc_configuration *config,
540 HDB *clientdb,
541 hdb_entry_ex *client,
542 hdb_entry_ex *server,
543 krb5_const_principal target)
544 {
545 const HDB_Ext_Constrained_delegation_acl *acl;
546 krb5_error_code ret;
547 size_t i;
548
549 /*
550 * constrained_delegation (S4U2Proxy) only works within
551 * the same realm. We use the already canonicalized version
552 * of the principals here, while "target" is the principal
553 * provided by the client.
554 */
555 if(!krb5_realm_compare(context, client->entry.principal, server->entry.principal)) {
556 ret = KRB5KDC_ERR_BADOPTION;
557 kdc_log(context, config, 4,
558 "Bad request for constrained delegation");
559 return ret;
560 }
561
562 if (clientdb->hdb_check_constrained_delegation) {
563 ret = clientdb->hdb_check_constrained_delegation(context, clientdb, client, target);
564 if (ret == 0)
565 return 0;
566 } else {
567 /* if client delegates to itself, that ok */
568 if (krb5_principal_compare(context, client->entry.principal, server->entry.principal) == TRUE)
569 return 0;
570
571 ret = hdb_entry_get_ConstrainedDelegACL(&client->entry, &acl);
572 if (ret) {
573 krb5_clear_error_message(context);
574 return ret;
575 }
576
577 if (acl) {
578 for (i = 0; i < acl->len; i++) {
579 if (krb5_principal_compare(context, target, &acl->val[i]) == TRUE)
580 return 0;
581 }
582 }
583 ret = KRB5KDC_ERR_BADOPTION;
584 }
585 kdc_log(context, config, 4,
586 "Bad request for constrained delegation");
587 return ret;
588 }
589
590 /*
591 * Determine if s4u2self is allowed from this client to this server
592 *
593 * For example, regardless of the principal being impersonated, if the
594 * 'client' and 'server' are the same, then it's safe.
595 */
596
597 static krb5_error_code
598 check_s4u2self(krb5_context context,
599 krb5_kdc_configuration *config,
600 HDB *clientdb,
601 hdb_entry_ex *client,
602 krb5_const_principal server)
603 {
604 krb5_error_code ret;
605
606 /* if client does a s4u2self to itself, that ok */
607 if (krb5_principal_compare(context, client->entry.principal, server) == TRUE)
608 return 0;
609
610 if (clientdb->hdb_check_s4u2self) {
611 ret = clientdb->hdb_check_s4u2self(context, clientdb, client, server);
612 if (ret == 0)
613 return 0;
614 } else {
615 ret = KRB5KDC_ERR_BADOPTION;
616 }
617 return ret;
618 }
619
620 /*
621 *
622 */
623
624 static krb5_error_code
625 verify_flags (krb5_context context,
626 krb5_kdc_configuration *config,
627 const EncTicketPart *et,
628 const char *pstr)
629 {
630 if(et->endtime < kdc_time){
631 kdc_log(context, config, 4, "Ticket expired (%s)", pstr);
632 return KRB5KRB_AP_ERR_TKT_EXPIRED;
633 }
634 if(et->flags.invalid){
635 kdc_log(context, config, 4, "Ticket not valid (%s)", pstr);
636 return KRB5KRB_AP_ERR_TKT_NYV;
637 }
638 return 0;
639 }
640
641 /*
642 *
643 */
644
645 static krb5_error_code
646 fix_transited_encoding(krb5_context context,
647 krb5_kdc_configuration *config,
648 krb5_boolean check_policy,
649 const TransitedEncoding *tr,
650 EncTicketPart *et,
651 const char *client_realm,
652 const char *server_realm,
653 const char *tgt_realm)
654 {
655 krb5_error_code ret = 0;
656 char **realms, **tmp;
657 unsigned int num_realms;
658 size_t i;
659
660 switch (tr->tr_type) {
661 case domain_X500_Compress:
662 break;
663 case 0:
664 /*
665 * Allow empty content of type 0 because that is was Microsoft
666 * generates in their TGT.
667 */
668 if (tr->contents.length == 0)
669 break;
670 kdc_log(context, config, 4,
671 "Transited type 0 with non empty content");
672 return KRB5KDC_ERR_TRTYPE_NOSUPP;
673 default:
674 kdc_log(context, config, 4,
675 "Unknown transited type: %u", tr->tr_type);
676 return KRB5KDC_ERR_TRTYPE_NOSUPP;
677 }
678
679 ret = krb5_domain_x500_decode(context,
680 tr->contents,
681 &realms,
682 &num_realms,
683 client_realm,
684 server_realm);
685 if(ret){
686 krb5_warn(context, ret,
687 "Decoding transited encoding");
688 return ret;
689 }
690
691 /*
692 * If the realm of the presented tgt is neither the client nor the server
693 * realm, it is a transit realm and must be added to transited set.
694 */
695 if(strcmp(client_realm, tgt_realm) && strcmp(server_realm, tgt_realm)) {
696 if (num_realms + 1 > UINT_MAX/sizeof(*realms)) {
697 ret = ERANGE;
698 goto free_realms;
699 }
700 tmp = realloc(realms, (num_realms + 1) * sizeof(*realms));
701 if(tmp == NULL){
702 ret = ENOMEM;
703 goto free_realms;
704 }
705 realms = tmp;
706 realms[num_realms] = strdup(tgt_realm);
707 if(realms[num_realms] == NULL){
708 ret = ENOMEM;
709 goto free_realms;
710 }
711 num_realms++;
712 }
713 if(num_realms == 0) {
714 if(strcmp(client_realm, server_realm))
715 kdc_log(context, config, 4,
716 "cross-realm %s -> %s", client_realm, server_realm);
717 } else {
718 size_t l = 0;
719 char *rs;
720 for(i = 0; i < num_realms; i++)
721 l += strlen(realms[i]) + 2;
722 rs = malloc(l);
723 if(rs != NULL) {
724 *rs = '\0';
725 for(i = 0; i < num_realms; i++) {
726 if(i > 0)
727 strlcat(rs, ", ", l);
728 strlcat(rs, realms[i], l);
729 }
730 kdc_log(context, config, 4,
731 "cross-realm %s -> %s via [%s]",
732 client_realm, server_realm, rs);
733 free(rs);
734 }
735 }
736 if(check_policy) {
737 ret = krb5_check_transited(context, client_realm,
738 server_realm,
739 realms, num_realms, NULL);
740 if(ret) {
741 krb5_warn(context, ret, "cross-realm %s -> %s",
742 client_realm, server_realm);
743 goto free_realms;
744 }
745 et->flags.transited_policy_checked = 1;
746 }
747 et->transited.tr_type = domain_X500_Compress;
748 ret = krb5_domain_x500_encode(realms, num_realms, &et->transited.contents);
749 if(ret)
750 krb5_warn(context, ret, "Encoding transited encoding");
751 free_realms:
752 for(i = 0; i < num_realms; i++)
753 free(realms[i]);
754 free(realms);
755 return ret;
756 }
757
758
759 static krb5_error_code
760 tgs_make_reply(astgs_request_t r,
761 krb5_const_principal tgt_name,
762 const EncTicketPart *tgt,
763 const krb5_keyblock *replykey,
764 int rk_is_subkey,
765 const EncryptionKey *serverkey,
766 const krb5_keyblock *sessionkey,
767 krb5_kvno kvno,
768 AuthorizationData *auth_data,
769 hdb_entry_ex *server,
770 krb5_principal server_principal,
771 hdb_entry_ex *client,
772 krb5_principal client_principal,
773 const char *tgt_realm,
774 hdb_entry_ex *krbtgt,
775 krb5_enctype krbtgt_etype,
776 krb5_principals spp,
777 const krb5_data *rspac,
778 const METHOD_DATA *enc_pa_data)
779 {
780 krb5_context context = r->context;
781 krb5_kdc_configuration *config = r->config;
782 KDC_REQ_BODY *b = &r->req.req_body;
783 const char **e_text = &r->e_text;
784 krb5_data *reply = r->reply;
785 KDC_REP rep;
786 EncKDCRepPart ek;
787 EncTicketPart et;
788 KDCOptions f = b->kdc_options;
789 krb5_error_code ret;
790 int is_weak = 0;
791
792 memset(&rep, 0, sizeof(rep));
793 memset(&et, 0, sizeof(et));
794 memset(&ek, 0, sizeof(ek));
795
796 rep.pvno = 5;
797 rep.msg_type = krb_tgs_rep;
798
799 et.authtime = tgt->authtime;
800 _kdc_fix_time(&b->till);
801 et.endtime = min(tgt->endtime, *b->till);
802 ALLOC(et.starttime);
803 *et.starttime = kdc_time;
804
805 ret = check_tgs_flags(r, b, tgt_name, tgt, &et);
806 if(ret)
807 goto out;
808
809 /* We should check the transited encoding if:
810 1) the request doesn't ask not to be checked
811 2) globally enforcing a check
812 3) principal requires checking
813 4) we allow non-check per-principal, but principal isn't marked as allowing this
814 5) we don't globally allow this
815 */
816
817 #define GLOBAL_FORCE_TRANSITED_CHECK \
818 (config->trpolicy == TRPOLICY_ALWAYS_CHECK)
819 #define GLOBAL_ALLOW_PER_PRINCIPAL \
820 (config->trpolicy == TRPOLICY_ALLOW_PER_PRINCIPAL)
821 #define GLOBAL_ALLOW_DISABLE_TRANSITED_CHECK \
822 (config->trpolicy == TRPOLICY_ALWAYS_HONOUR_REQUEST)
823
824 /* these will consult the database in future release */
825 #define PRINCIPAL_FORCE_TRANSITED_CHECK(P) 0
826 #define PRINCIPAL_ALLOW_DISABLE_TRANSITED_CHECK(P) 0
827
828 ret = fix_transited_encoding(context, config,
829 !f.disable_transited_check ||
830 GLOBAL_FORCE_TRANSITED_CHECK ||
831 PRINCIPAL_FORCE_TRANSITED_CHECK(server) ||
832 !((GLOBAL_ALLOW_PER_PRINCIPAL &&
833 PRINCIPAL_ALLOW_DISABLE_TRANSITED_CHECK(server)) ||
834 GLOBAL_ALLOW_DISABLE_TRANSITED_CHECK),
835 &tgt->transited, &et,
836 krb5_principal_get_realm(context, client_principal),
837 krb5_principal_get_realm(context, server->entry.principal),
838 tgt_realm);
839 if(ret)
840 goto out;
841
842 ret = copy_Realm(&server_principal->realm, &rep.ticket.realm);
843 if (ret)
844 goto out;
845 _krb5_principal2principalname(&rep.ticket.sname, server_principal);
846 ret = copy_Realm(&tgt_name->realm, &rep.crealm);
847 if (ret)
848 goto out;
849
850 /*
851 * RFC 8062 states "if the ticket in the TGS request is an anonymous
852 * one, the client and client realm are copied from that ticket". So
853 * whilst the TGT flag check below is superfluous, it is included in
854 * order to follow the specification to its letter.
855 */
856 if (et.flags.anonymous && !tgt->flags.anonymous)
857 _kdc_make_anonymous_principalname(&rep.cname);
858 else
859 ret = copy_PrincipalName(&tgt_name->name, &rep.cname);
860 if (ret)
861 goto out;
862 rep.ticket.tkt_vno = 5;
863
864 ek.caddr = et.caddr;
865
866 {
867 time_t life;
868 life = et.endtime - *et.starttime;
869 if(client && client->entry.max_life)
870 life = min(life, *client->entry.max_life);
871 if(server->entry.max_life)
872 life = min(life, *server->entry.max_life);
873 et.endtime = *et.starttime + life;
874 }
875 if(f.renewable_ok && tgt->flags.renewable &&
876 et.renew_till == NULL && et.endtime < *b->till &&
877 tgt->renew_till != NULL)
878 {
879 et.flags.renewable = 1;
880 ALLOC(et.renew_till);
881 *et.renew_till = *b->till;
882 }
883 if(et.renew_till){
884 time_t renew;
885 renew = *et.renew_till - *et.starttime;
886 if(client && client->entry.max_renew)
887 renew = min(renew, *client->entry.max_renew);
888 if(server->entry.max_renew)
889 renew = min(renew, *server->entry.max_renew);
890 *et.renew_till = *et.starttime + renew;
891 }
892
893 if(et.renew_till){
894 *et.renew_till = min(*et.renew_till, *tgt->renew_till);
895 *et.starttime = min(*et.starttime, *et.renew_till);
896 et.endtime = min(et.endtime, *et.renew_till);
897 }
898
899 *et.starttime = min(*et.starttime, et.endtime);
900
901 if(*et.starttime == et.endtime){
902 ret = KRB5KDC_ERR_NEVER_VALID;
903 goto out;
904 }
905 if(et.renew_till && et.endtime == *et.renew_till){
906 free(et.renew_till);
907 et.renew_till = NULL;
908 et.flags.renewable = 0;
909 }
910
911 et.flags.pre_authent = tgt->flags.pre_authent;
912 et.flags.hw_authent = tgt->flags.hw_authent;
913 et.flags.ok_as_delegate = server->entry.flags.ok_as_delegate;
914
915 /* See MS-KILE 3.3.5.1 */
916 if (!server->entry.flags.forwardable)
917 et.flags.forwardable = 0;
918 if (!server->entry.flags.proxiable)
919 et.flags.proxiable = 0;
920
921 /*
922 * For anonymous tickets, we should filter out positive authorization data
923 * that could reveal the client's identity, and return a policy error for
924 * restrictive authorization data. Policy for unknown authorization types
925 * is implementation dependent.
926 */
927 if (rspac->length && !et.flags.anonymous) {
928 /*
929 * No not need to filter out the any PAC from the
930 * auth_data since it's signed by the KDC.
931 */
932 ret = _kdc_tkt_add_if_relevant_ad(context, &et,
933 KRB5_AUTHDATA_WIN2K_PAC, rspac);
934 if (ret)
935 goto out;
936 }
937
938 if (auth_data) {
939 unsigned int i = 0;
940
941 /* XXX check authdata */
942
943 if (et.authorization_data == NULL) {
944 et.authorization_data = calloc(1, sizeof(*et.authorization_data));
945 if (et.authorization_data == NULL) {
946 ret = ENOMEM;
947 krb5_set_error_message(context, ret, "malloc: out of memory");
948 goto out;
949 }
950 }
951 for(i = 0; i < auth_data->len ; i++) {
952 ret = add_AuthorizationData(et.authorization_data, &auth_data->val[i]);
953 if (ret) {
954 krb5_set_error_message(context, ret, "malloc: out of memory");
955 goto out;
956 }
957 }
958
959 /* Filter out type KRB5SignedPath */
960 ret = find_KRB5SignedPath(context, et.authorization_data, NULL);
961 if (ret == 0) {
962 if (et.authorization_data->len == 1) {
963 free_AuthorizationData(et.authorization_data);
964 free(et.authorization_data);
965 et.authorization_data = NULL;
966 } else {
967 AuthorizationData *ad = et.authorization_data;
968 free_AuthorizationDataElement(&ad->val[ad->len - 1]);
969 ad->len--;
970 }
971 }
972 }
973
974 ret = krb5_copy_keyblock_contents(context, sessionkey, &et.key);
975 if (ret)
976 goto out;
977 et.crealm = rep.crealm;
978 et.cname = rep.cname;
979
980 ek.key = et.key;
981 /* MIT must have at least one last_req */
982 ek.last_req.val = calloc(1, sizeof(*ek.last_req.val));
983 if (ek.last_req.val == NULL) {
984 ret = ENOMEM;
985 goto out;
986 }
987 ek.last_req.len = 1; /* set after alloc to avoid null deref on cleanup */
988 ek.nonce = b->nonce;
989 ek.flags = et.flags;
990 ek.authtime = et.authtime;
991 ek.starttime = et.starttime;
992 ek.endtime = et.endtime;
993 ek.renew_till = et.renew_till;
994 ek.srealm = rep.ticket.realm;
995 ek.sname = rep.ticket.sname;
996
997 _kdc_log_timestamp(r, "TGS-REQ", et.authtime, et.starttime,
998 et.endtime, et.renew_till);
999
1000 /* Don't sign cross realm tickets, they can't be checked anyway */
1001 {
1002 char *realm = get_krbtgt_realm(&ek.sname);
1003
1004 if (realm == NULL || strcmp(realm, ek.srealm) == 0) {
1005 ret = _kdc_add_KRB5SignedPath(context,
1006 config,
1007 krbtgt,
1008 krbtgt_etype,
1009 client_principal,
1010 NULL,
1011 spp,
1012 &et);
1013 if (ret)
1014 goto out;
1015 }
1016 }
1017
1018 if (enc_pa_data->len) {
1019 rep.padata = calloc(1, sizeof(*rep.padata));
1020 if (rep.padata == NULL) {
1021 ret = ENOMEM;
1022 goto out;
1023 }
1024 ret = copy_METHOD_DATA(enc_pa_data, rep.padata);
1025 if (ret)
1026 goto out;
1027 }
1028
1029 if (krb5_enctype_valid(context, serverkey->keytype) != 0
1030 && _kdc_is_weak_exception(server->entry.principal, serverkey->keytype))
1031 {
1032 krb5_enctype_enable(context, serverkey->keytype);
1033 is_weak = 1;
1034 }
1035
1036
1037 /* It is somewhat unclear where the etype in the following
1038 encryption should come from. What we have is a session
1039 key in the passed tgt, and a list of preferred etypes
1040 *for the new ticket*. Should we pick the best possible
1041 etype, given the keytype in the tgt, or should we look
1042 at the etype list here as well? What if the tgt
1043 session key is DES3 and we want a ticket with a (say)
1044 CAST session key. Should the DES3 etype be added to the
1045 etype list, even if we don't want a session key with
1046 DES3? */
1047 ret = _kdc_encode_reply(context, config, NULL, 0,
1048 &rep, &et, &ek, serverkey->keytype,
1049 kvno,
1050 serverkey, 0, replykey, rk_is_subkey,
1051 e_text, reply);
1052 if (is_weak)
1053 krb5_enctype_disable(context, serverkey->keytype);
1054
1055 r->reply_key.keytype = replykey->keytype;
1056 _log_astgs_req(r, serverkey->keytype);
1057
1058 out:
1059 free_TGS_REP(&rep);
1060 free_TransitedEncoding(&et.transited);
1061 if(et.starttime)
1062 free(et.starttime);
1063 if(et.renew_till)
1064 free(et.renew_till);
1065 if(et.authorization_data) {
1066 free_AuthorizationData(et.authorization_data);
1067 free(et.authorization_data);
1068 }
1069 free_LastReq(&ek.last_req);
1070 memset(et.key.keyvalue.data, 0, et.key.keyvalue.length);
1071 free_EncryptionKey(&et.key);
1072 return ret;
1073 }
1074
1075 static krb5_error_code
1076 tgs_check_authenticator(krb5_context context,
1077 krb5_kdc_configuration *config,
1078 krb5_auth_context ac,
1079 KDC_REQ_BODY *b,
1080 const char **e_text,
1081 krb5_keyblock *key)
1082 {
1083 krb5_authenticator auth;
1084 size_t len = 0;
1085 unsigned char *buf;
1086 size_t buf_size;
1087 krb5_error_code ret;
1088 krb5_crypto crypto;
1089
1090 krb5_auth_con_getauthenticator(context, ac, &auth);
1091 if(auth->cksum == NULL){
1092 kdc_log(context, config, 4, "No authenticator in request");
1093 ret = KRB5KRB_AP_ERR_INAPP_CKSUM;
1094 goto out;
1095 }
1096 /*
1097 * according to RFC1510 it doesn't need to be keyed,
1098 * but according to the latest draft it needs to.
1099 */
1100 if (
1101 #if 0
1102 !krb5_checksum_is_keyed(context, auth->cksum->cksumtype)
1103 ||
1104 #endif
1105 !krb5_checksum_is_collision_proof(context, auth->cksum->cksumtype)) {
1106 kdc_log(context, config, 4, "Bad checksum type in authenticator: %d",
1107 auth->cksum->cksumtype);
1108 ret = KRB5KRB_AP_ERR_INAPP_CKSUM;
1109 goto out;
1110 }
1111
1112 /* XXX should not re-encode this */
1113 ASN1_MALLOC_ENCODE(KDC_REQ_BODY, buf, buf_size, b, &len, ret);
1114 if(ret){
1115 const char *msg = krb5_get_error_message(context, ret);
1116 kdc_log(context, config, 4, "Failed to encode KDC-REQ-BODY: %s", msg);
1117 krb5_free_error_message(context, msg);
1118 goto out;
1119 }
1120 if(buf_size != len) {
1121 free(buf);
1122 kdc_log(context, config, 4, "Internal error in ASN.1 encoder");
1123 *e_text = "KDC internal error";
1124 ret = KRB5KRB_ERR_GENERIC;
1125 goto out;
1126 }
1127 ret = krb5_crypto_init(context, key, 0, &crypto);
1128 if (ret) {
1129 const char *msg = krb5_get_error_message(context, ret);
1130 free(buf);
1131 kdc_log(context, config, 4, "krb5_crypto_init failed: %s", msg);
1132 krb5_free_error_message(context, msg);
1133 goto out;
1134 }
1135 ret = krb5_verify_checksum(context,
1136 crypto,
1137 KRB5_KU_TGS_REQ_AUTH_CKSUM,
1138 buf,
1139 len,
1140 auth->cksum);
1141 free(buf);
1142 krb5_crypto_destroy(context, crypto);
1143 if(ret){
1144 const char *msg = krb5_get_error_message(context, ret);
1145 kdc_log(context, config, 4,
1146 "Failed to verify authenticator checksum: %s", msg);
1147 krb5_free_error_message(context, msg);
1148 }
1149 out:
1150 free_Authenticator(auth);
1151 free(auth);
1152 return ret;
1153 }
1154
1155 static krb5_boolean
1156 need_referral(krb5_context context, krb5_kdc_configuration *config,
1157 const KDCOptions * const options, krb5_principal server,
1158 krb5_realm **realms)
1159 {
1160 const char *name;
1161
1162 if(!options->canonicalize && server->name.name_type != KRB5_NT_SRV_INST)
1163 return FALSE;
1164
1165 if (server->name.name_string.len == 1)
1166 name = server->name.name_string.val[0];
1167 else if (server->name.name_string.len == 3) {
1168 /*
1169 This is used to give referrals for the
1170 E3514235-4B06-11D1-AB04-00C04FC2DCD2/NTDSGUID/DNSDOMAIN
1171 SPN form, which is used for inter-domain communication in AD
1172 */
1173 name = server->name.name_string.val[2];
1174 kdc_log(context, config, 4, "Giving 3 part referral for %s", name);
1175 *realms = malloc(sizeof(char *)*2);
1176 if (*realms == NULL) {
1177 krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", ""));
1178 return FALSE;
1179 }
1180 (*realms)[0] = strdup(name);
1181 (*realms)[1] = NULL;
1182 return TRUE;
1183 } else if (server->name.name_string.len > 1)
1184 name = server->name.name_string.val[1];
1185 else
1186 return FALSE;
1187
1188 kdc_log(context, config, 5, "Searching referral for %s", name);
1189
1190 return _krb5_get_host_realm_int(context, name, FALSE, realms) == 0;
1191 }
1192
1193 static krb5_error_code
1194 tgs_parse_request(astgs_request_t r,
1195 const PA_DATA *tgs_req,
1196 hdb_entry_ex **krbtgt,
1197 krb5_enctype *krbtgt_etype,
1198 krb5_ticket **ticket,
1199 const char **e_text,
1200 const char *from,
1201 const struct sockaddr *from_addr,
1202 time_t **csec,
1203 int **cusec,
1204 AuthorizationData **auth_data,
1205 krb5_keyblock **replykey,
1206 int *rk_is_subkey)
1207 {
1208 krb5_context context = r->context;
1209 krb5_kdc_configuration *config = r->config;
1210 KDC_REQ_BODY *b = &r->req.req_body;
1211 static char failed[] = "<unparse_name failed>";
1212 krb5_ap_req ap_req;
1213 krb5_error_code ret;
1214 krb5_principal princ;
1215 krb5_auth_context ac = NULL;
1216 krb5_flags ap_req_options;
1217 krb5_flags verify_ap_req_flags = 0;
1218 krb5_crypto crypto;
1219 krb5uint32 krbtgt_kvno; /* kvno used for the PA-TGS-REQ AP-REQ Ticket */
1220 krb5uint32 krbtgt_kvno_try;
1221 int kvno_search_tries = 4; /* number of kvnos to try when tkt_vno == 0 */
1222 const Keys *krbtgt_keys;/* keyset for TGT tkt_vno */
1223 Key *tkey;
1224 krb5_keyblock *subkey = NULL;
1225 unsigned usage;
1226
1227 *auth_data = NULL;
1228 *csec = NULL;
1229 *cusec = NULL;
1230 *replykey = NULL;
1231
1232 memset(&ap_req, 0, sizeof(ap_req));
1233 ret = krb5_decode_ap_req(context, &tgs_req->padata_value, &ap_req);
1234 if(ret){
1235 const char *msg = krb5_get_error_message(context, ret);
1236 kdc_log(context, config, 4, "Failed to decode AP-REQ: %s", msg);
1237 krb5_free_error_message(context, msg);
1238 goto out;
1239 }
1240
1241 if(!get_krbtgt_realm(&ap_req.ticket.sname)){
1242 /* XXX check for ticket.sname == req.sname */
1243 kdc_log(context, config, 4, "PA-DATA is not a ticket-granting ticket");
1244 ret = KRB5KDC_ERR_POLICY; /* ? */
1245 goto out;
1246 }
1247
1248 _krb5_principalname2krb5_principal(context,
1249 &princ,
1250 ap_req.ticket.sname,
1251 ap_req.ticket.realm);
1252
1253 krbtgt_kvno = ap_req.ticket.enc_part.kvno ? *ap_req.ticket.enc_part.kvno : 0;
1254 ret = _kdc_db_fetch(context, config, princ, HDB_F_GET_KRBTGT,
1255 &krbtgt_kvno, NULL, krbtgt);
1256
1257 if (ret == HDB_ERR_NOT_FOUND_HERE) {
1258 /* XXX Factor out this unparsing of the same princ all over */
1259 char *p;
1260 ret = krb5_unparse_name(context, princ, &p);
1261 if (ret != 0)
1262 p = failed;
1263 krb5_free_principal(context, princ);
1264 kdc_log(context, config, 5,
1265 "Ticket-granting ticket account %s does not have secrets at "
1266 "this KDC, need to proxy", p);
1267 if (ret == 0)
1268 free(p);
1269 ret = HDB_ERR_NOT_FOUND_HERE;
1270 goto out;
1271 } else if (ret == HDB_ERR_KVNO_NOT_FOUND) {
1272 char *p;
1273 ret = krb5_unparse_name(context, princ, &p);
1274 if (ret != 0)
1275 p = failed;
1276 krb5_free_principal(context, princ);
1277 kdc_log(context, config, 5,
1278 "Ticket-granting ticket account %s does not have keys for "
1279 "kvno %d at this KDC", p, krbtgt_kvno);
1280 if (ret == 0)
1281 free(p);
1282 ret = HDB_ERR_KVNO_NOT_FOUND;
1283 goto out;
1284 } else if (ret == HDB_ERR_NO_MKEY) {
1285 char *p;
1286 ret = krb5_unparse_name(context, princ, &p);
1287 if (ret != 0)
1288 p = failed;
1289 krb5_free_principal(context, princ);
1290 kdc_log(context, config, 5,
1291 "Missing master key for decrypting keys for ticket-granting "
1292 "ticket account %s with kvno %d at this KDC", p, krbtgt_kvno);
1293 if (ret == 0)
1294 free(p);
1295 ret = HDB_ERR_KVNO_NOT_FOUND;
1296 goto out;
1297 } else if (ret) {
1298 const char *msg = krb5_get_error_message(context, ret);
1299 char *p;
1300 ret = krb5_unparse_name(context, princ, &p);
1301 if (ret != 0)
1302 p = failed;
1303 kdc_log(context, config, 4,
1304 "Ticket-granting ticket %s not found in database: %s", p, msg);
1305 krb5_free_principal(context, princ);
1306 krb5_free_error_message(context, msg);
1307 if (ret == 0)
1308 free(p);
1309 ret = KRB5KRB_AP_ERR_NOT_US;
1310 goto out;
1311 }
1312
1313 krbtgt_kvno_try = krbtgt_kvno ? krbtgt_kvno : (*krbtgt)->entry.kvno;
1314 *krbtgt_etype = ap_req.ticket.enc_part.etype;
1315
1316 next_kvno:
1317 krbtgt_keys = hdb_kvno2keys(context, &(*krbtgt)->entry, krbtgt_kvno_try);
1318 ret = hdb_enctype2key(context, &(*krbtgt)->entry, krbtgt_keys,
1319 ap_req.ticket.enc_part.etype, &tkey);
1320 if (ret && krbtgt_kvno == 0 && kvno_search_tries > 0) {
1321 kvno_search_tries--;
1322 krbtgt_kvno_try--;
1323 goto next_kvno;
1324 } else if (ret) {
1325 char *str = NULL, *p = NULL;
1326
1327 krb5_enctype_to_string(context, ap_req.ticket.enc_part.etype, &str);
1328 krb5_unparse_name(context, princ, &p);
1329 kdc_log(context, config, 4,
1330 "No server key with enctype %s found for %s",
1331 str ? str : "<unknown enctype>",
1332 p ? p : "<unparse_name failed>");
1333 free(str);
1334 free(p);
1335 ret = KRB5KRB_AP_ERR_BADKEYVER;
1336 goto out;
1337 }
1338
1339 if (b->kdc_options.validate)
1340 verify_ap_req_flags |= KRB5_VERIFY_AP_REQ_IGNORE_INVALID;
1341
1342 if (r->config->warn_ticket_addresses)
1343 verify_ap_req_flags |= KRB5_VERIFY_AP_REQ_IGNORE_ADDRS;
1344
1345 ret = krb5_verify_ap_req2(context,
1346 &ac,
1347 &ap_req,
1348 princ,
1349 &tkey->key,
1350 verify_ap_req_flags,
1351 &ap_req_options,
1352 ticket,
1353 KRB5_KU_TGS_REQ_AUTH);
1354 if (ticket && *ticket && (*ticket)->ticket.caddr)
1355 _kdc_audit_addaddrs((kdc_request_t)r, (*ticket)->ticket.caddr, "tixaddrs");
1356 if (r->config->warn_ticket_addresses && ret == KRB5KRB_AP_ERR_BADADDR &&
1357 *ticket != NULL) {
1358 _kdc_audit_addkv((kdc_request_t)r, 0, "wrongaddr", "yes");
1359 ret = 0;
1360 }
1361 if (ret == KRB5KRB_AP_ERR_BAD_INTEGRITY && kvno_search_tries > 0) {
1362 kvno_search_tries--;
1363 krbtgt_kvno_try--;
1364 goto next_kvno;
1365 }
1366
1367 krb5_free_principal(context, princ);
1368 if(ret) {
1369 const char *msg = krb5_get_error_message(context, ret);
1370 kdc_log(context, config, 4, "Failed to verify AP-REQ: %s", msg);
1371 krb5_free_error_message(context, msg);
1372 goto out;
1373 }
1374
1375 {
1376 krb5_authenticator auth;
1377
1378 ret = krb5_auth_con_getauthenticator(context, ac, &auth);
1379 if (ret == 0) {
1380 *csec = malloc(sizeof(**csec));
1381 if (*csec == NULL) {
1382 krb5_free_authenticator(context, &auth);
1383 kdc_log(context, config, 4, "malloc failed");
1384 goto out;
1385 }
1386 **csec = auth->ctime;
1387 *cusec = malloc(sizeof(**cusec));
1388 if (*cusec == NULL) {
1389 krb5_free_authenticator(context, &auth);
1390 kdc_log(context, config, 4, "malloc failed");
1391 goto out;
1392 }
1393 **cusec = auth->cusec;
1394 krb5_free_authenticator(context, &auth);
1395 }
1396 }
1397
1398 ret = tgs_check_authenticator(context, config,
1399 ac, b, e_text, &(*ticket)->ticket.key);
1400 if (ret) {
1401 krb5_auth_con_free(context, ac);
1402 goto out;
1403 }
1404
1405 usage = KRB5_KU_TGS_REQ_AUTH_DAT_SUBKEY;
1406 *rk_is_subkey = 1;
1407
1408 ret = krb5_auth_con_getremotesubkey(context, ac, &subkey);
1409 if(ret){
1410 const char *msg = krb5_get_error_message(context, ret);
1411 krb5_auth_con_free(context, ac);
1412 kdc_log(context, config, 4, "Failed to get remote subkey: %s", msg);
1413 krb5_free_error_message(context, msg);
1414 goto out;
1415 }
1416 if(subkey == NULL){
1417 usage = KRB5_KU_TGS_REQ_AUTH_DAT_SESSION;
1418 *rk_is_subkey = 0;
1419
1420 ret = krb5_auth_con_getkey(context, ac, &subkey);
1421 if(ret) {
1422 const char *msg = krb5_get_error_message(context, ret);
1423 krb5_auth_con_free(context, ac);
1424 kdc_log(context, config, 4, "Failed to get session key: %s", msg);
1425 krb5_free_error_message(context, msg);
1426 goto out;
1427 }
1428 }
1429 if(subkey == NULL){
1430 krb5_auth_con_free(context, ac);
1431 kdc_log(context, config, 4,
1432 "Failed to get key for enc-authorization-data");
1433 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY; /* ? */
1434 goto out;
1435 }
1436
1437 *replykey = subkey;
1438
1439 if (b->enc_authorization_data) {
1440 krb5_data ad;
1441
1442 ret = krb5_crypto_init(context, subkey, 0, &crypto);
1443 if (ret) {
1444 const char *msg = krb5_get_error_message(context, ret);
1445 krb5_auth_con_free(context, ac);
1446 kdc_log(context, config, 4, "krb5_crypto_init failed: %s", msg);
1447 krb5_free_error_message(context, msg);
1448 goto out;
1449 }
1450 ret = krb5_decrypt_EncryptedData (context,
1451 crypto,
1452 usage,
1453 b->enc_authorization_data,
1454 &ad);
1455 krb5_crypto_destroy(context, crypto);
1456 if(ret){
1457 krb5_auth_con_free(context, ac);
1458 kdc_log(context, config, 4,
1459 "Failed to decrypt enc-authorization-data");
1460 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY; /* ? */
1461 goto out;
1462 }
1463 ALLOC(*auth_data);
1464 if (*auth_data == NULL) {
1465 krb5_auth_con_free(context, ac);
1466 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY; /* ? */
1467 goto out;
1468 }
1469 ret = decode_AuthorizationData(ad.data, ad.length, *auth_data, NULL);
1470 if(ret){
1471 krb5_auth_con_free(context, ac);
1472 free(*auth_data);
1473 *auth_data = NULL;
1474 kdc_log(context, config, 4, "Failed to decode authorization data");
1475 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY; /* ? */
1476 goto out;
1477 }
1478 }
1479
1480 krb5_auth_con_free(context, ac);
1481
1482 out:
1483 free_AP_REQ(&ap_req);
1484
1485 return ret;
1486 }
1487
1488 static krb5_error_code
1489 build_server_referral(krb5_context context,
1490 krb5_kdc_configuration *config,
1491 krb5_crypto session,
1492 krb5_const_realm referred_realm,
1493 const PrincipalName *true_principal_name,
1494 const PrincipalName *requested_principal,
1495 krb5_data *outdata)
1496 {
1497 PA_ServerReferralData ref;
1498 krb5_error_code ret;
1499 EncryptedData ed;
1500 krb5_data data;
1501 size_t size = 0;
1502
1503 memset(&ref, 0, sizeof(ref));
1504
1505 if (referred_realm) {
1506 ALLOC(ref.referred_realm);
1507 if (ref.referred_realm == NULL)
1508 goto eout;
1509 *ref.referred_realm = strdup(referred_realm);
1510 if (*ref.referred_realm == NULL)
1511 goto eout;
1512 }
1513 if (true_principal_name) {
1514 ALLOC(ref.true_principal_name);
1515 if (ref.true_principal_name == NULL)
1516 goto eout;
1517 ret = copy_PrincipalName(true_principal_name, ref.true_principal_name);
1518 if (ret)
1519 goto eout;
1520 }
1521 if (requested_principal) {
1522 ALLOC(ref.requested_principal_name);
1523 if (ref.requested_principal_name == NULL)
1524 goto eout;
1525 ret = copy_PrincipalName(requested_principal,
1526 ref.requested_principal_name);
1527 if (ret)
1528 goto eout;
1529 }
1530
1531 ASN1_MALLOC_ENCODE(PA_ServerReferralData,
1532 data.data, data.length,
1533 &ref, &size, ret);
1534 free_PA_ServerReferralData(&ref);
1535 if (ret)
1536 return ret;
1537 if (data.length != size)
1538 krb5_abortx(context, "internal asn.1 encoder error");
1539
1540 ret = krb5_encrypt_EncryptedData(context, session,
1541 KRB5_KU_PA_SERVER_REFERRAL,
1542 data.data, data.length,
1543 0 /* kvno */, &ed);
1544 free(data.data);
1545 if (ret)
1546 return ret;
1547
1548 ASN1_MALLOC_ENCODE(EncryptedData,
1549 outdata->data, outdata->length,
1550 &ed, &size, ret);
1551 free_EncryptedData(&ed);
1552 if (ret)
1553 return ret;
1554 if (outdata->length != size)
1555 krb5_abortx(context, "internal asn.1 encoder error");
1556
1557 return 0;
1558 eout:
1559 free_PA_ServerReferralData(&ref);
1560 krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
1561 return ENOMEM;
1562 }
1563
1564 static krb5_error_code
1565 tgs_build_reply(astgs_request_t priv,
1566 hdb_entry_ex *krbtgt,
1567 krb5_enctype krbtgt_etype,
1568 const krb5_keyblock *replykey,
1569 int rk_is_subkey,
1570 krb5_ticket *ticket,
1571 const char **e_text,
1572 AuthorizationData **auth_data,
1573 const struct sockaddr *from_addr)
1574 {
1575 krb5_context context = priv->context;
1576 krb5_kdc_configuration *config = priv->config;
1577 KDC_REQ *req = &priv->req;
1578 KDC_REQ_BODY *b = &priv->req.req_body;
1579 const char *from = priv->from;
1580 krb5_error_code ret, ret2;
1581 krb5_principal cp = NULL, sp = NULL, rsp = NULL, tp = NULL, dp = NULL;
1582 krb5_principal krbtgt_out_principal = NULL;
1583 char *spn = NULL, *cpn = NULL, *tpn = NULL, *dpn = NULL, *krbtgt_out_n = NULL;
1584 hdb_entry_ex *server = NULL, *client = NULL, *s4u2self_impersonated_client = NULL;
1585 HDB *clientdb, *s4u2self_impersonated_clientdb;
1586 krb5_realm ref_realm = NULL;
1587 EncTicketPart *tgt = &ticket->ticket;
1588 krb5_principals spp = NULL;
1589 const EncryptionKey *ekey;
1590 krb5_keyblock sessionkey;
1591 krb5_kvno kvno;
1592 krb5_data rspac;
1593 const char *tgt_realm = /* Realm of TGT issuer */
1594 krb5_principal_get_realm(context, krbtgt->entry.principal);
1595 const char *our_realm = /* Realm of this KDC */
1596 krb5_principal_get_comp_string(context, krbtgt->entry.principal, 1);
1597 char **capath = NULL;
1598 size_t num_capath = 0;
1599
1600 hdb_entry_ex *krbtgt_out = NULL;
1601
1602 METHOD_DATA enc_pa_data;
1603
1604 PrincipalName *s;
1605 Realm r;
1606 EncTicketPart adtkt;
1607 char opt_str[128];
1608 int signedpath = 0;
1609
1610 Key *tkey_check;
1611 Key *tkey_sign;
1612 int flags = HDB_F_FOR_TGS_REQ;
1613
1614 memset(&sessionkey, 0, sizeof(sessionkey));
1615 memset(&adtkt, 0, sizeof(adtkt));
1616 krb5_data_zero(&rspac);
1617 memset(&enc_pa_data, 0, sizeof(enc_pa_data));
1618
1619 s = b->sname;
1620 r = b->realm;
1621
1622 /*
1623 * The canonicalize KDC option is passed as a hint to the backend, but
1624 * can typically be ignored. Per RFC 6806, names are not canonicalized
1625 * in response to a TGS request (although we make an exception, see
1626 * force-canonicalize below).
1627 */
1628 if (b->kdc_options.canonicalize)
1629 flags |= HDB_F_CANON;
1630
1631 if(b->kdc_options.enc_tkt_in_skey){
1632 Ticket *t;
1633 hdb_entry_ex *uu;
1634 krb5_principal p;
1635 Key *uukey;
1636 krb5uint32 second_kvno = 0;
1637 krb5uint32 *kvno_ptr = NULL;
1638
1639 if(b->additional_tickets == NULL ||
1640 b->additional_tickets->len == 0){
1641 ret = KRB5KDC_ERR_BADOPTION; /* ? */
1642 kdc_log(context, config, 4,
1643 "No second ticket present in user-to-user request");
1644 _kdc_audit_addreason((kdc_request_t)priv,
1645 "No second ticket present in user-to-user request");
1646 goto out;
1647 }
1648 t = &b->additional_tickets->val[0];
1649 if(!get_krbtgt_realm(&t->sname)){
1650 kdc_log(context, config, 4,
1651 "Additional ticket is not a ticket-granting ticket");
1652 _kdc_audit_addreason((kdc_request_t)priv,
1653 "Additional ticket is not a ticket-granting ticket");
1654 ret = KRB5KDC_ERR_POLICY;
1655 goto out;
1656 }
1657 _krb5_principalname2krb5_principal(context, &p, t->sname, t->realm);
1658 ret = krb5_unparse_name(context, p, &tpn);
1659 if (ret)
1660 goto out;
1661 if(t->enc_part.kvno){
1662 second_kvno = *t->enc_part.kvno;
1663 kvno_ptr = &second_kvno;
1664 }
1665 ret = _kdc_db_fetch(context, config, p,
1666 HDB_F_GET_KRBTGT, kvno_ptr,
1667 NULL, &uu);
1668 krb5_free_principal(context, p);
1669 if(ret){
1670 if (ret == HDB_ERR_NOENTRY)
1671 ret = KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN;
1672 _kdc_audit_addreason((kdc_request_t)priv,
1673 "User-to-user service principal (TGS) unknown");
1674 goto out;
1675 }
1676 ret = hdb_enctype2key(context, &uu->entry, NULL,
1677 t->enc_part.etype, &uukey);
1678 if(ret){
1679 _kdc_free_ent(context, uu);
1680 ret = KRB5KDC_ERR_ETYPE_NOSUPP; /* XXX */
1681 _kdc_audit_addreason((kdc_request_t)priv,
1682 "User-to-user enctype not supported");
1683 goto out;
1684 }
1685 ret = krb5_decrypt_ticket(context, t, &uukey->key, &adtkt, 0);
1686 _kdc_free_ent(context, uu);
1687 if(ret) {
1688 _kdc_audit_addreason((kdc_request_t)priv,
1689 "User-to-user TGT decrypt failure");
1690 goto out;
1691 }
1692
1693 ret = verify_flags(context, config, &adtkt, tpn);
1694 if (ret) {
1695 _kdc_audit_addreason((kdc_request_t)priv,
1696 "User-to-user TGT expired or invalid");
1697 goto out;
1698 }
1699
1700 s = &adtkt.cname;
1701 r = adtkt.crealm;
1702 }
1703
1704 _krb5_principalname2krb5_principal(context, &sp, *s, r);
1705 ret = krb5_unparse_name(context, sp, &priv->sname);
1706 if (ret)
1707 goto out;
1708 spn = priv->sname;
1709 _krb5_principalname2krb5_principal(context, &cp, tgt->cname, tgt->crealm);
1710 ret = krb5_unparse_name(context, cp, &priv->cname);
1711 if (ret)
1712 goto out;
1713 cpn = priv->cname;
1714 unparse_flags (KDCOptions2int(b->kdc_options),
1715 asn1_KDCOptions_units(),
1716 opt_str, sizeof(opt_str));
1717 if(*opt_str)
1718 kdc_log(context, config, 4,
1719 "TGS-REQ %s from %s for %s [%s]",
1720 cpn, from, spn, opt_str);
1721 else
1722 kdc_log(context, config, 4,
1723 "TGS-REQ %s from %s for %s", cpn, from, spn);
1724
1725 /*
1726 * Fetch server
1727 */
1728
1729 server_lookup:
1730 ret = _kdc_db_fetch(context, config, sp,
1731 HDB_F_GET_SERVER | HDB_F_DELAY_NEW_KEYS | flags,
1732 NULL, NULL, &server);
1733 priv->server = server;
1734 if (ret == HDB_ERR_NOT_FOUND_HERE) {
1735 kdc_log(context, config, 5, "target %s does not have secrets at this KDC, need to proxy", spn);
1736 _kdc_audit_addreason((kdc_request_t)priv, "Target not found here");
1737 goto out;
1738 } else if (ret == HDB_ERR_WRONG_REALM) {
1739 free(ref_realm);
1740 ref_realm = strdup(server->entry.principal->realm);
1741 if (ref_realm == NULL) {
1742 ret = krb5_enomem(context);
1743 goto out;
1744 }
1745
1746 kdc_log(context, config, 4,
1747 "Returning a referral to realm %s for "
1748 "server %s.",
1749 ref_realm, spn);
1750 krb5_free_principal(context, sp);
1751 sp = NULL;
1752 ret = krb5_make_principal(context, &sp, r, KRB5_TGS_NAME,
1753 ref_realm, NULL);
1754 if (ret)
1755 goto out;
1756 free(priv->sname);
1757 priv->sname = NULL;
1758 ret = krb5_unparse_name(context, sp, &priv->sname);
1759 if (ret)
1760 goto out;
1761 spn = priv->sname;
1762
1763 goto server_lookup;
1764 } else if (ret) {
1765 const char *new_rlm, *msg;
1766 Realm req_rlm;
1767 krb5_realm *realms;
1768
1769 if ((req_rlm = get_krbtgt_realm(&sp->name)) != NULL) {
1770 if (capath == NULL) {
1771 /* With referalls, hierarchical capaths are always enabled */
1772 ret2 = _krb5_find_capath(context, tgt->crealm, our_realm,
1773 req_rlm, TRUE, &capath, &num_capath);
1774 if (ret2) {
1775 ret = ret2;
1776 _kdc_audit_addreason((kdc_request_t)priv,
1777 "No trusted path from client realm to ours");
1778 goto out;
1779 }
1780 }
1781 new_rlm = num_capath > 0 ? capath[--num_capath] : NULL;
1782 if (new_rlm) {
1783 kdc_log(context, config, 5, "krbtgt from %s via %s for "
1784 "realm %s not found, trying %s", tgt->crealm,
1785 our_realm, req_rlm, new_rlm);
1786
1787 free(ref_realm);
1788 ref_realm = strdup(new_rlm);
1789 if (ref_realm == NULL) {
1790 ret = krb5_enomem(context);
1791 goto out;
1792 }
1793
1794 krb5_free_principal(context, sp);
1795 sp = NULL;
1796 krb5_make_principal(context, &sp, r,
1797 KRB5_TGS_NAME, ref_realm, NULL);
1798 free(priv->sname);
1799 priv->sname = NULL;
1800 ret = krb5_unparse_name(context, sp, &priv->sname);
1801 if (ret)
1802 goto out;
1803 spn = priv->sname;
1804 goto server_lookup;
1805 }
1806 } else if (need_referral(context, config, &b->kdc_options, sp, &realms)) {
1807 if (strcmp(realms[0], sp->realm) != 0) {
1808 kdc_log(context, config, 4,
1809 "Returning a referral to realm %s for "
1810 "server %s that was not found",
1811 realms[0], spn);
1812 krb5_free_principal(context, sp);
1813 sp = NULL;
1814 krb5_make_principal(context, &sp, r, KRB5_TGS_NAME,
1815 realms[0], NULL);
1816 free(priv->sname);
1817 priv->sname = NULL;
1818 ret = krb5_unparse_name(context, sp, &priv->sname);
1819 if (ret) {
1820 krb5_free_host_realm(context, realms);
1821 goto out;
1822 }
1823 spn = priv->sname;
1824
1825 free(ref_realm);
1826 ref_realm = strdup(realms[0]);
1827
1828 krb5_free_host_realm(context, realms);
1829 goto server_lookup;
1830 }
1831 krb5_free_host_realm(context, realms);
1832 }
1833 msg = krb5_get_error_message(context, ret);
1834 kdc_log(context, config, 3,
1835 "Server not found in database: %s: %s", spn, msg);
1836 krb5_free_error_message(context, msg);
1837 if (ret == HDB_ERR_NOENTRY)
1838 ret = KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN;
1839 _kdc_audit_addreason((kdc_request_t)priv,
1840 "Service principal unknown");
1841 goto out;
1842 }
1843
1844 /*
1845 * RFC 6806 notes that names MUST NOT be changed in the response to
1846 * a TGS request. Hence we ignore the setting of the canonicalize
1847 * KDC option. However, for legacy interoperability we do allow the
1848 * backend to override this by setting the force-canonicalize HDB
1849 * flag in the server entry.
1850 */
1851 if (server->entry.flags.force_canonicalize)
1852 rsp = server->entry.principal;
1853 else
1854 rsp = sp;
1855
1856 /*
1857 * Select enctype, return key and kvno.
1858 */
1859
1860 {
1861 krb5_enctype etype;
1862
1863 if(b->kdc_options.enc_tkt_in_skey) {
1864 size_t i;
1865 ekey = &adtkt.key;
1866 for(i = 0; i < b->etype.len; i++)
1867 if (b->etype.val[i] == adtkt.key.keytype)
1868 break;
1869 if(i == b->etype.len) {
1870 kdc_log(context, config, 4,
1871 "Addition ticket have not matching etypes");
1872 krb5_clear_error_message(context);
1873 ret = KRB5KDC_ERR_ETYPE_NOSUPP;
1874 _kdc_audit_addreason((kdc_request_t)priv,
1875 "No matching enctypes for 2nd ticket");
1876 goto out;
1877 }
1878 etype = b->etype.val[i];
1879 kvno = 0;
1880 } else {
1881 Key *skey;
1882
1883 ret = _kdc_find_etype(priv, krb5_principal_is_krbtgt(context, sp)
1884 ? KFE_IS_TGS : 0,
1885 b->etype.val, b->etype.len, &etype, NULL,
1886 NULL);
1887 if(ret) {
1888 kdc_log(context, config, 4,
1889 "Server (%s) has no support for etypes", spn);
1890 _kdc_audit_addreason((kdc_request_t)priv,
1891 "Enctype not supported");
1892 goto out;
1893 }
1894 ret = _kdc_get_preferred_key(context, config, server, spn,
1895 NULL, &skey);
1896 if(ret) {
1897 kdc_log(context, config, 4,
1898 "Server (%s) has no supported etypes", spn);
1899 _kdc_audit_addreason((kdc_request_t)priv,
1900 "Enctype not supported");
1901 goto out;
1902 }
1903 ekey = &skey->key;
1904 kvno = server->entry.kvno;
1905 }
1906
1907 ret = krb5_generate_random_keyblock(context, etype, &sessionkey);
1908 if (ret)
1909 goto out;
1910 }
1911
1912 /*
1913 * Check that service is in the same realm as the krbtgt. If it's
1914 * not the same, it's someone that is using a uni-directional trust
1915 * backward.
1916 */
1917
1918 /*
1919 * Validate authorization data
1920 */
1921
1922 ret = hdb_enctype2key(context, &krbtgt->entry, NULL, /* XXX use the right kvno! */
1923 krbtgt_etype, &tkey_check);
1924 if(ret) {
1925 kdc_log(context, config, 4,
1926 "Failed to find key for krbtgt PAC check");
1927 _kdc_audit_addreason((kdc_request_t)priv,
1928 "No key for krbtgt PAC check");
1929 goto out;
1930 }
1931
1932 /*
1933 * Now refetch the primary krbtgt, and get the current kvno (the
1934 * sign check may have been on an old kvno, and the server may
1935 * have been an incoming trust)
1936 */
1937
1938 ret = krb5_make_principal(context,
1939 &krbtgt_out_principal,
1940 our_realm,
1941 KRB5_TGS_NAME,
1942 our_realm,
1943 NULL);
1944 if (ret) {
1945 kdc_log(context, config, 4,
1946 "Failed to make krbtgt principal name object for "
1947 "authz-data signatures");
1948 goto out;
1949 }
1950 ret = krb5_unparse_name(context, krbtgt_out_principal, &krbtgt_out_n);
1951 if (ret) {
1952 kdc_log(context, config, 4,
1953 "Failed to make krbtgt principal name object for "
1954 "authz-data signatures");
1955 goto out;
1956 }
1957
1958 ret = _kdc_db_fetch(context, config, krbtgt_out_principal,
1959 HDB_F_GET_KRBTGT, NULL, NULL, &krbtgt_out);
1960 if (ret) {
1961 char *ktpn = NULL;
1962 ret = krb5_unparse_name(context, krbtgt->entry.principal, &ktpn);
1963 kdc_log(context, config, 4,
1964 "No such principal %s (needed for authz-data signature keys) "
1965 "while processing TGS-REQ for service %s with krbtg %s",
1966 krbtgt_out_n, spn, (ret == 0) ? ktpn : "<unknown>");
1967 free(ktpn);
1968 ret = KRB5KRB_AP_ERR_NOT_US;
1969 goto out;
1970 }
1971
1972 /*
1973 * The first realm is the realm of the service, the second is
1974 * krbtgt/<this>/@REALM component of the krbtgt DN the request was
1975 * encrypted to. The redirection via the krbtgt_out entry allows
1976 * the DB to possibly correct the case of the realm (Samba4 does
1977 * this) before the strcmp()
1978 */
1979 if (strcmp(krb5_principal_get_realm(context, server->entry.principal),
1980 krb5_principal_get_realm(context, krbtgt_out->entry.principal)) != 0) {
1981 char *ktpn;
1982 ret = krb5_unparse_name(context, krbtgt_out->entry.principal, &ktpn);
1983 kdc_log(context, config, 4,
1984 "Request with wrong krbtgt: %s",
1985 (ret == 0) ? ktpn : "<unknown>");
1986 if(ret == 0)
1987 free(ktpn);
1988 ret = KRB5KRB_AP_ERR_NOT_US;
1989 _kdc_audit_addreason((kdc_request_t)priv, "Request with wrong TGT");
1990 goto out;
1991 }
1992
1993 ret = _kdc_get_preferred_key(context, config, krbtgt_out, krbtgt_out_n,
1994 NULL, &tkey_sign);
1995 if (ret) {
1996 kdc_log(context, config, 4,
1997 "Failed to find key for krbtgt PAC signature");
1998 _kdc_audit_addreason((kdc_request_t)priv,
1999 "Failed to find key for krbtgt PAC signature");
2000 goto out;
2001 }
2002 ret = hdb_enctype2key(context, &krbtgt_out->entry, NULL,
2003 tkey_sign->key.keytype, &tkey_sign);
2004 if(ret) {
2005 kdc_log(context, config, 4,
2006 "Failed to find key for krbtgt PAC signature");
2007 _kdc_audit_addreason((kdc_request_t)priv,
2008 "Failed to find key for krbtgt PAC signature");
2009 goto out;
2010 }
2011
2012 {
2013 krb5_data verified_cas;
2014
2015 /*
2016 * If the client doesn't exist in the HDB but has a TGT and it's
2017 * obtained with PKINIT then we assume it's a synthetic client -- that
2018 * is, a client whose name was vouched for by a CA using a PKINIT SAN,
2019 * but which doesn't exist in the HDB proper. We'll allow such a
2020 * client to do TGT requests even though normally we'd reject all
2021 * clients that don't exist in the HDB.
2022 */
2023 ret = krb5_ticket_get_authorization_data_type(context, ticket,
2024 KRB5_AUTHDATA_INITIAL_VERIFIED_CAS,
2025 &verified_cas);
2026 if (ret == 0) {
2027 krb5_data_free(&verified_cas);
2028 flags |= HDB_F_SYNTHETIC_OK;
2029 }
2030 }
2031 ret = _kdc_db_fetch(context, config, cp, HDB_F_GET_CLIENT | flags,
2032 NULL, &clientdb, &client);
2033 flags &= ~HDB_F_SYNTHETIC_OK;
2034 priv->client = client;
2035 if(ret == HDB_ERR_NOT_FOUND_HERE) {
2036 /* This is OK, we are just trying to find out if they have
2037 * been disabled or deleted in the meantime, missing secrets
2038 * is OK */
2039 } else if(ret){
2040 const char *krbtgt_realm, *msg;
2041
2042 /*
2043 * If the client belongs to the same realm as our krbtgt, it
2044 * should exist in the local database.
2045 *
2046 */
2047
2048 krbtgt_realm = krb5_principal_get_realm(context, krbtgt_out->entry.principal);
2049
2050 if(strcmp(krb5_principal_get_realm(context, cp), krbtgt_realm) == 0) {
2051 if (ret == HDB_ERR_NOENTRY)
2052 ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
2053 kdc_log(context, config, 4, "Client no longer in database: %s",
2054 cpn);
2055 _kdc_audit_addreason((kdc_request_t)priv, "Client no longer in HDB");
2056 goto out;
2057 }
2058
2059 msg = krb5_get_error_message(context, ret);
2060 kdc_log(context, config, 4, "Client not found in database: %s", msg);
2061 _kdc_audit_addreason((kdc_request_t)priv, "Client does not exist");
2062 krb5_free_error_message(context, msg);
2063 } else if (ret == 0 &&
2064 (client->entry.flags.invalid || !client->entry.flags.client)) {
2065 _kdc_audit_addreason((kdc_request_t)priv, "Client has invalid bit set");
2066 kdc_log(context, config, 4, "Client has invalid bit set");
2067 ret = KRB5KDC_ERR_POLICY;
2068 goto out;
2069 }
2070
2071 ret = check_PAC(context, config, cp, NULL,
2072 client, server, krbtgt,
2073 &tkey_check->key,
2074 ekey, &tkey_sign->key,
2075 tgt, &rspac, &signedpath);
2076 if (ret) {
2077 const char *msg = krb5_get_error_message(context, ret);
2078 _kdc_audit_addreason((kdc_request_t)priv, "PAC check failed");
2079 kdc_log(context, config, 4,
2080 "Verify PAC failed for %s (%s) from %s with %s",
2081 spn, cpn, from, msg);
2082 krb5_free_error_message(context, msg);
2083 goto out;
2084 }
2085
2086 /* also check the krbtgt for signature */
2087 ret = check_KRB5SignedPath(context,
2088 config,
2089 krbtgt,
2090 cp,
2091 tgt,
2092 &spp,
2093 &signedpath);
2094 if (ret) {
2095 const char *msg = krb5_get_error_message(context, ret);
2096 _kdc_audit_addreason((kdc_request_t)priv, "KRB5SignedPath check failed");
2097 kdc_log(context, config, 4,
2098 "KRB5SignedPath check failed for %s (%s) from %s with %s",
2099 spn, cpn, from, msg);
2100 krb5_free_error_message(context, msg);
2101 goto out;
2102 }
2103
2104 /*
2105 * Process request
2106 */
2107
2108 /* by default the tgt principal matches the client principal */
2109 tp = cp;
2110 tpn = cpn;
2111
2112 if (client) {
2113 const PA_DATA *sdata;
2114 int i = 0;
2115
2116 sdata = _kdc_find_padata(req, &i, KRB5_PADATA_FOR_USER);
2117 if (sdata) {
2118 struct astgs_request_desc imp_req;
2119 krb5_crypto crypto;
2120 krb5_data datack;
2121 PA_S4U2Self self;
2122 const char *str;
2123
2124 ret = decode_PA_S4U2Self(sdata->padata_value.data,
2125 sdata->padata_value.length,
2126 &self, NULL);
2127 if (ret) {
2128 _kdc_audit_addreason((kdc_request_t)priv,
2129 "Failed to decode PA-S4U2Self");
2130 kdc_log(context, config, 4, "Failed to decode PA-S4U2Self");
2131 goto out;
2132 }
2133
2134 if (!krb5_checksum_is_keyed(context, self.cksum.cksumtype)) {
2135 free_PA_S4U2Self(&self);
2136 _kdc_audit_addreason((kdc_request_t)priv,
2137 "PA-S4U2Self with unkeyed checksum");
2138 kdc_log(context, config, 4, "Reject PA-S4U2Self with unkeyed checksum");
2139 ret = KRB5KRB_AP_ERR_INAPP_CKSUM;
2140 goto out;
2141 }
2142
2143 ret = _krb5_s4u2self_to_checksumdata(context, &self, &datack);
2144 if (ret)
2145 goto out;
2146
2147 ret = krb5_crypto_init(context, &tgt->key, 0, &crypto);
2148 if (ret) {
2149 const char *msg = krb5_get_error_message(context, ret);
2150 free_PA_S4U2Self(&self);
2151 krb5_data_free(&datack);
2152 kdc_log(context, config, 4, "krb5_crypto_init failed: %s", msg);
2153 krb5_free_error_message(context, msg);
2154 goto out;
2155 }
2156
2157 /* Allow HMAC_MD5 checksum with any key type */
2158 if (self.cksum.cksumtype == CKSUMTYPE_HMAC_MD5) {
2159 struct krb5_crypto_iov iov;
2160 unsigned char csdata[16];
2161 Checksum cs;
2162
2163 cs.checksum.length = sizeof(csdata);
2164 cs.checksum.data = &csdata;
2165
2166 iov.data.data = datack.data;
2167 iov.data.length = datack.length;
2168 iov.flags = KRB5_CRYPTO_TYPE_DATA;
2169
2170 ret = _krb5_HMAC_MD5_checksum(context, NULL, &crypto->key,
2171 KRB5_KU_OTHER_CKSUM, &iov, 1,
2172 &cs);
2173 if (ret == 0 &&
2174 krb5_data_ct_cmp(&cs.checksum, &self.cksum.checksum) != 0)
2175 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
2176 }
2177 else {
2178 ret = krb5_verify_checksum(context,
2179 crypto,
2180 KRB5_KU_OTHER_CKSUM,
2181 datack.data,
2182 datack.length,
2183 &self.cksum);
2184 }
2185 krb5_data_free(&datack);
2186 krb5_crypto_destroy(context, crypto);
2187 if (ret) {
2188 const char *msg = krb5_get_error_message(context, ret);
2189 free_PA_S4U2Self(&self);
2190 _kdc_audit_addreason((kdc_request_t)priv,
2191 "S4U2Self checksum failed");
2192 kdc_log(context, config, 4,
2193 "krb5_verify_checksum failed for S4U2Self: %s", msg);
2194 krb5_free_error_message(context, msg);
2195 goto out;
2196 }
2197
2198 ret = _krb5_principalname2krb5_principal(context,
2199 &tp,
2200 self.name,
2201 self.realm);
2202 free_PA_S4U2Self(&self);
2203 if (ret)
2204 goto out;
2205
2206 ret = krb5_unparse_name(context, tp, &tpn);
2207 if (ret)
2208 goto out;
2209
2210 /*
2211 * Note no HDB_F_SYNTHETIC_OK -- impersonating non-existent clients
2212 * is probably not desirable!
2213 */
2214 ret = _kdc_db_fetch(context, config, tp, HDB_F_GET_CLIENT | flags,
2215 NULL, &s4u2self_impersonated_clientdb,
2216 &s4u2self_impersonated_client);
2217 if (ret) {
2218 const char *msg;
2219
2220 /*
2221 * If the client belongs to the same realm as our krbtgt, it
2222 * should exist in the local database.
2223 *
2224 */
2225
2226 if (ret == HDB_ERR_NOENTRY)
2227 ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
2228 msg = krb5_get_error_message(context, ret);
2229 _kdc_audit_addreason((kdc_request_t)priv,
2230 "S4U2Self principal to impersonate not found");
2231 kdc_log(context, config, 2,
2232 "S4U2Self principal to impersonate %s not found in database: %s",
2233 tpn, msg);
2234 krb5_free_error_message(context, msg);
2235 goto out;
2236 }
2237
2238 /* Ignore require_pwchange and pw_end attributes (as Windows does),
2239 * since S4U2Self is not password authentication. */
2240 s4u2self_impersonated_client->entry.flags.require_pwchange = FALSE;
2241 free(s4u2self_impersonated_client->entry.pw_end);
2242 s4u2self_impersonated_client->entry.pw_end = NULL;
2243
2244 imp_req = *priv;
2245 imp_req.client = s4u2self_impersonated_client;
2246 imp_req.client_princ = tp;
2247
2248 ret = kdc_check_flags(&imp_req, FALSE);
2249 if (ret)
2250 goto out; /* kdc_check_flags() calls _kdc_audit_addreason() */
2251
2252 /* If we were about to put a PAC into the ticket, we better fix it to be the right PAC */
2253 if(rspac.data) {
2254 krb5_pac p = NULL;
2255 krb5_data_free(&rspac);
2256 ret = _kdc_pac_generate(context, s4u2self_impersonated_client, &p);
2257 if (ret) {
2258 _kdc_audit_addreason((kdc_request_t)priv,
2259 "KRB5SignedPath missing");
2260 kdc_log(context, config, 4, "PAC generation failed for -- %s",
2261 tpn);
2262 goto out;
2263 }
2264 if (p != NULL) {
2265 ret = _krb5_pac_sign(context, p, ticket->ticket.authtime,
2266 s4u2self_impersonated_client->entry.principal,
2267 ekey, &tkey_sign->key,
2268 &rspac);
2269 krb5_pac_free(context, p);
2270 if (ret) {
2271 kdc_log(context, config, 4, "PAC signing failed for -- %s",
2272 tpn);
2273 goto out;
2274 }
2275 }
2276 }
2277
2278 /*
2279 * Check that service doing the impersonating is
2280 * requesting a ticket to it-self.
2281 */
2282 ret = check_s4u2self(context, config, clientdb, client, sp);
2283 if (ret) {
2284 kdc_log(context, config, 4, "S4U2Self: %s is not allowed "
2285 "to impersonate to service "
2286 "(tried for user %s to service %s)",
2287 cpn, tpn, spn);
2288 goto out;
2289 }
2290
2291 /*
2292 * If the service isn't trusted for authentication to
2293 * delegation or if the impersonate client is disallowed
2294 * forwardable, remove the forwardable flag.
2295 */
2296
2297 if (client->entry.flags.trusted_for_delegation &&
2298 s4u2self_impersonated_client->entry.flags.forwardable) {
2299 str = "[forwardable]";
2300 } else {
2301 b->kdc_options.forwardable = 0;
2302 str = "";
2303 }
2304 kdc_log(context, config, 4, "s4u2self %s impersonating %s to "
2305 "service %s %s", cpn, tpn, spn, str);
2306 }
2307 }
2308
2309 /*
2310 * Constrained delegation
2311 */
2312
2313 if (client != NULL
2314 && b->additional_tickets != NULL
2315 && b->additional_tickets->len != 0
2316 && b->kdc_options.cname_in_addl_tkt
2317 && b->kdc_options.enc_tkt_in_skey == 0)
2318 {
2319 int ad_signedpath = 0;
2320 Key *clientkey;
2321 Ticket *t;
2322
2323 /*
2324 * Require that the KDC have issued the service's krbtgt (not
2325 * self-issued ticket with kimpersonate(1).
2326 */
2327 if (!signedpath) {
2328 ret = KRB5KDC_ERR_BADOPTION;
2329 _kdc_audit_addreason((kdc_request_t)priv, "KRB5SignedPath missing");
2330 kdc_log(context, config, 4,
2331 "Constrained delegation done on service ticket %s/%s",
2332 cpn, spn);
2333 goto out;
2334 }
2335
2336 t = &b->additional_tickets->val[0];
2337
2338 ret = hdb_enctype2key(context, &client->entry,
2339 hdb_kvno2keys(context, &client->entry,
2340 t->enc_part.kvno ? * t->enc_part.kvno : 0),
2341 t->enc_part.etype, &clientkey);
2342 if(ret){
2343 ret = KRB5KDC_ERR_ETYPE_NOSUPP; /* XXX */
2344 goto out;
2345 }
2346
2347 ret = krb5_decrypt_ticket(context, t, &clientkey->key, &adtkt, 0);
2348 if (ret) {
2349 _kdc_audit_addreason((kdc_request_t)priv,
2350 "Failed to decrypt constrained delegation ticket");
2351 kdc_log(context, config, 4,
2352 "failed to decrypt ticket for "
2353 "constrained delegation from %s to %s ", cpn, spn);
2354 goto out;
2355 }
2356
2357 ret = _krb5_principalname2krb5_principal(context,
2358 &tp,
2359 adtkt.cname,
2360 adtkt.crealm);
2361 if (ret)
2362 goto out;
2363
2364 ret = krb5_unparse_name(context, tp, &tpn);
2365 if (ret)
2366 goto out;
2367
2368 _kdc_audit_addkv((kdc_request_t)priv, 0, "impersonatee", "%s", tpn);
2369
2370 ret = _krb5_principalname2krb5_principal(context,
2371 &dp,
2372 t->sname,
2373 t->realm);
2374 if (ret)
2375 goto out;
2376
2377 ret = krb5_unparse_name(context, dp, &dpn);
2378 if (ret)
2379 goto out;
2380
2381 /* check that ticket is valid */
2382 if (adtkt.flags.forwardable == 0) {
2383 _kdc_audit_addreason((kdc_request_t)priv,
2384 "Missing forwardable flag on ticket for constrained delegation");
2385 kdc_log(context, config, 4,
2386 "Missing forwardable flag on ticket for "
2387 "constrained delegation from %s (%s) as %s to %s ",
2388 cpn, dpn, tpn, spn);
2389 ret = KRB5KDC_ERR_BADOPTION;
2390 goto out;
2391 }
2392
2393 ret = check_constrained_delegation(context, config, clientdb,
2394 client, server, sp);
2395 if (ret) {
2396 _kdc_audit_addreason((kdc_request_t)priv,
2397 "Constrained delegation not allowed");
2398 kdc_log(context, config, 4,
2399 "constrained delegation from %s (%s) as %s to %s not allowed",
2400 cpn, dpn, tpn, spn);
2401 goto out;
2402 }
2403
2404 ret = verify_flags(context, config, &adtkt, tpn);
2405 if (ret) {
2406 _kdc_audit_addreason((kdc_request_t)priv,
2407 "Constrained delegation ticket expired or invalid");
2408 goto out;
2409 }
2410
2411 krb5_data_free(&rspac);
2412
2413 /*
2414 * generate the PAC for the user.
2415 *
2416 * TODO: pass in t->sname and t->realm and build
2417 * a S4U_DELEGATION_INFO blob to the PAC.
2418 */
2419 ret = check_PAC(context, config, tp, dp,
2420 client, server, krbtgt,
2421 &clientkey->key,
2422 ekey, &tkey_sign->key,
2423 &adtkt, &rspac, &ad_signedpath);
2424 if (ret) {
2425 const char *msg = krb5_get_error_message(context, ret);
2426 _kdc_audit_addreason((kdc_request_t)priv,
2427 "Constrained delegation ticket PAC check failed");
2428 kdc_log(context, config, 4,
2429 "Verify delegated PAC failed to %s for client"
2430 "%s (%s) as %s from %s with %s",
2431 spn, cpn, dpn, tpn, from, msg);
2432 krb5_free_error_message(context, msg);
2433 goto out;
2434 }
2435
2436 /*
2437 * Check that the KDC issued the user's ticket.
2438 */
2439 ret = check_KRB5SignedPath(context,
2440 config,
2441 krbtgt,
2442 cp,
2443 &adtkt,
2444 NULL,
2445 &ad_signedpath);
2446 if (ret) {
2447 const char *msg = krb5_get_error_message(context, ret);
2448 kdc_log(context, config, 4,
2449 "KRB5SignedPath check from service %s failed "
2450 "for delegation to %s for client %s (%s)"
2451 "from %s failed with %s",
2452 spn, tpn, dpn, cpn, from, msg);
2453 krb5_free_error_message(context, msg);
2454 _kdc_audit_addreason((kdc_request_t)priv,
2455 "KRB5SignedPath check failed");
2456 goto out;
2457 }
2458
2459 if (!ad_signedpath) {
2460 ret = KRB5KDC_ERR_BADOPTION;
2461 kdc_log(context, config, 4,
2462 "Ticket not signed with PAC nor SignedPath service %s failed "
2463 "for delegation to %s for client %s (%s)"
2464 "from %s",
2465 spn, tpn, dpn, cpn, from);
2466 _kdc_audit_addreason((kdc_request_t)priv,
2467 "Constrained delegation ticket not signed");
2468 goto out;
2469 }
2470
2471 kdc_log(context, config, 4, "constrained delegation for %s "
2472 "from %s (%s) to %s", tpn, cpn, dpn, spn);
2473 }
2474
2475 /*
2476 * Check flags
2477 */
2478
2479 ret = kdc_check_flags(priv, FALSE);
2480 if(ret)
2481 goto out;
2482
2483 if((b->kdc_options.validate || b->kdc_options.renew) &&
2484 !krb5_principal_compare(context,
2485 krbtgt->entry.principal,
2486 server->entry.principal)){
2487 _kdc_audit_addreason((kdc_request_t)priv, "Inconsistent request");
2488 kdc_log(context, config, 4, "Inconsistent request.");
2489 ret = KRB5KDC_ERR_SERVER_NOMATCH;
2490 goto out;
2491 }
2492
2493 /* check for valid set of addresses */
2494 if (!_kdc_check_addresses(priv, tgt->caddr, from_addr)) {
2495 if (config->check_ticket_addresses) {
2496 ret = KRB5KRB_AP_ERR_BADADDR;
2497 _kdc_audit_addkv((kdc_request_t)priv, 0, "wrongaddr", "yes");
2498 kdc_log(context, config, 4, "Request from wrong address");
2499 _kdc_audit_addreason((kdc_request_t)priv, "Request from wrong address");
2500 goto out;
2501 } else if (config->warn_ticket_addresses) {
2502 _kdc_audit_addkv((kdc_request_t)priv, 0, "wrongaddr", "yes");
2503 }
2504 }
2505
2506 /* check local and per-principal anonymous ticket issuance policy */
2507 if (is_anon_tgs_request_p(b, tgt)) {
2508 ret = _kdc_check_anon_policy(priv);
2509 if (ret)
2510 goto out;
2511 }
2512
2513 /*
2514 * If this is an referral, add server referral data to the
2515 * auth_data reply .
2516 */
2517 if (ref_realm) {
2518 PA_DATA pa;
2519 krb5_crypto crypto;
2520
2521 kdc_log(context, config, 3,
2522 "Adding server referral to %s", ref_realm);
2523
2524 ret = krb5_crypto_init(context, &sessionkey, 0, &crypto);
2525 if (ret)
2526 goto out;
2527
2528 ret = build_server_referral(context, config, crypto, ref_realm,
2529 NULL, s, &pa.padata_value);
2530 krb5_crypto_destroy(context, crypto);
2531 if (ret) {
2532 _kdc_audit_addreason((kdc_request_t)priv, "Referral build failed");
2533 kdc_log(context, config, 4,
2534 "Failed building server referral");
2535 goto out;
2536 }
2537 pa.padata_type = KRB5_PADATA_SERVER_REFERRAL;
2538
2539 ret = add_METHOD_DATA(&enc_pa_data, &pa);
2540 krb5_data_free(&pa.padata_value);
2541 if (ret) {
2542 kdc_log(context, config, 4,
2543 "Add server referral METHOD-DATA failed");
2544 goto out;
2545 }
2546 }
2547
2548 /*
2549 *
2550 */
2551
2552 ret = tgs_make_reply(priv,
2553 tp,
2554 tgt,
2555 replykey,
2556 rk_is_subkey,
2557 ekey,
2558 &sessionkey,
2559 kvno,
2560 *auth_data,
2561 server,
2562 rsp,
2563 client,
2564 cp,
2565 tgt_realm,
2566 krbtgt_out,
2567 tkey_sign->key.keytype,
2568 spp,
2569 &rspac,
2570 &enc_pa_data);
2571
2572 out:
2573 if (tpn != cpn)
2574 free(tpn);
2575 free(dpn);
2576 free(krbtgt_out_n);
2577 _krb5_free_capath(context, capath);
2578
2579 krb5_data_free(&rspac);
2580 krb5_free_keyblock_contents(context, &sessionkey);
2581 if(krbtgt_out)
2582 _kdc_free_ent(context, krbtgt_out);
2583 if(server)
2584 _kdc_free_ent(context, server);
2585 if(client)
2586 _kdc_free_ent(context, client);
2587 if(s4u2self_impersonated_client)
2588 _kdc_free_ent(context, s4u2self_impersonated_client);
2589
2590 if (tp && tp != cp)
2591 krb5_free_principal(context, tp);
2592 krb5_free_principal(context, cp);
2593 krb5_free_principal(context, dp);
2594 krb5_free_principal(context, sp);
2595 krb5_free_principal(context, krbtgt_out_principal);
2596 free(ref_realm);
2597 free_METHOD_DATA(&enc_pa_data);
2598
2599 free_EncTicketPart(&adtkt);
2600
2601 return ret;
2602 }
2603
2604 /*
2605 *
2606 */
2607
2608 krb5_error_code
2609 _kdc_tgs_rep(astgs_request_t r)
2610 {
2611 krb5_context context = r->context;
2612 krb5_kdc_configuration *config = r->config;
2613 KDC_REQ *req = &r->req;
2614 krb5_data *data = r->reply;
2615 const char *from = r->from;
2616 struct sockaddr *from_addr = r->addr;
2617 int datagram_reply = r->datagram_reply;
2618 AuthorizationData *auth_data = NULL;
2619 krb5_error_code ret;
2620 int i = 0;
2621 const PA_DATA *tgs_req;
2622
2623 hdb_entry_ex *krbtgt = NULL;
2624 krb5_ticket *ticket = NULL;
2625 const char *e_text = NULL;
2626 krb5_enctype krbtgt_etype = ETYPE_NULL;
2627
2628 krb5_keyblock *replykey = NULL;
2629 int rk_is_subkey = 0;
2630 time_t *csec = NULL;
2631 int *cusec = NULL;
2632
2633 if(req->padata == NULL){
2634 ret = KRB5KDC_ERR_PREAUTH_REQUIRED; /* XXX ??? */
2635 kdc_log(context, config, 4,
2636 "TGS-REQ from %s without PA-DATA", from);
2637 goto out;
2638 }
2639
2640 tgs_req = _kdc_find_padata(req, &i, KRB5_PADATA_TGS_REQ);
2641
2642 if(tgs_req == NULL){
2643 ret = KRB5KDC_ERR_PADATA_TYPE_NOSUPP;
2644
2645 kdc_log(context, config, 4,
2646 "TGS-REQ from %s without PA-TGS-REQ", from);
2647 goto out;
2648 }
2649 ret = tgs_parse_request(r, tgs_req,
2650 &krbtgt,
2651 &krbtgt_etype,
2652 &ticket,
2653 &e_text,
2654 from, from_addr,
2655 &csec, &cusec,
2656 &auth_data,
2657 &replykey,
2658 &rk_is_subkey);
2659 if (ret == HDB_ERR_NOT_FOUND_HERE) {
2660 /* kdc_log() is called in tgs_parse_request() */
2661 goto out;
2662 }
2663 if (ret) {
2664 kdc_log(context, config, 4,
2665 "Failed parsing TGS-REQ from %s", from);
2666 goto out;
2667 }
2668
2669 {
2670 const PA_DATA *pa = _kdc_find_padata(req, &i, KRB5_PADATA_FX_FAST);
2671 if (pa)
2672 kdc_log(context, config, 5, "Got TGS FAST request");
2673 }
2674
2675
2676 ret = tgs_build_reply(r,
2677 krbtgt,
2678 krbtgt_etype,
2679 replykey,
2680 rk_is_subkey,
2681 ticket,
2682 &e_text,
2683 &auth_data,
2684 from_addr);
2685 if (ret) {
2686 kdc_log(context, config, 4,
2687 "Failed building TGS-REP to %s", from);
2688 goto out;
2689 }
2690
2691 /* */
2692 if (datagram_reply && data->length > config->max_datagram_reply_length) {
2693 krb5_data_free(data);
2694 ret = KRB5KRB_ERR_RESPONSE_TOO_BIG;
2695 e_text = "Reply packet too large";
2696 }
2697
2698 out:
2699 if (replykey)
2700 krb5_free_keyblock(context, replykey);
2701
2702 if(ret && ret != HDB_ERR_NOT_FOUND_HERE && data->data == NULL){
2703 /* XXX add fast wrapping on the error */
2704 METHOD_DATA error_method = { 0, NULL };
2705
2706
2707 kdc_log(context, config, 5, "tgs-req: sending error: %d to client", ret);
2708 ret = _kdc_fast_mk_error(r,
2709 &error_method,
2710 NULL,
2711 NULL,
2712 ret, NULL,
2713 NULL,
2714 NULL, NULL,
2715 csec, cusec,
2716 data);
2717 free_METHOD_DATA(&error_method);
2718 }
2719 free(csec);
2720 free(cusec);
2721 if (ticket)
2722 krb5_free_ticket(context, ticket);
2723 if(krbtgt)
2724 _kdc_free_ent(context, krbtgt);
2725
2726 if (auth_data) {
2727 free_AuthorizationData(auth_data);
2728 free(auth_data);
2729 }
2730
2731 return ret;
2732 }
Heimdal