[CRYPTO] users: Fix up scatterlist conversion errors
[linux-2.6.git] / net / rxrpc / rxkad.c
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>
21 #define rxrpc_debug rxkad_debug
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
138         sg_init_one(&sg[0], &tmpbuf, sizeof(tmpbuf));
139         sg_init_one(&sg[1], &tmpbuf, sizeof(tmpbuf));
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
182         sg_init_one(&sg[0], &tmpbuf, sizeof(tmpbuf));
183         sg_init_one(&sg[1], &tmpbuf, sizeof(tmpbuf));
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
228         sg_init_one(&sg[0], sechdr, sizeof(rxkhdr));
229         sg_init_one(&sg[1], &rxkhdr, sizeof(rxkhdr));
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
240         sg_init_table(sg, skb_to_sgvec(skb, sg, 0, len));
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
290         sg_init_one(&sg[0], &tmpbuf, sizeof(tmpbuf));
291         sg_init_one(&sg[1], &tmpbuf, sizeof(tmpbuf));
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;
331         struct scatterlist sg[16];
332         struct sk_buff *trailer;
333         u32 data_size, buf;
334         u16 check;
335         int nsg;
336
337         _enter("");
338
339         sp = rxrpc_skb(skb);
340
341         /* we want to decrypt the skbuff in-place */
342         nsg = skb_cow_data(skb, 0, &trailer);
343         if (nsg < 0 || nsg > 16)
344                 goto nomem;
345
346         sg_init_table(sg, nsg);
347         sg_mark_end(sg, skb_to_sgvec(skb, sg, 0, 8));
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
428         sg_init_table(sg, nsg);
429         sg_mark_end(sg, skb_to_sgvec(skb, sg, 0, skb->len));
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
524         sg_init_one(&sg[0], &tmpbuf, sizeof(tmpbuf));
525         sg_init_one(&sg[1], &tmpbuf, sizeof(tmpbuf));
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 {
692         int nsg = 1;
693
694         sg_init_table(sg, 2);
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);
701                 nsg++;
702         }
703
704         sg_mark_end(sg, nsg);
705
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;
718         struct scatterlist sg[2];
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
726         rxkad_sg_set_buf2(sg, &resp->encrypted, sizeof(resp->encrypted));
727         crypto_blkcipher_encrypt_iv(&desc, sg, sg, sizeof(resp->encrypted));
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;
822         struct scatterlist sg[1];
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
855         sg_init_one(&sg[0], ticket, ticket_len);
856         crypto_blkcipher_decrypt_iv(&desc, sg, sg, ticket_len);
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;
920         now = get_seconds();
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;
965         struct scatterlist sg[2];
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
983         rxkad_sg_set_buf2(sg, &resp->encrypted, sizeof(resp->encrypted));
984         crypto_blkcipher_decrypt_iv(&desc, sg, sg, sizeof(resp->encrypted));
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);