?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GSSAPI: use rk_UNCONST() on password and cert oid
[heimdal.git] / kdc / krb5tgs.c
bloba158502f67ad51f200c8839338e13bc1369c3224
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, 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, 5,
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 /*
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.starttime;
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.starttime + 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, serverkey->keytype) != 0
973 && _kdc_is_weak_exception(server->entry.principal, serverkey->keytype))
974 {
975 krb5_enctype_enable(context, serverkey->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, NULL, 0,
991 &rep, &et, &ek, serverkey->keytype,
992 kvno,
993 serverkey, 0, replykey, rk_is_subkey,
994 e_text, reply);
995 if (is_weak)
996 krb5_enctype_disable(context, serverkey->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 == 3 &&
1125 strcasecmp("E3514235-4B06-11D1-AB04-00C04FC2DCD2", server->name.name_string.val[0]) == 0) {
1126 /*
1127 This is used to give referrals for the
1128 E3514235-4B06-11D1-AB04-00C04FC2DCD2/NTDSGUID/DNSDOMAIN
1129 SPN form, which is used for inter-domain communication in AD
1130 */
1131 name = server->name.name_string.val[2];
1132 kdc_log(context, config, 0, "Giving 3 part DRSUAPI referral for %s", name);
1133 *realms = malloc(sizeof(char *)*2);
1134 if (*realms == NULL) {
1135 krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", ""));
1136 return FALSE;
1137 }
1138 (*realms)[0] = strdup(name);
1139 (*realms)[1] = NULL;
1140 return TRUE;
1141 } else if (server->name.name_string.len > 1)
1142 name = server->name.name_string.val[1];
1143 else
1144 return FALSE;
1145
1146 kdc_log(context, config, 0, "Searching referral for %s", name);
1147
1148 return _krb5_get_host_realm_int(context, name, FALSE, realms) == 0;
1149 }
1150
1151 static krb5_error_code
1152 tgs_parse_request(krb5_context context,
1153 krb5_kdc_configuration *config,
1154 KDC_REQ_BODY *b,
1155 const PA_DATA *tgs_req,
1156 hdb_entry_ex **krbtgt,
1157 krb5_enctype *krbtgt_etype,
1158 krb5_ticket **ticket,
1159 const char **e_text,
1160 const char *from,
1161 const struct sockaddr *from_addr,
1162 time_t **csec,
1163 int **cusec,
1164 AuthorizationData **auth_data,
1165 krb5_keyblock **replykey,
1166 int *rk_is_subkey)
1167 {
1168 static char failed[] = "<unparse_name failed>";
1169 krb5_ap_req ap_req;
1170 krb5_error_code ret;
1171 krb5_principal princ;
1172 krb5_auth_context ac = NULL;
1173 krb5_flags ap_req_options;
1174 krb5_flags verify_ap_req_flags;
1175 krb5_crypto crypto;
1176 krb5uint32 krbtgt_kvno; /* kvno used for the PA-TGS-REQ AP-REQ Ticket */
1177 krb5uint32 krbtgt_kvno_try;
1178 int kvno_search_tries = 4; /* number of kvnos to try when tkt_vno == 0 */
1179 const Keys *krbtgt_keys;/* keyset for TGT tkt_vno */
1180 Key *tkey;
1181 krb5_keyblock *subkey = NULL;
1182 unsigned usage;
1183
1184 *auth_data = NULL;
1185 *csec = NULL;
1186 *cusec = NULL;
1187 *replykey = NULL;
1188
1189 memset(&ap_req, 0, sizeof(ap_req));
1190 ret = krb5_decode_ap_req(context, &tgs_req->padata_value, &ap_req);
1191 if(ret){
1192 const char *msg = krb5_get_error_message(context, ret);
1193 kdc_log(context, config, 0, "Failed to decode AP-REQ: %s", msg);
1194 krb5_free_error_message(context, msg);
1195 goto out;
1196 }
1197
1198 if(!get_krbtgt_realm(&ap_req.ticket.sname)){
1199 /* XXX check for ticket.sname == req.sname */
1200 kdc_log(context, config, 0, "PA-DATA is not a ticket-granting ticket");
1201 ret = KRB5KDC_ERR_POLICY; /* ? */
1202 goto out;
1203 }
1204
1205 _krb5_principalname2krb5_principal(context,
1206 &princ,
1207 ap_req.ticket.sname,
1208 ap_req.ticket.realm);
1209
1210 krbtgt_kvno = ap_req.ticket.enc_part.kvno ? *ap_req.ticket.enc_part.kvno : 0;
1211 ret = _kdc_db_fetch(context, config, princ, HDB_F_GET_KRBTGT,
1212 &krbtgt_kvno, NULL, krbtgt);
1213
1214 if (ret == HDB_ERR_NOT_FOUND_HERE) {
1215 /* XXX Factor out this unparsing of the same princ all over */
1216 char *p;
1217 ret = krb5_unparse_name(context, princ, &p);
1218 if (ret != 0)
1219 p = failed;
1220 krb5_free_principal(context, princ);
1221 kdc_log(context, config, 5,
1222 "Ticket-granting ticket account %s does not have secrets at "
1223 "this KDC, need to proxy", p);
1224 if (ret == 0)
1225 free(p);
1226 ret = HDB_ERR_NOT_FOUND_HERE;
1227 goto out;
1228 } else if (ret == HDB_ERR_KVNO_NOT_FOUND) {
1229 char *p;
1230 ret = krb5_unparse_name(context, princ, &p);
1231 if (ret != 0)
1232 p = failed;
1233 krb5_free_principal(context, princ);
1234 kdc_log(context, config, 5,
1235 "Ticket-granting ticket account %s does not have keys for "
1236 "kvno %d at this KDC", p, krbtgt_kvno);
1237 if (ret == 0)
1238 free(p);
1239 ret = HDB_ERR_KVNO_NOT_FOUND;
1240 goto out;
1241 } else if (ret == HDB_ERR_NO_MKEY) {
1242 char *p;
1243 ret = krb5_unparse_name(context, princ, &p);
1244 if (ret != 0)
1245 p = failed;
1246 krb5_free_principal(context, princ);
1247 kdc_log(context, config, 5,
1248 "Missing master key for decrypting keys for ticket-granting "
1249 "ticket account %s with kvno %d at this KDC", p, krbtgt_kvno);
1250 if (ret == 0)
1251 free(p);
1252 ret = HDB_ERR_KVNO_NOT_FOUND;
1253 goto out;
1254 } else if (ret) {
1255 const char *msg = krb5_get_error_message(context, ret);
1256 char *p;
1257 ret = krb5_unparse_name(context, princ, &p);
1258 if (ret != 0)
1259 p = failed;
1260 krb5_free_principal(context, princ);
1261 kdc_log(context, config, 0,
1262 "Ticket-granting ticket not found in database: %s", msg);
1263 krb5_free_error_message(context, msg);
1264 if (ret == 0)
1265 free(p);
1266 ret = KRB5KRB_AP_ERR_NOT_US;
1267 goto out;
1268 }
1269
1270 krbtgt_kvno_try = krbtgt_kvno ? krbtgt_kvno : (*krbtgt)->entry.kvno;
1271 *krbtgt_etype = ap_req.ticket.enc_part.etype;
1272
1273 next_kvno:
1274 krbtgt_keys = hdb_kvno2keys(context, &(*krbtgt)->entry, krbtgt_kvno_try);
1275 ret = hdb_enctype2key(context, &(*krbtgt)->entry, krbtgt_keys,
1276 ap_req.ticket.enc_part.etype, &tkey);
1277 if (ret && krbtgt_kvno == 0 && kvno_search_tries > 0) {
1278 kvno_search_tries--;
1279 krbtgt_kvno_try--;
1280 goto next_kvno;
1281 } else if (ret) {
1282 char *str = NULL, *p = NULL;
1283
1284 krb5_enctype_to_string(context, ap_req.ticket.enc_part.etype, &str);
1285 krb5_unparse_name(context, princ, &p);
1286 kdc_log(context, config, 0,
1287 "No server key with enctype %s found for %s",
1288 str ? str : "<unknown enctype>",
1289 p ? p : "<unparse_name failed>");
1290 free(str);
1291 free(p);
1292 ret = KRB5KRB_AP_ERR_BADKEYVER;
1293 goto out;
1294 }
1295
1296 if (b->kdc_options.validate)
1297 verify_ap_req_flags = KRB5_VERIFY_AP_REQ_IGNORE_INVALID;
1298 else
1299 verify_ap_req_flags = 0;
1300
1301 ret = krb5_verify_ap_req2(context,
1302 &ac,
1303 &ap_req,
1304 princ,
1305 &tkey->key,
1306 verify_ap_req_flags,
1307 &ap_req_options,
1308 ticket,
1309 KRB5_KU_TGS_REQ_AUTH);
1310 if (ret == KRB5KRB_AP_ERR_BAD_INTEGRITY && kvno_search_tries > 0) {
1311 kvno_search_tries--;
1312 krbtgt_kvno_try--;
1313 goto next_kvno;
1314 }
1315
1316 krb5_free_principal(context, princ);
1317 if(ret) {
1318 const char *msg = krb5_get_error_message(context, ret);
1319 kdc_log(context, config, 0, "Failed to verify AP-REQ: %s", msg);
1320 krb5_free_error_message(context, msg);
1321 goto out;
1322 }
1323
1324 {
1325 krb5_authenticator auth;
1326
1327 ret = krb5_auth_con_getauthenticator(context, ac, &auth);
1328 if (ret == 0) {
1329 *csec = malloc(sizeof(**csec));
1330 if (*csec == NULL) {
1331 krb5_free_authenticator(context, &auth);
1332 kdc_log(context, config, 0, "malloc failed");
1333 goto out;
1334 }
1335 **csec = auth->ctime;
1336 *cusec = malloc(sizeof(**cusec));
1337 if (*cusec == NULL) {
1338 krb5_free_authenticator(context, &auth);
1339 kdc_log(context, config, 0, "malloc failed");
1340 goto out;
1341 }
1342 **cusec = auth->cusec;
1343 krb5_free_authenticator(context, &auth);
1344 }
1345 }
1346
1347 ret = tgs_check_authenticator(context, config,
1348 ac, b, e_text, &(*ticket)->ticket.key);
1349 if (ret) {
1350 krb5_auth_con_free(context, ac);
1351 goto out;
1352 }
1353
1354 usage = KRB5_KU_TGS_REQ_AUTH_DAT_SUBKEY;
1355 *rk_is_subkey = 1;
1356
1357 ret = krb5_auth_con_getremotesubkey(context, ac, &subkey);
1358 if(ret){
1359 const char *msg = krb5_get_error_message(context, ret);
1360 krb5_auth_con_free(context, ac);
1361 kdc_log(context, config, 0, "Failed to get remote subkey: %s", msg);
1362 krb5_free_error_message(context, msg);
1363 goto out;
1364 }
1365 if(subkey == NULL){
1366 usage = KRB5_KU_TGS_REQ_AUTH_DAT_SESSION;
1367 *rk_is_subkey = 0;
1368
1369 ret = krb5_auth_con_getkey(context, ac, &subkey);
1370 if(ret) {
1371 const char *msg = krb5_get_error_message(context, ret);
1372 krb5_auth_con_free(context, ac);
1373 kdc_log(context, config, 0, "Failed to get session key: %s", msg);
1374 krb5_free_error_message(context, msg);
1375 goto out;
1376 }
1377 }
1378 if(subkey == NULL){
1379 krb5_auth_con_free(context, ac);
1380 kdc_log(context, config, 0,
1381 "Failed to get key for enc-authorization-data");
1382 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY; /* ? */
1383 goto out;
1384 }
1385
1386 *replykey = subkey;
1387
1388 if (b->enc_authorization_data) {
1389 krb5_data ad;
1390
1391 ret = krb5_crypto_init(context, subkey, 0, &crypto);
1392 if (ret) {
1393 const char *msg = krb5_get_error_message(context, ret);
1394 krb5_auth_con_free(context, ac);
1395 kdc_log(context, config, 0, "krb5_crypto_init failed: %s", msg);
1396 krb5_free_error_message(context, msg);
1397 goto out;
1398 }
1399 ret = krb5_decrypt_EncryptedData (context,
1400 crypto,
1401 usage,
1402 b->enc_authorization_data,
1403 &ad);
1404 krb5_crypto_destroy(context, crypto);
1405 if(ret){
1406 krb5_auth_con_free(context, ac);
1407 kdc_log(context, config, 0,
1408 "Failed to decrypt enc-authorization-data");
1409 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY; /* ? */
1410 goto out;
1411 }
1412 ALLOC(*auth_data);
1413 if (*auth_data == NULL) {
1414 krb5_auth_con_free(context, ac);
1415 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY; /* ? */
1416 goto out;
1417 }
1418 ret = decode_AuthorizationData(ad.data, ad.length, *auth_data, NULL);
1419 if(ret){
1420 krb5_auth_con_free(context, ac);
1421 free(*auth_data);
1422 *auth_data = NULL;
1423 kdc_log(context, config, 0, "Failed to decode authorization data");
1424 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY; /* ? */
1425 goto out;
1426 }
1427 }
1428
1429 krb5_auth_con_free(context, ac);
1430
1431 out:
1432 free_AP_REQ(&ap_req);
1433
1434 return ret;
1435 }
1436
1437 static krb5_error_code
1438 build_server_referral(krb5_context context,
1439 krb5_kdc_configuration *config,
1440 krb5_crypto session,
1441 krb5_const_realm referred_realm,
1442 const PrincipalName *true_principal_name,
1443 const PrincipalName *requested_principal,
1444 krb5_data *outdata)
1445 {
1446 PA_ServerReferralData ref;
1447 krb5_error_code ret;
1448 EncryptedData ed;
1449 krb5_data data;
1450 size_t size = 0;
1451
1452 memset(&ref, 0, sizeof(ref));
1453
1454 if (referred_realm) {
1455 ALLOC(ref.referred_realm);
1456 if (ref.referred_realm == NULL)
1457 goto eout;
1458 *ref.referred_realm = strdup(referred_realm);
1459 if (*ref.referred_realm == NULL)
1460 goto eout;
1461 }
1462 if (true_principal_name) {
1463 ALLOC(ref.true_principal_name);
1464 if (ref.true_principal_name == NULL)
1465 goto eout;
1466 ret = copy_PrincipalName(true_principal_name, ref.true_principal_name);
1467 if (ret)
1468 goto eout;
1469 }
1470 if (requested_principal) {
1471 ALLOC(ref.requested_principal_name);
1472 if (ref.requested_principal_name == NULL)
1473 goto eout;
1474 ret = copy_PrincipalName(requested_principal,
1475 ref.requested_principal_name);
1476 if (ret)
1477 goto eout;
1478 }
1479
1480 ASN1_MALLOC_ENCODE(PA_ServerReferralData,
1481 data.data, data.length,
1482 &ref, &size, ret);
1483 free_PA_ServerReferralData(&ref);
1484 if (ret)
1485 return ret;
1486 if (data.length != size)
1487 krb5_abortx(context, "internal asn.1 encoder error");
1488
1489 ret = krb5_encrypt_EncryptedData(context, session,
1490 KRB5_KU_PA_SERVER_REFERRAL,
1491 data.data, data.length,
1492 0 /* kvno */, &ed);
1493 free(data.data);
1494 if (ret)
1495 return ret;
1496
1497 ASN1_MALLOC_ENCODE(EncryptedData,
1498 outdata->data, outdata->length,
1499 &ed, &size, ret);
1500 free_EncryptedData(&ed);
1501 if (ret)
1502 return ret;
1503 if (outdata->length != size)
1504 krb5_abortx(context, "internal asn.1 encoder error");
1505
1506 return 0;
1507 eout:
1508 free_PA_ServerReferralData(&ref);
1509 krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
1510 return ENOMEM;
1511 }
1512
1513 static krb5_error_code
1514 tgs_build_reply(krb5_context context,
1515 krb5_kdc_configuration *config,
1516 KDC_REQ *req,
1517 KDC_REQ_BODY *b,
1518 hdb_entry_ex *krbtgt,
1519 krb5_enctype krbtgt_etype,
1520 const krb5_keyblock *replykey,
1521 int rk_is_subkey,
1522 krb5_ticket *ticket,
1523 krb5_data *reply,
1524 const char *from,
1525 const char **e_text,
1526 AuthorizationData **auth_data,
1527 const struct sockaddr *from_addr)
1528 {
1529 krb5_error_code ret;
1530 krb5_principal cp = NULL, sp = NULL, rsp = NULL, tp = NULL, dp = NULL;
1531 krb5_principal krbtgt_out_principal = NULL;
1532 char *spn = NULL, *cpn = NULL, *tpn = NULL, *dpn = NULL, *krbtgt_out_n = NULL;
1533 hdb_entry_ex *server = NULL, *client = NULL, *s4u2self_impersonated_client = NULL;
1534 HDB *clientdb, *s4u2self_impersonated_clientdb;
1535 krb5_realm ref_realm = NULL;
1536 EncTicketPart *tgt = &ticket->ticket;
1537 krb5_principals spp = NULL;
1538 const EncryptionKey *ekey;
1539 krb5_keyblock sessionkey;
1540 krb5_kvno kvno;
1541 krb5_data rspac;
1542
1543 hdb_entry_ex *krbtgt_out = NULL;
1544
1545 METHOD_DATA enc_pa_data;
1546
1547 PrincipalName *s;
1548 Realm r;
1549 int nloop = 0;
1550 EncTicketPart adtkt;
1551 char opt_str[128];
1552 int signedpath = 0;
1553
1554 Key *tkey_check;
1555 Key *tkey_sign;
1556 int flags = HDB_F_FOR_TGS_REQ;
1557
1558 memset(&sessionkey, 0, sizeof(sessionkey));
1559 memset(&adtkt, 0, sizeof(adtkt));
1560 krb5_data_zero(&rspac);
1561 memset(&enc_pa_data, 0, sizeof(enc_pa_data));
1562
1563 s = b->sname;
1564 r = b->realm;
1565
1566 /*
1567 * Always to do CANON, see comment below about returned server principal (rsp).
1568 */
1569 flags |= HDB_F_CANON;
1570
1571 if(b->kdc_options.enc_tkt_in_skey){
1572 Ticket *t;
1573 hdb_entry_ex *uu;
1574 krb5_principal p;
1575 Key *uukey;
1576
1577 if(b->additional_tickets == NULL ||
1578 b->additional_tickets->len == 0){
1579 ret = KRB5KDC_ERR_BADOPTION; /* ? */
1580 kdc_log(context, config, 0,
1581 "No second ticket present in request");
1582 goto out;
1583 }
1584 t = &b->additional_tickets->val[0];
1585 if(!get_krbtgt_realm(&t->sname)){
1586 kdc_log(context, config, 0,
1587 "Additional ticket is not a ticket-granting ticket");
1588 ret = KRB5KDC_ERR_POLICY;
1589 goto out;
1590 }
1591 _krb5_principalname2krb5_principal(context, &p, t->sname, t->realm);
1592 ret = _kdc_db_fetch(context, config, p,
1593 HDB_F_GET_KRBTGT, t->enc_part.kvno,
1594 NULL, &uu);
1595 krb5_free_principal(context, p);
1596 if(ret){
1597 if (ret == HDB_ERR_NOENTRY)
1598 ret = KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN;
1599 goto out;
1600 }
1601 ret = hdb_enctype2key(context, &uu->entry, NULL,
1602 t->enc_part.etype, &uukey);
1603 if(ret){
1604 _kdc_free_ent(context, uu);
1605 ret = KRB5KDC_ERR_ETYPE_NOSUPP; /* XXX */
1606 goto out;
1607 }
1608 ret = krb5_decrypt_ticket(context, t, &uukey->key, &adtkt, 0);
1609 _kdc_free_ent(context, uu);
1610 if(ret)
1611 goto out;
1612
1613 ret = verify_flags(context, config, &adtkt, spn);
1614 if (ret)
1615 goto out;
1616
1617 s = &adtkt.cname;
1618 r = adtkt.crealm;
1619 }
1620
1621 _krb5_principalname2krb5_principal(context, &sp, *s, r);
1622 ret = krb5_unparse_name(context, sp, &spn);
1623 if (ret)
1624 goto out;
1625 _krb5_principalname2krb5_principal(context, &cp, tgt->cname, tgt->crealm);
1626 ret = krb5_unparse_name(context, cp, &cpn);
1627 if (ret)
1628 goto out;
1629 unparse_flags (KDCOptions2int(b->kdc_options),
1630 asn1_KDCOptions_units(),
1631 opt_str, sizeof(opt_str));
1632 if(*opt_str)
1633 kdc_log(context, config, 0,
1634 "TGS-REQ %s from %s for %s [%s]",
1635 cpn, from, spn, opt_str);
1636 else
1637 kdc_log(context, config, 0,
1638 "TGS-REQ %s from %s for %s", cpn, from, spn);
1639
1640 /*
1641 * Fetch server
1642 */
1643
1644 server_lookup:
1645 ret = _kdc_db_fetch(context, config, sp, HDB_F_GET_SERVER | flags,
1646 NULL, NULL, &server);
1647
1648 if(ret == HDB_ERR_NOT_FOUND_HERE) {
1649 kdc_log(context, config, 5, "target %s does not have secrets at this KDC, need to proxy", sp);
1650 goto out;
1651 } else if(ret){
1652 const char *new_rlm, *msg;
1653 Realm req_rlm;
1654 krb5_realm *realms;
1655
1656 if ((req_rlm = get_krbtgt_realm(&sp->name)) != NULL) {
1657 if(nloop++ < 2) {
1658 new_rlm = find_rpath(context, tgt->crealm, req_rlm);
1659 if(new_rlm) {
1660 kdc_log(context, config, 5, "krbtgt for realm %s "
1661 "not found, trying %s",
1662 req_rlm, new_rlm);
1663 krb5_free_principal(context, sp);
1664 free(spn);
1665 krb5_make_principal(context, &sp, r,
1666 KRB5_TGS_NAME, new_rlm, NULL);
1667 ret = krb5_unparse_name(context, sp, &spn);
1668 if (ret)
1669 goto out;
1670
1671 if (ref_realm)
1672 free(ref_realm);
1673 ref_realm = strdup(new_rlm);
1674 goto server_lookup;
1675 }
1676 }
1677 } else if(need_referral(context, config, &b->kdc_options, sp, &realms)) {
1678 if (strcmp(realms[0], sp->realm) != 0) {
1679 kdc_log(context, config, 5,
1680 "Returning a referral to realm %s for "
1681 "server %s that was not found",
1682 realms[0], spn);
1683 krb5_free_principal(context, sp);
1684 free(spn);
1685 krb5_make_principal(context, &sp, r, KRB5_TGS_NAME,
1686 realms[0], NULL);
1687 ret = krb5_unparse_name(context, sp, &spn);
1688 if (ret)
1689 goto out;
1690
1691 if (ref_realm)
1692 free(ref_realm);
1693 ref_realm = strdup(realms[0]);
1694
1695 krb5_free_host_realm(context, realms);
1696 goto server_lookup;
1697 }
1698 krb5_free_host_realm(context, realms);
1699 }
1700 msg = krb5_get_error_message(context, ret);
1701 kdc_log(context, config, 0,
1702 "Server not found in database: %s: %s", spn, msg);
1703 krb5_free_error_message(context, msg);
1704 if (ret == HDB_ERR_NOENTRY)
1705 ret = KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN;
1706 goto out;
1707 }
1708
1709 /* the name returned to the client depend on what was asked for,
1710 * return canonical name if kdc_options.canonicalize was set, the
1711 * client wants the true name of the principal, if not it just
1712 * wants the name its asked for.
1713 */
1714
1715 if (b->kdc_options.canonicalize)
1716 rsp = server->entry.principal;
1717 else
1718 rsp = sp;
1719
1720
1721 /*
1722 * Select enctype, return key and kvno.
1723 */
1724
1725 {
1726 krb5_enctype etype;
1727
1728 if(b->kdc_options.enc_tkt_in_skey) {
1729 size_t i;
1730 ekey = &adtkt.key;
1731 for(i = 0; i < b->etype.len; i++)
1732 if (b->etype.val[i] == adtkt.key.keytype)
1733 break;
1734 if(i == b->etype.len) {
1735 kdc_log(context, config, 0,
1736 "Addition ticket have not matching etypes");
1737 krb5_clear_error_message(context);
1738 ret = KRB5KDC_ERR_ETYPE_NOSUPP;
1739 goto out;
1740 }
1741 etype = b->etype.val[i];
1742 kvno = 0;
1743 } else {
1744 Key *skey;
1745
1746 ret = _kdc_find_etype(context,
1747 krb5_principal_is_krbtgt(context, sp) ?
1748 config->tgt_use_strongest_session_key :
1749 config->svc_use_strongest_session_key, FALSE,
1750 server, b->etype.val, b->etype.len, &etype,
1751 NULL);
1752 if(ret) {
1753 kdc_log(context, config, 0,
1754 "Server (%s) has no support for etypes", spn);
1755 goto out;
1756 }
1757 ret = _kdc_get_preferred_key(context, config, server, spn,
1758 NULL, &skey);
1759 if(ret) {
1760 kdc_log(context, config, 0,
1761 "Server (%s) has no supported etypes", spn);
1762 goto out;
1763 }
1764 ekey = &skey->key;
1765 kvno = server->entry.kvno;
1766 }
1767
1768 ret = krb5_generate_random_keyblock(context, etype, &sessionkey);
1769 if (ret)
1770 goto out;
1771 }
1772
1773 /*
1774 * Check that service is in the same realm as the krbtgt. If it's
1775 * not the same, it's someone that is using a uni-directional trust
1776 * backward.
1777 */
1778
1779 /*
1780 * Validate authoriation data
1781 */
1782
1783 ret = hdb_enctype2key(context, &krbtgt->entry, NULL, /* XXX use the right kvno! */
1784 krbtgt_etype, &tkey_check);
1785 if(ret) {
1786 kdc_log(context, config, 0,
1787 "Failed to find key for krbtgt PAC check");
1788 goto out;
1789 }
1790
1791 /*
1792 * Now refetch the primary krbtgt, and get the current kvno (the
1793 * sign check may have been on an old kvno, and the server may
1794 * have been an incoming trust)
1795 */
1796
1797 {
1798 const char *remote_realm =
1799 krb5_principal_get_comp_string(context, krbtgt->entry.principal, 1);
1800
1801 ret = krb5_make_principal(context,
1802 &krbtgt_out_principal,
1803 remote_realm,
1804 KRB5_TGS_NAME,
1805 remote_realm,
1806 NULL);
1807 if(ret) {
1808 kdc_log(context, config, 0,
1809 "Failed to make krbtgt principal name object for "
1810 "authz-data signatures");
1811 goto out;
1812 }
1813 ret = krb5_unparse_name(context, krbtgt_out_principal, &krbtgt_out_n);
1814 if (ret) {
1815 kdc_log(context, config, 0,
1816 "Failed to make krbtgt principal name object for "
1817 "authz-data signatures");
1818 goto out;
1819 }
1820 }
1821
1822 ret = _kdc_db_fetch(context, config, krbtgt_out_principal,
1823 HDB_F_GET_KRBTGT, NULL, NULL, &krbtgt_out);
1824 if (ret) {
1825 char *ktpn = NULL;
1826 ret = krb5_unparse_name(context, krbtgt->entry.principal, &ktpn);
1827 kdc_log(context, config, 0,
1828 "No such principal %s (needed for authz-data signature keys) "
1829 "while processing TGS-REQ for service %s with krbtg %s",
1830 krbtgt_out_n, spn, (ret == 0) ? ktpn : "<unknown>");
1831 free(ktpn);
1832 ret = KRB5KRB_AP_ERR_NOT_US;
1833 goto out;
1834 }
1835
1836 /*
1837 * The first realm is the realm of the service, the second is
1838 * krbtgt/<this>/@REALM component of the krbtgt DN the request was
1839 * encrypted to. The redirection via the krbtgt_out entry allows
1840 * the DB to possibly correct the case of the realm (Samba4 does
1841 * this) before the strcmp()
1842 */
1843 if (strcmp(krb5_principal_get_realm(context, server->entry.principal),
1844 krb5_principal_get_realm(context, krbtgt_out->entry.principal)) != 0) {
1845 char *ktpn;
1846 ret = krb5_unparse_name(context, krbtgt_out->entry.principal, &ktpn);
1847 kdc_log(context, config, 0,
1848 "Request with wrong krbtgt: %s",
1849 (ret == 0) ? ktpn : "<unknown>");
1850 if(ret == 0)
1851 free(ktpn);
1852 ret = KRB5KRB_AP_ERR_NOT_US;
1853 goto out;
1854 }
1855
1856 ret = _kdc_get_preferred_key(context, config, krbtgt_out, krbtgt_out_n,
1857 NULL, &tkey_sign);
1858 if (ret) {
1859 kdc_log(context, config, 0,
1860 "Failed to find key for krbtgt PAC signature");
1861 goto out;
1862 }
1863 ret = hdb_enctype2key(context, &krbtgt_out->entry, NULL,
1864 tkey_sign->key.keytype, &tkey_sign);
1865 if(ret) {
1866 kdc_log(context, config, 0,
1867 "Failed to find key for krbtgt PAC signature");
1868 goto out;
1869 }
1870
1871 ret = _kdc_db_fetch(context, config, cp, HDB_F_GET_CLIENT | flags,
1872 NULL, &clientdb, &client);
1873 if(ret == HDB_ERR_NOT_FOUND_HERE) {
1874 /* This is OK, we are just trying to find out if they have
1875 * been disabled or deleted in the meantime, missing secrets
1876 * is OK */
1877 } else if(ret){
1878 const char *krbtgt_realm, *msg;
1879
1880 /*
1881 * If the client belongs to the same realm as our krbtgt, it
1882 * should exist in the local database.
1883 *
1884 */
1885
1886 krbtgt_realm = krb5_principal_get_realm(context, krbtgt_out->entry.principal);
1887
1888 if(strcmp(krb5_principal_get_realm(context, cp), krbtgt_realm) == 0) {
1889 if (ret == HDB_ERR_NOENTRY)
1890 ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
1891 kdc_log(context, config, 1, "Client no longer in database: %s",
1892 cpn);
1893 goto out;
1894 }
1895
1896 msg = krb5_get_error_message(context, ret);
1897 kdc_log(context, config, 1, "Client not found in database: %s", msg);
1898 krb5_free_error_message(context, msg);
1899 }
1900
1901 ret = check_PAC(context, config, cp, NULL,
1902 client, server, krbtgt,
1903 &tkey_check->key,
1904 ekey, &tkey_sign->key,
1905 tgt, &rspac, &signedpath);
1906 if (ret) {
1907 const char *msg = krb5_get_error_message(context, ret);
1908 kdc_log(context, config, 0,
1909 "Verify PAC failed for %s (%s) from %s with %s",
1910 spn, cpn, from, msg);
1911 krb5_free_error_message(context, msg);
1912 goto out;
1913 }
1914
1915 /* also check the krbtgt for signature */
1916 ret = check_KRB5SignedPath(context,
1917 config,
1918 krbtgt,
1919 cp,
1920 tgt,
1921 &spp,
1922 &signedpath);
1923 if (ret) {
1924 const char *msg = krb5_get_error_message(context, ret);
1925 kdc_log(context, config, 0,
1926 "KRB5SignedPath check failed for %s (%s) from %s with %s",
1927 spn, cpn, from, msg);
1928 krb5_free_error_message(context, msg);
1929 goto out;
1930 }
1931
1932 /*
1933 * Process request
1934 */
1935
1936 /* by default the tgt principal matches the client principal */
1937 tp = cp;
1938 tpn = cpn;
1939
1940 if (client) {
1941 const PA_DATA *sdata;
1942 int i = 0;
1943
1944 sdata = _kdc_find_padata(req, &i, KRB5_PADATA_FOR_USER);
1945 if (sdata) {
1946 krb5_crypto crypto;
1947 krb5_data datack;
1948 PA_S4U2Self self;
1949 const char *str;
1950
1951 ret = decode_PA_S4U2Self(sdata->padata_value.data,
1952 sdata->padata_value.length,
1953 &self, NULL);
1954 if (ret) {
1955 kdc_log(context, config, 0, "Failed to decode PA-S4U2Self");
1956 goto out;
1957 }
1958
1959 ret = _krb5_s4u2self_to_checksumdata(context, &self, &datack);
1960 if (ret)
1961 goto out;
1962
1963 ret = krb5_crypto_init(context, &tgt->key, 0, &crypto);
1964 if (ret) {
1965 const char *msg = krb5_get_error_message(context, ret);
1966 free_PA_S4U2Self(&self);
1967 krb5_data_free(&datack);
1968 kdc_log(context, config, 0, "krb5_crypto_init failed: %s", msg);
1969 krb5_free_error_message(context, msg);
1970 goto out;
1971 }
1972
1973 ret = krb5_verify_checksum(context,
1974 crypto,
1975 KRB5_KU_OTHER_CKSUM,
1976 datack.data,
1977 datack.length,
1978 &self.cksum);
1979 krb5_data_free(&datack);
1980 krb5_crypto_destroy(context, crypto);
1981 if (ret) {
1982 const char *msg = krb5_get_error_message(context, ret);
1983 free_PA_S4U2Self(&self);
1984 kdc_log(context, config, 0,
1985 "krb5_verify_checksum failed for S4U2Self: %s", msg);
1986 krb5_free_error_message(context, msg);
1987 goto out;
1988 }
1989
1990 ret = _krb5_principalname2krb5_principal(context,
1991 &tp,
1992 self.name,
1993 self.realm);
1994 free_PA_S4U2Self(&self);
1995 if (ret)
1996 goto out;
1997
1998 ret = krb5_unparse_name(context, tp, &tpn);
1999 if (ret)
2000 goto out;
2001
2002 /* If we were about to put a PAC into the ticket, we better fix it to be the right PAC */
2003 if(rspac.data) {
2004 krb5_pac p = NULL;
2005 krb5_data_free(&rspac);
2006 ret = _kdc_db_fetch(context, config, tp, HDB_F_GET_CLIENT | flags,
2007 NULL, &s4u2self_impersonated_clientdb, &s4u2self_impersonated_client);
2008 if (ret) {
2009 const char *msg;
2010
2011 /*
2012 * If the client belongs to the same realm as our krbtgt, it
2013 * should exist in the local database.
2014 *
2015 */
2016
2017 if (ret == HDB_ERR_NOENTRY)
2018 ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
2019 msg = krb5_get_error_message(context, ret);
2020 kdc_log(context, config, 1,
2021 "S2U4Self principal to impersonate %s not found in database: %s",
2022 tpn, msg);
2023 krb5_free_error_message(context, msg);
2024 goto out;
2025 }
2026 ret = _kdc_pac_generate(context, s4u2self_impersonated_client, &p);
2027 if (ret) {
2028 kdc_log(context, config, 0, "PAC generation failed for -- %s",
2029 tpn);
2030 goto out;
2031 }
2032 if (p != NULL) {
2033 ret = _krb5_pac_sign(context, p, ticket->ticket.authtime,
2034 s4u2self_impersonated_client->entry.principal,
2035 ekey, &tkey_sign->key,
2036 &rspac);
2037 krb5_pac_free(context, p);
2038 if (ret) {
2039 kdc_log(context, config, 0, "PAC signing failed for -- %s",
2040 tpn);
2041 goto out;
2042 }
2043 }
2044 }
2045
2046 /*
2047 * Check that service doing the impersonating is
2048 * requesting a ticket to it-self.
2049 */
2050 ret = check_s4u2self(context, config, clientdb, client, sp);
2051 if (ret) {
2052 kdc_log(context, config, 0, "S4U2Self: %s is not allowed "
2053 "to impersonate to service "
2054 "(tried for user %s to service %s)",
2055 cpn, tpn, spn);
2056 goto out;
2057 }
2058
2059 /*
2060 * If the service isn't trusted for authentication to
2061 * delegation, remove the forward flag.
2062 */
2063
2064 if (client->entry.flags.trusted_for_delegation) {
2065 str = "[forwardable]";
2066 } else {
2067 b->kdc_options.forwardable = 0;
2068 str = "";
2069 }
2070 kdc_log(context, config, 0, "s4u2self %s impersonating %s to "
2071 "service %s %s", cpn, tpn, spn, str);
2072 }
2073 }
2074
2075 /*
2076 * Constrained delegation
2077 */
2078
2079 if (client != NULL
2080 && b->additional_tickets != NULL
2081 && b->additional_tickets->len != 0
2082 && b->kdc_options.enc_tkt_in_skey == 0)
2083 {
2084 int ad_signedpath = 0;
2085 Key *clientkey;
2086 Ticket *t;
2087
2088 /*
2089 * Require that the KDC have issued the service's krbtgt (not
2090 * self-issued ticket with kimpersonate(1).
2091 */
2092 if (!signedpath) {
2093 ret = KRB5KDC_ERR_BADOPTION;
2094 kdc_log(context, config, 0,
2095 "Constrained delegation done on service ticket %s/%s",
2096 cpn, spn);
2097 goto out;
2098 }
2099
2100 t = &b->additional_tickets->val[0];
2101
2102 ret = hdb_enctype2key(context, &client->entry,
2103 hdb_kvno2keys(context, &client->entry,
2104 t->enc_part.kvno ? * t->enc_part.kvno : 0),
2105 t->enc_part.etype, &clientkey);
2106 if(ret){
2107 ret = KRB5KDC_ERR_ETYPE_NOSUPP; /* XXX */
2108 goto out;
2109 }
2110
2111 ret = krb5_decrypt_ticket(context, t, &clientkey->key, &adtkt, 0);
2112 if (ret) {
2113 kdc_log(context, config, 0,
2114 "failed to decrypt ticket for "
2115 "constrained delegation from %s to %s ", cpn, spn);
2116 goto out;
2117 }
2118
2119 ret = _krb5_principalname2krb5_principal(context,
2120 &tp,
2121 adtkt.cname,
2122 adtkt.crealm);
2123 if (ret)
2124 goto out;
2125
2126 ret = krb5_unparse_name(context, tp, &tpn);
2127 if (ret)
2128 goto out;
2129
2130 ret = _krb5_principalname2krb5_principal(context,
2131 &dp,
2132 t->sname,
2133 t->realm);
2134 if (ret)
2135 goto out;
2136
2137 ret = krb5_unparse_name(context, dp, &dpn);
2138 if (ret)
2139 goto out;
2140
2141 /* check that ticket is valid */
2142 if (adtkt.flags.forwardable == 0) {
2143 kdc_log(context, config, 0,
2144 "Missing forwardable flag on ticket for "
2145 "constrained delegation from %s (%s) as %s to %s ",
2146 cpn, dpn, tpn, spn);
2147 ret = KRB5KDC_ERR_BADOPTION;
2148 goto out;
2149 }
2150
2151 ret = check_constrained_delegation(context, config, clientdb,
2152 client, server, sp);
2153 if (ret) {
2154 kdc_log(context, config, 0,
2155 "constrained delegation from %s (%s) as %s to %s not allowed",
2156 cpn, dpn, tpn, spn);
2157 goto out;
2158 }
2159
2160 ret = verify_flags(context, config, &adtkt, tpn);
2161 if (ret) {
2162 goto out;
2163 }
2164
2165 krb5_data_free(&rspac);
2166
2167 /*
2168 * generate the PAC for the user.
2169 *
2170 * TODO: pass in t->sname and t->realm and build
2171 * a S4U_DELEGATION_INFO blob to the PAC.
2172 */
2173 ret = check_PAC(context, config, tp, dp,
2174 client, server, krbtgt,
2175 &clientkey->key,
2176 ekey, &tkey_sign->key,
2177 &adtkt, &rspac, &ad_signedpath);
2178 if (ret) {
2179 const char *msg = krb5_get_error_message(context, ret);
2180 kdc_log(context, config, 0,
2181 "Verify delegated PAC failed to %s for client"
2182 "%s (%s) as %s from %s with %s",
2183 spn, cpn, dpn, tpn, from, msg);
2184 krb5_free_error_message(context, msg);
2185 goto out;
2186 }
2187
2188 /*
2189 * Check that the KDC issued the user's ticket.
2190 */
2191 ret = check_KRB5SignedPath(context,
2192 config,
2193 krbtgt,
2194 cp,
2195 &adtkt,
2196 NULL,
2197 &ad_signedpath);
2198 if (ret) {
2199 const char *msg = krb5_get_error_message(context, ret);
2200 kdc_log(context, config, 0,
2201 "KRB5SignedPath check from service %s failed "
2202 "for delegation to %s for client %s (%s)"
2203 "from %s failed with %s",
2204 spn, tpn, dpn, cpn, from, msg);
2205 krb5_free_error_message(context, msg);
2206 goto out;
2207 }
2208
2209 if (!ad_signedpath) {
2210 ret = KRB5KDC_ERR_BADOPTION;
2211 kdc_log(context, config, 0,
2212 "Ticket not signed with PAC nor SignedPath service %s failed "
2213 "for delegation to %s for client %s (%s)"
2214 "from %s",
2215 spn, tpn, dpn, cpn, from);
2216 goto out;
2217 }
2218
2219 kdc_log(context, config, 0, "constrained delegation for %s "
2220 "from %s (%s) to %s", tpn, cpn, dpn, spn);
2221 }
2222
2223 /*
2224 * Check flags
2225 */
2226
2227 ret = kdc_check_flags(context, config,
2228 client, cpn,
2229 server, spn,
2230 FALSE);
2231 if(ret)
2232 goto out;
2233
2234 if((b->kdc_options.validate || b->kdc_options.renew) &&
2235 !krb5_principal_compare(context,
2236 krbtgt->entry.principal,
2237 server->entry.principal)){
2238 kdc_log(context, config, 0, "Inconsistent request.");
2239 ret = KRB5KDC_ERR_SERVER_NOMATCH;
2240 goto out;
2241 }
2242
2243 /* check for valid set of addresses */
2244 if(!_kdc_check_addresses(context, config, tgt->caddr, from_addr)) {
2245 ret = KRB5KRB_AP_ERR_BADADDR;
2246 kdc_log(context, config, 0, "Request from wrong address");
2247 goto out;
2248 }
2249
2250 /*
2251 * If this is an referral, add server referral data to the
2252 * auth_data reply .
2253 */
2254 if (ref_realm) {
2255 PA_DATA pa;
2256 krb5_crypto crypto;
2257
2258 kdc_log(context, config, 0,
2259 "Adding server referral to %s", ref_realm);
2260
2261 ret = krb5_crypto_init(context, &sessionkey, 0, &crypto);
2262 if (ret)
2263 goto out;
2264
2265 ret = build_server_referral(context, config, crypto, ref_realm,
2266 NULL, s, &pa.padata_value);
2267 krb5_crypto_destroy(context, crypto);
2268 if (ret) {
2269 kdc_log(context, config, 0,
2270 "Failed building server referral");
2271 goto out;
2272 }
2273 pa.padata_type = KRB5_PADATA_SERVER_REFERRAL;
2274
2275 ret = add_METHOD_DATA(&enc_pa_data, &pa);
2276 krb5_data_free(&pa.padata_value);
2277 if (ret) {
2278 kdc_log(context, config, 0,
2279 "Add server referral METHOD-DATA failed");
2280 goto out;
2281 }
2282 }
2283
2284 /*
2285 *
2286 */
2287
2288 ret = tgs_make_reply(context,
2289 config,
2290 b,
2291 tp,
2292 tgt,
2293 replykey,
2294 rk_is_subkey,
2295 ekey,
2296 &sessionkey,
2297 kvno,
2298 *auth_data,
2299 server,
2300 rsp,
2301 spn,
2302 client,
2303 cp,
2304 krbtgt_out,
2305 tkey_sign->key.keytype,
2306 spp,
2307 &rspac,
2308 &enc_pa_data,
2309 e_text,
2310 reply);
2311
2312 out:
2313 if (tpn != cpn)
2314 free(tpn);
2315 free(spn);
2316 free(cpn);
2317 free(dpn);
2318 free(krbtgt_out_n);
2319
2320 krb5_data_free(&rspac);
2321 krb5_free_keyblock_contents(context, &sessionkey);
2322 if(krbtgt_out)
2323 _kdc_free_ent(context, krbtgt_out);
2324 if(server)
2325 _kdc_free_ent(context, server);
2326 if(client)
2327 _kdc_free_ent(context, client);
2328 if(s4u2self_impersonated_client)
2329 _kdc_free_ent(context, s4u2self_impersonated_client);
2330
2331 if (tp && tp != cp)
2332 krb5_free_principal(context, tp);
2333 krb5_free_principal(context, cp);
2334 krb5_free_principal(context, dp);
2335 krb5_free_principal(context, sp);
2336 krb5_free_principal(context, krbtgt_out_principal);
2337 if (ref_realm)
2338 free(ref_realm);
2339 free_METHOD_DATA(&enc_pa_data);
2340
2341 free_EncTicketPart(&adtkt);
2342
2343 return ret;
2344 }
2345
2346 /*
2347 *
2348 */
2349
2350 krb5_error_code
2351 _kdc_tgs_rep(krb5_context context,
2352 krb5_kdc_configuration *config,
2353 KDC_REQ *req,
2354 krb5_data *data,
2355 const char *from,
2356 struct sockaddr *from_addr,
2357 int datagram_reply)
2358 {
2359 AuthorizationData *auth_data = NULL;
2360 krb5_error_code ret;
2361 int i = 0;
2362 const PA_DATA *tgs_req;
2363
2364 hdb_entry_ex *krbtgt = NULL;
2365 krb5_ticket *ticket = NULL;
2366 const char *e_text = NULL;
2367 krb5_enctype krbtgt_etype = ETYPE_NULL;
2368
2369 krb5_keyblock *replykey = NULL;
2370 int rk_is_subkey = 0;
2371 time_t *csec = NULL;
2372 int *cusec = NULL;
2373
2374 if(req->padata == NULL){
2375 ret = KRB5KDC_ERR_PREAUTH_REQUIRED; /* XXX ??? */
2376 kdc_log(context, config, 0,
2377 "TGS-REQ from %s without PA-DATA", from);
2378 goto out;
2379 }
2380
2381 tgs_req = _kdc_find_padata(req, &i, KRB5_PADATA_TGS_REQ);
2382
2383 if(tgs_req == NULL){
2384 ret = KRB5KDC_ERR_PADATA_TYPE_NOSUPP;
2385
2386 kdc_log(context, config, 0,
2387 "TGS-REQ from %s without PA-TGS-REQ", from);
2388 goto out;
2389 }
2390 ret = tgs_parse_request(context, config,
2391 &req->req_body, tgs_req,
2392 &krbtgt,
2393 &krbtgt_etype,
2394 &ticket,
2395 &e_text,
2396 from, from_addr,
2397 &csec, &cusec,
2398 &auth_data,
2399 &replykey,
2400 &rk_is_subkey);
2401 if (ret == HDB_ERR_NOT_FOUND_HERE) {
2402 /* kdc_log() is called in tgs_parse_request() */
2403 goto out;
2404 }
2405 if (ret) {
2406 kdc_log(context, config, 0,
2407 "Failed parsing TGS-REQ from %s", from);
2408 goto out;
2409 }
2410
2411 {
2412 const PA_DATA *pa = _kdc_find_padata(req, &i, KRB5_PADATA_FX_FAST);
2413 if (pa)
2414 kdc_log(context, config, 10, "Got TGS FAST request");
2415 }
2416
2417
2418 ret = tgs_build_reply(context,
2419 config,
2420 req,
2421 &req->req_body,
2422 krbtgt,
2423 krbtgt_etype,
2424 replykey,
2425 rk_is_subkey,
2426 ticket,
2427 data,
2428 from,
2429 &e_text,
2430 &auth_data,
2431 from_addr);
2432 if (ret) {
2433 kdc_log(context, config, 0,
2434 "Failed building TGS-REP to %s", from);
2435 goto out;
2436 }
2437
2438 /* */
2439 if (datagram_reply && data->length > config->max_datagram_reply_length) {
2440 krb5_data_free(data);
2441 ret = KRB5KRB_ERR_RESPONSE_TOO_BIG;
2442 e_text = "Reply packet too large";
2443 }
2444
2445 out:
2446 if (replykey)
2447 krb5_free_keyblock(context, replykey);
2448
2449 if(ret && ret != HDB_ERR_NOT_FOUND_HERE && data->data == NULL){
2450 /* XXX add fast wrapping on the error */
2451 METHOD_DATA error_method = { 0, NULL };
2452
2453
2454 kdc_log(context, config, 10, "tgs-req: sending error: %d to client", ret);
2455 ret = _kdc_fast_mk_error(context, NULL,
2456 &error_method,
2457 NULL,
2458 NULL,
2459 ret, NULL,
2460 NULL, NULL,
2461 csec, cusec,
2462 data);
2463 free_METHOD_DATA(&error_method);
2464 }
2465 free(csec);
2466 free(cusec);
2467 if (ticket)
2468 krb5_free_ticket(context, ticket);
2469 if(krbtgt)
2470 _kdc_free_ent(context, krbtgt);
2471
2472 if (auth_data) {
2473 free_AuthorizationData(auth_data);
2474 free(auth_data);
2475 }
2476
2477 return ret;
2478 }
Heimdal