blob: 1948895beb6d137c3fb45058c66a96315dc618a0 [file] [log] [blame]
Herbert Xu38320c72008-01-28 19:35:05 -08001#include <crypto/aead.h>
2#include <crypto/authenc.h>
Herbert Xu6b7326c2006-07-30 15:41:01 +10003#include <linux/err.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07004#include <linux/module.h>
5#include <net/ip.h>
6#include <net/xfrm.h>
7#include <net/esp.h>
Adrian Bunk72998d82007-10-26 22:53:58 -07008#include <linux/scatterlist.h>
Herbert Xua02a6422005-10-10 21:11:08 -07009#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070010#include <linux/pfkeyv2.h>
Herbert Xu38320c72008-01-28 19:35:05 -080011#include <linux/rtnetlink.h>
12#include <linux/slab.h>
Herbert Xub7c65382007-10-09 13:33:35 -070013#include <linux/spinlock.h>
Thomas Graf2017a722007-12-10 16:53:05 -080014#include <linux/in6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <net/icmp.h>
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020016#include <net/protocol.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <net/udp.h>
18
Herbert Xu38320c72008-01-28 19:35:05 -080019struct esp_skb_cb {
20 struct xfrm_skb_cb xfrm;
21 void *tmp;
22};
23
24#define ESP_SKB_CB(__skb) ((struct esp_skb_cb *)&((__skb)->cb[0]))
25
26/*
27 * Allocate an AEAD request structure with extra space for SG and IV.
28 *
29 * For alignment considerations the IV is placed at the front, followed
30 * by the request and finally the SG list.
31 *
32 * TODO: Use spare space in skb for this where possible.
33 */
34static void *esp_alloc_tmp(struct crypto_aead *aead, int nfrags)
35{
36 unsigned int len;
37
38 len = crypto_aead_ivsize(aead);
39 if (len) {
40 len += crypto_aead_alignmask(aead) &
41 ~(crypto_tfm_ctx_alignment() - 1);
42 len = ALIGN(len, crypto_tfm_ctx_alignment());
43 }
44
45 len += sizeof(struct aead_givcrypt_request) + crypto_aead_reqsize(aead);
46 len = ALIGN(len, __alignof__(struct scatterlist));
47
48 len += sizeof(struct scatterlist) * nfrags;
49
50 return kmalloc(len, GFP_ATOMIC);
51}
52
53static inline u8 *esp_tmp_iv(struct crypto_aead *aead, void *tmp)
54{
55 return crypto_aead_ivsize(aead) ?
56 PTR_ALIGN((u8 *)tmp, crypto_aead_alignmask(aead) + 1) : tmp;
57}
58
59static inline struct aead_givcrypt_request *esp_tmp_givreq(
60 struct crypto_aead *aead, u8 *iv)
61{
62 struct aead_givcrypt_request *req;
63
64 req = (void *)PTR_ALIGN(iv + crypto_aead_ivsize(aead),
65 crypto_tfm_ctx_alignment());
66 aead_givcrypt_set_tfm(req, aead);
67 return req;
68}
69
70static inline struct aead_request *esp_tmp_req(struct crypto_aead *aead, u8 *iv)
71{
72 struct aead_request *req;
73
74 req = (void *)PTR_ALIGN(iv + crypto_aead_ivsize(aead),
75 crypto_tfm_ctx_alignment());
76 aead_request_set_tfm(req, aead);
77 return req;
78}
79
80static inline struct scatterlist *esp_req_sg(struct crypto_aead *aead,
81 struct aead_request *req)
82{
83 return (void *)ALIGN((unsigned long)(req + 1) +
84 crypto_aead_reqsize(aead),
85 __alignof__(struct scatterlist));
86}
87
88static inline struct scatterlist *esp_givreq_sg(
89 struct crypto_aead *aead, struct aead_givcrypt_request *req)
90{
91 return (void *)ALIGN((unsigned long)(req + 1) +
92 crypto_aead_reqsize(aead),
93 __alignof__(struct scatterlist));
94}
95
96static void esp_output_done(struct crypto_async_request *base, int err)
97{
98 struct sk_buff *skb = base->data;
99
100 kfree(ESP_SKB_CB(skb)->tmp);
101 xfrm_output_resume(skb, err);
102}
103
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104static int esp_output(struct xfrm_state *x, struct sk_buff *skb)
105{
106 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 struct ip_esp_hdr *esph;
Herbert Xu38320c72008-01-28 19:35:05 -0800108 struct crypto_aead *aead;
109 struct aead_givcrypt_request *req;
110 struct scatterlist *sg;
111 struct scatterlist *asg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 struct esp_data *esp;
113 struct sk_buff *trailer;
Herbert Xu38320c72008-01-28 19:35:05 -0800114 void *tmp;
115 u8 *iv;
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700116 u8 *tail;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 int blksize;
118 int clen;
119 int alen;
120 int nfrags;
121
Herbert Xu7b277b12007-10-10 15:44:06 -0700122 /* skb is pure payload to encrypt */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123
124 err = -ENOMEM;
125
126 /* Round to block size */
127 clen = skb->len;
128
129 esp = x->data;
Herbert Xu38320c72008-01-28 19:35:05 -0800130 aead = esp->aead;
131 alen = crypto_aead_authsize(aead);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132
Herbert Xu38320c72008-01-28 19:35:05 -0800133 blksize = ALIGN(crypto_aead_blocksize(aead), 4);
134 clen = ALIGN(clen + 2, blksize);
135 if (esp->padlen)
136 clen = ALIGN(clen, esp->padlen);
137
138 if ((err = skb_cow_data(skb, clen - skb->len + alen, &trailer)) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 goto error;
Herbert Xu38320c72008-01-28 19:35:05 -0800140 nfrags = err;
141
142 tmp = esp_alloc_tmp(aead, nfrags + 1);
143 if (!tmp)
144 goto error;
145
146 iv = esp_tmp_iv(aead, tmp);
147 req = esp_tmp_givreq(aead, iv);
148 asg = esp_givreq_sg(aead, req);
149 sg = asg + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150
151 /* Fill padding... */
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700152 tail = skb_tail_pointer(trailer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 do {
154 int i;
155 for (i=0; i<clen-skb->len - 2; i++)
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700156 tail[i] = i + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 } while (0);
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700158 tail[clen - skb->len - 2] = (clen - skb->len) - 2;
Herbert Xu38320c72008-01-28 19:35:05 -0800159 tail[clen - skb->len - 1] = *skb_mac_header(skb);
160 pskb_put(skb, trailer, clen - skb->len + alen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161
Herbert Xu7b277b12007-10-10 15:44:06 -0700162 skb_push(skb, -skb_network_offset(skb));
Herbert Xu87bdc482007-10-10 15:45:25 -0700163 esph = ip_esp_hdr(skb);
Herbert Xu37fedd32007-10-10 15:44:44 -0700164 *skb_mac_header(skb) = IPPROTO_ESP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165
166 /* this is non-NULL only with UDP Encapsulation */
167 if (x->encap) {
168 struct xfrm_encap_tmpl *encap = x->encap;
169 struct udphdr *uh;
Al Virod5a0a1e2006-11-08 00:23:14 -0800170 __be32 *udpdata32;
Al Viro5e226e42008-03-17 22:50:23 -0700171 __be16 sport, dport;
Herbert Xu38320c72008-01-28 19:35:05 -0800172 int encap_type;
173
174 spin_lock_bh(&x->lock);
175 sport = encap->encap_sport;
176 dport = encap->encap_dport;
177 encap_type = encap->encap_type;
178 spin_unlock_bh(&x->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179
180 uh = (struct udphdr *)esph;
Herbert Xu38320c72008-01-28 19:35:05 -0800181 uh->source = sport;
182 uh->dest = dport;
183 uh->len = htons(skb->len - skb_transport_offset(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 uh->check = 0;
185
Herbert Xu38320c72008-01-28 19:35:05 -0800186 switch (encap_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 default:
188 case UDP_ENCAP_ESPINUDP:
189 esph = (struct ip_esp_hdr *)(uh + 1);
190 break;
191 case UDP_ENCAP_ESPINUDP_NON_IKE:
Al Virod5a0a1e2006-11-08 00:23:14 -0800192 udpdata32 = (__be32 *)(uh + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 udpdata32[0] = udpdata32[1] = 0;
194 esph = (struct ip_esp_hdr *)(udpdata32 + 2);
195 break;
196 }
197
Herbert Xu37fedd32007-10-10 15:44:44 -0700198 *skb_mac_header(skb) = IPPROTO_UDP;
199 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200
201 esph->spi = x->id.spi;
Herbert Xub318e0e2008-02-12 22:50:35 -0800202 esph->seq_no = htonl(XFRM_SKB_CB(skb)->seq.output);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203
Herbert Xu38320c72008-01-28 19:35:05 -0800204 sg_init_table(sg, nfrags);
205 skb_to_sgvec(skb, sg,
206 esph->enc_data + crypto_aead_ivsize(aead) - skb->data,
207 clen + alen);
208 sg_init_one(asg, esph, sizeof(*esph));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209
Herbert Xu38320c72008-01-28 19:35:05 -0800210 aead_givcrypt_set_callback(req, 0, esp_output_done, skb);
211 aead_givcrypt_set_crypt(req, sg, sg, clen, iv);
212 aead_givcrypt_set_assoc(req, asg, sizeof(*esph));
Herbert Xub318e0e2008-02-12 22:50:35 -0800213 aead_givcrypt_set_giv(req, esph->enc_data,
214 XFRM_SKB_CB(skb)->seq.output);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215
Herbert Xu38320c72008-01-28 19:35:05 -0800216 ESP_SKB_CB(skb)->tmp = tmp;
217 err = crypto_aead_givencrypt(req);
218 if (err == -EINPROGRESS)
219 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220
Herbert Xu38320c72008-01-28 19:35:05 -0800221 if (err == -EBUSY)
222 err = NET_XMIT_DROP;
Herbert Xu6b7326c2006-07-30 15:41:01 +1000223
Herbert Xu38320c72008-01-28 19:35:05 -0800224 kfree(tmp);
Herbert Xub7c65382007-10-09 13:33:35 -0700225
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226error:
227 return err;
228}
229
Herbert Xu38320c72008-01-28 19:35:05 -0800230static int esp_input_done2(struct sk_buff *skb, int err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231{
232 struct iphdr *iph;
Herbert Xu38320c72008-01-28 19:35:05 -0800233 struct xfrm_state *x = xfrm_input_state(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 struct esp_data *esp = x->data;
Herbert Xu38320c72008-01-28 19:35:05 -0800235 struct crypto_aead *aead = esp->aead;
236 int alen = crypto_aead_authsize(aead);
237 int hlen = sizeof(struct ip_esp_hdr) + crypto_aead_ivsize(aead);
238 int elen = skb->len - hlen;
Herbert Xu31a4ab92006-05-27 23:06:13 -0700239 int ihl;
Herbert Xu4bf05ec2006-02-27 13:00:01 -0800240 u8 nexthdr[2];
Herbert Xu4bf05ec2006-02-27 13:00:01 -0800241 int padlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242
Herbert Xu38320c72008-01-28 19:35:05 -0800243 kfree(ESP_SKB_CB(skb)->tmp);
Herbert Xu0ebea8e2007-11-13 21:45:58 -0800244
Herbert Xu6b7326c2006-07-30 15:41:01 +1000245 if (unlikely(err))
Herbert Xu668dc8a2007-12-16 15:55:02 -0800246 goto out;
Herbert Xu4bf05ec2006-02-27 13:00:01 -0800247
248 if (skb_copy_bits(skb, skb->len-alen-2, nexthdr, 2))
249 BUG();
250
Herbert Xu668dc8a2007-12-16 15:55:02 -0800251 err = -EINVAL;
Herbert Xu4bf05ec2006-02-27 13:00:01 -0800252 padlen = nexthdr[0];
Herbert Xu38320c72008-01-28 19:35:05 -0800253 if (padlen + 2 + alen >= elen)
Herbert Xu4bf05ec2006-02-27 13:00:01 -0800254 goto out;
255
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900256 /* ... check padding bits here. Silly. :-) */
Herbert Xu4bf05ec2006-02-27 13:00:01 -0800257
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700258 iph = ip_hdr(skb);
Herbert Xu31a4ab92006-05-27 23:06:13 -0700259 ihl = iph->ihl * 4;
260
Herbert Xu752c1f42006-02-27 13:00:40 -0800261 if (x->encap) {
262 struct xfrm_encap_tmpl *encap = x->encap;
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700263 struct udphdr *uh = (void *)(skb_network_header(skb) + ihl);
Herbert Xu752c1f42006-02-27 13:00:40 -0800264
265 /*
266 * 1) if the NAT-T peer's IP or port changed then
267 * advertize the change to the keying daemon.
268 * This is an inbound SA, so just compare
269 * SRC ports.
270 */
271 if (iph->saddr != x->props.saddr.a4 ||
272 uh->source != encap->encap_sport) {
273 xfrm_address_t ipaddr;
274
275 ipaddr.a4 = iph->saddr;
276 km_new_mapping(x, &ipaddr, uh->source);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900277
Herbert Xu752c1f42006-02-27 13:00:40 -0800278 /* XXX: perhaps add an extra
279 * policy check here, to see
280 * if we should allow or
281 * reject a packet from a
282 * different source
283 * address/port.
284 */
Herbert Xu4bf05ec2006-02-27 13:00:01 -0800285 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900286
Herbert Xu752c1f42006-02-27 13:00:40 -0800287 /*
288 * 2) ignore UDP/TCP checksums in case
289 * of NAT-T in Transport Mode, or
290 * perform other post-processing fixes
291 * as per draft-ietf-ipsec-udp-encaps-06,
292 * section 3.1.2
293 */
Herbert Xu8bd17072007-10-10 15:41:41 -0700294 if (x->props.mode == XFRM_MODE_TRANSPORT)
Herbert Xu752c1f42006-02-27 13:00:40 -0800295 skb->ip_summed = CHECKSUM_UNNECESSARY;
Herbert Xu4bf05ec2006-02-27 13:00:01 -0800296 }
297
Herbert Xu4bf05ec2006-02-27 13:00:01 -0800298 pskb_trim(skb, skb->len - alen - padlen - 2);
Herbert Xu38320c72008-01-28 19:35:05 -0800299 __skb_pull(skb, hlen);
Arnaldo Carvalho de Melo967b05f2007-03-13 13:51:52 -0300300 skb_set_transport_header(skb, -ihl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
Herbert Xu38320c72008-01-28 19:35:05 -0800302 err = nexthdr[1];
303
304 /* RFC4303: Drop dummy packets without any error */
305 if (err == IPPROTO_NONE)
306 err = -EINVAL;
307
308out:
309 return err;
310}
311
312static void esp_input_done(struct crypto_async_request *base, int err)
313{
314 struct sk_buff *skb = base->data;
315
316 xfrm_input_resume(skb, esp_input_done2(skb, err));
317}
318
319/*
320 * Note: detecting truncated vs. non-truncated authentication data is very
321 * expensive, so we only support truncated data, which is the recommended
322 * and common case.
323 */
324static int esp_input(struct xfrm_state *x, struct sk_buff *skb)
325{
326 struct ip_esp_hdr *esph;
327 struct esp_data *esp = x->data;
328 struct crypto_aead *aead = esp->aead;
329 struct aead_request *req;
330 struct sk_buff *trailer;
331 int elen = skb->len - sizeof(*esph) - crypto_aead_ivsize(aead);
332 int nfrags;
333 void *tmp;
334 u8 *iv;
335 struct scatterlist *sg;
336 struct scatterlist *asg;
337 int err = -EINVAL;
338
Thomas Graf920fc942008-03-27 16:08:03 -0700339 if (!pskb_may_pull(skb, sizeof(*esph) + crypto_aead_ivsize(aead)))
Herbert Xu38320c72008-01-28 19:35:05 -0800340 goto out;
341
342 if (elen <= 0)
343 goto out;
344
345 if ((err = skb_cow_data(skb, 0, &trailer)) < 0)
346 goto out;
347 nfrags = err;
348
349 err = -ENOMEM;
350 tmp = esp_alloc_tmp(aead, nfrags + 1);
351 if (!tmp)
352 goto out;
353
354 ESP_SKB_CB(skb)->tmp = tmp;
355 iv = esp_tmp_iv(aead, tmp);
356 req = esp_tmp_req(aead, iv);
357 asg = esp_req_sg(aead, req);
358 sg = asg + 1;
359
360 skb->ip_summed = CHECKSUM_NONE;
361
362 esph = (struct ip_esp_hdr *)skb->data;
363
364 /* Get ivec. This can be wrong, check against another impls. */
365 iv = esph->enc_data;
366
367 sg_init_table(sg, nfrags);
368 skb_to_sgvec(skb, sg, sizeof(*esph) + crypto_aead_ivsize(aead), elen);
369 sg_init_one(asg, esph, sizeof(*esph));
370
371 aead_request_set_callback(req, 0, esp_input_done, skb);
372 aead_request_set_crypt(req, sg, sg, elen, iv);
373 aead_request_set_assoc(req, asg, sizeof(*esph));
374
375 err = crypto_aead_decrypt(req);
376 if (err == -EINPROGRESS)
377 goto out;
378
379 err = esp_input_done2(skb, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380
381out:
Herbert Xu668dc8a2007-12-16 15:55:02 -0800382 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383}
384
Patrick McHardyc5c25232007-04-09 11:47:18 -0700385static u32 esp4_get_mtu(struct xfrm_state *x, int mtu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386{
387 struct esp_data *esp = x->data;
Herbert Xu38320c72008-01-28 19:35:05 -0800388 u32 blksize = ALIGN(crypto_aead_blocksize(esp->aead), 4);
389 u32 align = max_t(u32, blksize, esp->padlen);
Patrick McHardyc5c25232007-04-09 11:47:18 -0700390 u32 rem;
391
Herbert Xu38320c72008-01-28 19:35:05 -0800392 mtu -= x->props.header_len + crypto_aead_authsize(esp->aead);
Patrick McHardyc5c25232007-04-09 11:47:18 -0700393 rem = mtu & (align - 1);
394 mtu &= ~(align - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395
Diego Beltrami0a694522006-10-03 23:47:05 -0700396 switch (x->props.mode) {
397 case XFRM_MODE_TUNNEL:
Diego Beltrami0a694522006-10-03 23:47:05 -0700398 break;
399 default:
400 case XFRM_MODE_TRANSPORT:
401 /* The worst case */
Patrick McHardyc5c25232007-04-09 11:47:18 -0700402 mtu -= blksize - 4;
403 mtu += min_t(u32, blksize - 4, rem);
Diego Beltrami0a694522006-10-03 23:47:05 -0700404 break;
405 case XFRM_MODE_BEET:
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900406 /* The worst case. */
Patrick McHardyc5c25232007-04-09 11:47:18 -0700407 mtu += min_t(u32, IPV4_BEET_PHMAXLEN, rem);
Diego Beltrami0a694522006-10-03 23:47:05 -0700408 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 }
Diego Beltrami0a694522006-10-03 23:47:05 -0700410
Patrick McHardyc5c25232007-04-09 11:47:18 -0700411 return mtu - 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412}
413
414static void esp4_err(struct sk_buff *skb, u32 info)
415{
Alexey Dobriyan4fb236b2008-11-25 17:59:27 -0800416 struct net *net = dev_net(skb->dev);
Jianjun Kongd93191002008-11-03 00:23:42 -0800417 struct iphdr *iph = (struct iphdr *)skb->data;
418 struct ip_esp_hdr *esph = (struct ip_esp_hdr *)(skb->data+(iph->ihl<<2));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 struct xfrm_state *x;
420
Arnaldo Carvalho de Melo88c76642007-03-13 14:43:18 -0300421 if (icmp_hdr(skb)->type != ICMP_DEST_UNREACH ||
422 icmp_hdr(skb)->code != ICMP_FRAG_NEEDED)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 return;
424
Alexey Dobriyan4fb236b2008-11-25 17:59:27 -0800425 x = xfrm_state_lookup(net, (xfrm_address_t *)&iph->daddr, esph->spi, IPPROTO_ESP, AF_INET);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 if (!x)
427 return;
Patrick McHardy64ce2072005-08-09 20:50:53 -0700428 NETDEBUG(KERN_DEBUG "pmtu discovery on SA ESP/%08x/%08x\n",
429 ntohl(esph->spi), ntohl(iph->daddr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 xfrm_state_put(x);
431}
432
433static void esp_destroy(struct xfrm_state *x)
434{
435 struct esp_data *esp = x->data;
436
437 if (!esp)
438 return;
439
Herbert Xu38320c72008-01-28 19:35:05 -0800440 crypto_free_aead(esp->aead);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 kfree(esp);
442}
443
Herbert Xu1a6509d2008-01-28 19:37:29 -0800444static int esp_init_aead(struct xfrm_state *x)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445{
Herbert Xu1a6509d2008-01-28 19:37:29 -0800446 struct esp_data *esp = x->data;
447 struct crypto_aead *aead;
448 int err;
449
450 aead = crypto_alloc_aead(x->aead->alg_name, 0, 0);
451 err = PTR_ERR(aead);
452 if (IS_ERR(aead))
453 goto error;
454
455 esp->aead = aead;
456
457 err = crypto_aead_setkey(aead, x->aead->alg_key,
458 (x->aead->alg_key_len + 7) / 8);
459 if (err)
460 goto error;
461
462 err = crypto_aead_setauthsize(aead, x->aead->alg_icv_len / 8);
463 if (err)
464 goto error;
465
466error:
467 return err;
468}
469
470static int esp_init_authenc(struct xfrm_state *x)
471{
472 struct esp_data *esp = x->data;
Herbert Xu38320c72008-01-28 19:35:05 -0800473 struct crypto_aead *aead;
474 struct crypto_authenc_key_param *param;
475 struct rtattr *rta;
476 char *key;
477 char *p;
478 char authenc_name[CRYPTO_MAX_ALG_NAME];
Herbert Xu38320c72008-01-28 19:35:05 -0800479 unsigned int keylen;
480 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481
Herbert Xu1a6509d2008-01-28 19:37:29 -0800482 err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 if (x->ealg == NULL)
Herbert Xu1a6509d2008-01-28 19:37:29 -0800484 goto error;
Herbert Xu38320c72008-01-28 19:35:05 -0800485
Herbert Xu1a6509d2008-01-28 19:37:29 -0800486 err = -ENAMETOOLONG;
Herbert Xu38320c72008-01-28 19:35:05 -0800487 if (snprintf(authenc_name, CRYPTO_MAX_ALG_NAME, "authenc(%s,%s)",
488 x->aalg ? x->aalg->alg_name : "digest_null",
489 x->ealg->alg_name) >= CRYPTO_MAX_ALG_NAME)
Herbert Xu1a6509d2008-01-28 19:37:29 -0800490 goto error;
Herbert Xu38320c72008-01-28 19:35:05 -0800491
492 aead = crypto_alloc_aead(authenc_name, 0, 0);
493 err = PTR_ERR(aead);
494 if (IS_ERR(aead))
495 goto error;
496
497 esp->aead = aead;
498
499 keylen = (x->aalg ? (x->aalg->alg_key_len + 7) / 8 : 0) +
500 (x->ealg->alg_key_len + 7) / 8 + RTA_SPACE(sizeof(*param));
501 err = -ENOMEM;
502 key = kmalloc(keylen, GFP_KERNEL);
503 if (!key)
504 goto error;
505
506 p = key;
507 rta = (void *)p;
508 rta->rta_type = CRYPTO_AUTHENC_KEYA_PARAM;
509 rta->rta_len = RTA_LENGTH(sizeof(*param));
510 param = RTA_DATA(rta);
511 p += RTA_SPACE(sizeof(*param));
512
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 if (x->aalg) {
514 struct xfrm_algo_desc *aalg_desc;
515
Herbert Xu38320c72008-01-28 19:35:05 -0800516 memcpy(p, x->aalg->alg_key, (x->aalg->alg_key_len + 7) / 8);
517 p += (x->aalg->alg_key_len + 7) / 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518
519 aalg_desc = xfrm_aalg_get_byname(x->aalg->alg_name, 0);
520 BUG_ON(!aalg_desc);
521
Herbert Xu38320c72008-01-28 19:35:05 -0800522 err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 if (aalg_desc->uinfo.auth.icv_fullbits/8 !=
Herbert Xu38320c72008-01-28 19:35:05 -0800524 crypto_aead_authsize(aead)) {
Patrick McHardy64ce2072005-08-09 20:50:53 -0700525 NETDEBUG(KERN_INFO "ESP: %s digestsize %u != %hu\n",
526 x->aalg->alg_name,
Herbert Xu38320c72008-01-28 19:35:05 -0800527 crypto_aead_authsize(aead),
Patrick McHardy64ce2072005-08-09 20:50:53 -0700528 aalg_desc->uinfo.auth.icv_fullbits/8);
Herbert Xu38320c72008-01-28 19:35:05 -0800529 goto free_key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 }
531
Herbert Xu38320c72008-01-28 19:35:05 -0800532 err = crypto_aead_setauthsize(
Martin Willi8f8a0882009-11-25 00:29:53 +0000533 aead, x->aalg->alg_trunc_len / 8);
Herbert Xu38320c72008-01-28 19:35:05 -0800534 if (err)
535 goto free_key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 }
Herbert Xu4b7137f2007-10-08 17:13:44 -0700537
Herbert Xu38320c72008-01-28 19:35:05 -0800538 param->enckeylen = cpu_to_be32((x->ealg->alg_key_len + 7) / 8);
539 memcpy(p, x->ealg->alg_key, (x->ealg->alg_key_len + 7) / 8);
540
541 err = crypto_aead_setkey(aead, key, keylen);
542
543free_key:
544 kfree(key);
545
Herbert Xu1a6509d2008-01-28 19:37:29 -0800546error:
547 return err;
548}
549
550static int esp_init_state(struct xfrm_state *x)
551{
552 struct esp_data *esp;
553 struct crypto_aead *aead;
554 u32 align;
555 int err;
556
557 esp = kzalloc(sizeof(*esp), GFP_KERNEL);
558 if (esp == NULL)
559 return -ENOMEM;
560
561 x->data = esp;
562
563 if (x->aead)
564 err = esp_init_aead(x);
565 else
566 err = esp_init_authenc(x);
567
Herbert Xu38320c72008-01-28 19:35:05 -0800568 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 goto error;
Herbert Xu38320c72008-01-28 19:35:05 -0800570
Herbert Xu1a6509d2008-01-28 19:37:29 -0800571 aead = esp->aead;
572
573 esp->padlen = 0;
574
Herbert Xu38320c72008-01-28 19:35:05 -0800575 x->props.header_len = sizeof(struct ip_esp_hdr) +
576 crypto_aead_ivsize(aead);
Masahide NAKAMURA7e49e6d2006-09-22 15:05:15 -0700577 if (x->props.mode == XFRM_MODE_TUNNEL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 x->props.header_len += sizeof(struct iphdr);
Joakim Koskelaeb49e632008-08-06 02:39:30 -0700579 else if (x->props.mode == XFRM_MODE_BEET && x->sel.family != AF_INET6)
Patrick McHardyac758e32007-04-09 11:47:58 -0700580 x->props.header_len += IPV4_BEET_PHMAXLEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 if (x->encap) {
582 struct xfrm_encap_tmpl *encap = x->encap;
583
584 switch (encap->encap_type) {
585 default:
586 goto error;
587 case UDP_ENCAP_ESPINUDP:
588 x->props.header_len += sizeof(struct udphdr);
589 break;
590 case UDP_ENCAP_ESPINUDP_NON_IKE:
591 x->props.header_len += sizeof(struct udphdr) + 2 * sizeof(u32);
592 break;
593 }
594 }
Herbert Xu38320c72008-01-28 19:35:05 -0800595
596 align = ALIGN(crypto_aead_blocksize(aead), 4);
597 if (esp->padlen)
598 align = max_t(u32, align, esp->padlen);
599 x->props.trailer_len = align + 1 + crypto_aead_authsize(esp->aead);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600
601error:
Herbert Xu38320c72008-01-28 19:35:05 -0800602 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603}
604
Eric Dumazet533cb5b2008-01-30 19:11:50 -0800605static const struct xfrm_type esp_type =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606{
607 .description = "ESP4",
608 .owner = THIS_MODULE,
609 .proto = IPPROTO_ESP,
Herbert Xu436a0a42007-10-08 17:25:53 -0700610 .flags = XFRM_TYPE_REPLAY_PROT,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 .init_state = esp_init_state,
612 .destructor = esp_destroy,
Patrick McHardyc5c25232007-04-09 11:47:18 -0700613 .get_mtu = esp4_get_mtu,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 .input = esp_input,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 .output = esp_output
616};
617
Alexey Dobriyan32613092009-09-14 12:21:47 +0000618static const struct net_protocol esp4_protocol = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 .handler = xfrm4_rcv,
620 .err_handler = esp4_err,
621 .no_policy = 1,
Alexey Dobriyan4fb236b2008-11-25 17:59:27 -0800622 .netns_ok = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623};
624
625static int __init esp4_init(void)
626{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 if (xfrm_register_type(&esp_type, AF_INET) < 0) {
628 printk(KERN_INFO "ip esp init: can't add xfrm type\n");
629 return -EAGAIN;
630 }
631 if (inet_add_protocol(&esp4_protocol, IPPROTO_ESP) < 0) {
632 printk(KERN_INFO "ip esp init: can't add protocol\n");
633 xfrm_unregister_type(&esp_type, AF_INET);
634 return -EAGAIN;
635 }
636 return 0;
637}
638
639static void __exit esp4_fini(void)
640{
641 if (inet_del_protocol(&esp4_protocol, IPPROTO_ESP) < 0)
642 printk(KERN_INFO "ip esp close: can't remove protocol\n");
643 if (xfrm_unregister_type(&esp_type, AF_INET) < 0)
644 printk(KERN_INFO "ip esp close: can't remove xfrm type\n");
645}
646
647module_init(esp4_init);
648module_exit(esp4_fini);
649MODULE_LICENSE("GPL");
Masahide NAKAMURAd3d6dd32007-06-26 23:57:49 -0700650MODULE_ALIAS_XFRM_TYPE(AF_INET, XFRM_PROTO_ESP);