?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ctdb-scripts: Drop use of eval in CTDB callout handling
[samba.git] / third_party / heimdal / kdc / kerberos5.c
blobe95bdad0a640e9f93f9910aa124744a9229f4a01
1 /*
2 * Copyright (c) 1997-2007 Kungliga Tekniska Högskolan
3 * (Royal Institute of Technology, Stockholm, Sweden).
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * 3. Neither the name of the Institute nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34 #include "kdc_locl.h"
35
36 #ifdef TIME_T_SIGNED
37 #if SIZEOF_TIME_T == 4
38 #define MAX_TIME ((time_t)INT32_MAX)
39 #elif SIZEOF_TIME_T == 8
40 #define MAX_TIME ((time_t)INT64_MAX)
41 #else
42 #error "Unexpected sizeof(time_t)"
43 #endif
44 #else
45
46 #if SIZEOF_TIME_T == 4
47 #define MAX_TIME ((time_t)UINT32_MAX)
48 #else
49 #define MAX_TIME ((time_t)UINT64_MAX)
50 #endif
51 #endif
52
53 #undef __attribute__
54 #define __attribute__(X)
55
56 void
57 _kdc_fix_time(time_t **t)
58 {
59 if(*t == NULL){
60 ALLOC(*t);
61 **t = MAX_TIME;
62 }
63 if(**t == 0) **t = MAX_TIME; /* fix for old clients */
64 }
65
66 static int
67 realloc_method_data(METHOD_DATA *md)
68 {
69 PA_DATA *pa;
70 pa = realloc(md->val, (md->len + 1) * sizeof(*md->val));
71 if(pa == NULL)
72 return ENOMEM;
73 md->val = pa;
74 md->len++;
75 return 0;
76 }
77
78 static krb5_error_code
79 get_pa_etype_info2(krb5_context context,
80 krb5_kdc_configuration *config,
81 METHOD_DATA *md, Key *ckey,
82 krb5_boolean include_salt);
83
84 static krb5_error_code
85 set_salt_padata(krb5_context context,
86 krb5_kdc_configuration *config,
87 METHOD_DATA *md, Key *key)
88 {
89 if (!key->salt)
90 return 0;
91
92 return get_pa_etype_info2(context, config, md, key, TRUE);
93 }
94
95 const PA_DATA*
96 _kdc_find_padata(const KDC_REQ *req, int *start, int type)
97 {
98 if (req->padata == NULL)
99 return NULL;
100
101 while((size_t)*start < req->padata->len){
102 (*start)++;
103 if(req->padata->val[*start - 1].padata_type == (unsigned)type)
104 return &req->padata->val[*start - 1];
105 }
106 return NULL;
107 }
108
109 /*
110 * This is a hack to allow predefined weak services, like afs to
111 * still use weak types
112 */
113
114 krb5_boolean
115 _kdc_is_weak_exception(krb5_principal principal, krb5_enctype etype)
116 {
117 if (principal->name.name_string.len > 0 &&
118 strcmp(principal->name.name_string.val[0], "afs") == 0 &&
119 (etype == ETYPE_DES_CBC_CRC
120 || etype == ETYPE_DES_CBC_MD4
121 || etype == ETYPE_DES_CBC_MD5))
122 return TRUE;
123 return FALSE;
124 }
125
126
127 /*
128 * Detect if `key' is the using the the precomputed `default_salt'.
129 */
130
131 static krb5_boolean
132 is_default_salt_p(const krb5_salt *default_salt, const Key *key)
133 {
134 if (key->salt == NULL)
135 return TRUE;
136 if (default_salt->salttype != key->salt->type)
137 return FALSE;
138 if (krb5_data_cmp(&default_salt->saltvalue, &key->salt->salt) != 0)
139 return FALSE;
140 return TRUE;
141 }
142
143 /*
144 * Detect if `key' is the using the the precomputed `default_salt'
145 * (for des-cbc-crc) or any salt otherwise.
146 *
147 * This is for avoiding Kerberos v4 (yes really) keys in AS-REQ as
148 * that salt is strange, and a buggy client will try to use the
149 * principal as the salt and not the returned value.
150 */
151
152 static krb5_boolean
153 is_good_salt_p(const krb5_salt *default_salt, const Key *key)
154 {
155 if (key->key.keytype == KRB5_ENCTYPE_DES_CBC_CRC)
156 return is_default_salt_p(default_salt, key);
157
158 return TRUE;
159 }
160
161 krb5_boolean
162 _kdc_is_anon_request(const KDC_REQ *req)
163 {
164 const KDC_REQ_BODY *b = &req->req_body;
165
166 /*
167 * Versions of Heimdal from 0.9rc1 through 1.50 use bit 14 instead
168 * of 16 for request_anonymous, as indicated in the anonymous draft
169 * prior to version 11. Bit 14 is assigned to S4U2Proxy, but S4U2Proxy
170 * requests are only sent to the TGS and, in any case, would have an
171 * additional ticket present.
172 */
173 return b->kdc_options.request_anonymous ||
174 (b->kdc_options.cname_in_addl_tkt && !b->additional_tickets);
175 }
176
177 /*
178 * return the first appropriate key of `princ' in `ret_key'. Look for
179 * all the etypes in (`etypes', `len'), stopping as soon as we find
180 * one, but preferring one that has default salt.
181 *
182 * XXX This function does way way too much. Split it up!
183 *
184 * XXX `etypes' and `len' are always `b->etype.val' and `b->etype.len' -- the
185 * etype list from the KDC-REQ-BODY, which is available here as
186 * `r->req->req_body', so we could just stop having it passed in.
187 *
188 * XXX Picking an enctype(s) for PA-ETYPE-INFO* is rather different than
189 * picking an enctype for a ticket's session key. The former is what we do
190 * here when `(flags & KFE_IS_PREAUTH)', the latter otherwise.
191 */
192
193 krb5_error_code
194 _kdc_find_etype(astgs_request_t r, uint32_t flags,
195 krb5_enctype *etypes, unsigned len,
196 krb5_enctype *ret_enctype, Key **ret_key,
197 krb5_boolean *ret_default_salt)
198 {
199 krb5_boolean use_strongest_session_key;
200 krb5_boolean is_preauth = flags & KFE_IS_PREAUTH;
201 krb5_boolean is_tgs = flags & KFE_IS_TGS;
202 hdb_entry *princ;
203 krb5_principal request_princ;
204 krb5_error_code ret;
205 krb5_salt def_salt;
206 krb5_enctype enctype = ETYPE_NULL;
207 const krb5_enctype *p;
208 Key *key = NULL;
209 size_t i, k, m;
210
211 if (is_preauth && (flags & KFE_USE_CLIENT) &&
212 r->client->flags.synthetic)
213 return KRB5KDC_ERR_ETYPE_NOSUPP;
214
215 if ((flags & KFE_USE_CLIENT) && !r->client->flags.synthetic) {
216 princ = r->client;
217 request_princ = r->client_princ;
218 } else {
219 princ = r->server;
220 request_princ = r->server->principal;
221 }
222
223 use_strongest_session_key =
224 is_preauth ? r->config->preauth_use_strongest_session_key
225 : (is_tgs ? r->config->tgt_use_strongest_session_key :
226 r->config->svc_use_strongest_session_key);
227
228 /* We'll want to avoid keys with v4 salted keys in the pre-auth case... */
229 ret = krb5_get_pw_salt(r->context, request_princ, &def_salt);
230 if (ret)
231 return ret;
232
233 ret = KRB5KDC_ERR_ETYPE_NOSUPP;
234
235 /*
236 * Pick an enctype that is in the intersection of:
237 *
238 * - permitted_enctypes (local policy)
239 * - requested enctypes (KDC-REQ-BODY's etype list)
240 * - the client's long-term keys' enctypes
241 * OR
242 * the server's configured etype list
243 *
244 * There are two sub-cases:
245 *
246 * - use local enctype preference (local policy)
247 * - use the client's preference list
248 */
249
250 if (use_strongest_session_key) {
251 /*
252 * Pick the strongest key that the KDC, target service, and
253 * client all support, using the local cryptosystem enctype
254 * list in strongest-to-weakest order to drive the search.
255 *
256 * This is not what RFC4120 says to do, but it encourages
257 * adoption of stronger enctypes. This doesn't play well with
258 * clients that have multiple Kerberos client implementations
259 * with different supported enctype lists sharing the same ccache.
260 */
261
262 /* drive the search with local supported enctypes list */
263 p = krb5_kerberos_enctypes(r->context);
264 for (i = 0;
265 p[i] != ETYPE_NULL && enctype == ETYPE_NULL;
266 i++) {
267 if (krb5_enctype_valid(r->context, p[i]) != 0 &&
268 !_kdc_is_weak_exception(princ->principal, p[i]))
269 continue;
270
271 /* check that the client supports it too */
272 for (k = 0; k < len && enctype == ETYPE_NULL; k++) {
273
274 if (p[i] != etypes[k])
275 continue;
276
277 if (!is_preauth && (flags & KFE_USE_CLIENT)) {
278 /*
279 * It suffices that the client says it supports this
280 * enctype in its KDC-REQ-BODY's etype list, which is what
281 * `etypes' is here.
282 */
283 enctype = p[i];
284 ret = 0;
285 break;
286 }
287
288 /* check target princ support */
289 key = NULL;
290 if (!is_preauth && !(flags & KFE_USE_CLIENT) && princ->etypes) {
291 /*
292 * Use the etypes list from the server's HDB entry instead
293 * of deriving it from its long-term keys. This allows an
294 * entry to have just one long-term key but record support
295 * for multiple enctypes.
296 */
297 for (m = 0; m < princ->etypes->len; m++) {
298 if (p[i] == princ->etypes->val[m]) {
299 enctype = p[i];
300 ret = 0;
301 break;
302 }
303 }
304 } else {
305 /*
306 * Use the entry's long-term keys as the source of its
307 * supported enctypes, either because we're making
308 * PA-ETYPE-INFO* or because we're selecting a session key
309 * enctype.
310 */
311 while (hdb_next_enctype2key(r->context, princ, NULL,
312 p[i], &key) == 0) {
313 if (key->key.keyvalue.length == 0) {
314 ret = KRB5KDC_ERR_NULL_KEY;
315 continue;
316 }
317 enctype = p[i];
318 ret = 0;
319 if (is_preauth && ret_key != NULL &&
320 !is_good_salt_p(&def_salt, key))
321 continue;
322 }
323 }
324 }
325 }
326 } else {
327 /*
328 * Pick the first key from the client's enctype list that is
329 * supported by the cryptosystem and by the given principal.
330 *
331 * RFC4120 says we SHOULD pick the first _strong_ key from the
332 * client's list... not the first key... If the admin disallows
333 * weak enctypes in krb5.conf and selects this key selection
334 * algorithm, then we get exactly what RFC4120 says.
335 */
336 for(i = 0; ret != 0 && i < len; i++) {
337
338 if (krb5_enctype_valid(r->context, etypes[i]) != 0 &&
339 !_kdc_is_weak_exception(princ->principal, etypes[i]))
340 continue;
341
342 key = NULL;
343 while (ret != 0 &&
344 hdb_next_enctype2key(r->context, princ, NULL,
345 etypes[i], &key) == 0) {
346 if (key->key.keyvalue.length == 0) {
347 ret = KRB5KDC_ERR_NULL_KEY;
348 continue;
349 }
350 enctype = etypes[i];
351 ret = 0;
352 if (is_preauth && ret_key != NULL &&
353 !is_good_salt_p(&def_salt, key))
354 continue;
355 }
356 }
357 }
358
359 if (ret == 0 && enctype == ETYPE_NULL) {
360 /*
361 * if the service principal is one for which there is a known 1DES
362 * exception and no other enctype matches both the client request and
363 * the service key list, provide a DES-CBC-CRC key.
364 */
365 if (ret_key == NULL &&
366 _kdc_is_weak_exception(princ->principal, ETYPE_DES_CBC_CRC)) {
367 ret = 0;
368 enctype = ETYPE_DES_CBC_CRC;
369 } else {
370 ret = KRB5KDC_ERR_ETYPE_NOSUPP;
371 }
372 }
373
374 if (ret == 0) {
375 if (ret_enctype != NULL)
376 *ret_enctype = enctype;
377 if (ret_key != NULL)
378 *ret_key = key;
379 if (ret_default_salt != NULL)
380 *ret_default_salt = is_default_salt_p(&def_salt, key);
381 }
382
383 krb5_free_salt (r->context, def_salt);
384 return ret;
385 }
386
387 krb5_error_code
388 _kdc_make_anonymous_principalname (PrincipalName *pn)
389 {
390 pn->name_type = KRB5_NT_WELLKNOWN;
391 pn->name_string.len = 2;
392 pn->name_string.val = calloc(2, sizeof(*pn->name_string.val));
393 if (pn->name_string.val == NULL)
394 goto failed;
395
396 pn->name_string.val[0] = strdup(KRB5_WELLKNOWN_NAME);
397 if (pn->name_string.val[0] == NULL)
398 goto failed;
399
400 pn->name_string.val[1] = strdup(KRB5_ANON_NAME);
401 if (pn->name_string.val[1] == NULL)
402 goto failed;
403
404 return 0;
405
406 failed:
407 free_PrincipalName(pn);
408
409 pn->name_type = KRB5_NT_UNKNOWN;
410 pn->name_string.len = 0;
411 pn->name_string.val = NULL;
412
413 return ENOMEM;
414 }
415
416 static void
417 _kdc_r_log(astgs_request_t r, int level, const char *fmt, ...)
418 __attribute__ ((__format__ (__printf__, 3, 4)))
419 {
420 va_list ap;
421 char *s;
422 va_start(ap, fmt);
423 s = kdc_log_msg_va(r->context, r->config, level, fmt, ap);
424 if(s) free(s);
425 va_end(ap);
426 }
427
428 void
429 _kdc_set_const_e_text(astgs_request_t r, const char *e_text)
430 {
431 /* We should never see this */
432 if (r->e_text) {
433 kdc_log(r->context, r->config, 1,
434 "trying to replace e-text \"%s\" with \"%s\"\n",
435 r->e_text, e_text);
436 return;
437 }
438
439 r->e_text = e_text;
440 kdc_log(r->context, r->config, 4, "%s", e_text);
441 }
442
443 void
444 _kdc_set_e_text(astgs_request_t r, const char *fmt, ...)
445 __attribute__ ((__format__ (__printf__, 2, 3)))
446 {
447 va_list ap;
448 char *e_text = NULL;
449 int vasprintf_ret;
450
451 va_start(ap, fmt);
452 vasprintf_ret = vasprintf(&e_text, fmt, ap);
453 va_end(ap);
454
455 if (vasprintf_ret < 0 || !e_text) {
456 /* not much else to do... */
457 kdc_log(r->context, r->config, 1,
458 "Could not set e_text: %s (out of memory)", fmt);
459 return;
460 }
461
462 /* We should never see this */
463 if (r->e_text) {
464 kdc_log(r->context, r->config, 1, "trying to replace e-text: %s\n",
465 e_text);
466 free(e_text);
467 return;
468 }
469
470 r->e_text = e_text;
471 r->e_text_buf = e_text;
472 kdc_log(r->context, r->config, 4, "%s", e_text);
473 }
474
475 void
476 _kdc_log_timestamp(astgs_request_t r, const char *type,
477 KerberosTime authtime, KerberosTime *starttime,
478 KerberosTime endtime, KerberosTime *renew_till)
479 {
480 krb5_kdc_configuration *config = r->config;
481 char authtime_str[100], starttime_str[100],
482 endtime_str[100], renewtime_str[100];
483
484 if (authtime)
485 kdc_audit_setkv_number((kdc_request_t)r, "auth", authtime);
486 if (starttime && *starttime)
487 kdc_audit_setkv_number((kdc_request_t)r, "start", *starttime);
488 if (endtime)
489 kdc_audit_setkv_number((kdc_request_t)r, "end", endtime);
490 if (renew_till && *renew_till)
491 kdc_audit_setkv_number((kdc_request_t)r, "renew", *renew_till);
492
493 krb5_format_time(r->context, authtime,
494 authtime_str, sizeof(authtime_str), TRUE);
495 if (starttime)
496 krb5_format_time(r->context, *starttime,
497 starttime_str, sizeof(starttime_str), TRUE);
498 else
499 strlcpy(starttime_str, "unset", sizeof(starttime_str));
500 krb5_format_time(r->context, endtime,
501 endtime_str, sizeof(endtime_str), TRUE);
502 if (renew_till)
503 krb5_format_time(r->context, *renew_till,
504 renewtime_str, sizeof(renewtime_str), TRUE);
505 else
506 strlcpy(renewtime_str, "unset", sizeof(renewtime_str));
507
508 kdc_log(r->context, config, 4,
509 "%s authtime: %s starttime: %s endtime: %s renew till: %s",
510 type, authtime_str, starttime_str, endtime_str, renewtime_str);
511 }
512
513 /*
514 *
515 */
516
517 #ifdef PKINIT
518
519 static krb5_error_code
520 pa_pkinit_validate(astgs_request_t r, const PA_DATA *pa)
521 {
522 pk_client_params *pkp = NULL;
523 char *client_cert = NULL;
524 krb5_error_code ret;
525
526 ret = _kdc_pk_rd_padata(r, pa, &pkp);
527 if (ret || pkp == NULL) {
528 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
529 _kdc_r_log(r, 4, "Failed to decode PKINIT PA-DATA -- %s",
530 r->cname);
531 goto out;
532 }
533
534 ret = _kdc_pk_check_client(r, pkp, &client_cert);
535 if (client_cert)
536 kdc_audit_addkv((kdc_request_t)r, 0, KDC_REQUEST_KV_PKINIT_CLIENT_CERT,
537 "%s", client_cert);
538 if (ret) {
539 _kdc_set_e_text(r, "PKINIT certificate not allowed to "
540 "impersonate principal");
541 kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
542 KDC_AUTH_EVENT_CLIENT_NAME_UNAUTHORIZED);
543 goto out;
544 }
545
546 r->pa_endtime = _kdc_pk_endtime(pkp);
547 if (!r->client->flags.synthetic)
548 r->pa_max_life = _kdc_pk_max_life(pkp);
549
550 _kdc_r_log(r, 4, "PKINIT pre-authentication succeeded -- %s using %s",
551 r->cname, client_cert);
552
553 ret = _kdc_pk_mk_pa_reply(r, pkp);
554 if (ret) {
555 _kdc_set_e_text(r, "Failed to build PK-INIT reply");
556 goto out;
557 }
558 ret = _kdc_add_initial_verified_cas(r->context, r->config,
559 pkp, &r->et);
560
561 kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
562 KDC_AUTH_EVENT_PREAUTH_SUCCEEDED);
563
564 out:
565 if (pkp)
566 _kdc_pk_free_client_param(r->context, pkp);
567 free(client_cert);
568
569 return ret;
570 }
571
572 #endif /* PKINIT */
573
574 static krb5_error_code
575 pa_gss_validate(astgs_request_t r, const PA_DATA *pa)
576 {
577 gss_client_params *gcp = NULL;
578 char *client_name = NULL;
579 krb5_error_code ret;
580 int open = 0;
581
582 ret = _kdc_gss_rd_padata(r, pa, &gcp, &open);
583 if (ret && gcp == NULL)
584 return ret;
585
586 if (open) {
587 ret = _kdc_gss_check_client(r, gcp, &client_name);
588 if (client_name)
589 kdc_audit_addkv((kdc_request_t)r, 0, KDC_REQUEST_KV_GSS_INITIATOR,
590 "%s", client_name);
591 if (ret) {
592 _kdc_set_e_text(r, "GSS-API client not allowed to "
593 "impersonate principal");
594 kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
595 KDC_AUTH_EVENT_CLIENT_NAME_UNAUTHORIZED);
596 goto out;
597 }
598
599 r->pa_endtime = _kdc_gss_endtime(r, gcp);
600
601 _kdc_r_log(r, 4, "GSS pre-authentication succeeded -- %s using %s",
602 r->cname, client_name);
603 kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
604 KDC_AUTH_EVENT_PREAUTH_SUCCEEDED);
605
606 ret = _kdc_gss_mk_composite_name_ad(r, gcp);
607 if (ret) {
608 _kdc_set_e_text(r, "Failed to build GSS authorization data");
609 goto out;
610 }
611 }
612
613 ret = _kdc_gss_mk_pa_reply(r, gcp);
614 if (ret) {
615 if (ret != KRB5_KDC_ERR_MORE_PREAUTH_DATA_REQUIRED)
616 _kdc_set_e_text(r, "Failed to build GSS pre-authentication reply");
617 goto out;
618 }
619
620 ret = kdc_request_set_attribute((kdc_request_t)r,
621 HSTR("org.h5l.pa-gss-client-params"), gcp);
622 if (ret)
623 goto out;
624
625 out:
626 kdc_object_release(gcp);
627 free(client_name);
628
629 return ret;
630 }
631
632 static krb5_error_code
633 pa_gss_finalize_pac(astgs_request_t r)
634 {
635 gss_client_params *gcp;
636
637 gcp = kdc_request_get_attribute((kdc_request_t)r, HSTR("org.h5l.pa-gss-client-params"));
638
639 heim_assert(gcp != NULL, "invalid GSS-API client params");
640
641 return _kdc_gss_finalize_pac(r, gcp);
642 }
643
644 static krb5_error_code
645 pa_enc_chal_validate(astgs_request_t r, const PA_DATA *pa)
646 {
647 krb5_data pepper1, pepper2;
648 int invalidPassword = 0;
649 EncryptedData enc_data;
650 krb5_enctype aenctype;
651 krb5_error_code ret;
652 struct Key *k;
653 size_t size;
654 int i;
655
656 heim_assert(r->armor_crypto != NULL, "ENC-CHAL called for non FAST");
657
658 if (_kdc_is_anon_request(&r->req)) {
659 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
660 kdc_log(r->context, r->config, 4, "ENC-CHALL doesn't support anon");
661 return ret;
662 }
663
664 if (r->client->flags.locked_out) {
665 ret = KRB5KDC_ERR_CLIENT_REVOKED;
666 kdc_log(r->context, r->config, 0,
667 "Client (%s) is locked out", r->cname);
668 kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
669 KDC_AUTH_EVENT_CLIENT_LOCKED_OUT);
670 return ret;
671 }
672
673 ret = decode_EncryptedData(pa->padata_value.data,
674 pa->padata_value.length,
675 &enc_data,
676 &size);
677 if (ret) {
678 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
679 _kdc_r_log(r, 4, "Failed to decode PA-DATA -- %s",
680 r->cname);
681 return ret;
682 }
683
684 pepper1.data = "clientchallengearmor";
685 pepper1.length = strlen(pepper1.data);
686 pepper2.data = "challengelongterm";
687 pepper2.length = strlen(pepper2.data);
688
689 krb5_crypto_getenctype(r->context, r->armor_crypto, &aenctype);
690
691 kdc_log(r->context, r->config, 5, "FAST armor enctype is: %d", (int)aenctype);
692
693 for (i = 0; i < r->client->keys.len; i++) {
694 krb5_crypto challengecrypto, longtermcrypto;
695 krb5_keyblock challengekey;
696
697 k = &r->client->keys.val[i];
698
699 ret = krb5_crypto_init(r->context, &k->key, 0, &longtermcrypto);
700 if (ret)
701 continue;
702
703 ret = krb5_crypto_fx_cf2(r->context, r->armor_crypto, longtermcrypto,
704 &pepper1, &pepper2, aenctype,
705 &challengekey);
706 if (ret) {
707 krb5_crypto_destroy(r->context, longtermcrypto);
708 continue;
709 }
710
711 ret = krb5_crypto_init(r->context, &challengekey, 0,
712 &challengecrypto);
713 krb5_free_keyblock_contents(r->context, &challengekey);
714 if (ret) {
715 krb5_crypto_destroy(r->context, longtermcrypto);
716 continue;
717 }
718
719 ret = _krb5_validate_pa_enc_challenge(r->context,
720 challengecrypto,
721 KRB5_KU_ENC_CHALLENGE_CLIENT,
722 &enc_data,
723 r->cname);
724 krb5_crypto_destroy(r->context, challengecrypto);
725 if (ret) {
726 const char *msg;
727 krb5_error_code ret2;
728 char *str = NULL;
729
730 krb5_crypto_destroy(r->context, longtermcrypto);
731
732 invalidPassword = (ret == KRB5KRB_AP_ERR_BAD_INTEGRITY);
733 if (!invalidPassword) {
734 goto out;
735 }
736
737 ret2 = krb5_enctype_to_string(r->context, k->key.keytype, &str);
738 if (ret2)
739 str = NULL;
740 msg = krb5_get_error_message(r->context, ret);
741 _kdc_r_log(r, 2, "Failed to decrypt ENC-CHAL -- %s "
742 "(enctype %s) error %s",
743 r->cname, str ? str : "unknown enctype", msg);
744 krb5_free_error_message(r->context, msg);
745 free(str);
746
747 continue;
748 }
749
750 /*
751 * Found a key that the client used, lets pick that as the reply key
752 */
753
754 krb5_free_keyblock_contents(r->context, &r->reply_key);
755 ret = krb5_copy_keyblock_contents(r->context, &k->key, &r->reply_key);
756 if (ret) {
757 krb5_crypto_destroy(r->context, longtermcrypto);
758 goto out;
759 }
760
761 krb5_free_keyblock_contents(r->context, &challengekey);
762
763 /*
764 * Provide KDC authentication to the client, uses a different
765 * challenge key (different pepper).
766 */
767
768 pepper1.data = "kdcchallengearmor";
769 pepper1.length = strlen(pepper1.data);
770
771 ret = krb5_crypto_fx_cf2(r->context, r->armor_crypto, longtermcrypto,
772 &pepper1, &pepper2, aenctype,
773 &challengekey);
774 krb5_crypto_destroy(r->context, longtermcrypto);
775 if (ret)
776 goto out;
777
778 ret = krb5_crypto_init(r->context, &challengekey, 0, &challengecrypto);
779 krb5_free_keyblock_contents(r->context, &challengekey);
780 if (ret)
781 goto out;
782
783 ret = _krb5_make_pa_enc_challenge(r->context, challengecrypto,
784 KRB5_KU_ENC_CHALLENGE_KDC,
785 r->rep.padata);
786 krb5_crypto_destroy(r->context, challengecrypto);
787 if (ret)
788 goto out;
789
790 if (ret == 0)
791 ret = set_salt_padata(r->context, r->config,
792 r->rep.padata, k);
793
794 /*
795 * Success
796 */
797 kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
798 KDC_AUTH_EVENT_VALIDATED_LONG_TERM_KEY);
799 goto out;
800 }
801
802 if (invalidPassword) {
803 kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
804 KDC_AUTH_EVENT_WRONG_LONG_TERM_KEY);
805 ret = KRB5KDC_ERR_PREAUTH_FAILED;
806 } else {
807 ret = KRB5KDC_ERR_ETYPE_NOSUPP;
808 }
809 out:
810 free_EncryptedData(&enc_data);
811
812 return ret;
813 }
814
815 static krb5_error_code
816 pa_enc_ts_validate(astgs_request_t r, const PA_DATA *pa)
817 {
818 EncryptedData enc_data;
819 krb5_error_code ret;
820 krb5_crypto crypto;
821 krb5_data ts_data;
822 PA_ENC_TS_ENC p;
823 size_t len;
824 Key *pa_key;
825 char *str;
826
827 if (r->armor_crypto && !r->config->enable_armored_pa_enc_timestamp) {
828 ret = KRB5KDC_ERR_POLICY;
829 kdc_log(r->context, r->config, 0,
830 "Armored encrypted timestamp pre-authentication is disabled");
831 return ret;
832 } else if (!r->armor_crypto && !r->config->enable_unarmored_pa_enc_timestamp) {
833 ret = KRB5KDC_ERR_POLICY;
834 kdc_log(r->context, r->config, 0,
835 "Unarmored encrypted timestamp pre-authentication is disabled");
836 return ret;
837 }
838
839 if (r->client->flags.locked_out) {
840 ret = KRB5KDC_ERR_CLIENT_REVOKED;
841 kdc_log(r->context, r->config, 0,
842 "Client (%s) is locked out", r->cname);
843 kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
844 KDC_AUTH_EVENT_CLIENT_LOCKED_OUT);
845 return ret;
846 }
847
848 ret = decode_EncryptedData(pa->padata_value.data,
849 pa->padata_value.length,
850 &enc_data,
851 &len);
852 if (ret) {
853 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
854 _kdc_r_log(r, 4, "Failed to decode PA-DATA -- %s",
855 r->cname);
856 goto out;
857 }
858
859 ret = hdb_enctype2key(r->context, r->client, NULL,
860 enc_data.etype, &pa_key);
861 if(ret){
862 char *estr;
863 _kdc_set_e_text(r, "No key matching entype");
864 ret = KRB5KDC_ERR_ETYPE_NOSUPP;
865 if(krb5_enctype_to_string(r->context, enc_data.etype, &estr))
866 estr = NULL;
867 if(estr == NULL)
868 _kdc_r_log(r, 4,
869 "No client key matching pa-data (%d) -- %s",
870 enc_data.etype, r->cname);
871 else
872 _kdc_r_log(r, 4,
873 "No client key matching pa-data (%s) -- %s",
874 estr, r->cname);
875 free(estr);
876 free_EncryptedData(&enc_data);
877 goto out;
878 }
879
880 try_next_key:
881 ret = krb5_crypto_init(r->context, &pa_key->key, 0, &crypto);
882 if (ret) {
883 const char *msg = krb5_get_error_message(r->context, ret);
884 _kdc_r_log(r, 4, "krb5_crypto_init failed: %s", msg);
885 krb5_free_error_message(r->context, msg);
886 free_EncryptedData(&enc_data);
887 goto out;
888 }
889
890 ret = krb5_decrypt_EncryptedData (r->context,
891 crypto,
892 KRB5_KU_PA_ENC_TIMESTAMP,
893 &enc_data,
894 &ts_data);
895 krb5_crypto_destroy(r->context, crypto);
896 /*
897 * Since the user might have several keys with the same
898 * enctype but with diffrent salting, we need to try all
899 * the keys with the same enctype.
900 */
901 if(ret){
902 krb5_error_code ret2;
903 const char *msg = krb5_get_error_message(r->context, ret);
904
905 ret2 = krb5_enctype_to_string(r->context,
906 pa_key->key.keytype, &str);
907 if (ret2)
908 str = NULL;
909 _kdc_r_log(r, 2, "Failed to decrypt PA-DATA -- %s "
910 "(enctype %s) error %s",
911 r->cname, str ? str : "unknown enctype", msg);
912 krb5_xfree(str);
913 krb5_free_error_message(r->context, msg);
914 kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_PA_ETYPE,
915 pa_key->key.keytype);
916 kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
917 KDC_AUTH_EVENT_WRONG_LONG_TERM_KEY);
918 if(hdb_next_enctype2key(r->context, r->client, NULL,
919 enc_data.etype, &pa_key) == 0)
920 goto try_next_key;
921
922 free_EncryptedData(&enc_data);
923
924 ret = KRB5KDC_ERR_PREAUTH_FAILED;
925 goto out;
926 }
927 free_EncryptedData(&enc_data);
928 ret = decode_PA_ENC_TS_ENC(ts_data.data,
929 ts_data.length,
930 &p,
931 &len);
932 krb5_data_free(&ts_data);
933 if(ret){
934 ret = KRB5KDC_ERR_PREAUTH_FAILED;
935 _kdc_r_log(r, 4, "Failed to decode PA-ENC-TS_ENC -- %s",
936 r->cname);
937 goto out;
938 }
939 if (labs(kdc_time - p.patimestamp) > r->context->max_skew) {
940 char client_time[100];
941
942 krb5_format_time(r->context, p.patimestamp,
943 client_time, sizeof(client_time), TRUE);
944
945 ret = KRB5KRB_AP_ERR_SKEW;
946 _kdc_r_log(r, 4, "Too large time skew, "
947 "client time %s is out by %u > %u seconds -- %s",
948 client_time,
949 (unsigned)labs(kdc_time - p.patimestamp),
950 r->context->max_skew,
951 r->cname);
952 kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
953 KDC_AUTH_EVENT_CLIENT_TIME_SKEW);
954
955 /*
956 * The following is needed to make windows clients to
957 * retry using the timestamp in the error message, if
958 * there is a e_text, they become unhappy.
959 */
960 r->e_text = NULL;
961 free_PA_ENC_TS_ENC(&p);
962 goto out;
963 }
964 free_PA_ENC_TS_ENC(&p);
965
966 ret = set_salt_padata(r->context, r->config,
967 r->rep.padata, pa_key);
968 if (ret == 0)
969 ret = krb5_copy_keyblock_contents(r->context, &pa_key->key, &r->reply_key);
970 if (ret)
971 return ret;
972
973 ret = krb5_enctype_to_string(r->context, pa_key->key.keytype, &str);
974 if (ret)
975 str = NULL;
976 _kdc_r_log(r, 4, "ENC-TS Pre-authentication succeeded -- %s using %s",
977 r->cname, str ? str : "unknown enctype");
978 krb5_xfree(str);
979 kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_PA_ETYPE,
980 pa_key->key.keytype);
981 kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
982 KDC_AUTH_EVENT_VALIDATED_LONG_TERM_KEY);
983
984 ret = 0;
985
986 out:
987
988 return ret;
989 }
990
991 struct kdc_patypes {
992 int type;
993 char *name;
994 unsigned int flags;
995 #define PA_ANNOUNCE 1
996 #define PA_REQ_FAST 2 /* only use inside fast */
997 #define PA_SYNTHETIC_OK 4
998 #define PA_REPLACE_REPLY_KEY 8 /* PA mech replaces reply key */
999 #define PA_USES_LONG_TERM_KEY 16 /* PA mech uses client's long-term key */
1000 krb5_error_code (*validate)(astgs_request_t, const PA_DATA *pa);
1001 krb5_error_code (*finalize_pac)(astgs_request_t r);
1002 void (*cleanup)(astgs_request_t r);
1003 };
1004
1005 static const struct kdc_patypes pat[] = {
1006 #ifdef PKINIT
1007 {
1008 KRB5_PADATA_PK_AS_REQ, "PK-INIT(ietf)",
1009 PA_ANNOUNCE | PA_SYNTHETIC_OK | PA_REPLACE_REPLY_KEY,
1010 pa_pkinit_validate, NULL, NULL
1011 },
1012 {
1013 KRB5_PADATA_PK_AS_REQ_WIN, "PK-INIT(win2k)", PA_ANNOUNCE | PA_REPLACE_REPLY_KEY,
1014 pa_pkinit_validate, NULL, NULL
1015 },
1016 {
1017 KRB5_PADATA_PKINIT_KX, "Anonymous PK-INIT", PA_ANNOUNCE,
1018 NULL, NULL, NULL
1019 },
1020 #else
1021 { KRB5_PADATA_PK_AS_REQ, "PK-INIT(ietf)", 0, NULL , NULL, NULL },
1022 { KRB5_PADATA_PK_AS_REQ_WIN, "PK-INIT(win2k)", 0, NULL, NULL, NULL },
1023 { KRB5_PADATA_PKINIT_KX, "Anonymous PK-INIT", 0, NULL, NULL, NULL },
1024 #endif
1025 { KRB5_PADATA_PA_PK_OCSP_RESPONSE , "OCSP", 0, NULL, NULL, NULL },
1026 {
1027 KRB5_PADATA_ENC_TIMESTAMP , "ENC-TS",
1028 PA_ANNOUNCE | PA_USES_LONG_TERM_KEY,
1029 pa_enc_ts_validate, NULL, NULL
1030 },
1031 {
1032 KRB5_PADATA_ENCRYPTED_CHALLENGE , "ENC-CHAL",
1033 PA_ANNOUNCE | PA_USES_LONG_TERM_KEY | PA_REQ_FAST,
1034 pa_enc_chal_validate, NULL, NULL
1035 },
1036 { KRB5_PADATA_REQ_ENC_PA_REP , "REQ-ENC-PA-REP", 0, NULL, NULL, NULL },
1037 { KRB5_PADATA_FX_FAST, "FX-FAST", PA_ANNOUNCE, NULL, NULL, NULL },
1038 { KRB5_PADATA_FX_ERROR, "FX-ERROR", 0, NULL, NULL, NULL },
1039 { KRB5_PADATA_FX_COOKIE, "FX-COOKIE", 0, NULL, NULL, NULL },
1040 {
1041 KRB5_PADATA_GSS , "GSS",
1042 PA_ANNOUNCE | PA_SYNTHETIC_OK | PA_REPLACE_REPLY_KEY,
1043 pa_gss_validate, pa_gss_finalize_pac, NULL
1044 },
1045 };
1046
1047 static void
1048 log_patypes(astgs_request_t r, METHOD_DATA *padata)
1049 {
1050 krb5_kdc_configuration *config = r->config;
1051 struct rk_strpool *p = NULL;
1052 char *str;
1053 size_t n, m;
1054
1055 for (n = 0; n < padata->len; n++) {
1056 for (m = 0; m < sizeof(pat) / sizeof(pat[0]); m++) {
1057 if (padata->val[n].padata_type == pat[m].type) {
1058 p = rk_strpoolprintf(p, "%s", pat[m].name);
1059 break;
1060 }
1061 }
1062 if (m == sizeof(pat) / sizeof(pat[0]))
1063 p = rk_strpoolprintf(p, "%d", padata->val[n].padata_type);
1064 if (p && n + 1 < padata->len)
1065 p = rk_strpoolprintf(p, ", ");
1066 if (p == NULL) {
1067 kdc_log(r->context, config, 1, "out of memory");
1068 return;
1069 }
1070 }
1071 if (p == NULL)
1072 p = rk_strpoolprintf(p, "none");
1073
1074 str = rk_strpoolcollect(p);
1075 kdc_log(r->context, config, 4, "Client sent patypes: %s", str);
1076 kdc_audit_addkv((kdc_request_t)r, KDC_AUDIT_EATWHITE,
1077 "client-pa", "%s", str);
1078 free(str);
1079 }
1080
1081 static krb5_boolean
1082 pa_used_flag_isset(astgs_request_t r, unsigned int flag)
1083 {
1084 if (r->pa_used == NULL)
1085 return FALSE;
1086
1087 return (r->pa_used->flags & flag) == flag;
1088 }
1089
1090 /*
1091 *
1092 */
1093
1094 krb5_error_code
1095 _kdc_encode_reply(krb5_context context,
1096 krb5_kdc_configuration *config,
1097 astgs_request_t r, uint32_t nonce,
1098 krb5_enctype etype,
1099 int skvno, const EncryptionKey *skey,
1100 int ckvno,
1101 int rk_is_subkey,
1102 krb5_data *reply)
1103 {
1104 unsigned char *buf;
1105 size_t buf_size;
1106 size_t len = 0;
1107 krb5_error_code ret;
1108 krb5_crypto crypto;
1109 KDC_REP *rep = &r->rep;
1110 EncTicketPart *et = &r->et;
1111 EncKDCRepPart *ek = &r->ek;
1112
1113 heim_assert(rep->padata != NULL, "reply padata uninitialized");
1114
1115 ASN1_MALLOC_ENCODE(EncTicketPart, buf, buf_size, et, &len, ret);
1116 if(ret) {
1117 const char *msg = krb5_get_error_message(context, ret);
1118 kdc_log(context, config, 4, "Failed to encode ticket: %s", msg);
1119 krb5_free_error_message(context, msg);
1120 return ret;
1121 }
1122 if(buf_size != len)
1123 krb5_abortx(context, "Internal error in ASN.1 encoder");
1124
1125 ret = krb5_crypto_init(context, skey, etype, &crypto);
1126 if (ret) {
1127 const char *msg = krb5_get_error_message(context, ret);
1128 kdc_log(context, config, 4, "krb5_crypto_init failed: %s", msg);
1129 krb5_free_error_message(context, msg);
1130 free(buf);
1131 return ret;
1132 }
1133
1134 ret = krb5_encrypt_EncryptedData(context,
1135 crypto,
1136 KRB5_KU_TICKET,
1137 buf,
1138 len,
1139 skvno,
1140 &rep->ticket.enc_part);
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, "Failed to encrypt data: %s", msg);
1146 krb5_free_error_message(context, msg);
1147 return ret;
1148 }
1149
1150 if (r && r->armor_crypto) {
1151 KrbFastFinished finished;
1152 krb5_data data;
1153
1154 kdc_log(context, config, 4, "FAST armor protection");
1155
1156 memset(&finished, 0, sizeof(finished));
1157 krb5_data_zero(&data);
1158
1159 finished.timestamp = kdc_time;
1160 finished.usec = 0;
1161 finished.crealm = et->crealm;
1162 finished.cname = et->cname;
1163
1164 ASN1_MALLOC_ENCODE(Ticket, data.data, data.length,
1165 &rep->ticket, &len, ret);
1166 if (ret)
1167 return ret;
1168 if (data.length != len)
1169 krb5_abortx(context, "internal asn.1 error");
1170
1171 ret = krb5_create_checksum(context, r->armor_crypto,
1172 KRB5_KU_FAST_FINISHED, 0,
1173 data.data, data.length,
1174 &finished.ticket_checksum);
1175 krb5_data_free(&data);
1176 if (ret)
1177 return ret;
1178
1179 ret = _kdc_fast_mk_response(context, r->armor_crypto,
1180 rep->padata, &r->strengthen_key, &finished,
1181 nonce, &data);
1182 free_Checksum(&finished.ticket_checksum);
1183 if (ret)
1184 return ret;
1185
1186 free_METHOD_DATA(r->rep.padata);
1187
1188 ret = krb5_padata_add(context, rep->padata,
1189 KRB5_PADATA_FX_FAST,
1190 data.data, data.length);
1191 if (ret)
1192 return ret;
1193
1194 /*
1195 * Hide client name for privacy reasons
1196 */
1197 if (r->fast.flags.requested_hidden_names) {
1198 Realm anon_realm = KRB5_ANON_REALM;
1199
1200 free_Realm(&rep->crealm);
1201 ret = copy_Realm(&anon_realm, &rep->crealm);
1202 if (ret == 0) {
1203 free_PrincipalName(&rep->cname);
1204 ret = _kdc_make_anonymous_principalname(&rep->cname);
1205 }
1206 if (ret)
1207 return ret;
1208 }
1209 }
1210
1211 if (rep->padata->len == 0) {
1212 free_METHOD_DATA(rep->padata);
1213 free(rep->padata);
1214 rep->padata = NULL;
1215 }
1216
1217 if(rep->msg_type == krb_as_rep && !config->encode_as_rep_as_tgs_rep)
1218 ASN1_MALLOC_ENCODE(EncASRepPart, buf, buf_size, ek, &len, ret);
1219 else
1220 ASN1_MALLOC_ENCODE(EncTGSRepPart, buf, buf_size, ek, &len, ret);
1221 if(ret) {
1222 const char *msg = krb5_get_error_message(context, ret);
1223 kdc_log(context, config, 4, "Failed to encode KDC-REP: %s", msg);
1224 krb5_free_error_message(context, msg);
1225 return ret;
1226 }
1227 if(buf_size != len) {
1228 free(buf);
1229 kdc_log(context, config, 4, "Internal error in ASN.1 encoder");
1230 _kdc_set_e_text(r, "KDC internal error");
1231 return KRB5KRB_ERR_GENERIC;
1232 }
1233 ret = krb5_crypto_init(context, &r->reply_key, 0, &crypto);
1234 if (ret) {
1235 const char *msg = krb5_get_error_message(context, ret);
1236 free(buf);
1237 kdc_log(context, config, 4, "krb5_crypto_init failed: %s", msg);
1238 krb5_free_error_message(context, msg);
1239 return ret;
1240 }
1241 if(rep->msg_type == krb_as_rep) {
1242 ret = krb5_encrypt_EncryptedData(context,
1243 crypto,
1244 KRB5_KU_AS_REP_ENC_PART,
1245 buf,
1246 len,
1247 ckvno,
1248 &rep->enc_part);
1249 free(buf);
1250 if (ret == 0)
1251 ASN1_MALLOC_ENCODE(AS_REP, buf, buf_size, rep, &len, ret);
1252 } else {
1253 ret = krb5_encrypt_EncryptedData(context,
1254 crypto,
1255 rk_is_subkey ?
1256 KRB5_KU_TGS_REP_ENC_PART_SUB_KEY :
1257 KRB5_KU_TGS_REP_ENC_PART_SESSION,
1258 buf,
1259 len,
1260 ckvno,
1261 &rep->enc_part);
1262 free(buf);
1263 if (ret == 0)
1264 ASN1_MALLOC_ENCODE(TGS_REP, buf, buf_size, rep, &len, ret);
1265 }
1266 krb5_crypto_destroy(context, crypto);
1267 if(ret) {
1268 const char *msg = krb5_get_error_message(context, ret);
1269 kdc_log(context, config, 4, "Failed to encode KDC-REP: %s", msg);
1270 krb5_free_error_message(context, msg);
1271 return ret;
1272 }
1273 if(buf_size != len) {
1274 free(buf);
1275 kdc_log(context, config, 4, "Internal error in ASN.1 encoder");
1276 _kdc_set_e_text(r, "KDC internal error");
1277 return KRB5KRB_ERR_GENERIC;
1278 }
1279 reply->data = buf;
1280 reply->length = buf_size;
1281 return 0;
1282 }
1283
1284 /*
1285 *
1286 */
1287
1288 static krb5_error_code
1289 get_pa_etype_info(krb5_context context,
1290 krb5_kdc_configuration *config,
1291 METHOD_DATA *md, Key *ckey,
1292 krb5_boolean include_salt)
1293 {
1294 krb5_error_code ret = 0;
1295 ETYPE_INFO_ENTRY eie; /* do not free this one */
1296 ETYPE_INFO ei;
1297 PA_DATA pa;
1298 size_t len;
1299
1300 /*
1301 * Code moved here from what used to be make_etype_info_entry() because
1302 * using the ASN.1 compiler-generated SEQUENCE OF add functions makes that
1303 * old function's body and this one's small and clean.
1304 *
1305 * The following comment blocks were there:
1306 *
1307 * According to `the specs', we can't send a salt if we have AFS3 salted
1308 * key, but that requires that you *know* what cell you are using (e.g by
1309 * assuming that the cell is the same as the realm in lower case)
1310 *
1311 * We shouldn't sent salttype since it is incompatible with the
1312 * specification and it breaks windows clients. The afs salting problem
1313 * is solved by using KRB5-PADATA-AFS3-SALT implemented in Heimdal 0.7 and
1314 * later.
1315 *
1316 * We return no salt type at all, as that should indicate the default salt
1317 * type and make everybody happy. some systems (like w2k) dislike being
1318 * told the salt type here.
1319 */
1320
1321 pa.padata_type = KRB5_PADATA_ETYPE_INFO;
1322 pa.padata_value.data = NULL;
1323 pa.padata_value.length = 0;
1324 ei.len = 0;
1325 ei.val = NULL;
1326 eie.etype = ckey->key.keytype;
1327 eie.salttype = NULL;
1328 eie.salt = NULL;
1329 if (include_salt && ckey->salt)
1330 eie.salt = &ckey->salt->salt;
1331 ret = add_ETYPE_INFO(&ei, &eie);
1332 if (ret == 0)
1333 ASN1_MALLOC_ENCODE(ETYPE_INFO, pa.padata_value.data, pa.padata_value.length,
1334 &ei, &len, ret);
1335 if (ret == 0)
1336 add_METHOD_DATA(md, &pa);
1337 free_ETYPE_INFO(&ei);
1338 free_PA_DATA(&pa);
1339 return ret;
1340 }
1341
1342 /*
1343 *
1344 */
1345
1346 extern int _krb5_AES_SHA1_string_to_default_iterator;
1347 extern int _krb5_AES_SHA2_string_to_default_iterator;
1348
1349 static krb5_error_code
1350 make_s2kparams(int value, size_t len, krb5_data **ps2kparams)
1351 {
1352 krb5_data *s2kparams;
1353 krb5_error_code ret;
1354
1355 ALLOC(s2kparams);
1356 if (s2kparams == NULL)
1357 return ENOMEM;
1358 ret = krb5_data_alloc(s2kparams, len);
1359 if (ret) {
1360 free(s2kparams);
1361 return ret;
1362 }
1363 _krb5_put_int(s2kparams->data, value, len);
1364 *ps2kparams = s2kparams;
1365 return 0;
1366 }
1367
1368 static krb5_error_code
1369 make_etype_info2_entry(ETYPE_INFO2_ENTRY *ent,
1370 Key *key,
1371 krb5_boolean include_salt)
1372 {
1373 krb5_error_code ret;
1374
1375 ent->etype = key->key.keytype;
1376 if (key->salt && include_salt) {
1377 ALLOC(ent->salt);
1378 if (ent->salt == NULL)
1379 return ENOMEM;
1380 *ent->salt = malloc(key->salt->salt.length + 1);
1381 if (*ent->salt == NULL) {
1382 free(ent->salt);
1383 ent->salt = NULL;
1384 return ENOMEM;
1385 }
1386 memcpy(*ent->salt, key->salt->salt.data, key->salt->salt.length);
1387 (*ent->salt)[key->salt->salt.length] = '\0';
1388 } else
1389 ent->salt = NULL;
1390
1391 ent->s2kparams = NULL;
1392
1393 switch (key->key.keytype) {
1394 case ETYPE_AES128_CTS_HMAC_SHA1_96:
1395 case ETYPE_AES256_CTS_HMAC_SHA1_96:
1396 ret = make_s2kparams(_krb5_AES_SHA1_string_to_default_iterator,
1397 4, &ent->s2kparams);
1398 break;
1399 case KRB5_ENCTYPE_AES128_CTS_HMAC_SHA256_128:
1400 case KRB5_ENCTYPE_AES256_CTS_HMAC_SHA384_192:
1401 ret = make_s2kparams(_krb5_AES_SHA2_string_to_default_iterator,
1402 4, &ent->s2kparams);
1403 break;
1404 case ETYPE_DES_CBC_CRC:
1405 case ETYPE_DES_CBC_MD4:
1406 case ETYPE_DES_CBC_MD5:
1407 /* Check if this was a AFS3 salted key */
1408 if(key->salt && key->salt->type == hdb_afs3_salt)
1409 ret = make_s2kparams(1, 1, &ent->s2kparams);
1410 else
1411 ret = 0;
1412 break;
1413 default:
1414 ret = 0;
1415 break;
1416 }
1417 return ret;
1418 }
1419
1420 /*
1421 * Return an ETYPE-INFO2. Enctypes are storted the same way as in the
1422 * database (client supported enctypes first, then the unsupported
1423 * enctypes).
1424 */
1425
1426 static krb5_error_code
1427 get_pa_etype_info2(krb5_context context,
1428 krb5_kdc_configuration *config,
1429 METHOD_DATA *md, Key *ckey,
1430 krb5_boolean include_salt)
1431 {
1432 krb5_error_code ret = 0;
1433 ETYPE_INFO2 pa;
1434 unsigned char *buf;
1435 size_t len;
1436
1437 pa.len = 1;
1438 pa.val = calloc(1, sizeof(pa.val[0]));
1439 if(pa.val == NULL)
1440 return ENOMEM;
1441
1442 ret = make_etype_info2_entry(&pa.val[0], ckey, include_salt);
1443 if (ret) {
1444 free_ETYPE_INFO2(&pa);
1445 return ret;
1446 }
1447
1448 ASN1_MALLOC_ENCODE(ETYPE_INFO2, buf, len, &pa, &len, ret);
1449 free_ETYPE_INFO2(&pa);
1450 if(ret)
1451 return ret;
1452 ret = realloc_method_data(md);
1453 if(ret) {
1454 free(buf);
1455 return ret;
1456 }
1457 md->val[md->len - 1].padata_type = KRB5_PADATA_ETYPE_INFO2;
1458 md->val[md->len - 1].padata_value.length = len;
1459 md->val[md->len - 1].padata_value.data = buf;
1460 return 0;
1461 }
1462
1463 /*
1464 * Return 0 if the client have only older enctypes, this is for
1465 * determining if the server should send ETYPE_INFO2 or not.
1466 */
1467
1468 static int
1469 newer_enctype_present(krb5_context context,
1470 struct KDC_REQ_BODY_etype *etype_list)
1471 {
1472 size_t i;
1473
1474 for (i = 0; i < etype_list->len; i++) {
1475 if (!krb5_is_enctype_old(context, etype_list->val[i]))
1476 return 1;
1477 }
1478 return 0;
1479 }
1480
1481 static krb5_error_code
1482 get_pa_etype_info_both(krb5_context context,
1483 krb5_kdc_configuration *config,
1484 struct KDC_REQ_BODY_etype *etype_list,
1485 METHOD_DATA *md, Key *ckey,
1486 krb5_boolean include_salt)
1487 {
1488 krb5_error_code ret;
1489
1490 /*
1491 * Windows 2019 (and earlier versions) always sends the salt
1492 * and Samba has testsuites that check this behaviour, so a
1493 * Samba AD DC will set this flag to match the AS-REP packet
1494 * more closely.
1495 */
1496 if (config->force_include_pa_etype_salt)
1497 include_salt = TRUE;
1498
1499 /*
1500 * RFC4120 requires:
1501 * When the AS server is to include pre-authentication data in a
1502 * KRB-ERROR or in an AS-REP, it MUST use PA-ETYPE-INFO2, not
1503 * PA-ETYPE-INFO, if the etype field of the client's AS-REQ lists
1504 * at least one "newer" encryption type. Otherwise (when the etype
1505 * field of the client's AS-REQ does not list any "newer" encryption
1506 * types), it MUST send both PA-ETYPE-INFO2 and PA-ETYPE-INFO (both
1507 * with an entry for each enctype). A "newer" enctype is any enctype
1508 * first officially specified concurrently with or subsequent to the
1509 * issue of this RFC. The enctypes DES, 3DES, or RC4 and any defined
1510 * in [RFC1510] are not "newer" enctypes.
1511 *
1512 * It goes on to state:
1513 * The preferred ordering of the "hint" pre-authentication data that
1514 * affect client key selection is: ETYPE-INFO2, followed by ETYPE-INFO,
1515 * followed by PW-SALT. As noted in Section 3.1.3, a KDC MUST NOT send
1516 * ETYPE-INFO or PW-SALT when the client's AS-REQ includes at least one
1517 * "newer" etype.
1518 */
1519
1520 ret = get_pa_etype_info2(context, config, md, ckey, include_salt);
1521 if (ret)
1522 return ret;
1523
1524 if (!newer_enctype_present(context, etype_list))
1525 ret = get_pa_etype_info(context, config, md, ckey, include_salt);
1526
1527 return ret;
1528 }
1529
1530 /*
1531 *
1532 */
1533
1534 void
1535 _log_astgs_req(astgs_request_t r, krb5_enctype setype)
1536 {
1537 const KDC_REQ_BODY *b = &r->req.req_body;
1538 krb5_enctype cetype = r->reply_key.keytype;
1539 krb5_error_code ret;
1540 struct rk_strpool *p;
1541 struct rk_strpool *s = NULL;
1542 char *str;
1543 char *cet;
1544 char *set;
1545 size_t i;
1546
1547 /*
1548 * we are collecting ``p'' and ``s''. The former is a textual
1549 * representation of the enctypes as strings which will be used
1550 * for debugging. The latter is a terse comma separated list of
1551 * the %d's of the enctypes to emit into our audit trail to
1552 * conserve space in the logs.
1553 */
1554
1555 p = rk_strpoolprintf(NULL, "%s", "Client supported enctypes: ");
1556
1557 for (i = 0; i < b->etype.len; i++) {
1558 ret = krb5_enctype_to_string(r->context, b->etype.val[i], &str);
1559 if (ret == 0) {
1560 p = rk_strpoolprintf(p, "%s", str);
1561 free(str);
1562 } else
1563 p = rk_strpoolprintf(p, "%d", b->etype.val[i]);
1564 if (p == NULL) {
1565 rk_strpoolfree(s);
1566 _kdc_r_log(r, 4, "out of memory");
1567 return;
1568 }
1569 s = rk_strpoolprintf(s, "%d", b->etype.val[i]);
1570 if (i + 1 < b->etype.len) {
1571 p = rk_strpoolprintf(p, ", ");
1572 s = rk_strpoolprintf(s, ",");
1573 }
1574 }
1575 if (p == NULL)
1576 p = rk_strpoolprintf(p, "no encryption types");
1577
1578 str = rk_strpoolcollect(s);
1579 if (str)
1580 kdc_audit_addkv((kdc_request_t)r, KDC_AUDIT_EATWHITE, "etypes", "%s",
1581 str);
1582 free(str);
1583
1584 ret = krb5_enctype_to_string(r->context, cetype, &cet);
1585 if(ret == 0) {
1586 ret = krb5_enctype_to_string(r->context, setype, &set);
1587 if (ret == 0) {
1588 p = rk_strpoolprintf(p, ", using %s/%s", cet, set);
1589 free(set);
1590 }
1591 free(cet);
1592 }
1593 if (ret != 0)
1594 p = rk_strpoolprintf(p, ", using enctypes %d/%d",
1595 cetype, setype);
1596
1597 str = rk_strpoolcollect(p);
1598 if (str)
1599 _kdc_r_log(r, 4, "%s", str);
1600 free(str);
1601
1602 kdc_audit_addkv((kdc_request_t)r, 0, "etype", "%d/%d", cetype, setype);
1603
1604 {
1605 char fixedstr[128];
1606 int result;
1607
1608 result = unparse_flags(KDCOptions2int(b->kdc_options), asn1_KDCOptions_units(),
1609 fixedstr, sizeof(fixedstr));
1610 if (result > 0) {
1611 _kdc_r_log(r, 4, "Requested flags: %s", fixedstr);
1612 kdc_audit_addkv((kdc_request_t)r, KDC_AUDIT_EATWHITE,
1613 "flags", "%s", fixedstr);
1614 }
1615 }
1616 }
1617
1618 /*
1619 * verify the flags on `client' and `server', returning 0
1620 * if they are OK and generating an error messages and returning
1621 * and error code otherwise.
1622 */
1623
1624 KDC_LIB_FUNCTION krb5_error_code KDC_LIB_CALL
1625 kdc_check_flags(astgs_request_t r,
1626 krb5_boolean is_as_req,
1627 hdb_entry *client,
1628 hdb_entry *server)
1629 {
1630 if (client != NULL) {
1631 /* check client */
1632 if (client->flags.locked_out) {
1633 kdc_audit_addreason((kdc_request_t)r, "Client is locked out");
1634 return KRB5KDC_ERR_CLIENT_REVOKED;
1635 }
1636
1637 if (client->flags.invalid) {
1638 kdc_audit_addreason((kdc_request_t)r,
1639 "Client has invalid bit set");
1640 return KRB5KDC_ERR_POLICY;
1641 }
1642
1643 if (!client->flags.client) {
1644 kdc_audit_addreason((kdc_request_t)r,
1645 "Principal may not act as client");
1646 return KRB5KDC_ERR_POLICY;
1647 }
1648
1649 if (client->valid_start && *client->valid_start > kdc_time) {
1650 char starttime_str[100];
1651 krb5_format_time(r->context, *client->valid_start,
1652 starttime_str, sizeof(starttime_str), TRUE);
1653 kdc_audit_addreason((kdc_request_t)r, "Client not yet valid "
1654 "until %s", starttime_str);
1655 return KRB5KDC_ERR_CLIENT_NOTYET;
1656 }
1657
1658 if (client->valid_end && *client->valid_end < kdc_time) {
1659 char endtime_str[100];
1660 krb5_format_time(r->context, *client->valid_end,
1661 endtime_str, sizeof(endtime_str), TRUE);
1662 kdc_audit_addreason((kdc_request_t)r, "Client expired at %s",
1663 endtime_str);
1664 return KRB5KDC_ERR_NAME_EXP;
1665 }
1666
1667 if (client->flags.require_pwchange &&
1668 (server == NULL || !server->flags.change_pw))
1669 return KRB5KDC_ERR_KEY_EXPIRED;
1670
1671 if (client->pw_end && *client->pw_end < kdc_time
1672 && (server == NULL || !server->flags.change_pw)) {
1673 char pwend_str[100];
1674 krb5_format_time(r->context, *client->pw_end,
1675 pwend_str, sizeof(pwend_str), TRUE);
1676 kdc_audit_addreason((kdc_request_t)r, "Client's key has expired "
1677 "at %s", pwend_str);
1678 return KRB5KDC_ERR_KEY_EXPIRED;
1679 }
1680 }
1681
1682 /* check server */
1683
1684 if (server != NULL) {
1685 if (server->flags.locked_out) {
1686 kdc_audit_addreason((kdc_request_t)r, "Server locked out");
1687 return KRB5KDC_ERR_SERVICE_REVOKED;
1688 }
1689 if (server->flags.invalid) {
1690 kdc_audit_addreason((kdc_request_t)r,
1691 "Server has invalid flag set");
1692 return KRB5KDC_ERR_POLICY;
1693 }
1694 if (!server->flags.server) {
1695 kdc_audit_addreason((kdc_request_t)r,
1696 "Principal may not act as server");
1697 return KRB5KDC_ERR_POLICY;
1698 }
1699
1700 if (!is_as_req && server->flags.initial) {
1701 kdc_audit_addreason((kdc_request_t)r,
1702 "AS-REQ is required for server");
1703 return KRB5KDC_ERR_POLICY;
1704 }
1705
1706 if (server->valid_start && *server->valid_start > kdc_time) {
1707 char starttime_str[100];
1708 krb5_format_time(r->context, *server->valid_start,
1709 starttime_str, sizeof(starttime_str), TRUE);
1710 kdc_audit_addreason((kdc_request_t)r, "Server not yet valid "
1711 "until %s", starttime_str);
1712 return KRB5KDC_ERR_SERVICE_NOTYET;
1713 }
1714
1715 if (server->valid_end && *server->valid_end < kdc_time) {
1716 char endtime_str[100];
1717 krb5_format_time(r->context, *server->valid_end,
1718 endtime_str, sizeof(endtime_str), TRUE);
1719 kdc_audit_addreason((kdc_request_t)r, "Server expired at %s",
1720 endtime_str);
1721 return KRB5KDC_ERR_SERVICE_EXP;
1722 }
1723
1724 if (server->pw_end && *server->pw_end < kdc_time) {
1725 char pwend_str[100];
1726 krb5_format_time(r->context, *server->pw_end,
1727 pwend_str, sizeof(pwend_str), TRUE);
1728 kdc_audit_addreason((kdc_request_t)r, "Server's key has expired "
1729 "at %s", pwend_str);
1730 return KRB5KDC_ERR_KEY_EXPIRED;
1731 }
1732 }
1733 return 0;
1734 }
1735
1736 /*
1737 * Return TRUE if `from' is part of `addresses' taking into consideration
1738 * the configuration variables that tells us how strict we should be about
1739 * these checks
1740 */
1741
1742 krb5_boolean
1743 _kdc_check_addresses(astgs_request_t r, HostAddresses *addresses,
1744 const struct sockaddr *from)
1745 {
1746 krb5_kdc_configuration *config = r->config;
1747 krb5_error_code ret;
1748 krb5_address addr;
1749 krb5_boolean result;
1750 krb5_boolean only_netbios = TRUE;
1751 size_t i;
1752
1753 if (!config->check_ticket_addresses && !config->warn_ticket_addresses)
1754 return TRUE;
1755
1756 /*
1757 * Fields of HostAddresses type are always OPTIONAL and should be non-
1758 * empty, but we check for empty just in case as our compiler doesn't
1759 * support size constraints on SEQUENCE OF.
1760 */
1761 if (addresses == NULL || addresses->len == 0)
1762 return config->allow_null_ticket_addresses;
1763
1764 for (i = 0; i < addresses->len; ++i) {
1765 if (addresses->val[i].addr_type != KRB5_ADDRESS_NETBIOS) {
1766 only_netbios = FALSE;
1767 }
1768 }
1769
1770 /* Windows sends it's netbios name, which I can only assume is
1771 * used for the 'allowed workstations' check. This is painful,
1772 * but we still want to check IP addresses if they happen to be
1773 * present.
1774 */
1775
1776 if(only_netbios)
1777 return config->allow_null_ticket_addresses;
1778
1779 ret = krb5_sockaddr2address (r->context, from, &addr);
1780 if(ret)
1781 return FALSE;
1782
1783 result = krb5_address_search(r->context, &addr, addresses);
1784 krb5_free_address (r->context, &addr);
1785 return result;
1786 }
1787
1788 /*
1789 *
1790 */
1791 krb5_error_code
1792 _kdc_check_anon_policy(astgs_request_t r)
1793 {
1794 if (!r->config->allow_anonymous) {
1795 kdc_audit_addreason((kdc_request_t)r,
1796 "Anonymous tickets denied by local policy");
1797 return KRB5KDC_ERR_POLICY;
1798 }
1799
1800 return 0;
1801 }
1802
1803 /*
1804 * Determine whether the client requested a PAC be included
1805 * or excluded explictly, or whether it doesn't care.
1806 */
1807
1808 static uint64_t
1809 get_pac_attributes(krb5_context context, KDC_REQ *req)
1810 {
1811 krb5_error_code ret;
1812 PA_PAC_REQUEST pacreq;
1813 const PA_DATA *pa;
1814 int i = 0;
1815 uint32_t pac_attributes;
1816
1817 pa = _kdc_find_padata(req, &i, KRB5_PADATA_PA_PAC_REQUEST);
1818 if (pa == NULL)
1819 return KRB5_PAC_WAS_GIVEN_IMPLICITLY;
1820
1821 ret = decode_PA_PAC_REQUEST(pa->padata_value.data,
1822 pa->padata_value.length,
1823 &pacreq,
1824 NULL);
1825 if (ret)
1826 return KRB5_PAC_WAS_GIVEN_IMPLICITLY;
1827
1828 pac_attributes = pacreq.include_pac ? KRB5_PAC_WAS_REQUESTED : 0;
1829 free_PA_PAC_REQUEST(&pacreq);
1830 return pac_attributes;
1831 }
1832
1833 /*
1834 *
1835 */
1836
1837 static krb5_error_code
1838 generate_pac(astgs_request_t r, const Key *skey, const Key *tkey,
1839 krb5_boolean is_tgs)
1840 {
1841 krb5_error_code ret;
1842 krb5_data data;
1843 uint16_t rodc_id;
1844 krb5_principal client;
1845 krb5_const_principal canon_princ = NULL;
1846
1847 r->pac_attributes = get_pac_attributes(r->context, &r->req);
1848 kdc_audit_setkv_number((kdc_request_t)r, "pac_attributes",
1849 r->pac_attributes);
1850
1851 if (!is_tgs && !(r->pac_attributes & (KRB5_PAC_WAS_REQUESTED | KRB5_PAC_WAS_GIVEN_IMPLICITLY)))
1852 return 0;
1853
1854 /*
1855 * When a PA mech does not use the client's long-term key, the PAC
1856 * may include the client's long-term key (encrypted in the reply key)
1857 * for use by other shared secret authentication protocols, e.g. NTLM.
1858 * Validate a PA mech was actually used before doing this.
1859 */
1860
1861 ret = _kdc_pac_generate(r,
1862 r->client,
1863 r->server,
1864 r->pa_used && !pa_used_flag_isset(r, PA_USES_LONG_TERM_KEY)
1865 ? &r->reply_key : NULL,
1866 r->pac_attributes,
1867 &r->pac);
1868 if (ret) {
1869 _kdc_r_log(r, 4, "PAC generation failed for -- %s",
1870 r->cname);
1871 return ret;
1872 }
1873 if (r->pac == NULL)
1874 return 0;
1875
1876 rodc_id = r->server->kvno >> 16;
1877
1878 /* libkrb5 expects ticket and PAC client names to match */
1879 ret = _krb5_principalname2krb5_principal(r->context, &client,
1880 r->et.cname, r->et.crealm);
1881 if (ret)
1882 return ret;
1883
1884 /*
1885 * Include the canonical name of the principal in the authorization
1886 * data, if the realms match (if they don't, then the KDC could
1887 * impersonate any realm. Windows always canonicalizes the realm,
1888 * but Heimdal permits aliases between realms.)
1889 */
1890 if (krb5_realm_compare(r->context, client, r->canon_client_princ)) {
1891 char *cpn = NULL;
1892
1893 canon_princ = r->canon_client_princ;
1894
1895 (void) krb5_unparse_name(r->context, canon_princ, &cpn);
1896 kdc_audit_addkv((kdc_request_t)r, 0, "canon_client_name", "%s",
1897 cpn ? cpn : "<unknown>");
1898 krb5_xfree(cpn);
1899 }
1900
1901 if (r->pa_used && r->pa_used->finalize_pac) {
1902 ret = r->pa_used->finalize_pac(r);
1903 if (ret)
1904 return ret;
1905 }
1906
1907 ret = _krb5_pac_sign(r->context,
1908 r->pac,
1909 r->et.authtime,
1910 client,
1911 &skey->key, /* Server key */
1912 &tkey->key, /* TGS key */
1913 rodc_id,
1914 NULL, /* UPN */
1915 canon_princ,
1916 is_tgs ? &r->pac_attributes : NULL,
1917 &data);
1918 krb5_free_principal(r->context, client);
1919 krb5_pac_free(r->context, r->pac);
1920 r->pac = NULL;
1921 if (ret) {
1922 _kdc_r_log(r, 4, "PAC signing failed for -- %s",
1923 r->cname);
1924 return ret;
1925 }
1926
1927 ret = _kdc_tkt_insert_pac(r->context, &r->et, &data);
1928 krb5_data_free(&data);
1929
1930 return ret;
1931 }
1932
1933 /*
1934 *
1935 */
1936
1937 krb5_boolean
1938 _kdc_is_anonymous(krb5_context context, krb5_const_principal principal)
1939 {
1940 return krb5_principal_is_anonymous(context, principal, KRB5_ANON_MATCH_ANY);
1941 }
1942
1943 /*
1944 * Returns TRUE if principal is the unauthenticated anonymous identity,
1945 * i.e. WELLKNOWN/ANONYMOUS@WELLKNOWN:ANONYMOUS. Unfortunately due to
1946 * backwards compatibility logic in krb5_principal_is_anonymous() we
1947 * have to use our own implementation.
1948 */
1949
1950 krb5_boolean
1951 _kdc_is_anonymous_pkinit(krb5_context context, krb5_const_principal principal)
1952 {
1953 return _kdc_is_anonymous(context, principal) &&
1954 strcmp(principal->realm, KRB5_ANON_REALM) == 0;
1955 }
1956
1957 static int
1958 require_preauth_p(astgs_request_t r)
1959 {
1960 return r->config->require_preauth
1961 || r->client->flags.require_preauth
1962 || r->server->flags.require_preauth;
1963 }
1964
1965
1966 /*
1967 *
1968 */
1969
1970 static krb5_error_code
1971 add_enc_pa_rep(astgs_request_t r)
1972 {
1973 krb5_error_code ret;
1974 krb5_crypto crypto;
1975 Checksum checksum;
1976 krb5_data cdata;
1977 size_t len;
1978
1979 ret = krb5_crypto_init(r->context, &r->reply_key, 0, &crypto);
1980 if (ret)
1981 return ret;
1982
1983 ret = krb5_create_checksum(r->context, crypto,
1984 KRB5_KU_AS_REQ, 0,
1985 r->request.data, r->request.length,
1986 &checksum);
1987 krb5_crypto_destroy(r->context, crypto);
1988 if (ret)
1989 return ret;
1990
1991 ASN1_MALLOC_ENCODE(Checksum, cdata.data, cdata.length,
1992 &checksum, &len, ret);
1993 free_Checksum(&checksum);
1994 if (ret)
1995 return ret;
1996 heim_assert(cdata.length == len, "ASN.1 internal error");
1997
1998 if (r->ek.encrypted_pa_data == NULL) {
1999 ALLOC(r->ek.encrypted_pa_data);
2000 if (r->ek.encrypted_pa_data == NULL)
2001 return ENOMEM;
2002 }
2003 ret = krb5_padata_add(r->context, r->ek.encrypted_pa_data,
2004 KRB5_PADATA_REQ_ENC_PA_REP, cdata.data, cdata.length);
2005 if (ret)
2006 return ret;
2007
2008 return krb5_padata_add(r->context, r->ek.encrypted_pa_data,
2009 KRB5_PADATA_FX_FAST, NULL, 0);
2010 }
2011
2012 /*
2013 * Add an authorization data element indicating that a synthetic
2014 * principal was used, so that the TGS does not accidentally
2015 * synthesize a non-synthetic principal that has since been deleted.
2016 */
2017 static krb5_error_code
2018 add_synthetic_princ_ad(astgs_request_t r)
2019 {
2020 krb5_data data;
2021
2022 krb5_data_zero(&data);
2023
2024 return _kdc_tkt_add_if_relevant_ad(r->context, &r->et,
2025 KRB5_AUTHDATA_SYNTHETIC_PRINC_USED,
2026 &data);
2027 }
2028
2029 static krb5_error_code
2030 get_local_tgs(krb5_context context,
2031 krb5_kdc_configuration *config,
2032 krb5_const_realm realm,
2033 HDB **krbtgtdb,
2034 hdb_entry **krbtgt)
2035 {
2036 krb5_error_code ret;
2037 krb5_principal tgs_name;
2038
2039 *krbtgtdb = NULL;
2040 *krbtgt = NULL;
2041
2042 ret = krb5_make_principal(context,
2043 &tgs_name,
2044 realm,
2045 KRB5_TGS_NAME,
2046 realm,
2047 NULL);
2048 if (ret)
2049 return ret;
2050
2051 ret = _kdc_db_fetch(context, config, tgs_name,
2052 HDB_F_GET_KRBTGT, NULL, krbtgtdb, krbtgt);
2053 krb5_free_principal(context, tgs_name);
2054
2055 return ret;
2056 }
2057
2058 /*
2059 *
2060 */
2061
2062 krb5_error_code
2063 _kdc_as_rep(astgs_request_t r)
2064 {
2065 krb5_kdc_configuration *config = r->config;
2066 KDC_REQ *req = &r->req;
2067 const char *from = r->from;
2068 KDC_REQ_BODY *b = NULL;
2069 KDC_REP *rep = &r->rep;
2070 KDCOptions f;
2071 krb5_enctype setype;
2072 krb5_error_code ret = 0;
2073 Key *skey;
2074 int found_pa = 0;
2075 int i, flags = HDB_F_FOR_AS_REQ;
2076 const PA_DATA *pa;
2077 krb5_boolean is_tgs;
2078 const char *msg;
2079 Key *krbtgt_key;
2080
2081 memset(rep, 0, sizeof(*rep));
2082
2083 ALLOC(rep->padata);
2084 if (rep->padata == NULL) {
2085 ret = ENOMEM;
2086 krb5_set_error_message(r->context, ret, N_("malloc: out of memory", ""));
2087 goto out;
2088 }
2089
2090 /*
2091 * Look for FAST armor and unwrap
2092 */
2093 ret = _kdc_fast_unwrap_request(r, NULL, NULL);
2094 if (ret) {
2095 _kdc_r_log(r, 1, "FAST unwrap request from %s failed: %d", from, ret);
2096 goto out;
2097 }
2098
2099 b = &req->req_body;
2100 f = b->kdc_options;
2101
2102 if (f.canonicalize)
2103 flags |= HDB_F_CANON;
2104
2105 if (b->sname == NULL) {
2106 ret = KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN;
2107 _kdc_set_e_text(r, "No server in request");
2108 goto out;
2109 }
2110
2111 ret = _krb5_principalname2krb5_principal(r->context, &r->server_princ,
2112 *(b->sname), b->realm);
2113 if (!ret)
2114 ret = krb5_unparse_name(r->context, r->server_princ, &r->sname);
2115 if (ret) {
2116 kdc_log(r->context, config, 2,
2117 "AS_REQ malformed server name from %s", from);
2118 goto out;
2119 }
2120
2121 if (b->cname == NULL) {
2122 ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
2123 _kdc_set_e_text(r, "No client in request");
2124 goto out;
2125 }
2126
2127 ret = _krb5_principalname2krb5_principal(r->context, &r->client_princ,
2128 *(b->cname), b->realm);
2129 if (!ret)
2130 ret = krb5_unparse_name(r->context, r->client_princ, &r->cname);
2131 if (ret) {
2132 kdc_log(r->context, config, 2,
2133 "AS-REQ malformed client name from %s", from);
2134 goto out;
2135 }
2136
2137 kdc_log(r->context, config, 4, "AS-REQ %s from %s for %s",
2138 r->cname, r->from, r->sname);
2139
2140 is_tgs = krb5_principal_is_krbtgt(r->context, r->server_princ);
2141
2142 if (_kdc_is_anonymous(r->context, r->client_princ) &&
2143 !_kdc_is_anon_request(req)) {
2144 kdc_log(r->context, config, 2, "Anonymous client w/o anonymous flag");
2145 ret = KRB5KDC_ERR_BADOPTION;
2146 goto out;
2147 }
2148
2149 ret = _kdc_db_fetch(r->context, config, r->client_princ,
2150 HDB_F_GET_CLIENT | HDB_F_SYNTHETIC_OK | flags, NULL,
2151 &r->clientdb, &r->client);
2152 switch (ret) {
2153 case 0: /* Success */
2154 break;
2155 case HDB_ERR_NOT_FOUND_HERE:
2156 kdc_log(r->context, config, 5, "client %s does not have secrets at this KDC, need to proxy",
2157 r->cname);
2158 goto out;
2159 case HDB_ERR_WRONG_REALM: {
2160 char *fixed_client_name = NULL;
2161
2162 ret = krb5_unparse_name(r->context, r->client->principal,
2163 &fixed_client_name);
2164 if (ret) {
2165 goto out;
2166 }
2167
2168 kdc_log(r->context, config, 4, "WRONG_REALM - %s -> %s",
2169 r->cname, fixed_client_name);
2170 free(fixed_client_name);
2171
2172 r->e_text = NULL;
2173 ret = _kdc_fast_mk_error(r, r->rep.padata, r->armor_crypto,
2174 &req->req_body,
2175 r->error_code = KRB5_KDC_ERR_WRONG_REALM,
2176 r->client->principal, r->server_princ,
2177 NULL, NULL, r->reply);
2178 goto out;
2179 }
2180 default:
2181 {
2182 msg = krb5_get_error_message(r->context, ret);
2183 kdc_log(r->context, config, 4, "UNKNOWN -- %s: %s", r->cname, msg);
2184 krb5_free_error_message(r->context, msg);
2185 ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
2186 kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
2187 KDC_AUTH_EVENT_CLIENT_UNKNOWN);
2188 goto out;
2189 }
2190 }
2191 ret = _kdc_db_fetch(r->context, config, r->server_princ,
2192 HDB_F_GET_SERVER | HDB_F_DELAY_NEW_KEYS |
2193 flags | (is_tgs ? HDB_F_GET_KRBTGT : 0),
2194 NULL, &r->serverdb, &r->server);
2195 switch (ret) {
2196 case 0: /* Success */
2197 break;
2198 case HDB_ERR_NOT_FOUND_HERE:
2199 kdc_log(r->context, config, 5, "target %s does not have secrets at this KDC, need to proxy",
2200 r->sname);
2201 goto out;
2202 default:
2203 msg = krb5_get_error_message(r->context, ret);
2204 kdc_log(r->context, config, 4, "UNKNOWN -- %s: %s", r->sname, msg);
2205 krb5_free_error_message(r->context, msg);
2206 ret = KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN;
2207 goto out;
2208 }
2209
2210 /*
2211 * Select an enctype for the to-be-issued ticket's session key using the
2212 * intersection of the client's requested enctypes and the server's (like a
2213 * root krbtgt, but not necessarily) etypes from its HDB entry.
2214 */
2215 ret = _kdc_find_etype(r, (is_tgs ? KFE_IS_TGS:0) | KFE_USE_CLIENT,
2216 b->etype.val, b->etype.len,
2217 &r->sessionetype, NULL, NULL);
2218 if (ret) {
2219 kdc_log(r->context, config, 4,
2220 "Client (%s) from %s has no common enctypes with KDC "
2221 "to use for the session key",
2222 r->cname, from);
2223 goto out;
2224 }
2225
2226 /*
2227 * Pre-auth processing
2228 */
2229
2230 if(req->padata){
2231 unsigned int n;
2232
2233 log_patypes(r, req->padata);
2234
2235 /* Check if preauth matching */
2236
2237 for (n = 0; !found_pa && n < sizeof(pat) / sizeof(pat[0]); n++) {
2238 if (pat[n].validate == NULL)
2239 continue;
2240 if (r->armor_crypto == NULL && (pat[n].flags & PA_REQ_FAST))
2241 continue;
2242
2243 kdc_log(r->context, config, 5,
2244 "Looking for %s pa-data -- %s", pat[n].name, r->cname);
2245 i = 0;
2246 pa = _kdc_find_padata(req, &i, pat[n].type);
2247 if (pa) {
2248 if (r->client->flags.synthetic &&
2249 !(pat[n].flags & PA_SYNTHETIC_OK)) {
2250 kdc_log(r->context, config, 4, "UNKNOWN -- %s", r->cname);
2251 ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
2252 goto out;
2253 }
2254 kdc_audit_addkv((kdc_request_t)r, KDC_AUDIT_VIS, "pa", "%s",
2255 pat[n].name);
2256 ret = pat[n].validate(r, pa);
2257 if (ret != 0) {
2258 krb5_error_code ret2;
2259 Key *ckey = NULL;
2260 krb5_boolean default_salt;
2261
2262 if (ret != KRB5_KDC_ERR_MORE_PREAUTH_DATA_REQUIRED &&
2263 !kdc_audit_getkv((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT))
2264 kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
2265 KDC_AUTH_EVENT_PREAUTH_FAILED);
2266
2267 /*
2268 * If there is a client key, send ETYPE_INFO{,2}
2269 */
2270 ret2 = _kdc_find_etype(r, KFE_IS_PREAUTH|KFE_USE_CLIENT,
2271 b->etype.val, b->etype.len,
2272 NULL, &ckey, &default_salt);
2273 if (ret2 == 0) {
2274 ret2 = get_pa_etype_info_both(r->context, config, &b->etype,
2275 r->rep.padata, ckey, !default_salt);
2276 if (ret2 != 0)
2277 ret = ret2;
2278 }
2279 goto out;
2280 }
2281 if (!kdc_audit_getkv((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT))
2282 kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
2283 KDC_AUTH_EVENT_PREAUTH_SUCCEEDED);
2284 kdc_log(r->context, config, 4,
2285 "%s pre-authentication succeeded -- %s",
2286 pat[n].name, r->cname);
2287 found_pa = 1;
2288 r->pa_used = &pat[n];
2289 r->et.flags.pre_authent = 1;
2290 }
2291 }
2292 }
2293
2294 if (found_pa == 0) {
2295 Key *ckey = NULL;
2296 size_t n;
2297 krb5_boolean default_salt;
2298
2299 if (r->client->flags.synthetic) {
2300 kdc_log(r->context, config, 4, "UNKNOWN -- %s", r->cname);
2301 ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
2302 goto out;
2303 }
2304
2305 for (n = 0; n < sizeof(pat) / sizeof(pat[0]); n++) {
2306 if ((pat[n].flags & PA_ANNOUNCE) == 0)
2307 continue;
2308
2309 if (!r->armor_crypto && (pat[n].flags & PA_REQ_FAST))
2310 continue;
2311 if (pat[n].type == KRB5_PADATA_ENC_TIMESTAMP) {
2312 if (r->armor_crypto && !r->config->enable_armored_pa_enc_timestamp)
2313 continue;
2314 if (!r->armor_crypto && !r->config->enable_unarmored_pa_enc_timestamp)
2315 continue;
2316 }
2317
2318 ret = krb5_padata_add(r->context, r->rep.padata,
2319 pat[n].type, NULL, 0);
2320 if (ret)
2321 goto out;
2322 }
2323
2324 /*
2325 * If there is a client key, send ETYPE_INFO{,2}
2326 */
2327 ret = _kdc_find_etype(r, KFE_IS_PREAUTH|KFE_USE_CLIENT,
2328 b->etype.val, b->etype.len,
2329 NULL, &ckey, &default_salt);
2330 if (ret == 0) {
2331 ret = get_pa_etype_info_both(r->context, config, &b->etype,
2332 r->rep.padata, ckey, !default_salt);
2333 if (ret)
2334 goto out;
2335 }
2336
2337 /*
2338 * send requre preauth is its required or anon is requested,
2339 * anon is today only allowed via preauth mechanisms.
2340 */
2341 if (require_preauth_p(r) || _kdc_is_anon_request(&r->req)) {
2342 ret = KRB5KDC_ERR_PREAUTH_REQUIRED;
2343 _kdc_set_e_text(r, "Need to use PA-ENC-TIMESTAMP/PA-PK-AS-REQ");
2344 goto out;
2345 }
2346
2347 if (ckey == NULL) {
2348 ret = KRB5KDC_ERR_CLIENT_NOTYET;
2349 _kdc_set_e_text(r, "Doesn't have a client key available");
2350 goto out;
2351 }
2352 krb5_free_keyblock_contents(r->context, &r->reply_key);
2353 ret = krb5_copy_keyblock_contents(r->context, &ckey->key, &r->reply_key);
2354 if (ret)
2355 goto out;
2356 }
2357
2358 r->canon_client_princ = r->client->principal;
2359
2360 /*
2361 * Verify flags after the user been required to prove its identity
2362 * with in a preauth mech.
2363 */
2364
2365 ret = _kdc_check_access(r);
2366 if(ret)
2367 goto out;
2368
2369 if (_kdc_is_anon_request(&r->req)) {
2370 ret = _kdc_check_anon_policy(r);
2371 if (ret) {
2372 _kdc_set_e_text(r, "Anonymous ticket requests are disabled");
2373 goto out;
2374 }
2375
2376 r->et.flags.anonymous = 1;
2377 }
2378
2379 kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
2380 KDC_AUTH_EVENT_CLIENT_AUTHORIZED);
2381
2382 /*
2383 * Select the best encryption type for the KDC with out regard to
2384 * the client since the client never needs to read that data.
2385 */
2386
2387 ret = _kdc_get_preferred_key(r->context, config,
2388 r->server, r->sname,
2389 &setype, &skey);
2390 if(ret)
2391 goto out;
2392
2393 /* If server is not krbtgt, fetch local krbtgt key for signing authdata */
2394 if (is_tgs) {
2395 krbtgt_key = skey;
2396 } else {
2397 ret = get_local_tgs(r->context, config, r->server_princ->realm,
2398 &r->krbtgtdb, &r->krbtgt);
2399 if (ret)
2400 goto out;
2401
2402 ret = _kdc_get_preferred_key(r->context, config, r->krbtgt,
2403 r->server_princ->realm,
2404 NULL, &krbtgt_key);
2405 if (ret)
2406 goto out;
2407 }
2408
2409 if(f.renew || f.validate || f.proxy || f.forwarded || f.enc_tkt_in_skey) {
2410 ret = KRB5KDC_ERR_BADOPTION;
2411 _kdc_set_e_text(r, "Bad KDC options");
2412 goto out;
2413 }
2414
2415 /*
2416 * Build reply
2417 */
2418 rep->pvno = 5;
2419 rep->msg_type = krb_as_rep;
2420
2421 if (!config->historical_anon_realm &&
2422 _kdc_is_anonymous(r->context, r->client_princ)) {
2423 Realm anon_realm = KRB5_ANON_REALM;
2424 ret = copy_Realm(&anon_realm, &rep->crealm);
2425 } else if (f.canonicalize || r->client->flags.force_canonicalize)
2426 ret = copy_Realm(&r->canon_client_princ->realm, &rep->crealm);
2427 else
2428 ret = copy_Realm(&r->client_princ->realm, &rep->crealm);
2429 if (ret)
2430 goto out;
2431 if (r->et.flags.anonymous)
2432 ret = _kdc_make_anonymous_principalname(&rep->cname);
2433 else if (f.canonicalize || r->client->flags.force_canonicalize)
2434 ret = _krb5_principal2principalname(&rep->cname, r->canon_client_princ);
2435 else
2436 ret = _krb5_principal2principalname(&rep->cname, r->client_princ);
2437 if (ret)
2438 goto out;
2439
2440 rep->ticket.tkt_vno = 5;
2441 if (f.canonicalize || r->server->flags.force_canonicalize)
2442 ret = copy_Realm(&r->server->principal->realm, &rep->ticket.realm);
2443 else
2444 ret = copy_Realm(&r->server_princ->realm, &rep->ticket.realm);
2445 if (ret)
2446 goto out;
2447 if (f.canonicalize || r->server->flags.force_canonicalize)
2448 _krb5_principal2principalname(&rep->ticket.sname,
2449 r->server->principal);
2450 else
2451 _krb5_principal2principalname(&rep->ticket.sname,
2452 r->server_princ);
2453 /* java 1.6 expects the name to be the same type, lets allow that
2454 * uncomplicated name-types, when f.canonicalize is not set (to
2455 * match Windows Server 1709). */
2456 #define CNT(sp,t) (((sp)->sname->name_type) == KRB5_NT_##t)
2457 if (!f.canonicalize
2458 && (CNT(b, UNKNOWN) || CNT(b, PRINCIPAL) || CNT(b, SRV_INST) || CNT(b, SRV_HST) || CNT(b, SRV_XHST))) {
2459 rep->ticket.sname.name_type = b->sname->name_type;
2460 }
2461 #undef CNT
2462
2463 r->et.flags.initial = 1;
2464 if(r->client->flags.forwardable && r->server->flags.forwardable)
2465 r->et.flags.forwardable = f.forwardable;
2466 if(r->client->flags.proxiable && r->server->flags.proxiable)
2467 r->et.flags.proxiable = f.proxiable;
2468 else if (f.proxiable) {
2469 _kdc_set_e_text(r, "Ticket may not be proxiable");
2470 ret = KRB5KDC_ERR_POLICY;
2471 goto out;
2472 }
2473 if(r->client->flags.postdate && r->server->flags.postdate)
2474 r->et.flags.may_postdate = f.allow_postdate;
2475 else if (f.allow_postdate){
2476 _kdc_set_e_text(r, "Ticket may not be postdate");
2477 ret = KRB5KDC_ERR_POLICY;
2478 goto out;
2479 }
2480
2481 if (b->addresses)
2482 kdc_audit_addaddrs((kdc_request_t)r, b->addresses, "reqaddrs");
2483
2484 /* check for valid set of addresses */
2485 if (!_kdc_check_addresses(r, b->addresses, r->addr)) {
2486 if (r->config->warn_ticket_addresses) {
2487 kdc_audit_setkv_bool((kdc_request_t)r, "wrongaddr", TRUE);
2488 } else {
2489 _kdc_set_e_text(r, "Request from wrong address");
2490 ret = KRB5KRB_AP_ERR_BADADDR;
2491 goto out;
2492 }
2493 }
2494
2495 ret = copy_PrincipalName(&rep->cname, &r->et.cname);
2496 if (ret)
2497 goto out;
2498 ret = copy_Realm(&rep->crealm, &r->et.crealm);
2499 if (ret)
2500 goto out;
2501
2502 {
2503 time_t start;
2504 time_t t;
2505
2506 start = r->et.authtime = kdc_time;
2507
2508 if(f.postdated && req->req_body.from){
2509 ALLOC(r->et.starttime);
2510 start = *r->et.starttime = *req->req_body.from;
2511 r->et.flags.invalid = 1;
2512 r->et.flags.postdated = 1; /* XXX ??? */
2513 }
2514 _kdc_fix_time(&b->till);
2515 t = *b->till;
2516
2517 /* be careful not overflowing */
2518
2519 /*
2520 * Pre-auth can override r->client->max_life if configured.
2521 *
2522 * See pre-auth methods, specifically PKINIT, which can get or derive
2523 * this from the client's certificate.
2524 */
2525 if (r->pa_max_life > 0)
2526 t = rk_time_add(start, min(rk_time_sub(t, start), r->pa_max_life));
2527 else if (r->client->max_life && *r->client->max_life)
2528 t = rk_time_add(start, min(rk_time_sub(t, start),
2529 *r->client->max_life));
2530
2531 if (r->server->max_life && *r->server->max_life)
2532 t = rk_time_add(start, min(rk_time_sub(t, start),
2533 *r->server->max_life));
2534
2535 /* Pre-auth can bound endtime as well */
2536 if (r->pa_endtime > 0)
2537 t = rk_time_add(start, min(rk_time_sub(t, start), r->pa_endtime));
2538 #if 0
2539 t = min(t, rk_time_add(start, realm->max_life));
2540 #endif
2541 r->et.endtime = t;
2542 if(f.renewable_ok && r->et.endtime < *b->till){
2543 f.renewable = 1;
2544 if(b->rtime == NULL){
2545 ALLOC(b->rtime);
2546 *b->rtime = 0;
2547 }
2548 if(*b->rtime < *b->till)
2549 *b->rtime = *b->till;
2550 }
2551 if(f.renewable && b->rtime){
2552 t = *b->rtime;
2553 if(t == 0)
2554 t = MAX_TIME;
2555 if(r->client->max_renew && *r->client->max_renew)
2556 t = rk_time_add(start, min(rk_time_sub(t, start),
2557 *r->client->max_renew));
2558 if(r->server->max_renew && *r->server->max_renew)
2559 t = rk_time_add(start, min(rk_time_sub(t, start),
2560 *r->server->max_renew));
2561 #if 0
2562 t = min(t, rk_time_add(start, realm->max_renew));
2563 #endif
2564 ALLOC(r->et.renew_till);
2565 *r->et.renew_till = t;
2566 r->et.flags.renewable = 1;
2567 }
2568 }
2569
2570 if(b->addresses){
2571 ALLOC(r->et.caddr);
2572 copy_HostAddresses(b->addresses, r->et.caddr);
2573 }
2574
2575 r->et.transited.tr_type = domain_X500_Compress;
2576 krb5_data_zero(&r->et.transited.contents);
2577
2578 /* The MIT ASN.1 library (obviously) doesn't tell lengths encoded
2579 * as 0 and as 0x80 (meaning indefinite length) apart, and is thus
2580 * incapable of correctly decoding SEQUENCE OF's of zero length.
2581 *
2582 * To fix this, always send at least one no-op last_req
2583 *
2584 * If there's a pw_end or valid_end we will use that,
2585 * otherwise just a dummy lr.
2586 */
2587 r->ek.last_req.val = malloc(2 * sizeof(*r->ek.last_req.val));
2588 if (r->ek.last_req.val == NULL) {
2589 ret = ENOMEM;
2590 goto out;
2591 }
2592 r->ek.last_req.len = 0;
2593 if (r->client->pw_end
2594 && (config->kdc_warn_pwexpire == 0
2595 || kdc_time + config->kdc_warn_pwexpire >= *r->client->pw_end)) {
2596 r->ek.last_req.val[r->ek.last_req.len].lr_type = LR_PW_EXPTIME;
2597 r->ek.last_req.val[r->ek.last_req.len].lr_value = *r->client->pw_end;
2598 ++r->ek.last_req.len;
2599 }
2600 if (r->client->valid_end) {
2601 r->ek.last_req.val[r->ek.last_req.len].lr_type = LR_ACCT_EXPTIME;
2602 r->ek.last_req.val[r->ek.last_req.len].lr_value = *r->client->valid_end;
2603 ++r->ek.last_req.len;
2604 }
2605 if (r->ek.last_req.len == 0) {
2606 r->ek.last_req.val[r->ek.last_req.len].lr_type = LR_NONE;
2607 r->ek.last_req.val[r->ek.last_req.len].lr_value = 0;
2608 ++r->ek.last_req.len;
2609 }
2610 r->ek.nonce = b->nonce;
2611 if (r->client->valid_end || r->client->pw_end) {
2612 ALLOC(r->ek.key_expiration);
2613 if (r->client->valid_end) {
2614 if (r->client->pw_end)
2615 *r->ek.key_expiration = min(*r->client->valid_end,
2616 *r->client->pw_end);
2617 else
2618 *r->ek.key_expiration = *r->client->valid_end;
2619 } else
2620 *r->ek.key_expiration = *r->client->pw_end;
2621 } else
2622 r->ek.key_expiration = NULL;
2623 r->ek.flags = r->et.flags;
2624 r->ek.authtime = r->et.authtime;
2625 if (r->et.starttime) {
2626 ALLOC(r->ek.starttime);
2627 *r->ek.starttime = *r->et.starttime;
2628 }
2629 r->ek.endtime = r->et.endtime;
2630 if (r->et.renew_till) {
2631 ALLOC(r->ek.renew_till);
2632 *r->ek.renew_till = *r->et.renew_till;
2633 }
2634 ret = copy_Realm(&rep->ticket.realm, &r->ek.srealm);
2635 if (ret)
2636 goto out;
2637 ret = copy_PrincipalName(&rep->ticket.sname, &r->ek.sname);
2638 if (ret)
2639 goto out;
2640 if(r->et.caddr){
2641 ALLOC(r->ek.caddr);
2642 copy_HostAddresses(r->et.caddr, r->ek.caddr);
2643 }
2644
2645 /*
2646 * Check and session and reply keys
2647 */
2648
2649 if (r->session_key.keytype == ETYPE_NULL) {
2650 ret = krb5_generate_random_keyblock(r->context, r->sessionetype, &r->session_key);
2651 if (ret)
2652 goto out;
2653 }
2654
2655 if (r->reply_key.keytype == ETYPE_NULL) {
2656 _kdc_set_e_text(r, "Client have no reply key");
2657 ret = KRB5KDC_ERR_CLIENT_NOTYET;
2658 goto out;
2659 }
2660
2661 ret = copy_EncryptionKey(&r->session_key, &r->et.key);
2662 if (ret)
2663 goto out;
2664
2665 ret = copy_EncryptionKey(&r->session_key, &r->ek.key);
2666 if (ret)
2667 goto out;
2668
2669 /* Add the PAC */
2670 if (!r->et.flags.anonymous) {
2671 generate_pac(r, skey, krbtgt_key, is_tgs);
2672 }
2673
2674 if (r->client->flags.synthetic) {
2675 ret = add_synthetic_princ_ad(r);
2676 if (ret)
2677 goto out;
2678 }
2679
2680 _kdc_log_timestamp(r, "AS-REQ", r->et.authtime,
2681 r->et.starttime, r->et.endtime,
2682 r->et.renew_till);
2683
2684 _log_astgs_req(r, setype);
2685
2686 /*
2687 * We always say we support FAST/enc-pa-rep
2688 */
2689
2690 r->et.flags.enc_pa_rep = r->ek.flags.enc_pa_rep = 1;
2691
2692 /*
2693 * update reply-key with strengthen-key
2694 */
2695
2696 ret = _kdc_fast_strengthen_reply_key(r);
2697 if (ret)
2698 goto out;
2699
2700 /*
2701 * Add REQ_ENC_PA_REP if client supports it
2702 */
2703
2704 i = 0;
2705 pa = _kdc_find_padata(req, &i, KRB5_PADATA_REQ_ENC_PA_REP);
2706 if (pa) {
2707
2708 ret = add_enc_pa_rep(r);
2709 if (ret) {
2710 msg = krb5_get_error_message(r->context, ret);
2711 _kdc_r_log(r, 4, "add_enc_pa_rep failed: %s: %d", msg, ret);
2712 krb5_free_error_message(r->context, msg);
2713 goto out;
2714 }
2715 }
2716
2717 /*
2718 * Last chance for plugins to update reply
2719 */
2720 ret = _kdc_finalize_reply(r);
2721 if (ret)
2722 goto out;
2723
2724 /*
2725 * Don't send kvno from client entry if the pre-authentication
2726 * mechanism replaced the reply key.
2727 */
2728
2729 ret = _kdc_encode_reply(r->context, config,
2730 r, req->req_body.nonce, setype,
2731 r->server->kvno, &skey->key,
2732 pa_used_flag_isset(r, PA_REPLACE_REPLY_KEY) ? 0 : r->client->kvno,
2733 0, r->reply);
2734 if (ret)
2735 goto out;
2736
2737 /*
2738 * Check if message too large
2739 */
2740 if (r->datagram_reply && r->reply->length > config->max_datagram_reply_length) {
2741 krb5_data_free(r->reply);
2742 ret = KRB5KRB_ERR_RESPONSE_TOO_BIG;
2743 _kdc_set_e_text(r, "Reply packet too large");
2744 }
2745
2746 out:
2747 r->error_code = ret;
2748 {
2749 krb5_error_code ret2 = _kdc_audit_request(r);
2750 if (ret2) {
2751 krb5_data_free(r->reply);
2752 ret = ret2;
2753 }
2754 }
2755
2756 /*
2757 * In case of a non proxy error, build an error message.
2758 */
2759 if (ret != 0 && ret != HDB_ERR_NOT_FOUND_HERE && r->reply->length == 0) {
2760 kdc_log(r->context, config, 5, "as-req: sending error: %d to client", ret);
2761 ret = _kdc_fast_mk_error(r,
2762 r->rep.padata,
2763 r->armor_crypto,
2764 &req->req_body,
2765 r->error_code,
2766 r->client_princ,
2767 r->server_princ,
2768 NULL, NULL,
2769 r->reply);
2770 }
2771
2772 if (r->pa_used && r->pa_used->cleanup)
2773 r->pa_used->cleanup(r);
2774
2775 free_AS_REP(&r->rep);
2776 free_EncTicketPart(&r->et);
2777 free_EncKDCRepPart(&r->ek);
2778 _kdc_free_fast_state(&r->fast);
2779
2780 if (r->client_princ) {
2781 krb5_free_principal(r->context, r->client_princ);
2782 r->client_princ = NULL;
2783 }
2784 if (r->server_princ){
2785 krb5_free_principal(r->context, r->server_princ);
2786 r->server_princ = NULL;
2787 }
2788 if (r->client)
2789 _kdc_free_ent(r->context, r->clientdb, r->client);
2790 if (r->server)
2791 _kdc_free_ent(r->context, r->serverdb, r->server);
2792 if (r->krbtgt)
2793 _kdc_free_ent(r->context, r->krbtgtdb, r->krbtgt);
2794 if (r->armor_crypto) {
2795 krb5_crypto_destroy(r->context, r->armor_crypto);
2796 r->armor_crypto = NULL;
2797 }
2798 if (r->armor_ticket)
2799 krb5_free_ticket(r->context, r->armor_ticket);
2800 if (r->armor_server)
2801 _kdc_free_ent(r->context, r->armor_serverdb, r->armor_server);
2802 krb5_free_keyblock_contents(r->context, &r->reply_key);
2803 krb5_free_keyblock_contents(r->context, &r->session_key);
2804 krb5_free_keyblock_contents(r->context, &r->strengthen_key);
2805 krb5_pac_free(r->context, r->pac);
2806
2807 return ret;
2808 }
Samba git mirror