1 | // SPDX-License-Identifier: BSD-3-Clause |
2 | /* |
3 | * linux/net/sunrpc/gss_krb5_mech.c |
4 | * |
5 | * Copyright (c) 2001-2008 The Regents of the University of Michigan. |
6 | * All rights reserved. |
7 | * |
8 | * Andy Adamson <andros@umich.edu> |
9 | * J. Bruce Fields <bfields@umich.edu> |
10 | */ |
11 | |
12 | #include <crypto/hash.h> |
13 | #include <crypto/skcipher.h> |
14 | #include <linux/err.h> |
15 | #include <linux/module.h> |
16 | #include <linux/init.h> |
17 | #include <linux/types.h> |
18 | #include <linux/slab.h> |
19 | #include <linux/sunrpc/auth.h> |
20 | #include <linux/sunrpc/gss_krb5.h> |
21 | #include <linux/sunrpc/xdr.h> |
22 | #include <kunit/visibility.h> |
23 | |
24 | #include "auth_gss_internal.h" |
25 | #include "gss_krb5_internal.h" |
26 | |
27 | #if IS_ENABLED(CONFIG_SUNRPC_DEBUG) |
28 | # define RPCDBG_FACILITY RPCDBG_AUTH |
29 | #endif |
30 | |
31 | static struct gss_api_mech gss_kerberos_mech; |
32 | |
33 | static const struct gss_krb5_enctype supported_gss_krb5_enctypes[] = { |
34 | #if defined(CONFIG_RPCSEC_GSS_KRB5_ENCTYPES_AES_SHA1) |
35 | /* |
36 | * AES-128 with SHA-1 (RFC 3962) |
37 | */ |
38 | { |
39 | .etype = ENCTYPE_AES128_CTS_HMAC_SHA1_96, |
40 | .ctype = CKSUMTYPE_HMAC_SHA1_96_AES128, |
41 | .name = "aes128-cts" , |
42 | .encrypt_name = "cts(cbc(aes))" , |
43 | .aux_cipher = "cbc(aes)" , |
44 | .cksum_name = "hmac(sha1)" , |
45 | .derive_key = krb5_derive_key_v2, |
46 | .encrypt = gss_krb5_aes_encrypt, |
47 | .decrypt = gss_krb5_aes_decrypt, |
48 | |
49 | .get_mic = gss_krb5_get_mic_v2, |
50 | .verify_mic = gss_krb5_verify_mic_v2, |
51 | .wrap = gss_krb5_wrap_v2, |
52 | .unwrap = gss_krb5_unwrap_v2, |
53 | |
54 | .signalg = -1, |
55 | .sealalg = -1, |
56 | .keybytes = 16, |
57 | .keylength = BITS2OCTETS(128), |
58 | .Kc_length = BITS2OCTETS(128), |
59 | .Ke_length = BITS2OCTETS(128), |
60 | .Ki_length = BITS2OCTETS(128), |
61 | .cksumlength = BITS2OCTETS(96), |
62 | .keyed_cksum = 1, |
63 | }, |
64 | /* |
65 | * AES-256 with SHA-1 (RFC 3962) |
66 | */ |
67 | { |
68 | .etype = ENCTYPE_AES256_CTS_HMAC_SHA1_96, |
69 | .ctype = CKSUMTYPE_HMAC_SHA1_96_AES256, |
70 | .name = "aes256-cts" , |
71 | .encrypt_name = "cts(cbc(aes))" , |
72 | .aux_cipher = "cbc(aes)" , |
73 | .cksum_name = "hmac(sha1)" , |
74 | .derive_key = krb5_derive_key_v2, |
75 | .encrypt = gss_krb5_aes_encrypt, |
76 | .decrypt = gss_krb5_aes_decrypt, |
77 | |
78 | .get_mic = gss_krb5_get_mic_v2, |
79 | .verify_mic = gss_krb5_verify_mic_v2, |
80 | .wrap = gss_krb5_wrap_v2, |
81 | .unwrap = gss_krb5_unwrap_v2, |
82 | |
83 | .signalg = -1, |
84 | .sealalg = -1, |
85 | .keybytes = 32, |
86 | .keylength = BITS2OCTETS(256), |
87 | .Kc_length = BITS2OCTETS(256), |
88 | .Ke_length = BITS2OCTETS(256), |
89 | .Ki_length = BITS2OCTETS(256), |
90 | .cksumlength = BITS2OCTETS(96), |
91 | .keyed_cksum = 1, |
92 | }, |
93 | #endif |
94 | |
95 | #if defined(CONFIG_RPCSEC_GSS_KRB5_ENCTYPES_CAMELLIA) |
96 | /* |
97 | * Camellia-128 with CMAC (RFC 6803) |
98 | */ |
99 | { |
100 | .etype = ENCTYPE_CAMELLIA128_CTS_CMAC, |
101 | .ctype = CKSUMTYPE_CMAC_CAMELLIA128, |
102 | .name = "camellia128-cts-cmac" , |
103 | .encrypt_name = "cts(cbc(camellia))" , |
104 | .aux_cipher = "cbc(camellia)" , |
105 | .cksum_name = "cmac(camellia)" , |
106 | .cksumlength = BITS2OCTETS(128), |
107 | .keyed_cksum = 1, |
108 | .keylength = BITS2OCTETS(128), |
109 | .Kc_length = BITS2OCTETS(128), |
110 | .Ke_length = BITS2OCTETS(128), |
111 | .Ki_length = BITS2OCTETS(128), |
112 | |
113 | .derive_key = krb5_kdf_feedback_cmac, |
114 | .encrypt = gss_krb5_aes_encrypt, |
115 | .decrypt = gss_krb5_aes_decrypt, |
116 | |
117 | .get_mic = gss_krb5_get_mic_v2, |
118 | .verify_mic = gss_krb5_verify_mic_v2, |
119 | .wrap = gss_krb5_wrap_v2, |
120 | .unwrap = gss_krb5_unwrap_v2, |
121 | }, |
122 | /* |
123 | * Camellia-256 with CMAC (RFC 6803) |
124 | */ |
125 | { |
126 | .etype = ENCTYPE_CAMELLIA256_CTS_CMAC, |
127 | .ctype = CKSUMTYPE_CMAC_CAMELLIA256, |
128 | .name = "camellia256-cts-cmac" , |
129 | .encrypt_name = "cts(cbc(camellia))" , |
130 | .aux_cipher = "cbc(camellia)" , |
131 | .cksum_name = "cmac(camellia)" , |
132 | .cksumlength = BITS2OCTETS(128), |
133 | .keyed_cksum = 1, |
134 | .keylength = BITS2OCTETS(256), |
135 | .Kc_length = BITS2OCTETS(256), |
136 | .Ke_length = BITS2OCTETS(256), |
137 | .Ki_length = BITS2OCTETS(256), |
138 | |
139 | .derive_key = krb5_kdf_feedback_cmac, |
140 | .encrypt = gss_krb5_aes_encrypt, |
141 | .decrypt = gss_krb5_aes_decrypt, |
142 | |
143 | .get_mic = gss_krb5_get_mic_v2, |
144 | .verify_mic = gss_krb5_verify_mic_v2, |
145 | .wrap = gss_krb5_wrap_v2, |
146 | .unwrap = gss_krb5_unwrap_v2, |
147 | }, |
148 | #endif |
149 | |
150 | #if defined(CONFIG_RPCSEC_GSS_KRB5_ENCTYPES_AES_SHA2) |
151 | /* |
152 | * AES-128 with SHA-256 (RFC 8009) |
153 | */ |
154 | { |
155 | .etype = ENCTYPE_AES128_CTS_HMAC_SHA256_128, |
156 | .ctype = CKSUMTYPE_HMAC_SHA256_128_AES128, |
157 | .name = "aes128-cts-hmac-sha256-128" , |
158 | .encrypt_name = "cts(cbc(aes))" , |
159 | .aux_cipher = "cbc(aes)" , |
160 | .cksum_name = "hmac(sha256)" , |
161 | .cksumlength = BITS2OCTETS(128), |
162 | .keyed_cksum = 1, |
163 | .keylength = BITS2OCTETS(128), |
164 | .Kc_length = BITS2OCTETS(128), |
165 | .Ke_length = BITS2OCTETS(128), |
166 | .Ki_length = BITS2OCTETS(128), |
167 | |
168 | .derive_key = krb5_kdf_hmac_sha2, |
169 | .encrypt = krb5_etm_encrypt, |
170 | .decrypt = krb5_etm_decrypt, |
171 | |
172 | .get_mic = gss_krb5_get_mic_v2, |
173 | .verify_mic = gss_krb5_verify_mic_v2, |
174 | .wrap = gss_krb5_wrap_v2, |
175 | .unwrap = gss_krb5_unwrap_v2, |
176 | }, |
177 | /* |
178 | * AES-256 with SHA-384 (RFC 8009) |
179 | */ |
180 | { |
181 | .etype = ENCTYPE_AES256_CTS_HMAC_SHA384_192, |
182 | .ctype = CKSUMTYPE_HMAC_SHA384_192_AES256, |
183 | .name = "aes256-cts-hmac-sha384-192" , |
184 | .encrypt_name = "cts(cbc(aes))" , |
185 | .aux_cipher = "cbc(aes)" , |
186 | .cksum_name = "hmac(sha384)" , |
187 | .cksumlength = BITS2OCTETS(192), |
188 | .keyed_cksum = 1, |
189 | .keylength = BITS2OCTETS(256), |
190 | .Kc_length = BITS2OCTETS(192), |
191 | .Ke_length = BITS2OCTETS(256), |
192 | .Ki_length = BITS2OCTETS(192), |
193 | |
194 | .derive_key = krb5_kdf_hmac_sha2, |
195 | .encrypt = krb5_etm_encrypt, |
196 | .decrypt = krb5_etm_decrypt, |
197 | |
198 | .get_mic = gss_krb5_get_mic_v2, |
199 | .verify_mic = gss_krb5_verify_mic_v2, |
200 | .wrap = gss_krb5_wrap_v2, |
201 | .unwrap = gss_krb5_unwrap_v2, |
202 | }, |
203 | #endif |
204 | }; |
205 | |
206 | /* |
207 | * The list of advertised enctypes is specified in order of most |
208 | * preferred to least. |
209 | */ |
210 | static char gss_krb5_enctype_priority_list[64]; |
211 | |
212 | static void gss_krb5_prepare_enctype_priority_list(void) |
213 | { |
214 | static const u32 gss_krb5_enctypes[] = { |
215 | #if defined(CONFIG_RPCSEC_GSS_KRB5_ENCTYPES_AES_SHA2) |
216 | ENCTYPE_AES256_CTS_HMAC_SHA384_192, |
217 | ENCTYPE_AES128_CTS_HMAC_SHA256_128, |
218 | #endif |
219 | #if defined(CONFIG_RPCSEC_GSS_KRB5_ENCTYPES_CAMELLIA) |
220 | ENCTYPE_CAMELLIA256_CTS_CMAC, |
221 | ENCTYPE_CAMELLIA128_CTS_CMAC, |
222 | #endif |
223 | #if defined(CONFIG_RPCSEC_GSS_KRB5_ENCTYPES_AES_SHA1) |
224 | ENCTYPE_AES256_CTS_HMAC_SHA1_96, |
225 | ENCTYPE_AES128_CTS_HMAC_SHA1_96, |
226 | #endif |
227 | }; |
228 | size_t total, i; |
229 | char buf[16]; |
230 | char *sep; |
231 | int n; |
232 | |
233 | sep = "" ; |
234 | gss_krb5_enctype_priority_list[0] = '\0'; |
235 | for (total = 0, i = 0; i < ARRAY_SIZE(gss_krb5_enctypes); i++) { |
236 | n = sprintf(buf, fmt: "%s%u" , sep, gss_krb5_enctypes[i]); |
237 | if (n < 0) |
238 | break; |
239 | if (total + n >= sizeof(gss_krb5_enctype_priority_list)) |
240 | break; |
241 | strcat(p: gss_krb5_enctype_priority_list, q: buf); |
242 | sep = "," ; |
243 | total += n; |
244 | } |
245 | } |
246 | |
247 | /** |
248 | * gss_krb5_lookup_enctype - Retrieve profile information for a given enctype |
249 | * @etype: ENCTYPE value |
250 | * |
251 | * Returns a pointer to a gss_krb5_enctype structure, or NULL if no |
252 | * matching etype is found. |
253 | */ |
254 | VISIBLE_IF_KUNIT |
255 | const struct gss_krb5_enctype *gss_krb5_lookup_enctype(u32 etype) |
256 | { |
257 | size_t i; |
258 | |
259 | for (i = 0; i < ARRAY_SIZE(supported_gss_krb5_enctypes); i++) |
260 | if (supported_gss_krb5_enctypes[i].etype == etype) |
261 | return &supported_gss_krb5_enctypes[i]; |
262 | return NULL; |
263 | } |
264 | EXPORT_SYMBOL_IF_KUNIT(gss_krb5_lookup_enctype); |
265 | |
266 | static struct crypto_sync_skcipher * |
267 | gss_krb5_alloc_cipher_v2(const char *cname, const struct xdr_netobj *key) |
268 | { |
269 | struct crypto_sync_skcipher *tfm; |
270 | |
271 | tfm = crypto_alloc_sync_skcipher(alg_name: cname, type: 0, mask: 0); |
272 | if (IS_ERR(ptr: tfm)) |
273 | return NULL; |
274 | if (crypto_sync_skcipher_setkey(tfm, key: key->data, keylen: key->len)) { |
275 | crypto_free_sync_skcipher(tfm); |
276 | return NULL; |
277 | } |
278 | return tfm; |
279 | } |
280 | |
281 | static struct crypto_ahash * |
282 | gss_krb5_alloc_hash_v2(struct krb5_ctx *kctx, const struct xdr_netobj *key) |
283 | { |
284 | struct crypto_ahash *tfm; |
285 | |
286 | tfm = crypto_alloc_ahash(alg_name: kctx->gk5e->cksum_name, type: 0, CRYPTO_ALG_ASYNC); |
287 | if (IS_ERR(ptr: tfm)) |
288 | return NULL; |
289 | if (crypto_ahash_setkey(tfm, key: key->data, keylen: key->len)) { |
290 | crypto_free_ahash(tfm); |
291 | return NULL; |
292 | } |
293 | return tfm; |
294 | } |
295 | |
296 | static int |
297 | gss_krb5_import_ctx_v2(struct krb5_ctx *ctx, gfp_t gfp_mask) |
298 | { |
299 | struct xdr_netobj keyin = { |
300 | .len = ctx->gk5e->keylength, |
301 | .data = ctx->Ksess, |
302 | }; |
303 | struct xdr_netobj keyout; |
304 | int ret = -EINVAL; |
305 | |
306 | keyout.data = kmalloc(GSS_KRB5_MAX_KEYLEN, flags: gfp_mask); |
307 | if (!keyout.data) |
308 | return -ENOMEM; |
309 | |
310 | /* initiator seal encryption */ |
311 | keyout.len = ctx->gk5e->Ke_length; |
312 | if (krb5_derive_key(kctx: ctx, inkey: &keyin, outkey: &keyout, KG_USAGE_INITIATOR_SEAL, |
313 | KEY_USAGE_SEED_ENCRYPTION, gfp_mask)) |
314 | goto out; |
315 | ctx->initiator_enc = gss_krb5_alloc_cipher_v2(cname: ctx->gk5e->encrypt_name, |
316 | key: &keyout); |
317 | if (ctx->initiator_enc == NULL) |
318 | goto out; |
319 | if (ctx->gk5e->aux_cipher) { |
320 | ctx->initiator_enc_aux = |
321 | gss_krb5_alloc_cipher_v2(cname: ctx->gk5e->aux_cipher, |
322 | key: &keyout); |
323 | if (ctx->initiator_enc_aux == NULL) |
324 | goto out_free; |
325 | } |
326 | |
327 | /* acceptor seal encryption */ |
328 | if (krb5_derive_key(kctx: ctx, inkey: &keyin, outkey: &keyout, KG_USAGE_ACCEPTOR_SEAL, |
329 | KEY_USAGE_SEED_ENCRYPTION, gfp_mask)) |
330 | goto out_free; |
331 | ctx->acceptor_enc = gss_krb5_alloc_cipher_v2(cname: ctx->gk5e->encrypt_name, |
332 | key: &keyout); |
333 | if (ctx->acceptor_enc == NULL) |
334 | goto out_free; |
335 | if (ctx->gk5e->aux_cipher) { |
336 | ctx->acceptor_enc_aux = |
337 | gss_krb5_alloc_cipher_v2(cname: ctx->gk5e->aux_cipher, |
338 | key: &keyout); |
339 | if (ctx->acceptor_enc_aux == NULL) |
340 | goto out_free; |
341 | } |
342 | |
343 | /* initiator sign checksum */ |
344 | keyout.len = ctx->gk5e->Kc_length; |
345 | if (krb5_derive_key(kctx: ctx, inkey: &keyin, outkey: &keyout, KG_USAGE_INITIATOR_SIGN, |
346 | KEY_USAGE_SEED_CHECKSUM, gfp_mask)) |
347 | goto out_free; |
348 | ctx->initiator_sign = gss_krb5_alloc_hash_v2(kctx: ctx, key: &keyout); |
349 | if (ctx->initiator_sign == NULL) |
350 | goto out_free; |
351 | |
352 | /* acceptor sign checksum */ |
353 | if (krb5_derive_key(kctx: ctx, inkey: &keyin, outkey: &keyout, KG_USAGE_ACCEPTOR_SIGN, |
354 | KEY_USAGE_SEED_CHECKSUM, gfp_mask)) |
355 | goto out_free; |
356 | ctx->acceptor_sign = gss_krb5_alloc_hash_v2(kctx: ctx, key: &keyout); |
357 | if (ctx->acceptor_sign == NULL) |
358 | goto out_free; |
359 | |
360 | /* initiator seal integrity */ |
361 | keyout.len = ctx->gk5e->Ki_length; |
362 | if (krb5_derive_key(kctx: ctx, inkey: &keyin, outkey: &keyout, KG_USAGE_INITIATOR_SEAL, |
363 | KEY_USAGE_SEED_INTEGRITY, gfp_mask)) |
364 | goto out_free; |
365 | ctx->initiator_integ = gss_krb5_alloc_hash_v2(kctx: ctx, key: &keyout); |
366 | if (ctx->initiator_integ == NULL) |
367 | goto out_free; |
368 | |
369 | /* acceptor seal integrity */ |
370 | if (krb5_derive_key(kctx: ctx, inkey: &keyin, outkey: &keyout, KG_USAGE_ACCEPTOR_SEAL, |
371 | KEY_USAGE_SEED_INTEGRITY, gfp_mask)) |
372 | goto out_free; |
373 | ctx->acceptor_integ = gss_krb5_alloc_hash_v2(kctx: ctx, key: &keyout); |
374 | if (ctx->acceptor_integ == NULL) |
375 | goto out_free; |
376 | |
377 | ret = 0; |
378 | out: |
379 | kfree_sensitive(objp: keyout.data); |
380 | return ret; |
381 | |
382 | out_free: |
383 | crypto_free_ahash(tfm: ctx->acceptor_integ); |
384 | crypto_free_ahash(tfm: ctx->initiator_integ); |
385 | crypto_free_ahash(tfm: ctx->acceptor_sign); |
386 | crypto_free_ahash(tfm: ctx->initiator_sign); |
387 | crypto_free_sync_skcipher(tfm: ctx->acceptor_enc_aux); |
388 | crypto_free_sync_skcipher(tfm: ctx->acceptor_enc); |
389 | crypto_free_sync_skcipher(tfm: ctx->initiator_enc_aux); |
390 | crypto_free_sync_skcipher(tfm: ctx->initiator_enc); |
391 | goto out; |
392 | } |
393 | |
394 | static int |
395 | gss_import_v2_context(const void *p, const void *end, struct krb5_ctx *ctx, |
396 | gfp_t gfp_mask) |
397 | { |
398 | u64 seq_send64; |
399 | int keylen; |
400 | u32 time32; |
401 | int ret; |
402 | |
403 | p = simple_get_bytes(p, end, res: &ctx->flags, len: sizeof(ctx->flags)); |
404 | if (IS_ERR(ptr: p)) |
405 | goto out_err; |
406 | ctx->initiate = ctx->flags & KRB5_CTX_FLAG_INITIATOR; |
407 | |
408 | p = simple_get_bytes(p, end, res: &time32, len: sizeof(time32)); |
409 | if (IS_ERR(ptr: p)) |
410 | goto out_err; |
411 | /* unsigned 32-bit time overflows in year 2106 */ |
412 | ctx->endtime = (time64_t)time32; |
413 | p = simple_get_bytes(p, end, res: &seq_send64, len: sizeof(seq_send64)); |
414 | if (IS_ERR(ptr: p)) |
415 | goto out_err; |
416 | atomic64_set(v: &ctx->seq_send64, i: seq_send64); |
417 | /* set seq_send for use by "older" enctypes */ |
418 | atomic_set(v: &ctx->seq_send, i: seq_send64); |
419 | if (seq_send64 != atomic_read(v: &ctx->seq_send)) { |
420 | dprintk("%s: seq_send64 %llx, seq_send %x overflow?\n" , __func__, |
421 | seq_send64, atomic_read(&ctx->seq_send)); |
422 | p = ERR_PTR(error: -EINVAL); |
423 | goto out_err; |
424 | } |
425 | p = simple_get_bytes(p, end, res: &ctx->enctype, len: sizeof(ctx->enctype)); |
426 | if (IS_ERR(ptr: p)) |
427 | goto out_err; |
428 | ctx->gk5e = gss_krb5_lookup_enctype(ctx->enctype); |
429 | if (ctx->gk5e == NULL) { |
430 | dprintk("gss_kerberos_mech: unsupported krb5 enctype %u\n" , |
431 | ctx->enctype); |
432 | p = ERR_PTR(error: -EINVAL); |
433 | goto out_err; |
434 | } |
435 | keylen = ctx->gk5e->keylength; |
436 | |
437 | p = simple_get_bytes(p, end, res: ctx->Ksess, len: keylen); |
438 | if (IS_ERR(ptr: p)) |
439 | goto out_err; |
440 | |
441 | if (p != end) { |
442 | p = ERR_PTR(error: -EINVAL); |
443 | goto out_err; |
444 | } |
445 | |
446 | ctx->mech_used.data = kmemdup(p: gss_kerberos_mech.gm_oid.data, |
447 | size: gss_kerberos_mech.gm_oid.len, gfp: gfp_mask); |
448 | if (unlikely(ctx->mech_used.data == NULL)) { |
449 | p = ERR_PTR(error: -ENOMEM); |
450 | goto out_err; |
451 | } |
452 | ctx->mech_used.len = gss_kerberos_mech.gm_oid.len; |
453 | |
454 | ret = gss_krb5_import_ctx_v2(ctx, gfp_mask); |
455 | if (ret) { |
456 | p = ERR_PTR(error: ret); |
457 | goto out_free; |
458 | } |
459 | |
460 | return 0; |
461 | |
462 | out_free: |
463 | kfree(objp: ctx->mech_used.data); |
464 | out_err: |
465 | return PTR_ERR(ptr: p); |
466 | } |
467 | |
468 | static int |
469 | gss_krb5_import_sec_context(const void *p, size_t len, struct gss_ctx *ctx_id, |
470 | time64_t *endtime, gfp_t gfp_mask) |
471 | { |
472 | const void *end = (const void *)((const char *)p + len); |
473 | struct krb5_ctx *ctx; |
474 | int ret; |
475 | |
476 | ctx = kzalloc(size: sizeof(*ctx), flags: gfp_mask); |
477 | if (ctx == NULL) |
478 | return -ENOMEM; |
479 | |
480 | ret = gss_import_v2_context(p, end, ctx, gfp_mask); |
481 | memzero_explicit(s: &ctx->Ksess, count: sizeof(ctx->Ksess)); |
482 | if (ret) { |
483 | kfree(objp: ctx); |
484 | return ret; |
485 | } |
486 | |
487 | ctx_id->internal_ctx_id = ctx; |
488 | if (endtime) |
489 | *endtime = ctx->endtime; |
490 | return 0; |
491 | } |
492 | |
493 | static void |
494 | gss_krb5_delete_sec_context(void *internal_ctx) |
495 | { |
496 | struct krb5_ctx *kctx = internal_ctx; |
497 | |
498 | crypto_free_sync_skcipher(tfm: kctx->seq); |
499 | crypto_free_sync_skcipher(tfm: kctx->enc); |
500 | crypto_free_sync_skcipher(tfm: kctx->acceptor_enc); |
501 | crypto_free_sync_skcipher(tfm: kctx->initiator_enc); |
502 | crypto_free_sync_skcipher(tfm: kctx->acceptor_enc_aux); |
503 | crypto_free_sync_skcipher(tfm: kctx->initiator_enc_aux); |
504 | crypto_free_ahash(tfm: kctx->acceptor_sign); |
505 | crypto_free_ahash(tfm: kctx->initiator_sign); |
506 | crypto_free_ahash(tfm: kctx->acceptor_integ); |
507 | crypto_free_ahash(tfm: kctx->initiator_integ); |
508 | kfree(objp: kctx->mech_used.data); |
509 | kfree(objp: kctx); |
510 | } |
511 | |
512 | /** |
513 | * gss_krb5_get_mic - get_mic for the Kerberos GSS mechanism |
514 | * @gctx: GSS context |
515 | * @text: plaintext to checksum |
516 | * @token: buffer into which to write the computed checksum |
517 | * |
518 | * Return values: |
519 | * %GSS_S_COMPLETE - success, and @token is filled in |
520 | * %GSS_S_FAILURE - checksum could not be generated |
521 | * %GSS_S_CONTEXT_EXPIRED - Kerberos context is no longer valid |
522 | */ |
523 | static u32 gss_krb5_get_mic(struct gss_ctx *gctx, struct xdr_buf *text, |
524 | struct xdr_netobj *token) |
525 | { |
526 | struct krb5_ctx *kctx = gctx->internal_ctx_id; |
527 | |
528 | return kctx->gk5e->get_mic(kctx, text, token); |
529 | } |
530 | |
531 | /** |
532 | * gss_krb5_verify_mic - verify_mic for the Kerberos GSS mechanism |
533 | * @gctx: GSS context |
534 | * @message_buffer: plaintext to check |
535 | * @read_token: received checksum to check |
536 | * |
537 | * Return values: |
538 | * %GSS_S_COMPLETE - computed and received checksums match |
539 | * %GSS_S_DEFECTIVE_TOKEN - received checksum is not valid |
540 | * %GSS_S_BAD_SIG - computed and received checksums do not match |
541 | * %GSS_S_FAILURE - received checksum could not be checked |
542 | * %GSS_S_CONTEXT_EXPIRED - Kerberos context is no longer valid |
543 | */ |
544 | static u32 gss_krb5_verify_mic(struct gss_ctx *gctx, |
545 | struct xdr_buf *message_buffer, |
546 | struct xdr_netobj *read_token) |
547 | { |
548 | struct krb5_ctx *kctx = gctx->internal_ctx_id; |
549 | |
550 | return kctx->gk5e->verify_mic(kctx, message_buffer, read_token); |
551 | } |
552 | |
553 | /** |
554 | * gss_krb5_wrap - gss_wrap for the Kerberos GSS mechanism |
555 | * @gctx: initialized GSS context |
556 | * @offset: byte offset in @buf to start writing the cipher text |
557 | * @buf: OUT: send buffer |
558 | * @pages: plaintext to wrap |
559 | * |
560 | * Return values: |
561 | * %GSS_S_COMPLETE - success, @buf has been updated |
562 | * %GSS_S_FAILURE - @buf could not be wrapped |
563 | * %GSS_S_CONTEXT_EXPIRED - Kerberos context is no longer valid |
564 | */ |
565 | static u32 gss_krb5_wrap(struct gss_ctx *gctx, int offset, |
566 | struct xdr_buf *buf, struct page **pages) |
567 | { |
568 | struct krb5_ctx *kctx = gctx->internal_ctx_id; |
569 | |
570 | return kctx->gk5e->wrap(kctx, offset, buf, pages); |
571 | } |
572 | |
573 | /** |
574 | * gss_krb5_unwrap - gss_unwrap for the Kerberos GSS mechanism |
575 | * @gctx: initialized GSS context |
576 | * @offset: starting byte offset into @buf |
577 | * @len: size of ciphertext to unwrap |
578 | * @buf: ciphertext to unwrap |
579 | * |
580 | * Return values: |
581 | * %GSS_S_COMPLETE - success, @buf has been updated |
582 | * %GSS_S_DEFECTIVE_TOKEN - received blob is not valid |
583 | * %GSS_S_BAD_SIG - computed and received checksums do not match |
584 | * %GSS_S_FAILURE - @buf could not be unwrapped |
585 | * %GSS_S_CONTEXT_EXPIRED - Kerberos context is no longer valid |
586 | */ |
587 | static u32 gss_krb5_unwrap(struct gss_ctx *gctx, int offset, |
588 | int len, struct xdr_buf *buf) |
589 | { |
590 | struct krb5_ctx *kctx = gctx->internal_ctx_id; |
591 | |
592 | return kctx->gk5e->unwrap(kctx, offset, len, buf, |
593 | &gctx->slack, &gctx->align); |
594 | } |
595 | |
596 | static const struct gss_api_ops gss_kerberos_ops = { |
597 | .gss_import_sec_context = gss_krb5_import_sec_context, |
598 | .gss_get_mic = gss_krb5_get_mic, |
599 | .gss_verify_mic = gss_krb5_verify_mic, |
600 | .gss_wrap = gss_krb5_wrap, |
601 | .gss_unwrap = gss_krb5_unwrap, |
602 | .gss_delete_sec_context = gss_krb5_delete_sec_context, |
603 | }; |
604 | |
605 | static struct pf_desc gss_kerberos_pfs[] = { |
606 | [0] = { |
607 | .pseudoflavor = RPC_AUTH_GSS_KRB5, |
608 | .qop = GSS_C_QOP_DEFAULT, |
609 | .service = RPC_GSS_SVC_NONE, |
610 | .name = "krb5" , |
611 | }, |
612 | [1] = { |
613 | .pseudoflavor = RPC_AUTH_GSS_KRB5I, |
614 | .qop = GSS_C_QOP_DEFAULT, |
615 | .service = RPC_GSS_SVC_INTEGRITY, |
616 | .name = "krb5i" , |
617 | .datatouch = true, |
618 | }, |
619 | [2] = { |
620 | .pseudoflavor = RPC_AUTH_GSS_KRB5P, |
621 | .qop = GSS_C_QOP_DEFAULT, |
622 | .service = RPC_GSS_SVC_PRIVACY, |
623 | .name = "krb5p" , |
624 | .datatouch = true, |
625 | }, |
626 | }; |
627 | |
628 | MODULE_ALIAS("rpc-auth-gss-krb5" ); |
629 | MODULE_ALIAS("rpc-auth-gss-krb5i" ); |
630 | MODULE_ALIAS("rpc-auth-gss-krb5p" ); |
631 | MODULE_ALIAS("rpc-auth-gss-390003" ); |
632 | MODULE_ALIAS("rpc-auth-gss-390004" ); |
633 | MODULE_ALIAS("rpc-auth-gss-390005" ); |
634 | MODULE_ALIAS("rpc-auth-gss-1.2.840.113554.1.2.2" ); |
635 | |
636 | static struct gss_api_mech gss_kerberos_mech = { |
637 | .gm_name = "krb5" , |
638 | .gm_owner = THIS_MODULE, |
639 | .gm_oid = { 9, "\x2a\x86\x48\x86\xf7\x12\x01\x02\x02" }, |
640 | .gm_ops = &gss_kerberos_ops, |
641 | .gm_pf_num = ARRAY_SIZE(gss_kerberos_pfs), |
642 | .gm_pfs = gss_kerberos_pfs, |
643 | .gm_upcall_enctypes = gss_krb5_enctype_priority_list, |
644 | }; |
645 | |
646 | static int __init init_kerberos_module(void) |
647 | { |
648 | int status; |
649 | |
650 | gss_krb5_prepare_enctype_priority_list(); |
651 | status = gss_mech_register(&gss_kerberos_mech); |
652 | if (status) |
653 | printk("Failed to register kerberos gss mechanism!\n" ); |
654 | return status; |
655 | } |
656 | |
657 | static void __exit cleanup_kerberos_module(void) |
658 | { |
659 | gss_mech_unregister(&gss_kerberos_mech); |
660 | } |
661 | |
662 | MODULE_DESCRIPTION("Sun RPC Kerberos 5 module" ); |
663 | MODULE_LICENSE("GPL" ); |
664 | module_init(init_kerberos_module); |
665 | module_exit(cleanup_kerberos_module); |
666 | |