2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4 * Copyright (c) 2005 Doug Rabson
7 * Redistribution and use in source and binary forms, with or without
8 * 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.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 #include <gssapi/gssapi.h>
32 #include <gssapi/gssapi_krb5.h>
34 /* RCSID("$Id: gss_krb5.c 21889 2007-08-09 07:43:24Z lha $"); */
41 gss_krb5_copy_ccache(OM_uint32 *minor_status,
45 gss_buffer_set_t data_set = GSS_C_NO_BUFFER_SET;
52 ret = gss_inquire_cred_by_oid(minor_status,
54 GSS_KRB5_COPY_CCACHE_X,
59 if (data_set == GSS_C_NO_BUFFER_SET || data_set->count != 1) {
60 gss_release_buffer_set(minor_status, &data_set);
61 *minor_status = EINVAL;
65 kret = krb5_init_context(&context);
68 gss_release_buffer_set(minor_status, &data_set);
72 kret = asprintf(&str, "%.*s", (int)data_set->elements[0].length,
73 (char *)data_set->elements[0].value);
74 gss_release_buffer_set(minor_status, &data_set);
76 *minor_status = ENOMEM;
80 kret = krb5_cc_resolve(context, str, &id);
87 kret = krb5_cc_copy_cache(context, id, out);
88 krb5_cc_close(context, id);
89 krb5_free_context(context);
99 gss_krb5_import_cred(OM_uint32 *minor_status,
101 krb5_principal keytab_principal,
105 gss_buffer_desc buffer;
106 OM_uint32 major_status;
107 krb5_context context;
113 *cred = GSS_C_NO_CREDENTIAL;
115 ret = krb5_init_context(&context);
118 return GSS_S_FAILURE;
121 sp = krb5_storage_emem();
123 *minor_status = ENOMEM;
124 major_status = GSS_S_FAILURE;
129 ret = krb5_cc_get_full_name(context, id, &str);
131 ret = krb5_store_string(sp, str);
135 ret = krb5_store_string(sp, "");
138 major_status = GSS_S_FAILURE;
142 if (keytab_principal) {
143 ret = krb5_unparse_name(context, keytab_principal, &str);
145 ret = krb5_store_string(sp, str);
149 krb5_store_string(sp, "");
152 major_status = GSS_S_FAILURE;
158 ret = krb5_kt_get_full_name(context, keytab, &str);
160 ret = krb5_store_string(sp, str);
164 krb5_store_string(sp, "");
167 major_status = GSS_S_FAILURE;
171 ret = krb5_storage_to_data(sp, &data);
174 major_status = GSS_S_FAILURE;
178 buffer.value = data.data;
179 buffer.length = data.length;
181 major_status = gss_set_cred_option(minor_status,
183 GSS_KRB5_IMPORT_CRED_X,
185 krb5_data_free(&data);
188 krb5_storage_free(sp);
189 krb5_free_context(context);
194 gsskrb5_register_acceptor_identity(const char *identity)
196 gss_buffer_desc buffer;
199 buffer.value = rk_UNCONST(identity);
200 buffer.length = strlen(identity);
202 gss_set_sec_context_option(&junk, NULL,
203 GSS_KRB5_REGISTER_ACCEPTOR_IDENTITY_X, &buffer);
205 return (GSS_S_COMPLETE);
209 gsskrb5_set_dns_canonicalize(int flag)
211 gss_buffer_desc buffer;
213 char b = (flag != 0);
216 buffer.length = sizeof(b);
218 gss_set_sec_context_option(&junk, NULL,
219 GSS_KRB5_SET_DNS_CANONICALIZE_X, &buffer);
221 return (GSS_S_COMPLETE);
226 static krb5_error_code
227 set_key(krb5_keyblock *keyblock, gss_krb5_lucid_key_t *key)
229 key->type = keyblock->keytype;
230 key->length = keyblock->keyvalue.length;
231 key->data = malloc(key->length);
232 if (key->data == NULL && key->length != 0)
234 memcpy(key->data, keyblock->keyvalue.data, key->length);
239 free_key(gss_krb5_lucid_key_t *key)
241 memset(key->data, 0, key->length);
243 memset(key, 0, sizeof(*key));
247 gss_krb5_export_lucid_sec_context(OM_uint32 *minor_status,
248 gss_ctx_id_t *context_handle,
252 krb5_context context = NULL;
254 gss_buffer_set_t data_set = GSS_C_NO_BUFFER_SET;
255 OM_uint32 major_status;
256 gss_krb5_lucid_context_v1_t *ctx = NULL;
257 krb5_storage *sp = NULL;
260 if (context_handle == NULL
261 || *context_handle == GSS_C_NO_CONTEXT
265 return GSS_S_FAILURE;
269 gss_inquire_sec_context_by_oid (minor_status,
271 GSS_KRB5_EXPORT_LUCID_CONTEXT_V1_X,
276 if (data_set == GSS_C_NO_BUFFER_SET || data_set->count != 1) {
277 gss_release_buffer_set(minor_status, &data_set);
278 *minor_status = EINVAL;
279 return GSS_S_FAILURE;
282 ret = krb5_init_context(&context);
286 ctx = calloc(1, sizeof(*ctx));
292 sp = krb5_storage_from_mem(data_set->elements[0].value,
293 data_set->elements[0].length);
299 ret = krb5_ret_uint32(sp, &num);
307 ret = krb5_ret_uint32(sp, &ctx->initiate);
310 ret = krb5_ret_uint32(sp, &ctx->endtime);
313 ret = krb5_ret_uint32(sp, &num);
315 ctx->send_seq = ((uint64_t)num) << 32;
316 ret = krb5_ret_uint32(sp, &num);
318 ctx->send_seq |= num;
320 ret = krb5_ret_uint32(sp, &num);
322 ctx->recv_seq = ((uint64_t)num) << 32;
323 ret = krb5_ret_uint32(sp, &num);
325 ctx->recv_seq |= num;
327 ret = krb5_ret_uint32(sp, &ctx->protocol);
329 if (ctx->protocol == 0) {
333 ret = krb5_ret_uint32(sp, &ctx->rfc1964_kd.sign_alg);
336 ret = krb5_ret_uint32(sp, &ctx->rfc1964_kd.seal_alg);
339 ret = krb5_ret_keyblock(sp, &key);
341 ret = set_key(&key, &ctx->rfc1964_kd.ctx_key);
342 krb5_free_keyblock_contents(context, &key);
344 } else if (ctx->protocol == 1) {
347 /* acceptor_subkey */
348 ret = krb5_ret_uint32(sp, &ctx->cfx_kd.have_acceptor_subkey);
351 ret = krb5_ret_keyblock(sp, &key);
353 ret = set_key(&key, &ctx->cfx_kd.ctx_key);
354 krb5_free_keyblock_contents(context, &key);
356 /* acceptor_subkey */
357 if (ctx->cfx_kd.have_acceptor_subkey) {
358 ret = krb5_ret_keyblock(sp, &key);
360 ret = set_key(&key, &ctx->cfx_kd.acceptor_subkey);
361 krb5_free_keyblock_contents(context, &key);
372 gss_release_buffer_set(minor_status, &data_set);
374 krb5_storage_free(sp);
376 krb5_free_context(context);
380 gss_krb5_free_lucid_sec_context(NULL, ctx);
383 return GSS_S_FAILURE;
386 return GSS_S_COMPLETE;
390 gss_krb5_free_lucid_sec_context(OM_uint32 *minor_status, void *c)
392 gss_krb5_lucid_context_v1_t *ctx = c;
394 if (ctx->version != 1) {
397 return GSS_S_FAILURE;
400 if (ctx->protocol == 0) {
401 free_key(&ctx->rfc1964_kd.ctx_key);
402 } else if (ctx->protocol == 1) {
403 free_key(&ctx->cfx_kd.ctx_key);
404 if (ctx->cfx_kd.have_acceptor_subkey)
405 free_key(&ctx->cfx_kd.acceptor_subkey);
410 return GSS_S_COMPLETE;
418 gss_krb5_set_allowable_enctypes(OM_uint32 *minor_status,
420 OM_uint32 num_enctypes,
424 OM_uint32 maj_status;
425 gss_buffer_desc buffer;
430 sp = krb5_storage_emem();
432 *minor_status = ENOMEM;
433 maj_status = GSS_S_FAILURE;
437 for (i = 0; i < num_enctypes; i++) {
438 ret = krb5_store_int32(sp, enctypes[i]);
441 maj_status = GSS_S_FAILURE;
446 ret = krb5_storage_to_data(sp, &data);
449 maj_status = GSS_S_FAILURE;
453 buffer.value = data.data;
454 buffer.length = data.length;
456 maj_status = gss_set_cred_option(minor_status,
458 GSS_KRB5_SET_ALLOWABLE_ENCTYPES_X,
460 krb5_data_free(&data);
463 krb5_storage_free(sp);
472 gsskrb5_set_send_to_kdc(struct gsskrb5_send_to_kdc *c)
474 gss_buffer_desc buffer;
479 buffer.length = sizeof(*c);
485 gss_set_sec_context_option(&junk, NULL,
486 GSS_KRB5_SEND_TO_KDC_X, &buffer);
488 return (GSS_S_COMPLETE);
496 gss_krb5_ccache_name(OM_uint32 *minor_status,
498 const char **out_name)
500 gss_buffer_desc buffer;
506 buffer.value = rk_UNCONST(name);
507 buffer.length = strlen(name);
509 gss_set_sec_context_option(&junk, NULL,
510 GSS_KRB5_CCACHE_NAME_X, &buffer);
512 return (GSS_S_COMPLETE);
521 gsskrb5_extract_authtime_from_sec_context(OM_uint32 *minor_status,
522 gss_ctx_id_t context_handle,
525 gss_buffer_set_t data_set = GSS_C_NO_BUFFER_SET;
528 if (context_handle == GSS_C_NO_CONTEXT) {
529 *minor_status = EINVAL;
530 return GSS_S_FAILURE;
534 gss_inquire_sec_context_by_oid (minor_status,
536 GSS_KRB5_GET_AUTHTIME_X,
541 if (data_set == GSS_C_NO_BUFFER_SET) {
542 gss_release_buffer_set(minor_status, &data_set);
543 *minor_status = EINVAL;
544 return GSS_S_FAILURE;
547 if (data_set->count != 1) {
548 gss_release_buffer_set(minor_status, &data_set);
549 *minor_status = EINVAL;
550 return GSS_S_FAILURE;
553 if (data_set->elements[0].length != 4) {
554 gss_release_buffer_set(minor_status, &data_set);
555 *minor_status = EINVAL;
556 return GSS_S_FAILURE;
560 unsigned char *buf = data_set->elements[0].value;
561 *authtime = (buf[3] <<24) | (buf[2] << 16) |
562 (buf[1] << 8) | (buf[0] << 0);
565 gss_release_buffer_set(minor_status, &data_set);
568 return GSS_S_COMPLETE;
576 gsskrb5_extract_authz_data_from_sec_context(OM_uint32 *minor_status,
577 gss_ctx_id_t context_handle,
579 gss_buffer_t ad_data)
581 gss_buffer_set_t data_set = GSS_C_NO_BUFFER_SET;
583 gss_OID_desc oid_flat;
584 heim_oid baseoid, oid;
587 if (context_handle == GSS_C_NO_CONTEXT) {
588 *minor_status = EINVAL;
589 return GSS_S_FAILURE;
592 /* All this to append an integer to an oid... */
594 if (der_get_oid(GSS_KRB5_EXTRACT_AUTHZ_DATA_FROM_SEC_CONTEXT_X->elements,
595 GSS_KRB5_EXTRACT_AUTHZ_DATA_FROM_SEC_CONTEXT_X->length,
596 &baseoid, NULL) != 0) {
597 *minor_status = EINVAL;
598 return GSS_S_FAILURE;
601 oid.length = baseoid.length + 1;
602 oid.components = calloc(oid.length, sizeof(*oid.components));
603 if (oid.components == NULL) {
604 der_free_oid(&baseoid);
606 *minor_status = ENOMEM;
607 return GSS_S_FAILURE;
610 memcpy(oid.components, baseoid.components,
611 baseoid.length * sizeof(*baseoid.components));
613 der_free_oid(&baseoid);
615 oid.components[oid.length - 1] = ad_type;
617 oid_flat.length = der_length_oid(&oid);
618 oid_flat.elements = malloc(oid_flat.length);
619 if (oid_flat.elements == NULL) {
620 free(oid.components);
621 *minor_status = ENOMEM;
622 return GSS_S_FAILURE;
625 if (der_put_oid((unsigned char *)oid_flat.elements + oid_flat.length - 1,
626 oid_flat.length, &oid, &size) != 0) {
627 free(oid.components);
628 free(oid_flat.elements);
629 *minor_status = EINVAL;
630 return GSS_S_FAILURE;
632 if (oid_flat.length != size)
635 free(oid.components);
637 /* FINALLY, we have the OID */
639 maj_stat = gss_inquire_sec_context_by_oid (minor_status,
644 free(oid_flat.elements);
649 if (data_set == GSS_C_NO_BUFFER_SET || data_set->count != 1) {
650 gss_release_buffer_set(minor_status, &data_set);
651 *minor_status = EINVAL;
652 return GSS_S_FAILURE;
655 ad_data->value = malloc(data_set->elements[0].length);
656 if (ad_data->value == NULL) {
657 gss_release_buffer_set(minor_status, &data_set);
658 *minor_status = ENOMEM;
659 return GSS_S_FAILURE;
662 ad_data->length = data_set->elements[0].length;
663 memcpy(ad_data->value, data_set->elements[0].value, ad_data->length);
664 gss_release_buffer_set(minor_status, &data_set);
667 return GSS_S_COMPLETE;
675 gsskrb5_extract_key(OM_uint32 *minor_status,
676 gss_ctx_id_t context_handle,
678 krb5_keyblock **keyblock)
681 gss_buffer_set_t data_set = GSS_C_NO_BUFFER_SET;
682 OM_uint32 major_status;
683 krb5_context context = NULL;
684 krb5_storage *sp = NULL;
686 if (context_handle == GSS_C_NO_CONTEXT) {
688 return GSS_S_FAILURE;
691 ret = krb5_init_context(&context);
694 return GSS_S_FAILURE;
698 gss_inquire_sec_context_by_oid (minor_status,
705 if (data_set == GSS_C_NO_BUFFER_SET || data_set->count != 1) {
706 gss_release_buffer_set(minor_status, &data_set);
707 *minor_status = EINVAL;
708 return GSS_S_FAILURE;
711 sp = krb5_storage_from_mem(data_set->elements[0].value,
712 data_set->elements[0].length);
718 *keyblock = calloc(1, sizeof(**keyblock));
719 if (keyblock == NULL) {
724 ret = krb5_ret_keyblock(sp, *keyblock);
727 gss_release_buffer_set(minor_status, &data_set);
729 krb5_storage_free(sp);
730 if (ret && keyblock) {
731 krb5_free_keyblock(context, *keyblock);
735 krb5_free_context(context);
739 return GSS_S_FAILURE;
741 return GSS_S_COMPLETE;
749 gsskrb5_extract_service_keyblock(OM_uint32 *minor_status,
750 gss_ctx_id_t context_handle,
751 krb5_keyblock **keyblock)
753 return gsskrb5_extract_key(minor_status,
755 GSS_KRB5_GET_SERVICE_KEYBLOCK_X,
760 gsskrb5_get_initiator_subkey(OM_uint32 *minor_status,
761 gss_ctx_id_t context_handle,
762 krb5_keyblock **keyblock)
764 return gsskrb5_extract_key(minor_status,
766 GSS_KRB5_GET_INITIATOR_SUBKEY_X,
771 gsskrb5_get_subkey(OM_uint32 *minor_status,
772 gss_ctx_id_t context_handle,
773 krb5_keyblock **keyblock)
775 return gsskrb5_extract_key(minor_status,
777 GSS_KRB5_GET_SUBKEY_X,
782 gsskrb5_set_default_realm(const char *realm)
784 gss_buffer_desc buffer;
787 buffer.value = rk_UNCONST(realm);
788 buffer.length = strlen(realm);
790 gss_set_sec_context_option(&junk, NULL,
791 GSS_KRB5_SET_DEFAULT_REALM_X, &buffer);
793 return (GSS_S_COMPLETE);
797 gss_krb5_get_tkt_flags(OM_uint32 *minor_status,
798 gss_ctx_id_t context_handle,
799 OM_uint32 *tkt_flags)
802 OM_uint32 major_status;
803 gss_buffer_set_t data_set = GSS_C_NO_BUFFER_SET;
805 if (context_handle == GSS_C_NO_CONTEXT) {
806 *minor_status = EINVAL;
807 return GSS_S_FAILURE;
811 gss_inquire_sec_context_by_oid (minor_status,
813 GSS_KRB5_GET_TKT_FLAGS_X,
818 if (data_set == GSS_C_NO_BUFFER_SET ||
819 data_set->count != 1 ||
820 data_set->elements[0].length < 4) {
821 gss_release_buffer_set(minor_status, &data_set);
822 *minor_status = EINVAL;
823 return GSS_S_FAILURE;
827 const u_char *p = data_set->elements[0].value;
828 *tkt_flags = (p[0] << 0) | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
831 gss_release_buffer_set(minor_status, &data_set);
832 return GSS_S_COMPLETE;