2 * Copyright (c) 2006 - 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 #include <rfc2459_asn1.h>
46 _kdc_try_kx509_request(void *ptr
, size_t len
, struct Kx509Request
*req
, size_t *size
)
50 if (memcmp("\x00\x00\x02\x00", ptr
, 4) != 0)
52 return decode_Kx509Request(((unsigned char *)ptr
) + 4, len
- 4, req
, size
);
59 static const unsigned char version_2_0
[4] = {0 , 0, 2, 0};
61 static krb5_error_code
62 verify_req_hash(krb5_context context
,
63 const Kx509Request
*req
,
66 unsigned char digest
[SHA_DIGEST_LENGTH
];
69 if (req
->pk_hash
.length
!= sizeof(digest
)) {
70 krb5_set_error_message(context
, KRB5KDC_ERR_PREAUTH_FAILED
,
71 "pk-hash have wrong length: %lu",
72 (unsigned long)req
->pk_hash
.length
);
73 return KRB5KDC_ERR_PREAUTH_FAILED
;
78 key
->keyvalue
.data
, key
->keyvalue
.length
,
80 if (sizeof(digest
) != HMAC_size(&ctx
))
81 krb5_abortx(context
, "runtime error, hmac buffer wrong size in kx509");
82 HMAC_Update(&ctx
, version_2_0
, sizeof(version_2_0
));
83 HMAC_Update(&ctx
, req
->pk_key
.data
, req
->pk_key
.length
);
84 HMAC_Final(&ctx
, digest
, 0);
85 HMAC_CTX_cleanup(&ctx
);
87 if (memcmp(req
->pk_hash
.data
, digest
, sizeof(digest
)) != 0) {
88 krb5_set_error_message(context
, KRB5KDC_ERR_PREAUTH_FAILED
,
89 "pk-hash is not correct");
90 return KRB5KDC_ERR_PREAUTH_FAILED
;
95 static krb5_error_code
96 calculate_reply_hash(krb5_context context
,
105 HMAC_Init_ex(&ctx
, key
->keyvalue
.data
, key
->keyvalue
.length
,
107 ret
= krb5_data_alloc(rep
->hash
, HMAC_size(&ctx
));
109 HMAC_CTX_cleanup(&ctx
);
110 krb5_set_error_message(context
, ENOMEM
, "malloc: out of memory");
114 HMAC_Update(&ctx
, version_2_0
, sizeof(version_2_0
));
115 if (rep
->error_code
) {
116 int32_t t
= *rep
->error_code
;
118 unsigned char p
= (t
& 0xff);
119 HMAC_Update(&ctx
, &p
, 1);
123 if (rep
->certificate
)
124 HMAC_Update(&ctx
, rep
->certificate
->data
, rep
->certificate
->length
);
126 HMAC_Update(&ctx
, (unsigned char *)*rep
->e_text
, strlen(*rep
->e_text
));
128 HMAC_Final(&ctx
, rep
->hash
->data
, 0);
129 HMAC_CTX_cleanup(&ctx
);
135 * Build a certifate for `principal´ that will expire at `endtime´.
138 static krb5_error_code
139 build_certificate(krb5_context context
,
140 krb5_kdc_configuration
*config
,
141 const krb5_data
*key
,
143 krb5_principal principal
,
144 krb5_data
*certificate
)
146 hx509_context hxctx
= NULL
;
147 hx509_ca_tbs tbs
= NULL
;
148 hx509_env env
= NULL
;
149 hx509_cert cert
= NULL
;
150 hx509_cert signer
= NULL
;
153 if (krb5_principal_get_comp_string(context
, principal
, 1) != NULL
) {
154 kdc_log(context
, config
, 0, "Principal is not a user");
158 ret
= hx509_context_init(&hxctx
);
162 ret
= hx509_env_add(hxctx
, &env
, "principal-name",
163 krb5_principal_get_comp_string(context
, principal
, 0));
171 ret
= hx509_certs_init(hxctx
, config
->kx509_ca
, 0,
174 kdc_log(context
, config
, 0, "Failed to load CA %s",
178 ret
= hx509_query_alloc(hxctx
, &q
);
180 hx509_certs_free(&certs
);
184 hx509_query_match_option(q
, HX509_QUERY_OPTION_PRIVATE_KEY
);
185 hx509_query_match_option(q
, HX509_QUERY_OPTION_KU_KEYCERTSIGN
);
187 ret
= hx509_certs_find(hxctx
, certs
, q
, &signer
);
188 hx509_query_free(hxctx
, q
);
189 hx509_certs_free(&certs
);
191 kdc_log(context
, config
, 0, "Failed to find a CA in %s",
197 ret
= hx509_ca_tbs_init(hxctx
, &tbs
);
202 SubjectPublicKeyInfo spki
;
205 memset(&spki
, 0, sizeof(spki
));
207 spki
.subjectPublicKey
.data
= key
->data
;
208 spki
.subjectPublicKey
.length
= key
->length
* 8;
210 ret
= der_copy_oid(oid_id_pkcs1_rsaEncryption(),
211 &spki
.algorithm
.algorithm
);
213 any
.data
= "\x05\x00";
215 spki
.algorithm
.parameters
= &any
;
217 ret
= hx509_ca_tbs_set_spki(hxctx
, tbs
, &spki
);
218 der_free_oid(&spki
.algorithm
.algorithm
);
227 ret
= hx509_certs_init(hxctx
, config
->kx509_template
, 0,
230 kdc_log(context
, config
, 0, "Failed to load template %s",
231 config
->kx509_template
);
234 ret
= hx509_get_one_cert(hxctx
, certs
, &template);
235 hx509_certs_free(&certs
);
237 kdc_log(context
, config
, 0, "Failed to find template in %s",
238 config
->kx509_template
);
241 ret
= hx509_ca_tbs_set_template(hxctx
, tbs
,
242 HX509_CA_TEMPLATE_SUBJECT
|
243 HX509_CA_TEMPLATE_KU
|
244 HX509_CA_TEMPLATE_EKU
,
246 hx509_cert_free(template);
251 hx509_ca_tbs_set_notAfter(hxctx
, tbs
, endtime
);
253 hx509_ca_tbs_subject_expand(hxctx
, tbs
, env
);
254 hx509_env_free(&env
);
256 ret
= hx509_ca_sign(hxctx
, tbs
, signer
, &cert
);
257 hx509_cert_free(signer
);
261 hx509_ca_tbs_free(&tbs
);
263 ret
= hx509_cert_binary(hxctx
, cert
, certificate
);
264 hx509_cert_free(cert
);
268 hx509_context_free(&hxctx
);
273 hx509_env_free(&env
);
275 hx509_ca_tbs_free(&tbs
);
277 hx509_cert_free(signer
);
279 hx509_context_free(&hxctx
);
280 krb5_set_error_message(context
, ret
, "cert creation failed");
289 _kdc_do_kx509(krb5_context context
,
290 krb5_kdc_configuration
*config
,
291 const struct Kx509Request
*req
, krb5_data
*reply
,
292 const char *from
, struct sockaddr
*addr
)
295 krb5_ticket
*ticket
= NULL
;
296 krb5_flags ap_req_options
;
297 krb5_auth_context ac
= NULL
;
298 krb5_keytab id
= NULL
;
299 krb5_principal sprincipal
= NULL
, cprincipal
= NULL
;
303 krb5_keyblock
*key
= NULL
;
305 krb5_data_zero(reply
);
306 memset(&rep
, 0, sizeof(rep
));
308 if(!config
->enable_kx509
) {
309 kdc_log(context
, config
, 0,
310 "Rejected kx509 request (disabled) from %s", from
);
311 return KRB5KDC_ERR_POLICY
;
314 kdc_log(context
, config
, 0, "Kx509 request from %s", from
);
316 ret
= krb5_kt_resolve(context
, "HDB:", &id
);
318 kdc_log(context
, config
, 0, "Can't open database for digest");
322 ret
= krb5_rd_req(context
,
332 ret
= krb5_ticket_get_client(context
, ticket
, &cprincipal
);
336 ret
= krb5_unparse_name(context
, cprincipal
, &cname
);
340 /* verify server principal */
342 ret
= krb5_sname_to_principal(context
, NULL
, "kca_service",
343 KRB5_NT_UNKNOWN
, &sprincipal
);
348 krb5_principal principal
= NULL
;
350 ret
= krb5_ticket_get_server(context
, ticket
, &principal
);
354 ret
= krb5_principal_compare(context
, sprincipal
, principal
);
355 krb5_free_principal(context
, principal
);
357 ret
= KRB5KDC_ERR_SERVER_NOMATCH
;
358 krb5_set_error_message(context
, ret
,
359 "User %s used wrong Kx509 service principal",
365 ret
= krb5_auth_con_getkey(context
, ac
, &key
);
366 if (ret
== 0 && key
== NULL
)
367 ret
= KRB5KDC_ERR_NULL_KEY
;
369 krb5_set_error_message(context
, ret
, "Kx509 can't get session key");
373 ret
= verify_req_hash(context
, req
, key
);
377 /* Verify that the key is encoded RSA key */
382 ret
= decode_RSAPublicKey(req
->pk_key
.data
, req
->pk_key
.length
,
386 free_RSAPublicKey(&key
);
387 if (size
!= req
->pk_key
.length
)
391 ALLOC(rep
.certificate
);
392 if (rep
.certificate
== NULL
)
394 krb5_data_zero(rep
.certificate
);
396 if (rep
.hash
== NULL
)
398 krb5_data_zero(rep
.hash
);
400 ret
= build_certificate(context
, config
, &req
->pk_key
,
401 krb5_ticket_get_endtime(context
, ticket
),
402 cprincipal
, rep
.certificate
);
406 ret
= calculate_reply_hash(context
, key
, &rep
);
411 * Encode reply, [ version | Kx509Response ]
417 ASN1_MALLOC_ENCODE(Kx509Response
, data
.data
, data
.length
, &rep
,
420 krb5_set_error_message(context
, ret
, "Failed to encode kx509 reply");
423 if (size
!= data
.length
)
424 krb5_abortx(context
, "ASN1 internal error");
426 ret
= krb5_data_alloc(reply
, data
.length
+ sizeof(version_2_0
));
431 memcpy(reply
->data
, version_2_0
, sizeof(version_2_0
));
432 memcpy(((unsigned char *)reply
->data
) + sizeof(version_2_0
),
433 data
.data
, data
.length
);
437 kdc_log(context
, config
, 0, "Successful Kx509 request for %s", cname
);
441 krb5_auth_con_free(context
, ac
);
443 krb5_warn(context
, ret
, "Kx509 request from %s failed", from
);
445 krb5_free_ticket(context
, ticket
);
447 krb5_kt_close(context
, id
);
449 krb5_free_principal(context
, sprincipal
);
451 krb5_free_principal(context
, cprincipal
);
453 krb5_free_keyblock (context
, key
);
456 free_Kx509Response(&rep
);