2 * Copyright (c) 1997-2007 Kungliga Tekniska Högskolan
3 * (Royal Institute of Technology, Stockholm, Sweden).
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
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.
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.
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
36 #define MAX_TIME ((time_t)((1U << 31) - 1))
39 _kdc_fix_time(time_t **t
)
45 if(**t
== 0) **t
= MAX_TIME
; /* fix for old clients */
49 realloc_method_data(METHOD_DATA
*md
)
52 pa
= realloc(md
->val
, (md
->len
+ 1) * sizeof(*md
->val
));
61 set_salt_padata(METHOD_DATA
*md
, Salt
*salt
)
64 realloc_method_data(md
);
65 md
->val
[md
->len
- 1].padata_type
= salt
->type
;
66 der_copy_octet_string(&salt
->salt
,
67 &md
->val
[md
->len
- 1].padata_value
);
72 _kdc_find_padata(const KDC_REQ
*req
, int *start
, int type
)
74 if (req
->padata
== NULL
)
77 while((size_t)*start
< req
->padata
->len
){
79 if(req
->padata
->val
[*start
- 1].padata_type
== (unsigned)type
)
80 return &req
->padata
->val
[*start
- 1];
86 * This is a hack to allow predefined weak services, like afs to
87 * still use weak types
91 _kdc_is_weak_exception(krb5_principal principal
, krb5_enctype etype
)
93 if (principal
->name
.name_string
.len
> 0 &&
94 strcmp(principal
->name
.name_string
.val
[0], "afs") == 0 &&
95 (etype
== (krb5_enctype
)ETYPE_DES_CBC_CRC
96 || etype
== (krb5_enctype
)ETYPE_DES_CBC_MD4
97 || etype
== (krb5_enctype
)ETYPE_DES_CBC_MD5
))
104 * Detect if `key' is the using the the precomputed `default_salt'.
108 is_default_salt_p(const krb5_salt
*default_salt
, const Key
*key
)
110 if (key
->salt
== NULL
)
112 if (default_salt
->salttype
!= key
->salt
->type
)
114 if (krb5_data_cmp(&default_salt
->saltvalue
, &key
->salt
->salt
))
120 * return the first appropriate key of `princ' in `ret_key'. Look for
121 * all the etypes in (`etypes', `len'), stopping as soon as we find
122 * one, but preferring one that has default salt.
126 _kdc_find_etype(krb5_context context
, krb5_boolean use_strongest_session_key
,
127 krb5_boolean is_preauth
, hdb_entry_ex
*princ
,
128 krb5_enctype
*etypes
, unsigned len
,
129 krb5_enctype
*ret_enctype
, Key
**ret_key
)
133 krb5_enctype enctype
= (krb5_enctype
)ETYPE_NULL
;
134 const krb5_enctype
*p
;
138 /* We'll want to avoid keys with v4 salted keys in the pre-auth case... */
139 ret
= krb5_get_pw_salt(context
, princ
->entry
.principal
, &def_salt
);
143 ret
= KRB5KDC_ERR_ETYPE_NOSUPP
;
145 if (use_strongest_session_key
) {
148 * Pick the strongest key that the KDC, target service, and
149 * client all support, using the local cryptosystem enctype
150 * list in strongest-to-weakest order to drive the search.
152 * This is not what RFC4120 says to do, but it encourages
153 * adoption of stronger enctypes. This doesn't play well with
154 * clients that have multiple Kerberos client implementations
155 * available with different supported enctype lists.
158 /* drive the search with local supported enctypes list */
159 p
= krb5_kerberos_enctypes(context
);
161 p
[i
] != (krb5_enctype
)ETYPE_NULL
&& enctype
== (krb5_enctype
)ETYPE_NULL
;
163 if (krb5_enctype_valid(context
, p
[i
]) != 0 &&
164 !_kdc_is_weak_exception(princ
->entry
.principal
, p
[i
]))
167 /* check that the client supports it too */
168 for (k
= 0; k
< len
&& enctype
== (krb5_enctype
)ETYPE_NULL
; k
++) {
170 if (p
[i
] != etypes
[k
])
173 /* check target princ support */
175 while (hdb_next_enctype2key(context
, &princ
->entry
, NULL
,
177 if (key
->key
.keyvalue
.length
== 0) {
178 ret
= KRB5KDC_ERR_NULL_KEY
;
183 if (is_preauth
&& ret_key
!= NULL
&&
184 !is_default_salt_p(&def_salt
, key
))
191 * Pick the first key from the client's enctype list that is
192 * supported by the cryptosystem and by the given principal.
194 * RFC4120 says we SHOULD pick the first _strong_ key from the
195 * client's list... not the first key... If the admin disallows
196 * weak enctypes in krb5.conf and selects this key selection
197 * algorithm, then we get exactly what RFC4120 says.
199 for(i
= 0; ret
!= 0 && i
< len
; i
++) {
201 if (krb5_enctype_valid(context
, etypes
[i
]) != 0 &&
202 !_kdc_is_weak_exception(princ
->entry
.principal
, etypes
[i
]))
207 hdb_next_enctype2key(context
, &princ
->entry
, NULL
,
208 etypes
[i
], &key
) == 0) {
209 if (key
->key
.keyvalue
.length
== 0) {
210 ret
= KRB5KDC_ERR_NULL_KEY
;
215 if (is_preauth
&& ret_key
!= NULL
&&
216 !is_default_salt_p(&def_salt
, key
))
222 if (enctype
== (krb5_enctype
)ETYPE_NULL
) {
224 * if the service principal is one for which there is a known 1DES
225 * exception and no other enctype matches both the client request and
226 * the service key list, provide a DES-CBC-CRC key.
228 if (ret_key
== NULL
&&
229 _kdc_is_weak_exception(princ
->entry
.principal
, ETYPE_DES_CBC_CRC
)) {
231 enctype
= ETYPE_DES_CBC_CRC
;
233 ret
= KRB5KDC_ERR_ETYPE_NOSUPP
;
238 if (ret_enctype
!= NULL
)
239 *ret_enctype
= enctype
;
244 krb5_free_salt (context
, def_salt
);
249 _kdc_make_anonymous_principalname (PrincipalName
*pn
)
251 pn
->name_type
= KRB5_NT_PRINCIPAL
;
252 pn
->name_string
.len
= 1;
253 pn
->name_string
.val
= malloc(sizeof(*pn
->name_string
.val
));
254 if (pn
->name_string
.val
== NULL
)
256 pn
->name_string
.val
[0] = strdup("anonymous");
257 if (pn
->name_string
.val
[0] == NULL
) {
258 free(pn
->name_string
.val
);
259 pn
->name_string
.val
= NULL
;
266 _kdc_r_log(kdc_request_t r
, int level
, const char *fmt
, ...)
271 s
= kdc_log_msg_va(r
->context
, r
->config
, level
, fmt
, ap
);
277 _kdc_set_e_text(kdc_request_t r
, const char *e_text
)
280 kdc_log(r
->context
, r
->config
, 0, "%s", e_text
);
284 _kdc_log_timestamp(krb5_context context
,
285 krb5_kdc_configuration
*config
,
287 KerberosTime authtime
, KerberosTime
*starttime
,
288 KerberosTime endtime
, KerberosTime
*renew_till
)
290 char authtime_str
[100], starttime_str
[100],
291 endtime_str
[100], renewtime_str
[100];
293 krb5_format_time(context
, authtime
,
294 authtime_str
, sizeof(authtime_str
), TRUE
);
296 krb5_format_time(context
, *starttime
,
297 starttime_str
, sizeof(starttime_str
), TRUE
);
299 strlcpy(starttime_str
, "unset", sizeof(starttime_str
));
300 krb5_format_time(context
, endtime
,
301 endtime_str
, sizeof(endtime_str
), TRUE
);
303 krb5_format_time(context
, *renew_till
,
304 renewtime_str
, sizeof(renewtime_str
), TRUE
);
306 strlcpy(renewtime_str
, "unset", sizeof(renewtime_str
));
308 kdc_log(context
, config
, 5,
309 "%s authtime: %s starttime: %s endtime: %s renew till: %s",
310 type
, authtime_str
, starttime_str
, endtime_str
, renewtime_str
);
319 static krb5_error_code
320 pa_pkinit_validate(kdc_request_t r
, const PA_DATA
*pa
)
322 pk_client_params
*pkp
= NULL
;
323 char *client_cert
= NULL
;
326 ret
= _kdc_pk_rd_padata(r
->context
, r
->config
, &r
->req
, pa
, r
->client
, &pkp
);
327 if (ret
|| pkp
== NULL
) {
328 ret
= KRB5KRB_AP_ERR_BAD_INTEGRITY
;
329 _kdc_r_log(r
, 5, "Failed to decode PKINIT PA-DATA -- %s",
334 ret
= _kdc_pk_check_client(r
->context
,
341 _kdc_set_e_text(r
, "PKINIT certificate not allowed to "
342 "impersonate principal");
346 _kdc_r_log(r
, 0, "PKINIT pre-authentication succeeded -- %s using %s",
347 r
->client_name
, client_cert
);
350 ret
= _kdc_pk_mk_pa_reply(r
->context
, r
->config
, pkp
, r
->client
,
351 r
->sessionetype
, &r
->req
, &r
->request
,
352 &r
->reply_key
, &r
->session_key
, &r
->outpadata
);
354 _kdc_set_e_text(r
, "Failed to build PK-INIT reply");
358 ret
= _kdc_add_inital_verified_cas(r
->context
, r
->config
,
363 _kdc_pk_free_client_param(r
->context
, pkp
);
374 static krb5_error_code
375 make_pa_enc_challange(krb5_context context
, METHOD_DATA
*md
,
382 EncryptedData encdata
;
387 krb5_us_timeofday (context
, &p
.patimestamp
, &usec
);
391 ASN1_MALLOC_ENCODE(PA_ENC_TS_ENC
, buf
, buf_size
, &p
, &len
, ret
);
395 krb5_abortx(context
, "internal error in ASN.1 encoder");
397 ret
= krb5_encrypt_EncryptedData(context
,
399 KRB5_KU_ENC_CHALLENGE_KDC
,
408 ASN1_MALLOC_ENCODE(EncryptedData
, buf
, buf_size
, &encdata
, &len
, ret
);
409 free_EncryptedData(&encdata
);
413 krb5_abortx(context
, "internal error in ASN.1 encoder");
415 ret
= krb5_padata_add(context
, md
, KRB5_PADATA_ENCRYPTED_CHALLENGE
, buf
, len
);
421 static krb5_error_code
422 pa_enc_chal_validate(kdc_request_t r
, const PA_DATA
*pa
)
424 krb5_data pepper1
, pepper2
, ts_data
;
425 KDC_REQ_BODY
*b
= &r
->req
.req_body
;
426 EncryptedData enc_data
;
427 krb5_enctype aenctype
;
433 heim_assert(r
->armor_crypto
!= NULL
, "ENC-CHAL called for non FAST");
435 if (_kdc_is_anon_request(b
)) {
436 ret
= KRB5KRB_AP_ERR_BAD_INTEGRITY
;
437 kdc_log(r
->context
, r
->config
, 0, "ENC-CHALL doesn't support anon");
441 ret
= decode_EncryptedData(pa
->padata_value
.data
,
442 pa
->padata_value
.length
,
446 ret
= KRB5KRB_AP_ERR_BAD_INTEGRITY
;
447 _kdc_r_log(r
, 5, "Failed to decode PA-DATA -- %s",
452 pepper1
.data
= "clientchallengearmor";
453 pepper1
.length
= strlen(pepper1
.data
);
454 pepper2
.data
= "challengelongterm";
455 pepper2
.length
= strlen(pepper2
.data
);
457 krb5_crypto_getenctype(r
->context
, r
->armor_crypto
, &aenctype
);
459 for (i
= 0; i
< r
->client
->entry
.keys
.len
; i
++) {
460 krb5_crypto challangecrypto
, longtermcrypto
;
461 krb5_keyblock challangekey
;
464 k
= &r
->client
->entry
.keys
.val
[i
];
466 ret
= krb5_crypto_init(r
->context
, &k
->key
, 0, &longtermcrypto
);
470 ret
= krb5_crypto_fx_cf2(r
->context
, r
->armor_crypto
, longtermcrypto
,
471 &pepper1
, &pepper2
, aenctype
,
473 krb5_crypto_destroy(r
->context
, longtermcrypto
);
477 ret
= krb5_crypto_init(r
->context
, &challangekey
, 0,
482 ret
= krb5_decrypt_EncryptedData(r
->context
, challangecrypto
,
483 KRB5_KU_ENC_CHALLENGE_CLIENT
,
489 ret
= decode_PA_ENC_TS_ENC(ts_data
.data
,
493 krb5_data_free(&ts_data
);
495 krb5_crypto_destroy(r
->context
, challangecrypto
);
496 ret
= KRB5KDC_ERR_PREAUTH_FAILED
;
497 _kdc_r_log(r
, 5, "Failed to decode PA-ENC-TS_ENC -- %s",
502 if (abs(kdc_time
- p
.patimestamp
) > r
->context
->max_skew
) {
503 char client_time
[100];
505 krb5_crypto_destroy(r
->context
, challangecrypto
);
507 krb5_format_time(r
->context
, p
.patimestamp
,
508 client_time
, sizeof(client_time
), TRUE
);
510 ret
= KRB5KRB_AP_ERR_SKEW
;
511 _kdc_r_log(r
, 0, "Too large time skew, "
512 "client time %s is out by %u > %u seconds -- %s",
514 (unsigned)abs(kdc_time
- p
.patimestamp
),
515 r
->context
->max_skew
,
518 free_PA_ENC_TS_ENC(&p
);
522 free_PA_ENC_TS_ENC(&p
);
524 ret
= make_pa_enc_challange(r
->context
, &r
->outpadata
,
526 krb5_crypto_destroy(r
->context
, challangecrypto
);
530 set_salt_padata(&r
->outpadata
, k
->salt
);
531 krb5_free_keyblock_contents(r
->context
, &r
->reply_key
);
532 ret
= krb5_copy_keyblock_contents(r
->context
, &k
->key
, &r
->reply_key
);
538 if (i
< r
->client
->entry
.keys
.len
)
539 ret
= KRB5KDC_ERR_PREAUTH_FAILED
;
541 free_EncryptedData(&enc_data
);
546 static krb5_error_code
547 pa_enc_ts_validate(kdc_request_t r
, const PA_DATA
*pa
)
549 EncryptedData enc_data
;
558 if (_kdc_is_anon_request(&r
->req
.req_body
)) {
559 ret
= KRB5KRB_AP_ERR_BAD_INTEGRITY
;
560 _kdc_set_e_text(r
, "ENC-TS doesn't support anon");
564 ret
= decode_EncryptedData(pa
->padata_value
.data
,
565 pa
->padata_value
.length
,
569 ret
= KRB5KRB_AP_ERR_BAD_INTEGRITY
;
570 _kdc_r_log(r
, 5, "Failed to decode PA-DATA -- %s",
575 ret
= hdb_enctype2key(r
->context
, &r
->client
->entry
, NULL
,
576 enc_data
.etype
, &pa_key
);
579 _kdc_set_e_text(r
, "No key matching entype");
580 ret
= KRB5KDC_ERR_ETYPE_NOSUPP
;
581 if(krb5_enctype_to_string(r
->context
, enc_data
.etype
, &estr
))
585 "No client key matching pa-data (%d) -- %s",
586 enc_data
.etype
, r
->client_name
);
589 "No client key matching pa-data (%s) -- %s",
590 estr
, r
->client_name
);
592 free_EncryptedData(&enc_data
);
597 ret
= krb5_crypto_init(r
->context
, &pa_key
->key
, 0, &crypto
);
599 const char *msg
= krb5_get_error_message(r
->context
, ret
);
600 _kdc_r_log(r
, 0, "krb5_crypto_init failed: %s", msg
);
601 krb5_free_error_message(r
->context
, msg
);
602 free_EncryptedData(&enc_data
);
606 ret
= krb5_decrypt_EncryptedData (r
->context
,
608 KRB5_KU_PA_ENC_TIMESTAMP
,
611 krb5_crypto_destroy(r
->context
, crypto
);
613 * Since the user might have several keys with the same
614 * enctype but with diffrent salting, we need to try all
615 * the keys with the same enctype.
618 krb5_error_code ret2
;
619 const char *msg
= krb5_get_error_message(r
->context
, ret
);
621 ret2
= krb5_enctype_to_string(r
->context
,
622 pa_key
->key
.keytype
, &str
);
625 _kdc_r_log(r
, 5, "Failed to decrypt PA-DATA -- %s "
626 "(enctype %s) error %s",
627 r
->client_name
, str
? str
: "unknown enctype", msg
);
628 krb5_free_error_message(r
->context
, msg
);
631 if(hdb_next_enctype2key(r
->context
, &r
->client
->entry
, NULL
,
632 enc_data
.etype
, &pa_key
) == 0)
635 free_EncryptedData(&enc_data
);
637 if (r
->clientdb
->hdb_auth_status
)
638 r
->clientdb
->hdb_auth_status(r
->context
, r
->clientdb
, r
->client
,
639 HDB_AUTH_WRONG_PASSWORD
);
641 ret
= KRB5KDC_ERR_PREAUTH_FAILED
;
644 free_EncryptedData(&enc_data
);
645 ret
= decode_PA_ENC_TS_ENC(ts_data
.data
,
649 krb5_data_free(&ts_data
);
651 ret
= KRB5KDC_ERR_PREAUTH_FAILED
;
652 _kdc_r_log(r
, 5, "Failed to decode PA-ENC-TS_ENC -- %s",
656 if (abs(kdc_time
- p
.patimestamp
) > r
->context
->max_skew
) {
657 char client_time
[100];
659 krb5_format_time(r
->context
, p
.patimestamp
,
660 client_time
, sizeof(client_time
), TRUE
);
662 ret
= KRB5KRB_AP_ERR_SKEW
;
663 _kdc_r_log(r
, 0, "Too large time skew, "
664 "client time %s is out by %u > %u seconds -- %s",
666 (unsigned)abs(kdc_time
- p
.patimestamp
),
667 r
->context
->max_skew
,
671 * The following is needed to make windows clients to
672 * retry using the timestamp in the error message, if
673 * there is a e_text, they become unhappy.
676 free_PA_ENC_TS_ENC(&p
);
679 free_PA_ENC_TS_ENC(&p
);
681 set_salt_padata(&r
->outpadata
, pa_key
->salt
);
683 ret
= krb5_copy_keyblock_contents(r
->context
, &pa_key
->key
, &r
->reply_key
);
687 ret
= krb5_enctype_to_string(r
->context
, pa_key
->key
.keytype
, &str
);
690 _kdc_r_log(r
, 2, "ENC-TS Pre-authentication succeeded -- %s using %s",
691 r
->client_name
, str
? str
: "unknown enctype");
705 #define PA_ANNOUNCE 1
706 #define PA_REQ_FAST 2 /* only use inside fast */
707 krb5_error_code (*validate
)(kdc_request_t
, const PA_DATA
*pa
);
710 static const struct kdc_patypes pat
[] = {
713 KRB5_PADATA_PK_AS_REQ
, "PK-INIT(ietf)", PA_ANNOUNCE
,
717 KRB5_PADATA_PK_AS_REQ_WIN
, "PK-INIT(win2k)", PA_ANNOUNCE
,
721 KRB5_PADATA_PKINIT_KX
, "Anonymous PK-INIT", PA_ANNOUNCE
,
725 { KRB5_PADATA_PK_AS_REQ
, "PK-INIT(ietf)", 0, NULL
},
726 { KRB5_PADATA_PK_AS_REQ_WIN
, "PK-INIT(win2k)", 0, NULL
},
727 { KRB5_PADATA_PKINIT_KX
, "Anonymous PK-INIT", 0, NULL
},
729 { KRB5_PADATA_PA_PK_OCSP_RESPONSE
, "OCSP", 0, NULL
},
731 KRB5_PADATA_ENC_TIMESTAMP
, "ENC-TS",
736 KRB5_PADATA_ENCRYPTED_CHALLENGE
, "ENC-CHAL",
737 PA_ANNOUNCE
| PA_REQ_FAST
,
740 { KRB5_PADATA_REQ_ENC_PA_REP
, "REQ-ENC-PA-REP", 0, NULL
},
741 { KRB5_PADATA_FX_FAST
, "FX-FAST", PA_ANNOUNCE
, NULL
},
742 { KRB5_PADATA_FX_ERROR
, "FX-ERROR", 0, NULL
},
743 { KRB5_PADATA_FX_COOKIE
, "FX-COOKIE", 0, NULL
}
747 log_patypes(krb5_context context
,
748 krb5_kdc_configuration
*config
,
751 struct rk_strpool
*p
= NULL
;
755 for (n
= 0; n
< padata
->len
; n
++) {
756 for (m
= 0; m
< sizeof(pat
) / sizeof(pat
[0]); m
++) {
757 if (padata
->val
[n
].padata_type
== pat
[m
].type
) {
758 p
= rk_strpoolprintf(p
, "%s", pat
[m
].name
);
762 if (m
== sizeof(pat
) / sizeof(pat
[0]))
763 p
= rk_strpoolprintf(p
, "%d", padata
->val
[n
].padata_type
);
764 if (p
&& n
+ 1 < padata
->len
)
765 p
= rk_strpoolprintf(p
, ", ");
767 kdc_log(context
, config
, 0, "out of memory");
772 p
= rk_strpoolprintf(p
, "none");
774 str
= rk_strpoolcollect(p
);
775 kdc_log(context
, config
, 0, "Client sent patypes: %s", str
);
784 _kdc_encode_reply(krb5_context context
,
785 krb5_kdc_configuration
*config
,
786 krb5_crypto armor_crypto
, uint32_t nonce
,
787 KDC_REP
*rep
, EncTicketPart
*et
, EncKDCRepPart
*ek
,
789 int skvno
, const EncryptionKey
*skey
,
790 int ckvno
, const EncryptionKey
*reply_key
,
801 ASN1_MALLOC_ENCODE(EncTicketPart
, buf
, buf_size
, et
, &len
, ret
);
803 const char *msg
= krb5_get_error_message(context
, ret
);
804 kdc_log(context
, config
, 0, "Failed to encode ticket: %s", msg
);
805 krb5_free_error_message(context
, msg
);
809 krb5_abortx(context
, "Internal error in ASN.1 encoder");
811 ret
= krb5_crypto_init(context
, skey
, etype
, &crypto
);
813 const char *msg
= krb5_get_error_message(context
, ret
);
814 kdc_log(context
, config
, 0, "krb5_crypto_init failed: %s", msg
);
815 krb5_free_error_message(context
, msg
);
819 ret
= krb5_encrypt_EncryptedData(context
,
825 &rep
->ticket
.enc_part
);
827 krb5_crypto_destroy(context
, crypto
);
829 const char *msg
= krb5_get_error_message(context
, ret
);
830 kdc_log(context
, config
, 0, "Failed to encrypt data: %s", msg
);
831 krb5_free_error_message(context
, msg
);
837 krb5_keyblock
*strengthen_key
= NULL
;
838 KrbFastFinished finished
;
840 kdc_log(context
, config
, 0, "FAST armor protection");
842 memset(&finished
, 0, sizeof(finished
));
843 krb5_data_zero(&data
);
845 finished
.timestamp
= kdc_time
;
847 finished
.crealm
= et
->crealm
;
848 finished
.cname
= et
->cname
;
850 ASN1_MALLOC_ENCODE(Ticket
, data
.data
, data
.length
,
851 &rep
->ticket
, &len
, ret
);
854 if (data
.length
!= len
)
855 krb5_abortx(context
, "internal asn.1 error");
857 ret
= krb5_create_checksum(context
, armor_crypto
,
858 KRB5_KU_FAST_FINISHED
, 0,
859 data
.data
, data
.length
,
860 &finished
.ticket_checksum
);
861 krb5_data_free(&data
);
865 ret
= _kdc_fast_mk_response(context
, armor_crypto
,
866 rep
->padata
, strengthen_key
, &finished
,
868 free_Checksum(&finished
.ticket_checksum
);
873 free_METHOD_DATA(rep
->padata
);
875 rep
->padata
= calloc(1, sizeof(*(rep
->padata
)));
876 if (rep
->padata
== NULL
) {
877 krb5_data_free(&data
);
882 ret
= krb5_padata_add(context
, rep
->padata
,
884 data
.data
, data
.length
);
889 * Hide client name of privacy reasons
891 if (1 /* r->fast_options.hide_client_names */) {
892 rep
->crealm
[0] = '\0';
893 free_PrincipalName(&rep
->cname
);
894 rep
->cname
.name_type
= 0;
898 if(rep
->msg_type
== krb_as_rep
&& !config
->encode_as_rep_as_tgs_rep
)
899 ASN1_MALLOC_ENCODE(EncASRepPart
, buf
, buf_size
, ek
, &len
, ret
);
901 ASN1_MALLOC_ENCODE(EncTGSRepPart
, buf
, buf_size
, ek
, &len
, ret
);
903 const char *msg
= krb5_get_error_message(context
, ret
);
904 kdc_log(context
, config
, 0, "Failed to encode KDC-REP: %s", msg
);
905 krb5_free_error_message(context
, msg
);
908 if(buf_size
!= len
) {
910 kdc_log(context
, config
, 0, "Internal error in ASN.1 encoder");
911 *e_text
= "KDC internal error";
912 return KRB5KRB_ERR_GENERIC
;
914 ret
= krb5_crypto_init(context
, reply_key
, 0, &crypto
);
916 const char *msg
= krb5_get_error_message(context
, ret
);
918 kdc_log(context
, config
, 0, "krb5_crypto_init failed: %s", msg
);
919 krb5_free_error_message(context
, msg
);
922 if(rep
->msg_type
== krb_as_rep
) {
923 krb5_encrypt_EncryptedData(context
,
925 KRB5_KU_AS_REP_ENC_PART
,
931 ASN1_MALLOC_ENCODE(AS_REP
, buf
, buf_size
, rep
, &len
, ret
);
933 krb5_encrypt_EncryptedData(context
,
935 rk_is_subkey
? KRB5_KU_TGS_REP_ENC_PART_SUB_KEY
: KRB5_KU_TGS_REP_ENC_PART_SESSION
,
941 ASN1_MALLOC_ENCODE(TGS_REP
, buf
, buf_size
, rep
, &len
, ret
);
943 krb5_crypto_destroy(context
, crypto
);
945 const char *msg
= krb5_get_error_message(context
, ret
);
946 kdc_log(context
, config
, 0, "Failed to encode KDC-REP: %s", msg
);
947 krb5_free_error_message(context
, msg
);
950 if(buf_size
!= len
) {
952 kdc_log(context
, config
, 0, "Internal error in ASN.1 encoder");
953 *e_text
= "KDC internal error";
954 return KRB5KRB_ERR_GENERIC
;
957 reply
->length
= buf_size
;
962 * Return 1 if the client have only older enctypes, this is for
963 * determining if the server should send ETYPE_INFO2 or not.
967 older_enctype(krb5_enctype enctype
)
970 case ETYPE_DES_CBC_CRC
:
971 case ETYPE_DES_CBC_MD4
:
972 case ETYPE_DES_CBC_MD5
:
973 case ETYPE_DES3_CBC_SHA1
:
974 case ETYPE_ARCFOUR_HMAC_MD5
:
975 case ETYPE_ARCFOUR_HMAC_MD5_56
:
977 * The following three is "old" windows enctypes and is needed for
978 * windows 2000 hosts.
980 case ETYPE_ARCFOUR_MD4
:
981 case ETYPE_ARCFOUR_HMAC_OLD
:
982 case ETYPE_ARCFOUR_HMAC_OLD_EXP
:
993 static krb5_error_code
994 make_etype_info_entry(krb5_context context
, ETYPE_INFO_ENTRY
*ent
, Key
*key
)
996 ent
->etype
= key
->key
.keytype
;
999 ALLOC(ent
->salttype
);
1001 if(key
->salt
->type
== hdb_pw_salt
)
1002 *ent
->salttype
= 0; /* or 1? or NULL? */
1003 else if(key
->salt
->type
== hdb_afs3_salt
)
1006 kdc_log(context
, config
, 0, "unknown salt-type: %d",
1008 return KRB5KRB_ERR_GENERIC
;
1010 /* according to `the specs', we can't send a salt if
1011 we have AFS3 salted key, but that requires that you
1012 *know* what cell you are using (e.g by assuming
1013 that the cell is the same as the realm in lower
1016 ALLOC(ent
->salttype
);
1017 *ent
->salttype
= key
->salt
->type
;
1020 * We shouldn't sent salttype since it is incompatible with the
1021 * specification and it breaks windows clients. The afs
1022 * salting problem is solved by using KRB5-PADATA-AFS3-SALT
1023 * implemented in Heimdal 0.7 and later.
1025 ent
->salttype
= NULL
;
1027 krb5_copy_data(context
, &key
->salt
->salt
,
1030 /* we return no salt type at all, as that should indicate
1031 * the default salt type and make everybody happy. some
1032 * systems (like w2k) dislike being told the salt type
1035 ent
->salttype
= NULL
;
1041 static krb5_error_code
1042 get_pa_etype_info(krb5_context context
,
1043 krb5_kdc_configuration
*config
,
1044 METHOD_DATA
*md
, Key
*ckey
)
1046 krb5_error_code ret
= 0;
1053 pa
.val
= calloc(1, sizeof(pa
.val
[0]));
1057 ret
= make_etype_info_entry(context
, &pa
.val
[0], ckey
);
1059 free_ETYPE_INFO(&pa
);
1063 ASN1_MALLOC_ENCODE(ETYPE_INFO
, buf
, len
, &pa
, &len
, ret
);
1064 free_ETYPE_INFO(&pa
);
1067 ret
= realloc_method_data(md
);
1072 md
->val
[md
->len
- 1].padata_type
= KRB5_PADATA_ETYPE_INFO
;
1073 md
->val
[md
->len
- 1].padata_value
.length
= len
;
1074 md
->val
[md
->len
- 1].padata_value
.data
= buf
;
1082 extern int _krb5_AES_string_to_default_iterator
;
1084 static krb5_error_code
1085 make_etype_info2_entry(ETYPE_INFO2_ENTRY
*ent
, Key
*key
)
1087 ent
->etype
= key
->key
.keytype
;
1090 if (ent
->salt
== NULL
)
1092 *ent
->salt
= malloc(key
->salt
->salt
.length
+ 1);
1093 if (*ent
->salt
== NULL
) {
1098 memcpy(*ent
->salt
, key
->salt
->salt
.data
, key
->salt
->salt
.length
);
1099 (*ent
->salt
)[key
->salt
->salt
.length
] = '\0';
1103 ent
->s2kparams
= NULL
;
1105 switch (key
->key
.keytype
) {
1106 case ETYPE_AES128_CTS_HMAC_SHA1_96
:
1107 case ETYPE_AES256_CTS_HMAC_SHA1_96
:
1108 ALLOC(ent
->s2kparams
);
1109 if (ent
->s2kparams
== NULL
)
1111 ent
->s2kparams
->length
= 4;
1112 ent
->s2kparams
->data
= malloc(ent
->s2kparams
->length
);
1113 if (ent
->s2kparams
->data
== NULL
) {
1114 free(ent
->s2kparams
);
1115 ent
->s2kparams
= NULL
;
1118 _krb5_put_int(ent
->s2kparams
->data
,
1119 _krb5_AES_string_to_default_iterator
,
1120 ent
->s2kparams
->length
);
1122 case ETYPE_DES_CBC_CRC
:
1123 case ETYPE_DES_CBC_MD4
:
1124 case ETYPE_DES_CBC_MD5
:
1125 /* Check if this was a AFS3 salted key */
1126 if(key
->salt
&& key
->salt
->type
== hdb_afs3_salt
){
1127 ALLOC(ent
->s2kparams
);
1128 if (ent
->s2kparams
== NULL
)
1130 ent
->s2kparams
->length
= 1;
1131 ent
->s2kparams
->data
= malloc(ent
->s2kparams
->length
);
1132 if (ent
->s2kparams
->data
== NULL
) {
1133 free(ent
->s2kparams
);
1134 ent
->s2kparams
= NULL
;
1137 _krb5_put_int(ent
->s2kparams
->data
,
1139 ent
->s2kparams
->length
);
1149 * Return an ETYPE-INFO2. Enctypes are storted the same way as in the
1150 * database (client supported enctypes first, then the unsupported
1154 static krb5_error_code
1155 get_pa_etype_info2(krb5_context context
,
1156 krb5_kdc_configuration
*config
,
1157 METHOD_DATA
*md
, Key
*ckey
)
1159 krb5_error_code ret
= 0;
1165 pa
.val
= calloc(1, sizeof(pa
.val
[0]));
1169 ret
= make_etype_info2_entry(&pa
.val
[0], ckey
);
1171 free_ETYPE_INFO2(&pa
);
1175 ASN1_MALLOC_ENCODE(ETYPE_INFO2
, buf
, len
, &pa
, &len
, ret
);
1176 free_ETYPE_INFO2(&pa
);
1179 ret
= realloc_method_data(md
);
1184 md
->val
[md
->len
- 1].padata_type
= KRB5_PADATA_ETYPE_INFO2
;
1185 md
->val
[md
->len
- 1].padata_value
.length
= len
;
1186 md
->val
[md
->len
- 1].padata_value
.data
= buf
;
1195 log_as_req(krb5_context context
,
1196 krb5_kdc_configuration
*config
,
1197 krb5_enctype cetype
,
1198 krb5_enctype setype
,
1199 const KDC_REQ_BODY
*b
)
1201 krb5_error_code ret
;
1202 struct rk_strpool
*p
;
1206 p
= rk_strpoolprintf(NULL
, "%s", "Client supported enctypes: ");
1208 for (i
= 0; i
< b
->etype
.len
; i
++) {
1209 ret
= krb5_enctype_to_string(context
, b
->etype
.val
[i
], &str
);
1211 p
= rk_strpoolprintf(p
, "%s", str
);
1214 p
= rk_strpoolprintf(p
, "%d", b
->etype
.val
[i
]);
1215 if (p
&& i
+ 1 < b
->etype
.len
)
1216 p
= rk_strpoolprintf(p
, ", ");
1218 kdc_log(context
, config
, 0, "out of memory");
1223 p
= rk_strpoolprintf(p
, "no encryption types");
1229 ret
= krb5_enctype_to_string(context
, cetype
, &cet
);
1231 ret
= krb5_enctype_to_string(context
, setype
, &set
);
1233 p
= rk_strpoolprintf(p
, ", using %s/%s", cet
, set
);
1239 p
= rk_strpoolprintf(p
, ", using enctypes %d/%d",
1243 str
= rk_strpoolcollect(p
);
1244 kdc_log(context
, config
, 0, "%s", str
);
1249 unparse_flags(KDCOptions2int(b
->kdc_options
), asn1_KDCOptions_units(),
1250 fixedstr
, sizeof(fixedstr
));
1252 kdc_log(context
, config
, 0, "Requested flags: %s", fixedstr
);
1257 * verify the flags on `client' and `server', returning 0
1258 * if they are OK and generating an error messages and returning
1259 * and error code otherwise.
1263 kdc_check_flags(krb5_context context
,
1264 krb5_kdc_configuration
*config
,
1265 hdb_entry_ex
*client_ex
, const char *client_name
,
1266 hdb_entry_ex
*server_ex
, const char *server_name
,
1267 krb5_boolean is_as_req
)
1269 if(client_ex
!= NULL
) {
1270 hdb_entry
*client
= &client_ex
->entry
;
1273 if (client
->flags
.locked_out
) {
1274 kdc_log(context
, config
, 0,
1275 "Client (%s) is locked out", client_name
);
1276 return KRB5KDC_ERR_POLICY
;
1279 if (client
->flags
.invalid
) {
1280 kdc_log(context
, config
, 0,
1281 "Client (%s) has invalid bit set", client_name
);
1282 return KRB5KDC_ERR_POLICY
;
1285 if(!client
->flags
.client
){
1286 kdc_log(context
, config
, 0,
1287 "Principal may not act as client -- %s", client_name
);
1288 return KRB5KDC_ERR_POLICY
;
1291 if (client
->valid_start
&& *client
->valid_start
> kdc_time
) {
1292 char starttime_str
[100];
1293 krb5_format_time(context
, *client
->valid_start
,
1294 starttime_str
, sizeof(starttime_str
), TRUE
);
1295 kdc_log(context
, config
, 0,
1296 "Client not yet valid until %s -- %s",
1297 starttime_str
, client_name
);
1298 return KRB5KDC_ERR_CLIENT_NOTYET
;
1301 if (client
->valid_end
&& *client
->valid_end
< kdc_time
) {
1302 char endtime_str
[100];
1303 krb5_format_time(context
, *client
->valid_end
,
1304 endtime_str
, sizeof(endtime_str
), TRUE
);
1305 kdc_log(context
, config
, 0,
1306 "Client expired at %s -- %s",
1307 endtime_str
, client_name
);
1308 return KRB5KDC_ERR_NAME_EXP
;
1311 if (client
->flags
.require_pwchange
&&
1312 (server_ex
== NULL
|| !server_ex
->entry
.flags
.change_pw
)) {
1313 kdc_log(context
, config
, 0,
1314 "Client's key must be changed -- %s", client_name
);
1315 return KRB5KDC_ERR_KEY_EXPIRED
;
1318 if (client
->pw_end
&& *client
->pw_end
< kdc_time
1319 && (server_ex
== NULL
|| !server_ex
->entry
.flags
.change_pw
)) {
1320 char pwend_str
[100];
1321 krb5_format_time(context
, *client
->pw_end
,
1322 pwend_str
, sizeof(pwend_str
), TRUE
);
1323 kdc_log(context
, config
, 0,
1324 "Client's key has expired at %s -- %s",
1325 pwend_str
, client_name
);
1326 return KRB5KDC_ERR_KEY_EXPIRED
;
1332 if (server_ex
!= NULL
) {
1333 hdb_entry
*server
= &server_ex
->entry
;
1335 if (server
->flags
.locked_out
) {
1336 kdc_log(context
, config
, 0,
1337 "Client server locked out -- %s", server_name
);
1338 return KRB5KDC_ERR_POLICY
;
1340 if (server
->flags
.invalid
) {
1341 kdc_log(context
, config
, 0,
1342 "Server has invalid flag set -- %s", server_name
);
1343 return KRB5KDC_ERR_POLICY
;
1346 if(!server
->flags
.server
){
1347 kdc_log(context
, config
, 0,
1348 "Principal may not act as server -- %s", server_name
);
1349 return KRB5KDC_ERR_POLICY
;
1352 if(!is_as_req
&& server
->flags
.initial
) {
1353 kdc_log(context
, config
, 0,
1354 "AS-REQ is required for server -- %s", server_name
);
1355 return KRB5KDC_ERR_POLICY
;
1358 if (server
->valid_start
&& *server
->valid_start
> kdc_time
) {
1359 char starttime_str
[100];
1360 krb5_format_time(context
, *server
->valid_start
,
1361 starttime_str
, sizeof(starttime_str
), TRUE
);
1362 kdc_log(context
, config
, 0,
1363 "Server not yet valid until %s -- %s",
1364 starttime_str
, server_name
);
1365 return KRB5KDC_ERR_SERVICE_NOTYET
;
1368 if (server
->valid_end
&& *server
->valid_end
< kdc_time
) {
1369 char endtime_str
[100];
1370 krb5_format_time(context
, *server
->valid_end
,
1371 endtime_str
, sizeof(endtime_str
), TRUE
);
1372 kdc_log(context
, config
, 0,
1373 "Server expired at %s -- %s",
1374 endtime_str
, server_name
);
1375 return KRB5KDC_ERR_SERVICE_EXP
;
1378 if (server
->pw_end
&& *server
->pw_end
< kdc_time
) {
1379 char pwend_str
[100];
1380 krb5_format_time(context
, *server
->pw_end
,
1381 pwend_str
, sizeof(pwend_str
), TRUE
);
1382 kdc_log(context
, config
, 0,
1383 "Server's key has expired at -- %s",
1384 pwend_str
, server_name
);
1385 return KRB5KDC_ERR_KEY_EXPIRED
;
1392 * Return TRUE if `from' is part of `addresses' taking into consideration
1393 * the configuration variables that tells us how strict we should be about
1398 _kdc_check_addresses(krb5_context context
,
1399 krb5_kdc_configuration
*config
,
1400 HostAddresses
*addresses
, const struct sockaddr
*from
)
1402 krb5_error_code ret
;
1404 krb5_boolean result
;
1405 krb5_boolean only_netbios
= TRUE
;
1408 if(config
->check_ticket_addresses
== 0)
1411 if(addresses
== NULL
)
1412 return config
->allow_null_ticket_addresses
;
1414 for (i
= 0; i
< addresses
->len
; ++i
) {
1415 if (addresses
->val
[i
].addr_type
!= KRB5_ADDRESS_NETBIOS
) {
1416 only_netbios
= FALSE
;
1420 /* Windows sends it's netbios name, which I can only assume is
1421 * used for the 'allowed workstations' check. This is painful,
1422 * but we still want to check IP addresses if they happen to be
1427 return config
->allow_null_ticket_addresses
;
1429 ret
= krb5_sockaddr2address (context
, from
, &addr
);
1433 result
= krb5_address_search(context
, &addr
, addresses
);
1434 krb5_free_address (context
, &addr
);
1443 send_pac_p(krb5_context context
, KDC_REQ
*req
)
1445 krb5_error_code ret
;
1446 PA_PAC_REQUEST pacreq
;
1450 pa
= _kdc_find_padata(req
, &i
, KRB5_PADATA_PA_PAC_REQUEST
);
1454 ret
= decode_PA_PAC_REQUEST(pa
->padata_value
.data
,
1455 pa
->padata_value
.length
,
1460 i
= pacreq
.include_pac
;
1461 free_PA_PAC_REQUEST(&pacreq
);
1471 static krb5_error_code
1472 generate_pac(kdc_request_t r
, Key
*skey
)
1474 krb5_error_code ret
;
1478 ret
= _kdc_pac_generate(r
->context
, r
->client
, &p
);
1480 _kdc_r_log(r
, 0, "PAC generation failed for -- %s",
1487 ret
= _krb5_pac_sign(r
->context
, p
, r
->et
.authtime
,
1488 r
->client
->entry
.principal
,
1489 &skey
->key
, /* Server key */
1490 &skey
->key
, /* FIXME: should be krbtgt key */
1492 krb5_pac_free(r
->context
, p
);
1494 _kdc_r_log(r
, 0, "PAC signing failed for -- %s",
1499 ret
= _kdc_tkt_add_if_relevant_ad(r
->context
, &r
->et
,
1500 KRB5_AUTHDATA_WIN2K_PAC
,
1502 krb5_data_free(&data
);
1512 _kdc_is_anonymous(krb5_context context
, krb5_principal principal
)
1514 if (principal
->name
.name_type
!= KRB5_NT_WELLKNOWN
||
1515 principal
->name
.name_string
.len
!= 2 ||
1516 strcmp(principal
->name
.name_string
.val
[0], KRB5_WELLKNOWN_NAME
) != 0 ||
1517 strcmp(principal
->name
.name_string
.val
[1], KRB5_ANON_NAME
) != 0)
1523 require_preauth_p(kdc_request_t r
)
1525 return r
->config
->require_preauth
1526 || r
->client
->entry
.flags
.require_preauth
1527 || r
->server
->entry
.flags
.require_preauth
;
1535 static krb5_error_code
1536 add_enc_pa_rep(kdc_request_t r
)
1538 krb5_error_code ret
;
1544 ret
= krb5_crypto_init(r
->context
, &r
->reply_key
, 0, &crypto
);
1548 ret
= krb5_create_checksum(r
->context
, crypto
,
1550 r
->request
.data
, r
->request
.length
,
1552 krb5_crypto_destroy(r
->context
, crypto
);
1556 ASN1_MALLOC_ENCODE(Checksum
, cdata
.data
, cdata
.length
,
1557 &checksum
, &len
, ret
);
1558 free_Checksum(&checksum
);
1561 heim_assert(cdata
.length
== len
, "ASN.1 internal error");
1563 if (r
->ek
.encrypted_pa_data
== NULL
) {
1564 ALLOC(r
->ek
.encrypted_pa_data
);
1565 if (r
->ek
.encrypted_pa_data
== NULL
)
1568 ret
= krb5_padata_add(r
->context
, r
->ek
.encrypted_pa_data
,
1569 KRB5_PADATA_REQ_ENC_PA_REP
, cdata
.data
, cdata
.length
);
1573 return krb5_padata_add(r
->context
, r
->ek
.encrypted_pa_data
,
1574 KRB5_PADATA_FX_FAST
, NULL
, 0);
1582 _kdc_as_rep(kdc_request_t r
,
1585 struct sockaddr
*from_addr
,
1588 krb5_context context
= r
->context
;
1589 krb5_kdc_configuration
*config
= r
->config
;
1590 KDC_REQ
*req
= &r
->req
;
1591 KDC_REQ_BODY
*b
= NULL
;
1594 krb5_enctype setype
;
1595 krb5_error_code ret
= 0;
1598 int i
, flags
= HDB_F_FOR_AS_REQ
;
1599 METHOD_DATA error_method
;
1602 memset(&rep
, 0, sizeof(rep
));
1603 error_method
.len
= 0;
1604 error_method
.val
= NULL
;
1607 * Look for FAST armor and unwrap
1609 ret
= _kdc_fast_unwrap_request(r
);
1611 _kdc_r_log(r
, 0, "FAST unwrap request from %s failed: %d", from
, ret
);
1619 flags
|= HDB_F_CANON
;
1621 if(b
->sname
== NULL
){
1622 ret
= KRB5KRB_ERR_GENERIC
;
1623 _kdc_set_e_text(r
, "No server in request");
1625 ret
= _krb5_principalname2krb5_principal (context
,
1630 ret
= krb5_unparse_name(context
, r
->server_princ
, &r
->server_name
);
1633 kdc_log(context
, config
, 0,
1634 "AS-REQ malformed server name from %s", from
);
1637 if(b
->cname
== NULL
){
1638 ret
= KRB5KRB_ERR_GENERIC
;
1639 _kdc_set_e_text(r
, "No client in request");
1641 ret
= _krb5_principalname2krb5_principal (context
,
1648 ret
= krb5_unparse_name(context
, r
->client_princ
, &r
->client_name
);
1651 kdc_log(context
, config
, 0,
1652 "AS-REQ malformed client name from %s", from
);
1656 kdc_log(context
, config
, 0, "AS-REQ %s from %s for %s",
1657 r
->client_name
, from
, r
->server_name
);
1663 if (_kdc_is_anonymous(context
, r
->client_princ
)) {
1664 if (!_kdc_is_anon_request(b
)) {
1665 kdc_log(context
, config
, 0, "Anonymous ticket w/o anonymous flag");
1666 ret
= KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN
;
1669 } else if (_kdc_is_anon_request(b
)) {
1670 kdc_log(context
, config
, 0,
1671 "Request for a anonymous ticket with non "
1672 "anonymous client name: %s", r
->client_name
);
1673 ret
= KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN
;
1681 ret
= _kdc_db_fetch(context
, config
, r
->client_princ
,
1682 HDB_F_GET_CLIENT
| flags
, NULL
,
1683 &r
->clientdb
, &r
->client
);
1684 if(ret
== HDB_ERR_NOT_FOUND_HERE
) {
1685 kdc_log(context
, config
, 5, "client %s does not have secrets at this KDC, need to proxy",
1689 const char *msg
= krb5_get_error_message(context
, ret
);
1690 kdc_log(context
, config
, 0, "UNKNOWN -- %s: %s", r
->client_name
, msg
);
1691 krb5_free_error_message(context
, msg
);
1692 ret
= KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN
;
1695 ret
= _kdc_db_fetch(context
, config
, r
->server_princ
,
1696 HDB_F_GET_SERVER
|HDB_F_GET_KRBTGT
| flags
,
1697 NULL
, NULL
, &r
->server
);
1698 if(ret
== HDB_ERR_NOT_FOUND_HERE
) {
1699 kdc_log(context
, config
, 5, "target %s does not have secrets at this KDC, need to proxy",
1703 const char *msg
= krb5_get_error_message(context
, ret
);
1704 kdc_log(context
, config
, 0, "UNKNOWN -- %s: %s", r
->server_name
, msg
);
1705 krb5_free_error_message(context
, msg
);
1706 ret
= KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN
;
1711 * Select a session enctype from the list of the crypto system
1712 * supported enctypes that is supported by the client and is one of
1713 * the enctype of the enctype of the service (likely krbtgt).
1715 * The latter is used as a hint of what enctypes all KDC support,
1716 * to make sure a newer version of KDC won't generate a session
1717 * enctype that an older version of a KDC in the same realm can't
1721 ret
= _kdc_find_etype(context
,
1722 krb5_principal_is_krbtgt(context
, r
->server_princ
) ?
1723 config
->tgt_use_strongest_session_key
:
1724 config
->svc_use_strongest_session_key
, FALSE
,
1725 r
->client
, b
->etype
.val
, b
->etype
.len
, &r
->sessionetype
,
1728 kdc_log(context
, config
, 0,
1729 "Client (%s) from %s has no common enctypes with KDC "
1730 "to use for the session key",
1731 r
->client_name
, from
);
1736 * Pre-auth processing
1742 log_patypes(context
, config
, req
->padata
);
1744 /* Check if preauth matching */
1746 for (n
= 0; !found_pa
&& n
< sizeof(pat
) / sizeof(pat
[0]); n
++) {
1747 if (pat
[n
].validate
== NULL
)
1749 if (r
->armor_crypto
== NULL
&& (pat
[n
].flags
& PA_REQ_FAST
))
1752 kdc_log(context
, config
, 5,
1753 "Looking for %s pa-data -- %s", pat
[n
].name
, r
->client_name
);
1755 pa
= _kdc_find_padata(req
, &i
, pat
[n
].type
);
1757 ret
= pat
[n
].validate(r
, pa
);
1759 kdc_log(context
, config
, 0,
1760 "%s pre-authentication succeeded -- %s",
1761 pat
[n
].name
, r
->client_name
);
1763 r
->et
.flags
.pre_authent
= 1;
1769 if (found_pa
== 0) {
1773 for (n
= 0; n
< sizeof(pat
) / sizeof(pat
[0]); n
++) {
1774 if ((pat
[n
].flags
& PA_ANNOUNCE
) == 0)
1776 ret
= krb5_padata_add(context
, &error_method
,
1777 pat
[n
].type
, NULL
, 0);
1783 * If there is a client key, send ETYPE_INFO{,2}
1785 ret
= _kdc_find_etype(context
,
1786 config
->preauth_use_strongest_session_key
, TRUE
,
1787 r
->client
, b
->etype
.val
, b
->etype
.len
, NULL
, &ckey
);
1792 * - If the client only knows about old enctypes, then send
1793 * both info replies (we send 'info' first in the list).
1794 * - If the client is 'modern', because it knows about 'new'
1795 * enctype types, then only send the 'info2' reply.
1797 * Before we send the full list of etype-info data, we pick
1798 * the client key we would have used anyway below, just pick
1802 if (older_enctype(ckey
->key
.keytype
)) {
1803 ret
= get_pa_etype_info(context
, config
,
1804 &error_method
, ckey
);
1808 ret
= get_pa_etype_info2(context
, config
,
1809 &error_method
, ckey
);
1815 * send requre preauth is its required or anon is requested,
1816 * anon is today only allowed via preauth mechanisms.
1818 if (require_preauth_p(r
) || _kdc_is_anon_request(b
)) {
1819 ret
= KRB5KDC_ERR_PREAUTH_REQUIRED
;
1820 _kdc_set_e_text(r
, "Need to use PA-ENC-TIMESTAMP/PA-PK-AS-REQ");
1825 ret
= KRB5KDC_ERR_CLIENT_NOTYET
;
1826 _kdc_set_e_text(r
, "Doesn't have a client key available");
1829 krb5_free_keyblock_contents(r
->context
, &r
->reply_key
);
1830 ret
= krb5_copy_keyblock_contents(r
->context
, &ckey
->key
, &r
->reply_key
);
1835 if (r
->clientdb
->hdb_auth_status
)
1836 r
->clientdb
->hdb_auth_status(context
, r
->clientdb
, r
->client
,
1840 * Verify flags after the user been required to prove its identity
1841 * with in a preauth mech.
1844 ret
= _kdc_check_access(context
, config
, r
->client
, r
->client_name
,
1845 r
->server
, r
->server_name
,
1846 req
, &error_method
);
1851 * Select the best encryption type for the KDC with out regard to
1852 * the client since the client never needs to read that data.
1855 ret
= _kdc_get_preferred_key(context
, config
,
1856 r
->server
, r
->server_name
,
1861 if(f
.renew
|| f
.validate
|| f
.proxy
|| f
.forwarded
|| f
.enc_tkt_in_skey
1862 || (_kdc_is_anon_request(b
) && !config
->allow_anonymous
)) {
1863 ret
= KRB5KDC_ERR_BADOPTION
;
1864 _kdc_set_e_text(r
, "Bad KDC options");
1873 rep
.msg_type
= krb_as_rep
;
1875 if (_kdc_is_anonymous(context
, r
->client_princ
)) {
1876 Realm anon_realm
=KRB5_ANON_REALM
;
1877 ret
= copy_Realm(&anon_realm
, &rep
.crealm
);
1879 ret
= copy_Realm(&r
->client
->entry
.principal
->realm
, &rep
.crealm
);
1882 ret
= _krb5_principal2principalname(&rep
.cname
, r
->client
->entry
.principal
);
1886 rep
.ticket
.tkt_vno
= 5;
1887 copy_Realm(&r
->server
->entry
.principal
->realm
, &rep
.ticket
.realm
);
1888 _krb5_principal2principalname(&rep
.ticket
.sname
,
1889 r
->server
->entry
.principal
);
1890 /* java 1.6 expects the name to be the same type, lets allow that
1891 * uncomplicated name-types. */
1892 #define CNT(sp,t) (((sp)->sname->name_type) == KRB5_NT_##t)
1893 if (CNT(b
, UNKNOWN
) || CNT(b
, PRINCIPAL
) || CNT(b
, SRV_INST
) || CNT(b
, SRV_HST
) || CNT(b
, SRV_XHST
))
1894 rep
.ticket
.sname
.name_type
= b
->sname
->name_type
;
1897 r
->et
.flags
.initial
= 1;
1898 if(r
->client
->entry
.flags
.forwardable
&& r
->server
->entry
.flags
.forwardable
)
1899 r
->et
.flags
.forwardable
= f
.forwardable
;
1900 else if (f
.forwardable
) {
1901 _kdc_set_e_text(r
, "Ticket may not be forwardable");
1902 ret
= KRB5KDC_ERR_POLICY
;
1905 if(r
->client
->entry
.flags
.proxiable
&& r
->server
->entry
.flags
.proxiable
)
1906 r
->et
.flags
.proxiable
= f
.proxiable
;
1907 else if (f
.proxiable
) {
1908 _kdc_set_e_text(r
, "Ticket may not be proxiable");
1909 ret
= KRB5KDC_ERR_POLICY
;
1912 if(r
->client
->entry
.flags
.postdate
&& r
->server
->entry
.flags
.postdate
)
1913 r
->et
.flags
.may_postdate
= f
.allow_postdate
;
1914 else if (f
.allow_postdate
){
1915 _kdc_set_e_text(r
, "Ticket may not be postdate");
1916 ret
= KRB5KDC_ERR_POLICY
;
1920 /* check for valid set of addresses */
1921 if(!_kdc_check_addresses(context
, config
, b
->addresses
, from_addr
)) {
1922 _kdc_set_e_text(r
, "Bad address list in requested");
1923 ret
= KRB5KRB_AP_ERR_BADADDR
;
1927 ret
= copy_PrincipalName(&rep
.cname
, &r
->et
.cname
);
1930 ret
= copy_Realm(&rep
.crealm
, &r
->et
.crealm
);
1938 start
= r
->et
.authtime
= kdc_time
;
1940 if(f
.postdated
&& req
->req_body
.from
){
1941 ALLOC(r
->et
.starttime
);
1942 start
= *r
->et
.starttime
= *req
->req_body
.from
;
1943 r
->et
.flags
.invalid
= 1;
1944 r
->et
.flags
.postdated
= 1; /* XXX ??? */
1946 _kdc_fix_time(&b
->till
);
1949 /* be careful not overflowing */
1951 if(r
->client
->entry
.max_life
)
1952 t
= start
+ min(t
- start
, *r
->client
->entry
.max_life
);
1953 if(r
->server
->entry
.max_life
)
1954 t
= start
+ min(t
- start
, *r
->server
->entry
.max_life
);
1956 t
= min(t
, start
+ realm
->max_life
);
1959 if(f
.renewable_ok
&& r
->et
.endtime
< *b
->till
){
1961 if(b
->rtime
== NULL
){
1965 if(*b
->rtime
< *b
->till
)
1966 *b
->rtime
= *b
->till
;
1968 if(f
.renewable
&& b
->rtime
){
1972 if(r
->client
->entry
.max_renew
)
1973 t
= start
+ min(t
- start
, *r
->client
->entry
.max_renew
);
1974 if(r
->server
->entry
.max_renew
)
1975 t
= start
+ min(t
- start
, *r
->server
->entry
.max_renew
);
1977 t
= min(t
, start
+ realm
->max_renew
);
1979 ALLOC(r
->et
.renew_till
);
1980 *r
->et
.renew_till
= t
;
1981 r
->et
.flags
.renewable
= 1;
1985 if (_kdc_is_anon_request(b
))
1986 r
->et
.flags
.anonymous
= 1;
1990 copy_HostAddresses(b
->addresses
, r
->et
.caddr
);
1993 r
->et
.transited
.tr_type
= DOMAIN_X500_COMPRESS
;
1994 krb5_data_zero(&r
->et
.transited
.contents
);
1996 /* The MIT ASN.1 library (obviously) doesn't tell lengths encoded
1997 * as 0 and as 0x80 (meaning indefinite length) apart, and is thus
1998 * incapable of correctly decoding SEQUENCE OF's of zero length.
2000 * To fix this, always send at least one no-op last_req
2002 * If there's a pw_end or valid_end we will use that,
2003 * otherwise just a dummy lr.
2005 r
->ek
.last_req
.val
= malloc(2 * sizeof(*r
->ek
.last_req
.val
));
2006 if (r
->ek
.last_req
.val
== NULL
) {
2010 r
->ek
.last_req
.len
= 0;
2011 if (r
->client
->entry
.pw_end
2012 && (config
->kdc_warn_pwexpire
== 0
2013 || kdc_time
+ config
->kdc_warn_pwexpire
>= *r
->client
->entry
.pw_end
)) {
2014 r
->ek
.last_req
.val
[r
->ek
.last_req
.len
].lr_type
= LR_PW_EXPTIME
;
2015 r
->ek
.last_req
.val
[r
->ek
.last_req
.len
].lr_value
= *r
->client
->entry
.pw_end
;
2016 ++r
->ek
.last_req
.len
;
2018 if (r
->client
->entry
.valid_end
) {
2019 r
->ek
.last_req
.val
[r
->ek
.last_req
.len
].lr_type
= LR_ACCT_EXPTIME
;
2020 r
->ek
.last_req
.val
[r
->ek
.last_req
.len
].lr_value
= *r
->client
->entry
.valid_end
;
2021 ++r
->ek
.last_req
.len
;
2023 if (r
->ek
.last_req
.len
== 0) {
2024 r
->ek
.last_req
.val
[r
->ek
.last_req
.len
].lr_type
= LR_NONE
;
2025 r
->ek
.last_req
.val
[r
->ek
.last_req
.len
].lr_value
= 0;
2026 ++r
->ek
.last_req
.len
;
2028 r
->ek
.nonce
= b
->nonce
;
2029 if (r
->client
->entry
.valid_end
|| r
->client
->entry
.pw_end
) {
2030 ALLOC(r
->ek
.key_expiration
);
2031 if (r
->client
->entry
.valid_end
) {
2032 if (r
->client
->entry
.pw_end
)
2033 *r
->ek
.key_expiration
= min(*r
->client
->entry
.valid_end
,
2034 *r
->client
->entry
.pw_end
);
2036 *r
->ek
.key_expiration
= *r
->client
->entry
.valid_end
;
2038 *r
->ek
.key_expiration
= *r
->client
->entry
.pw_end
;
2040 r
->ek
.key_expiration
= NULL
;
2041 r
->ek
.flags
= r
->et
.flags
;
2042 r
->ek
.authtime
= r
->et
.authtime
;
2043 if (r
->et
.starttime
) {
2044 ALLOC(r
->ek
.starttime
);
2045 *r
->ek
.starttime
= *r
->et
.starttime
;
2047 r
->ek
.endtime
= r
->et
.endtime
;
2048 if (r
->et
.renew_till
) {
2049 ALLOC(r
->ek
.renew_till
);
2050 *r
->ek
.renew_till
= *r
->et
.renew_till
;
2052 copy_Realm(&rep
.ticket
.realm
, &r
->ek
.srealm
);
2053 copy_PrincipalName(&rep
.ticket
.sname
, &r
->ek
.sname
);
2056 copy_HostAddresses(r
->et
.caddr
, r
->ek
.caddr
);
2060 * Check and session and reply keys
2063 if (r
->session_key
.keytype
== ETYPE_NULL
) {
2064 ret
= krb5_generate_random_keyblock(context
, r
->sessionetype
, &r
->session_key
);
2069 if (r
->reply_key
.keytype
== ETYPE_NULL
) {
2070 _kdc_set_e_text(r
, "Client have no reply key");
2071 ret
= KRB5KDC_ERR_CLIENT_NOTYET
;
2075 ret
= copy_EncryptionKey(&r
->session_key
, &r
->et
.key
);
2079 ret
= copy_EncryptionKey(&r
->session_key
, &r
->ek
.key
);
2084 * Add signing of alias referral
2087 if (f
.canonicalize
) {
2088 PA_ClientCanonicalized canon
;
2091 krb5_crypto cryptox
;
2094 memset(&canon
, 0, sizeof(canon
));
2096 canon
.names
.requested_name
= *b
->cname
;
2097 canon
.names
.mapped_name
= r
->client
->entry
.principal
->name
;
2099 ASN1_MALLOC_ENCODE(PA_ClientCanonicalizedNames
, data
.data
, data
.length
,
2100 &canon
.names
, &len
, ret
);
2103 if (data
.length
!= len
)
2104 krb5_abortx(context
, "internal asn.1 error");
2106 /* sign using "returned session key" */
2107 ret
= krb5_crypto_init(context
, &r
->et
.key
, 0, &cryptox
);
2113 ret
= krb5_create_checksum(context
, cryptox
,
2114 KRB5_KU_CANONICALIZED_NAMES
, 0,
2115 data
.data
, data
.length
,
2116 &canon
.canon_checksum
);
2118 krb5_crypto_destroy(context
, cryptox
);
2122 ASN1_MALLOC_ENCODE(PA_ClientCanonicalized
, data
.data
, data
.length
,
2124 free_Checksum(&canon
.canon_checksum
);
2127 if (data
.length
!= len
)
2128 krb5_abortx(context
, "internal asn.1 error");
2130 tmppa
.padata_type
= KRB5_PADATA_CLIENT_CANONICALIZED
;
2131 tmppa
.padata_value
= data
;
2132 ret
= add_METHOD_DATA(&r
->outpadata
, &tmppa
);
2138 if (r
->outpadata
.len
) {
2141 if (rep
.padata
== NULL
) {
2145 ret
= copy_METHOD_DATA(&r
->outpadata
, rep
.padata
);
2151 if (send_pac_p(context
, req
)) {
2152 generate_pac(r
, skey
);
2155 _kdc_log_timestamp(context
, config
, "AS-REQ", r
->et
.authtime
, r
->et
.starttime
,
2156 r
->et
.endtime
, r
->et
.renew_till
);
2158 /* do this as the last thing since this signs the EncTicketPart */
2159 ret
= _kdc_add_KRB5SignedPath(context
,
2163 r
->client
->entry
.principal
,
2170 log_as_req(context
, config
, r
->reply_key
.keytype
, setype
, b
);
2173 * We always say we support FAST/enc-pa-rep
2176 r
->et
.flags
.enc_pa_rep
= r
->ek
.flags
.enc_pa_rep
= 1;
2179 * Add REQ_ENC_PA_REP if client supports it
2183 pa
= _kdc_find_padata(req
, &i
, KRB5_PADATA_REQ_ENC_PA_REP
);
2186 ret
= add_enc_pa_rep(r
);
2188 const char *msg
= krb5_get_error_message(r
->context
, ret
);
2189 _kdc_r_log(r
, 0, "add_enc_pa_rep failed: %s: %d", msg
, ret
);
2190 krb5_free_error_message(r
->context
, msg
);
2199 ret
= _kdc_encode_reply(context
, config
,
2200 r
->armor_crypto
, req
->req_body
.nonce
,
2201 &rep
, &r
->et
, &r
->ek
, setype
, r
->server
->entry
.kvno
,
2202 &skey
->key
, r
->client
->entry
.kvno
,
2203 &r
->reply_key
, 0, &r
->e_text
, reply
);
2208 * Check if message too large
2210 if (datagram_reply
&& reply
->length
> config
->max_datagram_reply_length
) {
2211 krb5_data_free(reply
);
2212 ret
= KRB5KRB_ERR_RESPONSE_TOO_BIG
;
2213 _kdc_set_e_text(r
, "Reply packet too large");
2220 * In case of a non proxy error, build an error message.
2222 if(ret
!= 0 && ret
!= HDB_ERR_NOT_FOUND_HERE
) {
2223 ret
= _kdc_fast_mk_error(context
, r
,
2228 r
->client_princ
, r
->server_princ
,
2235 free_EncTicketPart(&r
->et
);
2236 free_EncKDCRepPart(&r
->ek
);
2237 free_KDCFastState(&r
->fast
);
2239 if (error_method
.len
)
2240 free_METHOD_DATA(&error_method
);
2241 if (r
->outpadata
.len
)
2242 free_METHOD_DATA(&r
->outpadata
);
2243 if (r
->client_princ
) {
2244 krb5_free_principal(context
, r
->client_princ
);
2245 r
->client_princ
= NULL
;
2247 if (r
->client_name
) {
2248 free(r
->client_name
);
2249 r
->client_name
= NULL
;
2251 if (r
->server_princ
){
2252 krb5_free_principal(context
, r
->server_princ
);
2253 r
->server_princ
= NULL
;
2255 if (r
->server_name
) {
2256 free(r
->server_name
);
2257 r
->server_name
= NULL
;
2260 _kdc_free_ent(context
, r
->client
);
2262 _kdc_free_ent(context
, r
->server
);
2263 if (r
->armor_crypto
) {
2264 krb5_crypto_destroy(r
->context
, r
->armor_crypto
);
2265 r
->armor_crypto
= NULL
;
2267 krb5_free_keyblock_contents(r
->context
, &r
->reply_key
);
2268 krb5_free_keyblock_contents(r
->context
, &r
->session_key
);
2273 * Add the AuthorizationData `data´ of `type´ to the last element in
2274 * the sequence of authorization_data in `tkt´ wrapped in an IF_RELEVANT
2278 _kdc_tkt_add_if_relevant_ad(krb5_context context
,
2281 const krb5_data
*data
)
2283 krb5_error_code ret
;
2286 if (tkt
->authorization_data
== NULL
) {
2287 tkt
->authorization_data
= calloc(1, sizeof(*tkt
->authorization_data
));
2288 if (tkt
->authorization_data
== NULL
) {
2289 krb5_set_error_message(context
, ENOMEM
, "out of memory");
2294 /* add the entry to the last element */
2296 AuthorizationData ad
= { 0, NULL
};
2297 AuthorizationDataElement ade
;
2300 ade
.ad_data
= *data
;
2302 ret
= add_AuthorizationData(&ad
, &ade
);
2304 krb5_set_error_message(context
, ret
, "add AuthorizationData failed");
2308 ade
.ad_type
= KRB5_AUTHDATA_IF_RELEVANT
;
2310 ASN1_MALLOC_ENCODE(AuthorizationData
,
2311 ade
.ad_data
.data
, ade
.ad_data
.length
,
2313 free_AuthorizationData(&ad
);
2315 krb5_set_error_message(context
, ret
, "ASN.1 encode of "
2316 "AuthorizationData failed");
2319 if (ade
.ad_data
.length
!= size
)
2320 krb5_abortx(context
, "internal asn.1 encoder error");
2322 ret
= add_AuthorizationData(tkt
->authorization_data
, &ade
);
2323 der_free_octet_string(&ade
.ad_data
);
2325 krb5_set_error_message(context
, ret
, "add AuthorizationData failed");
2334 _kdc_is_anon_request(const KDC_REQ_BODY
*b
)
2336 /* some versions of heimdal use bit 14 instead of 16 for
2337 request_anonymous, as indicated in the anonymous draft prior to
2338 version 11. Bit 14 is assigned to S4U2Proxy, but all S4U2Proxy
2339 requests will have a second ticket; don't consider those anonymous */
2340 return (b
->kdc_options
.request_anonymous
||
2341 (b
->kdc_options
.constrained_delegation
&& !b
->additional_tickets
));