]>
Commit | Line | Data |
---|---|---|
17926a79 DH |
1 | /* Kerberos-based RxRPC security |
2 | * | |
3 | * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved. | |
4 | * Written by David Howells (dhowells@redhat.com) | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or | |
7 | * modify it under the terms of the GNU General Public License | |
8 | * as published by the Free Software Foundation; either version | |
9 | * 2 of the License, or (at your option) any later version. | |
10 | */ | |
11 | ||
12 | #include <linux/module.h> | |
13 | #include <linux/net.h> | |
14 | #include <linux/skbuff.h> | |
15 | #include <linux/udp.h> | |
16 | #include <linux/crypto.h> | |
17 | #include <linux/scatterlist.h> | |
18 | #include <linux/ctype.h> | |
19 | #include <net/sock.h> | |
20 | #include <net/af_rxrpc.h> | |
b1bdb691 | 21 | #define rxrpc_debug rxkad_debug |
17926a79 DH |
22 | #include "ar-internal.h" |
23 | ||
24 | #define RXKAD_VERSION 2 | |
25 | #define MAXKRB5TICKETLEN 1024 | |
26 | #define RXKAD_TKT_TYPE_KERBEROS_V5 256 | |
27 | #define ANAME_SZ 40 /* size of authentication name */ | |
28 | #define INST_SZ 40 /* size of principal's instance */ | |
29 | #define REALM_SZ 40 /* size of principal's auth domain */ | |
30 | #define SNAME_SZ 40 /* size of service name */ | |
31 | ||
32 | unsigned rxrpc_debug; | |
33 | module_param_named(debug, rxrpc_debug, uint, S_IWUSR | S_IRUGO); | |
34 | MODULE_PARM_DESC(rxrpc_debug, "rxkad debugging mask"); | |
35 | ||
36 | struct rxkad_level1_hdr { | |
37 | __be32 data_size; /* true data size (excluding padding) */ | |
38 | }; | |
39 | ||
40 | struct rxkad_level2_hdr { | |
41 | __be32 data_size; /* true data size (excluding padding) */ | |
42 | __be32 checksum; /* decrypted data checksum */ | |
43 | }; | |
44 | ||
45 | MODULE_DESCRIPTION("RxRPC network protocol type-2 security (Kerberos)"); | |
46 | MODULE_AUTHOR("Red Hat, Inc."); | |
47 | MODULE_LICENSE("GPL"); | |
48 | ||
49 | /* | |
50 | * this holds a pinned cipher so that keventd doesn't get called by the cipher | |
51 | * alloc routine, but since we have it to hand, we use it to decrypt RESPONSE | |
52 | * packets | |
53 | */ | |
54 | static struct crypto_blkcipher *rxkad_ci; | |
55 | static DEFINE_MUTEX(rxkad_ci_mutex); | |
56 | ||
57 | /* | |
58 | * initialise connection security | |
59 | */ | |
60 | static int rxkad_init_connection_security(struct rxrpc_connection *conn) | |
61 | { | |
62 | struct rxrpc_key_payload *payload; | |
63 | struct crypto_blkcipher *ci; | |
64 | int ret; | |
65 | ||
66 | _enter("{%d},{%x}", conn->debug_id, key_serial(conn->key)); | |
67 | ||
68 | payload = conn->key->payload.data; | |
69 | conn->security_ix = payload->k.security_index; | |
70 | ||
71 | ci = crypto_alloc_blkcipher("pcbc(fcrypt)", 0, CRYPTO_ALG_ASYNC); | |
72 | if (IS_ERR(ci)) { | |
73 | _debug("no cipher"); | |
74 | ret = PTR_ERR(ci); | |
75 | goto error; | |
76 | } | |
77 | ||
78 | if (crypto_blkcipher_setkey(ci, payload->k.session_key, | |
79 | sizeof(payload->k.session_key)) < 0) | |
80 | BUG(); | |
81 | ||
82 | switch (conn->security_level) { | |
83 | case RXRPC_SECURITY_PLAIN: | |
84 | break; | |
85 | case RXRPC_SECURITY_AUTH: | |
86 | conn->size_align = 8; | |
87 | conn->security_size = sizeof(struct rxkad_level1_hdr); | |
88 | conn->header_size += sizeof(struct rxkad_level1_hdr); | |
89 | break; | |
90 | case RXRPC_SECURITY_ENCRYPT: | |
91 | conn->size_align = 8; | |
92 | conn->security_size = sizeof(struct rxkad_level2_hdr); | |
93 | conn->header_size += sizeof(struct rxkad_level2_hdr); | |
94 | break; | |
95 | default: | |
96 | ret = -EKEYREJECTED; | |
97 | goto error; | |
98 | } | |
99 | ||
100 | conn->cipher = ci; | |
101 | ret = 0; | |
102 | error: | |
103 | _leave(" = %d", ret); | |
104 | return ret; | |
105 | } | |
106 | ||
107 | /* | |
108 | * prime the encryption state with the invariant parts of a connection's | |
109 | * description | |
110 | */ | |
111 | static void rxkad_prime_packet_security(struct rxrpc_connection *conn) | |
112 | { | |
113 | struct rxrpc_key_payload *payload; | |
114 | struct blkcipher_desc desc; | |
115 | struct scatterlist sg[2]; | |
116 | struct rxrpc_crypt iv; | |
117 | struct { | |
118 | __be32 x[4]; | |
119 | } tmpbuf __attribute__((aligned(16))); /* must all be in same page */ | |
120 | ||
121 | _enter(""); | |
122 | ||
123 | if (!conn->key) | |
124 | return; | |
125 | ||
126 | payload = conn->key->payload.data; | |
127 | memcpy(&iv, payload->k.session_key, sizeof(iv)); | |
128 | ||
129 | desc.tfm = conn->cipher; | |
130 | desc.info = iv.x; | |
131 | desc.flags = 0; | |
132 | ||
133 | tmpbuf.x[0] = conn->epoch; | |
134 | tmpbuf.x[1] = conn->cid; | |
135 | tmpbuf.x[2] = 0; | |
136 | tmpbuf.x[3] = htonl(conn->security_ix); | |
137 | ||
68e3f5dd HX |
138 | sg_init_one(&sg[0], &tmpbuf, sizeof(tmpbuf)); |
139 | sg_init_one(&sg[1], &tmpbuf, sizeof(tmpbuf)); | |
17926a79 DH |
140 | crypto_blkcipher_encrypt_iv(&desc, &sg[0], &sg[1], sizeof(tmpbuf)); |
141 | ||
142 | memcpy(&conn->csum_iv, &tmpbuf.x[2], sizeof(conn->csum_iv)); | |
143 | ASSERTCMP(conn->csum_iv.n[0], ==, tmpbuf.x[2]); | |
144 | ||
145 | _leave(""); | |
146 | } | |
147 | ||
148 | /* | |
149 | * partially encrypt a packet (level 1 security) | |
150 | */ | |
151 | static int rxkad_secure_packet_auth(const struct rxrpc_call *call, | |
152 | struct sk_buff *skb, | |
153 | u32 data_size, | |
154 | void *sechdr) | |
155 | { | |
156 | struct rxrpc_skb_priv *sp; | |
157 | struct blkcipher_desc desc; | |
158 | struct rxrpc_crypt iv; | |
159 | struct scatterlist sg[2]; | |
160 | struct { | |
161 | struct rxkad_level1_hdr hdr; | |
162 | __be32 first; /* first four bytes of data and padding */ | |
163 | } tmpbuf __attribute__((aligned(8))); /* must all be in same page */ | |
164 | u16 check; | |
165 | ||
166 | sp = rxrpc_skb(skb); | |
167 | ||
168 | _enter(""); | |
169 | ||
170 | check = ntohl(sp->hdr.seq ^ sp->hdr.callNumber); | |
171 | data_size |= (u32) check << 16; | |
172 | ||
173 | tmpbuf.hdr.data_size = htonl(data_size); | |
174 | memcpy(&tmpbuf.first, sechdr + 4, sizeof(tmpbuf.first)); | |
175 | ||
176 | /* start the encryption afresh */ | |
177 | memset(&iv, 0, sizeof(iv)); | |
178 | desc.tfm = call->conn->cipher; | |
179 | desc.info = iv.x; | |
180 | desc.flags = 0; | |
181 | ||
68e3f5dd HX |
182 | sg_init_one(&sg[0], &tmpbuf, sizeof(tmpbuf)); |
183 | sg_init_one(&sg[1], &tmpbuf, sizeof(tmpbuf)); | |
17926a79 DH |
184 | crypto_blkcipher_encrypt_iv(&desc, &sg[0], &sg[1], sizeof(tmpbuf)); |
185 | ||
186 | memcpy(sechdr, &tmpbuf, sizeof(tmpbuf)); | |
187 | ||
188 | _leave(" = 0"); | |
189 | return 0; | |
190 | } | |
191 | ||
192 | /* | |
193 | * wholly encrypt a packet (level 2 security) | |
194 | */ | |
195 | static int rxkad_secure_packet_encrypt(const struct rxrpc_call *call, | |
196 | struct sk_buff *skb, | |
197 | u32 data_size, | |
198 | void *sechdr) | |
199 | { | |
200 | const struct rxrpc_key_payload *payload; | |
201 | struct rxkad_level2_hdr rxkhdr | |
202 | __attribute__((aligned(8))); /* must be all on one page */ | |
203 | struct rxrpc_skb_priv *sp; | |
204 | struct blkcipher_desc desc; | |
205 | struct rxrpc_crypt iv; | |
206 | struct scatterlist sg[16]; | |
207 | struct sk_buff *trailer; | |
208 | unsigned len; | |
209 | u16 check; | |
210 | int nsg; | |
211 | ||
212 | sp = rxrpc_skb(skb); | |
213 | ||
214 | _enter(""); | |
215 | ||
216 | check = ntohl(sp->hdr.seq ^ sp->hdr.callNumber); | |
217 | ||
218 | rxkhdr.data_size = htonl(data_size | (u32) check << 16); | |
219 | rxkhdr.checksum = 0; | |
220 | ||
221 | /* encrypt from the session key */ | |
222 | payload = call->conn->key->payload.data; | |
223 | memcpy(&iv, payload->k.session_key, sizeof(iv)); | |
224 | desc.tfm = call->conn->cipher; | |
225 | desc.info = iv.x; | |
226 | desc.flags = 0; | |
227 | ||
68e3f5dd HX |
228 | sg_init_one(&sg[0], sechdr, sizeof(rxkhdr)); |
229 | sg_init_one(&sg[1], &rxkhdr, sizeof(rxkhdr)); | |
17926a79 DH |
230 | crypto_blkcipher_encrypt_iv(&desc, &sg[0], &sg[1], sizeof(rxkhdr)); |
231 | ||
232 | /* we want to encrypt the skbuff in-place */ | |
233 | nsg = skb_cow_data(skb, 0, &trailer); | |
234 | if (nsg < 0 || nsg > 16) | |
235 | return -ENOMEM; | |
236 | ||
237 | len = data_size + call->conn->size_align - 1; | |
238 | len &= ~(call->conn->size_align - 1); | |
239 | ||
68e3f5dd | 240 | sg_init_table(sg, skb_to_sgvec(skb, sg, 0, len)); |
17926a79 DH |
241 | crypto_blkcipher_encrypt_iv(&desc, sg, sg, len); |
242 | ||
243 | _leave(" = 0"); | |
244 | return 0; | |
245 | } | |
246 | ||
247 | /* | |
248 | * checksum an RxRPC packet header | |
249 | */ | |
250 | static int rxkad_secure_packet(const struct rxrpc_call *call, | |
251 | struct sk_buff *skb, | |
252 | size_t data_size, | |
253 | void *sechdr) | |
254 | { | |
255 | struct rxrpc_skb_priv *sp; | |
256 | struct blkcipher_desc desc; | |
257 | struct rxrpc_crypt iv; | |
258 | struct scatterlist sg[2]; | |
259 | struct { | |
260 | __be32 x[2]; | |
261 | } tmpbuf __attribute__((aligned(8))); /* must all be in same page */ | |
262 | __be32 x; | |
263 | int ret; | |
264 | ||
265 | sp = rxrpc_skb(skb); | |
266 | ||
267 | _enter("{%d{%x}},{#%u},%zu,", | |
268 | call->debug_id, key_serial(call->conn->key), ntohl(sp->hdr.seq), | |
269 | data_size); | |
270 | ||
271 | if (!call->conn->cipher) | |
272 | return 0; | |
273 | ||
274 | ret = key_validate(call->conn->key); | |
275 | if (ret < 0) | |
276 | return ret; | |
277 | ||
278 | /* continue encrypting from where we left off */ | |
279 | memcpy(&iv, call->conn->csum_iv.x, sizeof(iv)); | |
280 | desc.tfm = call->conn->cipher; | |
281 | desc.info = iv.x; | |
282 | desc.flags = 0; | |
283 | ||
284 | /* calculate the security checksum */ | |
285 | x = htonl(call->channel << (32 - RXRPC_CIDSHIFT)); | |
286 | x |= sp->hdr.seq & __constant_cpu_to_be32(0x3fffffff); | |
287 | tmpbuf.x[0] = sp->hdr.callNumber; | |
288 | tmpbuf.x[1] = x; | |
289 | ||
68e3f5dd HX |
290 | sg_init_one(&sg[0], &tmpbuf, sizeof(tmpbuf)); |
291 | sg_init_one(&sg[1], &tmpbuf, sizeof(tmpbuf)); | |
17926a79 DH |
292 | crypto_blkcipher_encrypt_iv(&desc, &sg[0], &sg[1], sizeof(tmpbuf)); |
293 | ||
294 | x = ntohl(tmpbuf.x[1]); | |
295 | x = (x >> 16) & 0xffff; | |
296 | if (x == 0) | |
297 | x = 1; /* zero checksums are not permitted */ | |
298 | sp->hdr.cksum = htons(x); | |
299 | ||
300 | switch (call->conn->security_level) { | |
301 | case RXRPC_SECURITY_PLAIN: | |
302 | ret = 0; | |
303 | break; | |
304 | case RXRPC_SECURITY_AUTH: | |
305 | ret = rxkad_secure_packet_auth(call, skb, data_size, sechdr); | |
306 | break; | |
307 | case RXRPC_SECURITY_ENCRYPT: | |
308 | ret = rxkad_secure_packet_encrypt(call, skb, data_size, | |
309 | sechdr); | |
310 | break; | |
311 | default: | |
312 | ret = -EPERM; | |
313 | break; | |
314 | } | |
315 | ||
316 | _leave(" = %d [set %hx]", ret, x); | |
317 | return ret; | |
318 | } | |
319 | ||
320 | /* | |
321 | * decrypt partial encryption on a packet (level 1 security) | |
322 | */ | |
323 | static int rxkad_verify_packet_auth(const struct rxrpc_call *call, | |
324 | struct sk_buff *skb, | |
325 | u32 *_abort_code) | |
326 | { | |
327 | struct rxkad_level1_hdr sechdr; | |
328 | struct rxrpc_skb_priv *sp; | |
329 | struct blkcipher_desc desc; | |
330 | struct rxrpc_crypt iv; | |
68e3f5dd | 331 | struct scatterlist sg[16]; |
17926a79 DH |
332 | struct sk_buff *trailer; |
333 | u32 data_size, buf; | |
334 | u16 check; | |
68e3f5dd | 335 | int nsg; |
17926a79 DH |
336 | |
337 | _enter(""); | |
338 | ||
339 | sp = rxrpc_skb(skb); | |
340 | ||
341 | /* we want to decrypt the skbuff in-place */ | |
68e3f5dd HX |
342 | nsg = skb_cow_data(skb, 0, &trailer); |
343 | if (nsg < 0 || nsg > 16) | |
17926a79 DH |
344 | goto nomem; |
345 | ||
68e3f5dd HX |
346 | sg_init_table(sg, nsg); |
347 | sg_mark_end(sg, skb_to_sgvec(skb, sg, 0, 8)); | |
17926a79 DH |
348 | |
349 | /* start the decryption afresh */ | |
350 | memset(&iv, 0, sizeof(iv)); | |
351 | desc.tfm = call->conn->cipher; | |
352 | desc.info = iv.x; | |
353 | desc.flags = 0; | |
354 | ||
355 | crypto_blkcipher_decrypt_iv(&desc, sg, sg, 8); | |
356 | ||
357 | /* remove the decrypted packet length */ | |
358 | if (skb_copy_bits(skb, 0, &sechdr, sizeof(sechdr)) < 0) | |
359 | goto datalen_error; | |
360 | if (!skb_pull(skb, sizeof(sechdr))) | |
361 | BUG(); | |
362 | ||
363 | buf = ntohl(sechdr.data_size); | |
364 | data_size = buf & 0xffff; | |
365 | ||
366 | check = buf >> 16; | |
367 | check ^= ntohl(sp->hdr.seq ^ sp->hdr.callNumber); | |
368 | check &= 0xffff; | |
369 | if (check != 0) { | |
370 | *_abort_code = RXKADSEALEDINCON; | |
371 | goto protocol_error; | |
372 | } | |
373 | ||
374 | /* shorten the packet to remove the padding */ | |
375 | if (data_size > skb->len) | |
376 | goto datalen_error; | |
377 | else if (data_size < skb->len) | |
378 | skb->len = data_size; | |
379 | ||
380 | _leave(" = 0 [dlen=%x]", data_size); | |
381 | return 0; | |
382 | ||
383 | datalen_error: | |
384 | *_abort_code = RXKADDATALEN; | |
385 | protocol_error: | |
386 | _leave(" = -EPROTO"); | |
387 | return -EPROTO; | |
388 | ||
389 | nomem: | |
390 | _leave(" = -ENOMEM"); | |
391 | return -ENOMEM; | |
392 | } | |
393 | ||
394 | /* | |
395 | * wholly decrypt a packet (level 2 security) | |
396 | */ | |
397 | static int rxkad_verify_packet_encrypt(const struct rxrpc_call *call, | |
398 | struct sk_buff *skb, | |
399 | u32 *_abort_code) | |
400 | { | |
401 | const struct rxrpc_key_payload *payload; | |
402 | struct rxkad_level2_hdr sechdr; | |
403 | struct rxrpc_skb_priv *sp; | |
404 | struct blkcipher_desc desc; | |
405 | struct rxrpc_crypt iv; | |
406 | struct scatterlist _sg[4], *sg; | |
407 | struct sk_buff *trailer; | |
408 | u32 data_size, buf; | |
409 | u16 check; | |
410 | int nsg; | |
411 | ||
412 | _enter(",{%d}", skb->len); | |
413 | ||
414 | sp = rxrpc_skb(skb); | |
415 | ||
416 | /* we want to decrypt the skbuff in-place */ | |
417 | nsg = skb_cow_data(skb, 0, &trailer); | |
418 | if (nsg < 0) | |
419 | goto nomem; | |
420 | ||
421 | sg = _sg; | |
422 | if (unlikely(nsg > 4)) { | |
423 | sg = kmalloc(sizeof(*sg) * nsg, GFP_NOIO); | |
424 | if (!sg) | |
425 | goto nomem; | |
426 | } | |
427 | ||
68e3f5dd HX |
428 | sg_init_table(sg, nsg); |
429 | sg_mark_end(sg, skb_to_sgvec(skb, sg, 0, skb->len)); | |
17926a79 DH |
430 | |
431 | /* decrypt from the session key */ | |
432 | payload = call->conn->key->payload.data; | |
433 | memcpy(&iv, payload->k.session_key, sizeof(iv)); | |
434 | desc.tfm = call->conn->cipher; | |
435 | desc.info = iv.x; | |
436 | desc.flags = 0; | |
437 | ||
438 | crypto_blkcipher_decrypt_iv(&desc, sg, sg, skb->len); | |
439 | if (sg != _sg) | |
440 | kfree(sg); | |
441 | ||
442 | /* remove the decrypted packet length */ | |
443 | if (skb_copy_bits(skb, 0, &sechdr, sizeof(sechdr)) < 0) | |
444 | goto datalen_error; | |
445 | if (!skb_pull(skb, sizeof(sechdr))) | |
446 | BUG(); | |
447 | ||
448 | buf = ntohl(sechdr.data_size); | |
449 | data_size = buf & 0xffff; | |
450 | ||
451 | check = buf >> 16; | |
452 | check ^= ntohl(sp->hdr.seq ^ sp->hdr.callNumber); | |
453 | check &= 0xffff; | |
454 | if (check != 0) { | |
455 | *_abort_code = RXKADSEALEDINCON; | |
456 | goto protocol_error; | |
457 | } | |
458 | ||
459 | /* shorten the packet to remove the padding */ | |
460 | if (data_size > skb->len) | |
461 | goto datalen_error; | |
462 | else if (data_size < skb->len) | |
463 | skb->len = data_size; | |
464 | ||
465 | _leave(" = 0 [dlen=%x]", data_size); | |
466 | return 0; | |
467 | ||
468 | datalen_error: | |
469 | *_abort_code = RXKADDATALEN; | |
470 | protocol_error: | |
471 | _leave(" = -EPROTO"); | |
472 | return -EPROTO; | |
473 | ||
474 | nomem: | |
475 | _leave(" = -ENOMEM"); | |
476 | return -ENOMEM; | |
477 | } | |
478 | ||
479 | /* | |
480 | * verify the security on a received packet | |
481 | */ | |
482 | static int rxkad_verify_packet(const struct rxrpc_call *call, | |
483 | struct sk_buff *skb, | |
484 | u32 *_abort_code) | |
485 | { | |
486 | struct blkcipher_desc desc; | |
487 | struct rxrpc_skb_priv *sp; | |
488 | struct rxrpc_crypt iv; | |
489 | struct scatterlist sg[2]; | |
490 | struct { | |
491 | __be32 x[2]; | |
492 | } tmpbuf __attribute__((aligned(8))); /* must all be in same page */ | |
493 | __be32 x; | |
494 | __be16 cksum; | |
495 | int ret; | |
496 | ||
497 | sp = rxrpc_skb(skb); | |
498 | ||
499 | _enter("{%d{%x}},{#%u}", | |
500 | call->debug_id, key_serial(call->conn->key), | |
501 | ntohl(sp->hdr.seq)); | |
502 | ||
503 | if (!call->conn->cipher) | |
504 | return 0; | |
505 | ||
506 | if (sp->hdr.securityIndex != 2) { | |
507 | *_abort_code = RXKADINCONSISTENCY; | |
508 | _leave(" = -EPROTO [not rxkad]"); | |
509 | return -EPROTO; | |
510 | } | |
511 | ||
512 | /* continue encrypting from where we left off */ | |
513 | memcpy(&iv, call->conn->csum_iv.x, sizeof(iv)); | |
514 | desc.tfm = call->conn->cipher; | |
515 | desc.info = iv.x; | |
516 | desc.flags = 0; | |
517 | ||
518 | /* validate the security checksum */ | |
519 | x = htonl(call->channel << (32 - RXRPC_CIDSHIFT)); | |
520 | x |= sp->hdr.seq & __constant_cpu_to_be32(0x3fffffff); | |
521 | tmpbuf.x[0] = call->call_id; | |
522 | tmpbuf.x[1] = x; | |
523 | ||
68e3f5dd HX |
524 | sg_init_one(&sg[0], &tmpbuf, sizeof(tmpbuf)); |
525 | sg_init_one(&sg[1], &tmpbuf, sizeof(tmpbuf)); | |
17926a79 DH |
526 | crypto_blkcipher_encrypt_iv(&desc, &sg[0], &sg[1], sizeof(tmpbuf)); |
527 | ||
528 | x = ntohl(tmpbuf.x[1]); | |
529 | x = (x >> 16) & 0xffff; | |
530 | if (x == 0) | |
531 | x = 1; /* zero checksums are not permitted */ | |
532 | ||
533 | cksum = htons(x); | |
534 | if (sp->hdr.cksum != cksum) { | |
535 | *_abort_code = RXKADSEALEDINCON; | |
536 | _leave(" = -EPROTO [csum failed]"); | |
537 | return -EPROTO; | |
538 | } | |
539 | ||
540 | switch (call->conn->security_level) { | |
541 | case RXRPC_SECURITY_PLAIN: | |
542 | ret = 0; | |
543 | break; | |
544 | case RXRPC_SECURITY_AUTH: | |
545 | ret = rxkad_verify_packet_auth(call, skb, _abort_code); | |
546 | break; | |
547 | case RXRPC_SECURITY_ENCRYPT: | |
548 | ret = rxkad_verify_packet_encrypt(call, skb, _abort_code); | |
549 | break; | |
550 | default: | |
551 | ret = -ENOANO; | |
552 | break; | |
553 | } | |
554 | ||
555 | _leave(" = %d", ret); | |
556 | return ret; | |
557 | } | |
558 | ||
559 | /* | |
560 | * issue a challenge | |
561 | */ | |
562 | static int rxkad_issue_challenge(struct rxrpc_connection *conn) | |
563 | { | |
564 | struct rxkad_challenge challenge; | |
565 | struct rxrpc_header hdr; | |
566 | struct msghdr msg; | |
567 | struct kvec iov[2]; | |
568 | size_t len; | |
569 | int ret; | |
570 | ||
571 | _enter("{%d,%x}", conn->debug_id, key_serial(conn->key)); | |
572 | ||
573 | ret = key_validate(conn->key); | |
574 | if (ret < 0) | |
575 | return ret; | |
576 | ||
577 | get_random_bytes(&conn->security_nonce, sizeof(conn->security_nonce)); | |
578 | ||
579 | challenge.version = htonl(2); | |
580 | challenge.nonce = htonl(conn->security_nonce); | |
581 | challenge.min_level = htonl(0); | |
582 | challenge.__padding = 0; | |
583 | ||
584 | msg.msg_name = &conn->trans->peer->srx.transport.sin; | |
585 | msg.msg_namelen = sizeof(conn->trans->peer->srx.transport.sin); | |
586 | msg.msg_control = NULL; | |
587 | msg.msg_controllen = 0; | |
588 | msg.msg_flags = 0; | |
589 | ||
590 | hdr.epoch = conn->epoch; | |
591 | hdr.cid = conn->cid; | |
592 | hdr.callNumber = 0; | |
593 | hdr.seq = 0; | |
594 | hdr.type = RXRPC_PACKET_TYPE_CHALLENGE; | |
595 | hdr.flags = conn->out_clientflag; | |
596 | hdr.userStatus = 0; | |
597 | hdr.securityIndex = conn->security_ix; | |
598 | hdr._rsvd = 0; | |
599 | hdr.serviceId = conn->service_id; | |
600 | ||
601 | iov[0].iov_base = &hdr; | |
602 | iov[0].iov_len = sizeof(hdr); | |
603 | iov[1].iov_base = &challenge; | |
604 | iov[1].iov_len = sizeof(challenge); | |
605 | ||
606 | len = iov[0].iov_len + iov[1].iov_len; | |
607 | ||
608 | hdr.serial = htonl(atomic_inc_return(&conn->serial)); | |
609 | _proto("Tx CHALLENGE %%%u", ntohl(hdr.serial)); | |
610 | ||
611 | ret = kernel_sendmsg(conn->trans->local->socket, &msg, iov, 2, len); | |
612 | if (ret < 0) { | |
613 | _debug("sendmsg failed: %d", ret); | |
614 | return -EAGAIN; | |
615 | } | |
616 | ||
617 | _leave(" = 0"); | |
618 | return 0; | |
619 | } | |
620 | ||
621 | /* | |
622 | * send a Kerberos security response | |
623 | */ | |
624 | static int rxkad_send_response(struct rxrpc_connection *conn, | |
625 | struct rxrpc_header *hdr, | |
626 | struct rxkad_response *resp, | |
627 | const struct rxkad_key *s2) | |
628 | { | |
629 | struct msghdr msg; | |
630 | struct kvec iov[3]; | |
631 | size_t len; | |
632 | int ret; | |
633 | ||
634 | _enter(""); | |
635 | ||
636 | msg.msg_name = &conn->trans->peer->srx.transport.sin; | |
637 | msg.msg_namelen = sizeof(conn->trans->peer->srx.transport.sin); | |
638 | msg.msg_control = NULL; | |
639 | msg.msg_controllen = 0; | |
640 | msg.msg_flags = 0; | |
641 | ||
642 | hdr->epoch = conn->epoch; | |
643 | hdr->seq = 0; | |
644 | hdr->type = RXRPC_PACKET_TYPE_RESPONSE; | |
645 | hdr->flags = conn->out_clientflag; | |
646 | hdr->userStatus = 0; | |
647 | hdr->_rsvd = 0; | |
648 | ||
649 | iov[0].iov_base = hdr; | |
650 | iov[0].iov_len = sizeof(*hdr); | |
651 | iov[1].iov_base = resp; | |
652 | iov[1].iov_len = sizeof(*resp); | |
653 | iov[2].iov_base = (void *) s2->ticket; | |
654 | iov[2].iov_len = s2->ticket_len; | |
655 | ||
656 | len = iov[0].iov_len + iov[1].iov_len + iov[2].iov_len; | |
657 | ||
658 | hdr->serial = htonl(atomic_inc_return(&conn->serial)); | |
659 | _proto("Tx RESPONSE %%%u", ntohl(hdr->serial)); | |
660 | ||
661 | ret = kernel_sendmsg(conn->trans->local->socket, &msg, iov, 3, len); | |
662 | if (ret < 0) { | |
663 | _debug("sendmsg failed: %d", ret); | |
664 | return -EAGAIN; | |
665 | } | |
666 | ||
667 | _leave(" = 0"); | |
668 | return 0; | |
669 | } | |
670 | ||
671 | /* | |
672 | * calculate the response checksum | |
673 | */ | |
674 | static void rxkad_calc_response_checksum(struct rxkad_response *response) | |
675 | { | |
676 | u32 csum = 1000003; | |
677 | int loop; | |
678 | u8 *p = (u8 *) response; | |
679 | ||
680 | for (loop = sizeof(*response); loop > 0; loop--) | |
681 | csum = csum * 0x10204081 + *p++; | |
682 | ||
683 | response->encrypted.checksum = htonl(csum); | |
684 | } | |
685 | ||
686 | /* | |
687 | * load a scatterlist with a potentially split-page buffer | |
688 | */ | |
689 | static void rxkad_sg_set_buf2(struct scatterlist sg[2], | |
690 | void *buf, size_t buflen) | |
691 | { | |
68e3f5dd | 692 | int nsg = 1; |
17926a79 | 693 | |
68e3f5dd | 694 | sg_init_table(sg, 2); |
17926a79 DH |
695 | |
696 | sg_set_buf(&sg[0], buf, buflen); | |
697 | if (sg[0].offset + buflen > PAGE_SIZE) { | |
698 | /* the buffer was split over two pages */ | |
699 | sg[0].length = PAGE_SIZE - sg[0].offset; | |
700 | sg_set_buf(&sg[1], buf + sg[0].length, buflen - sg[0].length); | |
68e3f5dd | 701 | nsg++; |
17926a79 DH |
702 | } |
703 | ||
68e3f5dd HX |
704 | sg_mark_end(sg, nsg); |
705 | ||
17926a79 DH |
706 | ASSERTCMP(sg[0].length + sg[1].length, ==, buflen); |
707 | } | |
708 | ||
709 | /* | |
710 | * encrypt the response packet | |
711 | */ | |
712 | static void rxkad_encrypt_response(struct rxrpc_connection *conn, | |
713 | struct rxkad_response *resp, | |
714 | const struct rxkad_key *s2) | |
715 | { | |
716 | struct blkcipher_desc desc; | |
717 | struct rxrpc_crypt iv; | |
68e3f5dd | 718 | struct scatterlist sg[2]; |
17926a79 DH |
719 | |
720 | /* continue encrypting from where we left off */ | |
721 | memcpy(&iv, s2->session_key, sizeof(iv)); | |
722 | desc.tfm = conn->cipher; | |
723 | desc.info = iv.x; | |
724 | desc.flags = 0; | |
725 | ||
68e3f5dd HX |
726 | rxkad_sg_set_buf2(sg, &resp->encrypted, sizeof(resp->encrypted)); |
727 | crypto_blkcipher_encrypt_iv(&desc, sg, sg, sizeof(resp->encrypted)); | |
17926a79 DH |
728 | } |
729 | ||
730 | /* | |
731 | * respond to a challenge packet | |
732 | */ | |
733 | static int rxkad_respond_to_challenge(struct rxrpc_connection *conn, | |
734 | struct sk_buff *skb, | |
735 | u32 *_abort_code) | |
736 | { | |
737 | const struct rxrpc_key_payload *payload; | |
738 | struct rxkad_challenge challenge; | |
739 | struct rxkad_response resp | |
740 | __attribute__((aligned(8))); /* must be aligned for crypto */ | |
741 | struct rxrpc_skb_priv *sp; | |
742 | u32 version, nonce, min_level, abort_code; | |
743 | int ret; | |
744 | ||
745 | _enter("{%d,%x}", conn->debug_id, key_serial(conn->key)); | |
746 | ||
747 | if (!conn->key) { | |
748 | _leave(" = -EPROTO [no key]"); | |
749 | return -EPROTO; | |
750 | } | |
751 | ||
752 | ret = key_validate(conn->key); | |
753 | if (ret < 0) { | |
754 | *_abort_code = RXKADEXPIRED; | |
755 | return ret; | |
756 | } | |
757 | ||
758 | abort_code = RXKADPACKETSHORT; | |
759 | sp = rxrpc_skb(skb); | |
760 | if (skb_copy_bits(skb, 0, &challenge, sizeof(challenge)) < 0) | |
761 | goto protocol_error; | |
762 | ||
763 | version = ntohl(challenge.version); | |
764 | nonce = ntohl(challenge.nonce); | |
765 | min_level = ntohl(challenge.min_level); | |
766 | ||
767 | _proto("Rx CHALLENGE %%%u { v=%u n=%u ml=%u }", | |
768 | ntohl(sp->hdr.serial), version, nonce, min_level); | |
769 | ||
770 | abort_code = RXKADINCONSISTENCY; | |
771 | if (version != RXKAD_VERSION) | |
772 | goto protocol_error; | |
773 | ||
774 | abort_code = RXKADLEVELFAIL; | |
775 | if (conn->security_level < min_level) | |
776 | goto protocol_error; | |
777 | ||
778 | payload = conn->key->payload.data; | |
779 | ||
780 | /* build the response packet */ | |
781 | memset(&resp, 0, sizeof(resp)); | |
782 | ||
783 | resp.version = RXKAD_VERSION; | |
784 | resp.encrypted.epoch = conn->epoch; | |
785 | resp.encrypted.cid = conn->cid; | |
786 | resp.encrypted.securityIndex = htonl(conn->security_ix); | |
787 | resp.encrypted.call_id[0] = | |
788 | (conn->channels[0] ? conn->channels[0]->call_id : 0); | |
789 | resp.encrypted.call_id[1] = | |
790 | (conn->channels[1] ? conn->channels[1]->call_id : 0); | |
791 | resp.encrypted.call_id[2] = | |
792 | (conn->channels[2] ? conn->channels[2]->call_id : 0); | |
793 | resp.encrypted.call_id[3] = | |
794 | (conn->channels[3] ? conn->channels[3]->call_id : 0); | |
795 | resp.encrypted.inc_nonce = htonl(nonce + 1); | |
796 | resp.encrypted.level = htonl(conn->security_level); | |
797 | resp.kvno = htonl(payload->k.kvno); | |
798 | resp.ticket_len = htonl(payload->k.ticket_len); | |
799 | ||
800 | /* calculate the response checksum and then do the encryption */ | |
801 | rxkad_calc_response_checksum(&resp); | |
802 | rxkad_encrypt_response(conn, &resp, &payload->k); | |
803 | return rxkad_send_response(conn, &sp->hdr, &resp, &payload->k); | |
804 | ||
805 | protocol_error: | |
806 | *_abort_code = abort_code; | |
807 | _leave(" = -EPROTO [%d]", abort_code); | |
808 | return -EPROTO; | |
809 | } | |
810 | ||
811 | /* | |
812 | * decrypt the kerberos IV ticket in the response | |
813 | */ | |
814 | static int rxkad_decrypt_ticket(struct rxrpc_connection *conn, | |
815 | void *ticket, size_t ticket_len, | |
816 | struct rxrpc_crypt *_session_key, | |
817 | time_t *_expiry, | |
818 | u32 *_abort_code) | |
819 | { | |
820 | struct blkcipher_desc desc; | |
821 | struct rxrpc_crypt iv, key; | |
68e3f5dd | 822 | struct scatterlist sg[1]; |
17926a79 DH |
823 | struct in_addr addr; |
824 | unsigned life; | |
825 | time_t issue, now; | |
826 | bool little_endian; | |
827 | int ret; | |
828 | u8 *p, *q, *name, *end; | |
829 | ||
830 | _enter("{%d},{%x}", conn->debug_id, key_serial(conn->server_key)); | |
831 | ||
832 | *_expiry = 0; | |
833 | ||
834 | ret = key_validate(conn->server_key); | |
835 | if (ret < 0) { | |
836 | switch (ret) { | |
837 | case -EKEYEXPIRED: | |
838 | *_abort_code = RXKADEXPIRED; | |
839 | goto error; | |
840 | default: | |
841 | *_abort_code = RXKADNOAUTH; | |
842 | goto error; | |
843 | } | |
844 | } | |
845 | ||
846 | ASSERT(conn->server_key->payload.data != NULL); | |
847 | ASSERTCMP((unsigned long) ticket & 7UL, ==, 0); | |
848 | ||
849 | memcpy(&iv, &conn->server_key->type_data, sizeof(iv)); | |
850 | ||
851 | desc.tfm = conn->server_key->payload.data; | |
852 | desc.info = iv.x; | |
853 | desc.flags = 0; | |
854 | ||
68e3f5dd HX |
855 | sg_init_one(&sg[0], ticket, ticket_len); |
856 | crypto_blkcipher_decrypt_iv(&desc, sg, sg, ticket_len); | |
17926a79 DH |
857 | |
858 | p = ticket; | |
859 | end = p + ticket_len; | |
860 | ||
861 | #define Z(size) \ | |
862 | ({ \ | |
863 | u8 *__str = p; \ | |
864 | q = memchr(p, 0, end - p); \ | |
865 | if (!q || q - p > (size)) \ | |
866 | goto bad_ticket; \ | |
867 | for (; p < q; p++) \ | |
868 | if (!isprint(*p)) \ | |
869 | goto bad_ticket; \ | |
870 | p++; \ | |
871 | __str; \ | |
872 | }) | |
873 | ||
874 | /* extract the ticket flags */ | |
875 | _debug("KIV FLAGS: %x", *p); | |
876 | little_endian = *p & 1; | |
877 | p++; | |
878 | ||
879 | /* extract the authentication name */ | |
880 | name = Z(ANAME_SZ); | |
881 | _debug("KIV ANAME: %s", name); | |
882 | ||
883 | /* extract the principal's instance */ | |
884 | name = Z(INST_SZ); | |
885 | _debug("KIV INST : %s", name); | |
886 | ||
887 | /* extract the principal's authentication domain */ | |
888 | name = Z(REALM_SZ); | |
889 | _debug("KIV REALM: %s", name); | |
890 | ||
891 | if (end - p < 4 + 8 + 4 + 2) | |
892 | goto bad_ticket; | |
893 | ||
894 | /* get the IPv4 address of the entity that requested the ticket */ | |
895 | memcpy(&addr, p, sizeof(addr)); | |
896 | p += 4; | |
897 | _debug("KIV ADDR : "NIPQUAD_FMT, NIPQUAD(addr)); | |
898 | ||
899 | /* get the session key from the ticket */ | |
900 | memcpy(&key, p, sizeof(key)); | |
901 | p += 8; | |
902 | _debug("KIV KEY : %08x %08x", ntohl(key.n[0]), ntohl(key.n[1])); | |
903 | memcpy(_session_key, &key, sizeof(key)); | |
904 | ||
905 | /* get the ticket's lifetime */ | |
906 | life = *p++ * 5 * 60; | |
907 | _debug("KIV LIFE : %u", life); | |
908 | ||
909 | /* get the issue time of the ticket */ | |
910 | if (little_endian) { | |
911 | __le32 stamp; | |
912 | memcpy(&stamp, p, 4); | |
913 | issue = le32_to_cpu(stamp); | |
914 | } else { | |
915 | __be32 stamp; | |
916 | memcpy(&stamp, p, 4); | |
917 | issue = be32_to_cpu(stamp); | |
918 | } | |
919 | p += 4; | |
2c6b47de | 920 | now = get_seconds(); |
17926a79 DH |
921 | _debug("KIV ISSUE: %lx [%lx]", issue, now); |
922 | ||
923 | /* check the ticket is in date */ | |
924 | if (issue > now) { | |
925 | *_abort_code = RXKADNOAUTH; | |
926 | ret = -EKEYREJECTED; | |
927 | goto error; | |
928 | } | |
929 | ||
930 | if (issue < now - life) { | |
931 | *_abort_code = RXKADEXPIRED; | |
932 | ret = -EKEYEXPIRED; | |
933 | goto error; | |
934 | } | |
935 | ||
936 | *_expiry = issue + life; | |
937 | ||
938 | /* get the service name */ | |
939 | name = Z(SNAME_SZ); | |
940 | _debug("KIV SNAME: %s", name); | |
941 | ||
942 | /* get the service instance name */ | |
943 | name = Z(INST_SZ); | |
944 | _debug("KIV SINST: %s", name); | |
945 | ||
946 | ret = 0; | |
947 | error: | |
948 | _leave(" = %d", ret); | |
949 | return ret; | |
950 | ||
951 | bad_ticket: | |
952 | *_abort_code = RXKADBADTICKET; | |
953 | ret = -EBADMSG; | |
954 | goto error; | |
955 | } | |
956 | ||
957 | /* | |
958 | * decrypt the response packet | |
959 | */ | |
960 | static void rxkad_decrypt_response(struct rxrpc_connection *conn, | |
961 | struct rxkad_response *resp, | |
962 | const struct rxrpc_crypt *session_key) | |
963 | { | |
964 | struct blkcipher_desc desc; | |
68e3f5dd | 965 | struct scatterlist sg[2]; |
17926a79 DH |
966 | struct rxrpc_crypt iv; |
967 | ||
968 | _enter(",,%08x%08x", | |
969 | ntohl(session_key->n[0]), ntohl(session_key->n[1])); | |
970 | ||
971 | ASSERT(rxkad_ci != NULL); | |
972 | ||
973 | mutex_lock(&rxkad_ci_mutex); | |
974 | if (crypto_blkcipher_setkey(rxkad_ci, session_key->x, | |
975 | sizeof(*session_key)) < 0) | |
976 | BUG(); | |
977 | ||
978 | memcpy(&iv, session_key, sizeof(iv)); | |
979 | desc.tfm = rxkad_ci; | |
980 | desc.info = iv.x; | |
981 | desc.flags = 0; | |
982 | ||
68e3f5dd HX |
983 | rxkad_sg_set_buf2(sg, &resp->encrypted, sizeof(resp->encrypted)); |
984 | crypto_blkcipher_decrypt_iv(&desc, sg, sg, sizeof(resp->encrypted)); | |
17926a79 DH |
985 | mutex_unlock(&rxkad_ci_mutex); |
986 | ||
987 | _leave(""); | |
988 | } | |
989 | ||
990 | /* | |
991 | * verify a response | |
992 | */ | |
993 | static int rxkad_verify_response(struct rxrpc_connection *conn, | |
994 | struct sk_buff *skb, | |
995 | u32 *_abort_code) | |
996 | { | |
997 | struct rxkad_response response | |
998 | __attribute__((aligned(8))); /* must be aligned for crypto */ | |
999 | struct rxrpc_skb_priv *sp; | |
1000 | struct rxrpc_crypt session_key; | |
1001 | time_t expiry; | |
1002 | void *ticket; | |
1003 | u32 abort_code, version, kvno, ticket_len, csum, level; | |
1004 | int ret; | |
1005 | ||
1006 | _enter("{%d,%x}", conn->debug_id, key_serial(conn->server_key)); | |
1007 | ||
1008 | abort_code = RXKADPACKETSHORT; | |
1009 | if (skb_copy_bits(skb, 0, &response, sizeof(response)) < 0) | |
1010 | goto protocol_error; | |
1011 | if (!pskb_pull(skb, sizeof(response))) | |
1012 | BUG(); | |
1013 | ||
1014 | version = ntohl(response.version); | |
1015 | ticket_len = ntohl(response.ticket_len); | |
1016 | kvno = ntohl(response.kvno); | |
1017 | sp = rxrpc_skb(skb); | |
1018 | _proto("Rx RESPONSE %%%u { v=%u kv=%u tl=%u }", | |
1019 | ntohl(sp->hdr.serial), version, kvno, ticket_len); | |
1020 | ||
1021 | abort_code = RXKADINCONSISTENCY; | |
1022 | if (version != RXKAD_VERSION) | |
1023 | ||
1024 | abort_code = RXKADTICKETLEN; | |
1025 | if (ticket_len < 4 || ticket_len > MAXKRB5TICKETLEN) | |
1026 | goto protocol_error; | |
1027 | ||
1028 | abort_code = RXKADUNKNOWNKEY; | |
1029 | if (kvno >= RXKAD_TKT_TYPE_KERBEROS_V5) | |
1030 | goto protocol_error; | |
1031 | ||
1032 | /* extract the kerberos ticket and decrypt and decode it */ | |
1033 | ticket = kmalloc(ticket_len, GFP_NOFS); | |
1034 | if (!ticket) | |
1035 | return -ENOMEM; | |
1036 | ||
1037 | abort_code = RXKADPACKETSHORT; | |
1038 | if (skb_copy_bits(skb, 0, ticket, ticket_len) < 0) | |
1039 | goto protocol_error_free; | |
1040 | ||
1041 | ret = rxkad_decrypt_ticket(conn, ticket, ticket_len, &session_key, | |
1042 | &expiry, &abort_code); | |
1043 | if (ret < 0) { | |
1044 | *_abort_code = abort_code; | |
1045 | kfree(ticket); | |
1046 | return ret; | |
1047 | } | |
1048 | ||
1049 | /* use the session key from inside the ticket to decrypt the | |
1050 | * response */ | |
1051 | rxkad_decrypt_response(conn, &response, &session_key); | |
1052 | ||
1053 | abort_code = RXKADSEALEDINCON; | |
1054 | if (response.encrypted.epoch != conn->epoch) | |
1055 | goto protocol_error_free; | |
1056 | if (response.encrypted.cid != conn->cid) | |
1057 | goto protocol_error_free; | |
1058 | if (ntohl(response.encrypted.securityIndex) != conn->security_ix) | |
1059 | goto protocol_error_free; | |
1060 | csum = response.encrypted.checksum; | |
1061 | response.encrypted.checksum = 0; | |
1062 | rxkad_calc_response_checksum(&response); | |
1063 | if (response.encrypted.checksum != csum) | |
1064 | goto protocol_error_free; | |
1065 | ||
1066 | if (ntohl(response.encrypted.call_id[0]) > INT_MAX || | |
1067 | ntohl(response.encrypted.call_id[1]) > INT_MAX || | |
1068 | ntohl(response.encrypted.call_id[2]) > INT_MAX || | |
1069 | ntohl(response.encrypted.call_id[3]) > INT_MAX) | |
1070 | goto protocol_error_free; | |
1071 | ||
1072 | abort_code = RXKADOUTOFSEQUENCE; | |
1073 | if (response.encrypted.inc_nonce != htonl(conn->security_nonce + 1)) | |
1074 | goto protocol_error_free; | |
1075 | ||
1076 | abort_code = RXKADLEVELFAIL; | |
1077 | level = ntohl(response.encrypted.level); | |
1078 | if (level > RXRPC_SECURITY_ENCRYPT) | |
1079 | goto protocol_error_free; | |
1080 | conn->security_level = level; | |
1081 | ||
1082 | /* create a key to hold the security data and expiration time - after | |
1083 | * this the connection security can be handled in exactly the same way | |
1084 | * as for a client connection */ | |
1085 | ret = rxrpc_get_server_data_key(conn, &session_key, expiry, kvno); | |
1086 | if (ret < 0) { | |
1087 | kfree(ticket); | |
1088 | return ret; | |
1089 | } | |
1090 | ||
1091 | kfree(ticket); | |
1092 | _leave(" = 0"); | |
1093 | return 0; | |
1094 | ||
1095 | protocol_error_free: | |
1096 | kfree(ticket); | |
1097 | protocol_error: | |
1098 | *_abort_code = abort_code; | |
1099 | _leave(" = -EPROTO [%d]", abort_code); | |
1100 | return -EPROTO; | |
1101 | } | |
1102 | ||
1103 | /* | |
1104 | * clear the connection security | |
1105 | */ | |
1106 | static void rxkad_clear(struct rxrpc_connection *conn) | |
1107 | { | |
1108 | _enter(""); | |
1109 | ||
1110 | if (conn->cipher) | |
1111 | crypto_free_blkcipher(conn->cipher); | |
1112 | } | |
1113 | ||
1114 | /* | |
1115 | * RxRPC Kerberos-based security | |
1116 | */ | |
1117 | static struct rxrpc_security rxkad = { | |
1118 | .owner = THIS_MODULE, | |
1119 | .name = "rxkad", | |
1120 | .security_index = RXKAD_VERSION, | |
1121 | .init_connection_security = rxkad_init_connection_security, | |
1122 | .prime_packet_security = rxkad_prime_packet_security, | |
1123 | .secure_packet = rxkad_secure_packet, | |
1124 | .verify_packet = rxkad_verify_packet, | |
1125 | .issue_challenge = rxkad_issue_challenge, | |
1126 | .respond_to_challenge = rxkad_respond_to_challenge, | |
1127 | .verify_response = rxkad_verify_response, | |
1128 | .clear = rxkad_clear, | |
1129 | }; | |
1130 | ||
1131 | static __init int rxkad_init(void) | |
1132 | { | |
1133 | _enter(""); | |
1134 | ||
1135 | /* pin the cipher we need so that the crypto layer doesn't invoke | |
1136 | * keventd to go get it */ | |
1137 | rxkad_ci = crypto_alloc_blkcipher("pcbc(fcrypt)", 0, CRYPTO_ALG_ASYNC); | |
1138 | if (IS_ERR(rxkad_ci)) | |
1139 | return PTR_ERR(rxkad_ci); | |
1140 | ||
1141 | return rxrpc_register_security(&rxkad); | |
1142 | } | |
1143 | ||
1144 | module_init(rxkad_init); | |
1145 | ||
1146 | static __exit void rxkad_exit(void) | |
1147 | { | |
1148 | _enter(""); | |
1149 | ||
1150 | rxrpc_unregister_security(&rxkad); | |
1151 | crypto_free_blkcipher(rxkad_ci); | |
1152 | } | |
1153 | ||
1154 | module_exit(rxkad_exit); |