Debian Codegraph @

lib/gssapi/krb5/inquire_sec_context_by_oid.c

raw
1 /*
2 * Copyright (c) 2004, PADL Software Pty Ltd.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 *
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.
15 *
16 * 3. Neither the name of PADL Software nor the names of its contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY PADL SOFTWARE AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL PADL SOFTWARE OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 */
32
33 #include "gsskrb5_locl.h"
34
35 static int
36 oid_prefix_equal(gss_OID oid_enc, gss_OID prefix_enc, unsigned *suffix)
37 {
38 int ret;
39 heim_oid oid;
40 heim_oid prefix;
41
42 *suffix = 0;
43
44 ret = der_get_oid(oid_enc->elements, oid_enc->length,
45 &oid, NULL);
46 if (ret) {
47 return 0;
48 }
49
50 ret = der_get_oid(prefix_enc->elements, prefix_enc->length,
51 &prefix, NULL);
52 if (ret) {
53 der_free_oid(&oid);
54 return 0;
55 }
56
57 ret = 0;
58
59 if (oid.length - 1 == prefix.length) {
60 *suffix = oid.components[oid.length - 1];
61 oid.length--;
62 ret = (der_heim_oid_cmp(&oid, &prefix) == 0);
63 oid.length++;
64 }
65
66 der_free_oid(&oid);
67 der_free_oid(&prefix);
68
69 return ret;
70 }
71
72 static OM_uint32 inquire_sec_context_tkt_flags
73 (OM_uint32 *minor_status,
74 const gsskrb5_ctx context_handle,
75 gss_buffer_set_t *data_set)
76 {
77 OM_uint32 tkt_flags;
78 unsigned char buf[4];
79 gss_buffer_desc value;
80
81 HEIMDAL_MUTEX_lock(&context_handle->ctx_id_mutex);
82
83 if (context_handle->ticket == NULL) {
84 HEIMDAL_MUTEX_unlock(&context_handle->ctx_id_mutex);
85 _gsskrb5_set_status(EINVAL, "No ticket from which to obtain flags");
86 *minor_status = EINVAL;
87 return GSS_S_BAD_MECH;
88 }
89
90 tkt_flags = TicketFlags2int(context_handle->ticket->ticket.flags);
91 HEIMDAL_MUTEX_unlock(&context_handle->ctx_id_mutex);
92
93 _gsskrb5_encode_om_uint32(tkt_flags, buf);
94 value.length = sizeof(buf);
95 value.value = buf;
96
97 return gss_add_buffer_set_member(minor_status,
98 &value,
99 data_set);
100 }
101
102 enum keytype { ACCEPTOR_KEY, INITIATOR_KEY, TOKEN_KEY };
103
104 static OM_uint32 inquire_sec_context_get_subkey
105 (OM_uint32 *minor_status,
106 const gsskrb5_ctx context_handle,
107 krb5_context context,
108 enum keytype keytype,
109 gss_buffer_set_t *data_set)
110 {
111 krb5_keyblock *key = NULL;
112 krb5_storage *sp = NULL;
113 krb5_data data;
114 OM_uint32 maj_stat = GSS_S_COMPLETE;
115 krb5_error_code ret;
116
117 krb5_data_zero(&data);
118
119 sp = krb5_storage_emem();
120 if (sp == NULL) {
121 _gsskrb5_clear_status();
122 ret = ENOMEM;
123 goto out;
124 }
125
126 HEIMDAL_MUTEX_lock(&context_handle->ctx_id_mutex);
127 switch(keytype) {
128 case ACCEPTOR_KEY:
129 ret = _gsskrb5i_get_acceptor_subkey(context_handle, context, &key);
130 break;
131 case INITIATOR_KEY:
132 ret = _gsskrb5i_get_initiator_subkey(context_handle, context, &key);
133 break;
134 case TOKEN_KEY:
135 ret = _gsskrb5i_get_token_key(context_handle, context, &key);
136 break;
137 default:
138 _gsskrb5_set_status(EINVAL, "%d is not a valid subkey type", keytype);
139 ret = EINVAL;
140 break;
141 }
142 HEIMDAL_MUTEX_unlock(&context_handle->ctx_id_mutex);
143 if (ret)
144 goto out;
145 if (key == NULL) {
146 _gsskrb5_set_status(EINVAL, "have no subkey of type %d", keytype);
147 ret = EINVAL;
148 goto out;
149 }
150
151 ret = krb5_store_keyblock(sp, *key);
152 if (ret)
153 goto out;
154
155 ret = krb5_storage_to_data(sp, &data);
156 if (ret)
157 goto out;
158
159 {
160 gss_buffer_desc value;
161
162 value.length = data.length;
163 value.value = data.data;
164
165 maj_stat = gss_add_buffer_set_member(minor_status,
166 &value,
167 data_set);
168 }
169
170 out:
171 krb5_free_keyblock(context, key);
172 krb5_data_free(&data);
173 if (sp)
174 krb5_storage_free(sp);
175 if (ret) {
176 *minor_status = ret;
177 maj_stat = GSS_S_FAILURE;
178 }
179 return maj_stat;
180 }
181
182 static OM_uint32 inquire_sec_context_get_sspi_session_key
183 (OM_uint32 *minor_status,
184 const gsskrb5_ctx context_handle,
185 krb5_context context,
186 gss_buffer_set_t *data_set)
187 {
188 krb5_keyblock *key;
189 OM_uint32 maj_stat = GSS_S_COMPLETE;
190 krb5_error_code ret;
191 gss_buffer_desc value;
192
193 HEIMDAL_MUTEX_lock(&context_handle->ctx_id_mutex);
194 ret = _gsskrb5i_get_token_key(context_handle, context, &key);
195 HEIMDAL_MUTEX_unlock(&context_handle->ctx_id_mutex);
196
197 if (ret)
198 goto out;
199 if (key == NULL) {
200 ret = EINVAL;
201 goto out;
202 }
203
204 value.length = key->keyvalue.length;
205 value.value = key->keyvalue.data;
206
207 maj_stat = gss_add_buffer_set_member(minor_status,
208 &value,
209 data_set);
210 krb5_free_keyblock(context, key);
211
212 /* MIT also returns the enctype encoded as an OID in data_set[1] */
213
214 out:
215 if (ret) {
216 *minor_status = ret;
217 maj_stat = GSS_S_FAILURE;
218 }
219 return maj_stat;
220 }
221
222 static OM_uint32 inquire_sec_context_authz_data
223 (OM_uint32 *minor_status,
224 const gsskrb5_ctx context_handle,
225 krb5_context context,
226 unsigned ad_type,
227 gss_buffer_set_t *data_set)
228 {
229 krb5_data data;
230 gss_buffer_desc ad_data;
231 OM_uint32 ret;
232
233 *minor_status = 0;
234 *data_set = GSS_C_NO_BUFFER_SET;
235
236 HEIMDAL_MUTEX_lock(&context_handle->ctx_id_mutex);
237 if (context_handle->ticket == NULL) {
238 HEIMDAL_MUTEX_unlock(&context_handle->ctx_id_mutex);
239 *minor_status = EINVAL;
240 _gsskrb5_set_status(EINVAL, "No ticket to obtain authz data from");
241 return GSS_S_NO_CONTEXT;
242 }
243
244 ret = krb5_ticket_get_authorization_data_type(context,
245 context_handle->ticket,
246 ad_type,
247 &data);
248 HEIMDAL_MUTEX_unlock(&context_handle->ctx_id_mutex);
249 if (ret) {
250 *minor_status = ret;
251 return GSS_S_FAILURE;
252 }
253
254 ad_data.value = data.data;
255 ad_data.length = data.length;
256
257 ret = gss_add_buffer_set_member(minor_status,
258 &ad_data,
259 data_set);
260
261 krb5_data_free(&data);
262
263 return ret;
264 }
265
266 static OM_uint32 inquire_sec_context_has_updated_spnego
267 (OM_uint32 *minor_status,
268 const gsskrb5_ctx context_handle,
269 gss_buffer_set_t *data_set)
270 {
271 int is_updated = 0;
272
273 *minor_status = 0;
274 *data_set = GSS_C_NO_BUFFER_SET;
275
276 /*
277 * For Windows SPNEGO implementations, both the initiator and the
278 * acceptor are assumed to have been updated if a "newer" [CLAR] or
279 * different enctype is negotiated for use by the Kerberos GSS-API
280 * mechanism.
281 */
282 HEIMDAL_MUTEX_lock(&context_handle->ctx_id_mutex);
283 is_updated = (context_handle->more_flags & IS_CFX);
284 if (is_updated == 0) {
285 krb5_keyblock *acceptor_subkey;
286
287 if (context_handle->more_flags & LOCAL)
288 acceptor_subkey = context_handle->auth_context->remote_subkey;
289 else
290 acceptor_subkey = context_handle->auth_context->local_subkey;
291
292 if (acceptor_subkey != NULL)
293 is_updated = (acceptor_subkey->keytype !=
294 context_handle->auth_context->keyblock->keytype);
295 }
296 HEIMDAL_MUTEX_unlock(&context_handle->ctx_id_mutex);
297
298 return is_updated ? GSS_S_COMPLETE : GSS_S_FAILURE;
299 }
300
301 /*
302 *
303 */
304
305 static OM_uint32
306 export_lucid_sec_context_v1(OM_uint32 *minor_status,
307 gsskrb5_ctx context_handle,
308 krb5_context context,
309 gss_buffer_set_t *data_set)
310 {
311 krb5_storage *sp = NULL;
312 OM_uint32 major_status = GSS_S_COMPLETE;
313 krb5_error_code ret;
314 krb5_keyblock *key = NULL;
315 int32_t number;
316 int is_cfx;
317 krb5_data data;
318
319 *minor_status = 0;
320
321 HEIMDAL_MUTEX_lock(&context_handle->ctx_id_mutex);
322
323 is_cfx = (context_handle->more_flags & IS_CFX);
324
325 sp = krb5_storage_emem();
326 if (sp == NULL) {
327 _gsskrb5_clear_status();
328 ret = ENOMEM;
329 goto out;
330 }
331
332 ret = krb5_store_int32(sp, 1);
333 if (ret) goto out;
334 ret = krb5_store_int32(sp, (context_handle->more_flags & LOCAL) ? 1 : 0);
335 if (ret) goto out;
336 /* XXX need krb5_store_int64() */
337 ret = krb5_store_int32(sp, context_handle->endtime);
338 if (ret) goto out;
339 krb5_auth_con_getlocalseqnumber (context,
340 context_handle->auth_context,
341 &number);
342 ret = krb5_store_uint32(sp, (uint32_t)0); /* store top half as zero */
343 if (ret) goto out;
344 ret = krb5_store_uint32(sp, (uint32_t)number);
345 if (ret) goto out;
346 krb5_auth_con_getremoteseqnumber (context,
347 context_handle->auth_context,
348 &number);
349 ret = krb5_store_uint32(sp, (uint32_t)0); /* store top half as zero */
350 if (ret) goto out;
351 ret = krb5_store_uint32(sp, (uint32_t)number);
352 if (ret) goto out;
353 ret = krb5_store_int32(sp, (is_cfx) ? 1 : 0);
354 if (ret) goto out;
355
356 ret = _gsskrb5i_get_token_key(context_handle, context, &key);
357 if (ret) goto out;
358
359 if (is_cfx == 0) {
360 int sign_alg, seal_alg;
361
362 switch (key->keytype) {
363 case ETYPE_DES_CBC_CRC:
364 case ETYPE_DES_CBC_MD4:
365 case ETYPE_DES_CBC_MD5:
366 sign_alg = 0;
367 seal_alg = 0;
368 break;
369 case ETYPE_DES3_CBC_MD5:
370 case ETYPE_DES3_CBC_SHA1:
371 sign_alg = 4;
372 seal_alg = 2;
373 break;
374 case ETYPE_ARCFOUR_HMAC_MD5:
375 case ETYPE_ARCFOUR_HMAC_MD5_56:
376 sign_alg = 17;
377 seal_alg = 16;
378 break;
379 default:
380 sign_alg = -1;
381 seal_alg = -1;
382 break;
383 }
384 ret = krb5_store_int32(sp, sign_alg);
385 if (ret) goto out;
386 ret = krb5_store_int32(sp, seal_alg);
387 if (ret) goto out;
388 /* ctx_key */
389 ret = krb5_store_keyblock(sp, *key);
390 if (ret) goto out;
391 } else {
392 int subkey_p = (context_handle->more_flags & ACCEPTOR_SUBKEY) ? 1 : 0;
393
394 /* have_acceptor_subkey */
395 ret = krb5_store_int32(sp, subkey_p);
396 if (ret) goto out;
397 /* ctx_key */
398 ret = krb5_store_keyblock(sp, *key);
399 if (ret) goto out;
400 /* acceptor_subkey */
401 if (subkey_p) {
402 ret = krb5_store_keyblock(sp, *key);
403 if (ret) goto out;
404 }
405 }
406 ret = krb5_storage_to_data(sp, &data);
407 if (ret) goto out;
408
409 {
410 gss_buffer_desc ad_data;
411
412 ad_data.value = data.data;
413 ad_data.length = data.length;
414
415 ret = gss_add_buffer_set_member(minor_status, &ad_data, data_set);
416 krb5_data_free(&data);
417 if (ret)
418 goto out;
419 }
420
421 out:
422 if (key)
423 krb5_free_keyblock (context, key);
424 if (sp)
425 krb5_storage_free(sp);
426 if (ret) {
427 *minor_status = ret;
428 major_status = GSS_S_FAILURE;
429 }
430 HEIMDAL_MUTEX_unlock(&context_handle->ctx_id_mutex);
431 return major_status;
432 }
433
434 static OM_uint32
435 get_authtime(OM_uint32 *minor_status,
436 gsskrb5_ctx ctx,
437 gss_buffer_set_t *data_set)
438
439 {
440 gss_buffer_desc value;
441 unsigned char buf[4];
442 OM_uint32 authtime;
443
444 HEIMDAL_MUTEX_lock(&ctx->ctx_id_mutex);
445 if (ctx->ticket == NULL) {
446 HEIMDAL_MUTEX_unlock(&ctx->ctx_id_mutex);
447 _gsskrb5_set_status(EINVAL, "No ticket to obtain auth time from");
448 *minor_status = EINVAL;
449 return GSS_S_FAILURE;
450 }
451
452 authtime = ctx->ticket->ticket.authtime;
453
454 HEIMDAL_MUTEX_unlock(&ctx->ctx_id_mutex);
455
456 _gsskrb5_encode_om_uint32(authtime, buf);
457 value.length = sizeof(buf);
458 value.value = buf;
459
460 return gss_add_buffer_set_member(minor_status,
461 &value,
462 data_set);
463 }
464
465
466 static OM_uint32
467 get_service_keyblock
468 (OM_uint32 *minor_status,
469 gsskrb5_ctx ctx,
470 gss_buffer_set_t *data_set)
471 {
472 krb5_storage *sp = NULL;
473 krb5_data data;
474 OM_uint32 maj_stat = GSS_S_COMPLETE;
475 krb5_error_code ret = EINVAL;
476
477 sp = krb5_storage_emem();
478 if (sp == NULL) {
479 _gsskrb5_clear_status();
480 *minor_status = ENOMEM;
481 return GSS_S_FAILURE;
482 }
483
484 HEIMDAL_MUTEX_lock(&ctx->ctx_id_mutex);
485 if (ctx->service_keyblock == NULL) {
486 HEIMDAL_MUTEX_unlock(&ctx->ctx_id_mutex);
487 krb5_storage_free(sp);
488 _gsskrb5_set_status(EINVAL, "No service keyblock on gssapi context");
489 *minor_status = EINVAL;
490 return GSS_S_FAILURE;
491 }
492
493 krb5_data_zero(&data);
494
495 ret = krb5_store_keyblock(sp, *ctx->service_keyblock);
496
497 HEIMDAL_MUTEX_unlock(&ctx->ctx_id_mutex);
498
499 if (ret)
500 goto out;
501
502 ret = krb5_storage_to_data(sp, &data);
503 if (ret)
504 goto out;
505
506 {
507 gss_buffer_desc value;
508
509 value.length = data.length;
510 value.value = data.data;
511
512 maj_stat = gss_add_buffer_set_member(minor_status,
513 &value,
514 data_set);
515 }
516
517 out:
518 krb5_data_free(&data);
519 if (sp)
520 krb5_storage_free(sp);
521 if (ret) {
522 *minor_status = ret;
523 maj_stat = GSS_S_FAILURE;
524 }
525 return maj_stat;
526 }
527 /*
528 *
529 */
530
531 OM_uint32 GSSAPI_CALLCONV _gsskrb5_inquire_sec_context_by_oid
532 (OM_uint32 *minor_status,
533 gss_const_ctx_id_t context_handle,
534 const gss_OID desired_object,
535 gss_buffer_set_t *data_set)
536 {
537 krb5_context context;
538 const gsskrb5_ctx ctx = (const gsskrb5_ctx) context_handle;
539 unsigned suffix;
540
541 if (ctx == NULL) {
542 *minor_status = EINVAL;
543 return GSS_S_NO_CONTEXT;
544 }
545
546 GSSAPI_KRB5_INIT (&context);
547
548 if (gss_oid_equal(desired_object, GSS_KRB5_GET_TKT_FLAGS_X)) {
549 return inquire_sec_context_tkt_flags(minor_status,
550 ctx,
551 data_set);
552 } else if (gss_oid_equal(desired_object, GSS_C_PEER_HAS_UPDATED_SPNEGO)) {
553 return inquire_sec_context_has_updated_spnego(minor_status,
554 ctx,
555 data_set);
556 } else if (gss_oid_equal(desired_object, GSS_KRB5_GET_SUBKEY_X)) {
557 return inquire_sec_context_get_subkey(minor_status,
558 ctx,
559 context,
560 TOKEN_KEY,
561 data_set);
562 } else if (gss_oid_equal(desired_object, GSS_KRB5_GET_INITIATOR_SUBKEY_X)) {
563 return inquire_sec_context_get_subkey(minor_status,
564 ctx,
565 context,
566 INITIATOR_KEY,
567 data_set);
568 } else if (gss_oid_equal(desired_object, GSS_KRB5_GET_ACCEPTOR_SUBKEY_X)) {
569 return inquire_sec_context_get_subkey(minor_status,
570 ctx,
571 context,
572 ACCEPTOR_KEY,
573 data_set);
574 } else if (gss_oid_equal(desired_object, GSS_C_INQ_SSPI_SESSION_KEY)) {
575 return inquire_sec_context_get_sspi_session_key(minor_status,
576 ctx,
577 context,
578 data_set);
579 } else if (gss_oid_equal(desired_object, GSS_KRB5_GET_AUTHTIME_X)) {
580 return get_authtime(minor_status, ctx, data_set);
581 } else if (oid_prefix_equal(desired_object,
582 GSS_KRB5_EXTRACT_AUTHZ_DATA_FROM_SEC_CONTEXT_X,
583 &suffix)) {
584 return inquire_sec_context_authz_data(minor_status,
585 ctx,
586 context,
587 suffix,
588 data_set);
589 } else if (oid_prefix_equal(desired_object,
590 GSS_KRB5_EXPORT_LUCID_CONTEXT_X,
591 &suffix)) {
592 if (suffix == 1)
593 return export_lucid_sec_context_v1(minor_status,
594 ctx,
595 context,
596 data_set);
597 *minor_status = 0;
598 return GSS_S_FAILURE;
599 } else if (gss_oid_equal(desired_object, GSS_KRB5_GET_SERVICE_KEYBLOCK_X)) {
600 return get_service_keyblock(minor_status, ctx, data_set);
601 } else {
602 *minor_status = 0;
603 return GSS_S_FAILURE;
604 }
605 }
606