Joe Perches | afd46503 | 2012-03-12 07:03:32 +0000 | [diff] [blame] | 1 | #define pr_fmt(fmt) "IPsec: " fmt |
| 2 | |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 3 | #include <crypto/hash.h> |
Herbert Xu | 07d4ee5 | 2006-08-20 14:24:50 +1000 | [diff] [blame] | 4 | #include <linux/err.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 5 | #include <linux/module.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 6 | #include <linux/slab.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 7 | #include <net/ip.h> |
| 8 | #include <net/xfrm.h> |
| 9 | #include <net/ah.h> |
| 10 | #include <linux/crypto.h> |
| 11 | #include <linux/pfkeyv2.h> |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 12 | #include <linux/scatterlist.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | #include <net/icmp.h> |
Arnaldo Carvalho de Melo | 14c8502 | 2005-12-27 02:43:12 -0200 | [diff] [blame] | 14 | #include <net/protocol.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 16 | struct ah_skb_cb { |
| 17 | struct xfrm_skb_cb xfrm; |
| 18 | void *tmp; |
| 19 | }; |
| 20 | |
| 21 | #define AH_SKB_CB(__skb) ((struct ah_skb_cb *)&((__skb)->cb[0])) |
| 22 | |
| 23 | static void *ah_alloc_tmp(struct crypto_ahash *ahash, int nfrags, |
| 24 | unsigned int size) |
| 25 | { |
| 26 | unsigned int len; |
| 27 | |
| 28 | len = size + crypto_ahash_digestsize(ahash) + |
| 29 | (crypto_ahash_alignmask(ahash) & |
| 30 | ~(crypto_tfm_ctx_alignment() - 1)); |
| 31 | |
| 32 | len = ALIGN(len, crypto_tfm_ctx_alignment()); |
| 33 | |
| 34 | len += sizeof(struct ahash_request) + crypto_ahash_reqsize(ahash); |
| 35 | len = ALIGN(len, __alignof__(struct scatterlist)); |
| 36 | |
| 37 | len += sizeof(struct scatterlist) * nfrags; |
| 38 | |
| 39 | return kmalloc(len, GFP_ATOMIC); |
| 40 | } |
| 41 | |
| 42 | static inline u8 *ah_tmp_auth(void *tmp, unsigned int offset) |
| 43 | { |
| 44 | return tmp + offset; |
| 45 | } |
| 46 | |
| 47 | static inline u8 *ah_tmp_icv(struct crypto_ahash *ahash, void *tmp, |
| 48 | unsigned int offset) |
| 49 | { |
| 50 | return PTR_ALIGN((u8 *)tmp + offset, crypto_ahash_alignmask(ahash) + 1); |
| 51 | } |
| 52 | |
| 53 | static inline struct ahash_request *ah_tmp_req(struct crypto_ahash *ahash, |
| 54 | u8 *icv) |
| 55 | { |
| 56 | struct ahash_request *req; |
| 57 | |
| 58 | req = (void *)PTR_ALIGN(icv + crypto_ahash_digestsize(ahash), |
| 59 | crypto_tfm_ctx_alignment()); |
| 60 | |
| 61 | ahash_request_set_tfm(req, ahash); |
| 62 | |
| 63 | return req; |
| 64 | } |
| 65 | |
| 66 | static inline struct scatterlist *ah_req_sg(struct crypto_ahash *ahash, |
| 67 | struct ahash_request *req) |
| 68 | { |
| 69 | return (void *)ALIGN((unsigned long)(req + 1) + |
| 70 | crypto_ahash_reqsize(ahash), |
| 71 | __alignof__(struct scatterlist)); |
| 72 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 73 | |
| 74 | /* Clear mutable options and find final destination to substitute |
| 75 | * into IP header for icv calculation. Options are already checked |
| 76 | * for validity, so paranoia is not required. */ |
| 77 | |
Eric Dumazet | b71d1d4 | 2011-04-22 04:53:02 +0000 | [diff] [blame] | 78 | static int ip_clear_mutable_options(const struct iphdr *iph, __be32 *daddr) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 79 | { |
Daniel Baluta | 5e73ea1 | 2012-04-15 01:34:41 +0000 | [diff] [blame] | 80 | unsigned char *optptr = (unsigned char *)(iph+1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 81 | int l = iph->ihl*4 - sizeof(struct iphdr); |
| 82 | int optlen; |
| 83 | |
| 84 | while (l > 0) { |
| 85 | switch (*optptr) { |
| 86 | case IPOPT_END: |
| 87 | return 0; |
| 88 | case IPOPT_NOOP: |
| 89 | l--; |
| 90 | optptr++; |
| 91 | continue; |
| 92 | } |
| 93 | optlen = optptr[1]; |
| 94 | if (optlen<2 || optlen>l) |
| 95 | return -EINVAL; |
| 96 | switch (*optptr) { |
| 97 | case IPOPT_SEC: |
| 98 | case 0x85: /* Some "Extended Security" crap. */ |
Paul Moore | 11a03f7 | 2006-08-03 16:46:20 -0700 | [diff] [blame] | 99 | case IPOPT_CIPSO: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 100 | case IPOPT_RA: |
| 101 | case 0x80|21: /* RFC1770 */ |
| 102 | break; |
| 103 | case IPOPT_LSRR: |
| 104 | case IPOPT_SSRR: |
| 105 | if (optlen < 6) |
| 106 | return -EINVAL; |
| 107 | memcpy(daddr, optptr+optlen-4, 4); |
| 108 | /* Fall through */ |
| 109 | default: |
Nick Bowler | 96fe1c0 | 2007-08-22 12:33:51 -0700 | [diff] [blame] | 110 | memset(optptr, 0, optlen); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 111 | } |
| 112 | l -= optlen; |
| 113 | optptr += optlen; |
| 114 | } |
| 115 | return 0; |
| 116 | } |
| 117 | |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 118 | static void ah_output_done(struct crypto_async_request *base, int err) |
| 119 | { |
| 120 | u8 *icv; |
| 121 | struct iphdr *iph; |
| 122 | struct sk_buff *skb = base->data; |
| 123 | struct xfrm_state *x = skb_dst(skb)->xfrm; |
| 124 | struct ah_data *ahp = x->data; |
| 125 | struct iphdr *top_iph = ip_hdr(skb); |
| 126 | struct ip_auth_hdr *ah = ip_auth_hdr(skb); |
| 127 | int ihl = ip_hdrlen(skb); |
| 128 | |
| 129 | iph = AH_SKB_CB(skb)->tmp; |
| 130 | icv = ah_tmp_icv(ahp->ahash, iph, ihl); |
| 131 | memcpy(ah->auth_data, icv, ahp->icv_trunc_len); |
| 132 | |
| 133 | top_iph->tos = iph->tos; |
| 134 | top_iph->ttl = iph->ttl; |
| 135 | top_iph->frag_off = iph->frag_off; |
| 136 | if (top_iph->ihl != 5) { |
| 137 | top_iph->daddr = iph->daddr; |
| 138 | memcpy(top_iph+1, iph+1, top_iph->ihl*4 - sizeof(struct iphdr)); |
| 139 | } |
| 140 | |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 141 | kfree(AH_SKB_CB(skb)->tmp); |
| 142 | xfrm_output_resume(skb, err); |
| 143 | } |
| 144 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 145 | static int ah_output(struct xfrm_state *x, struct sk_buff *skb) |
| 146 | { |
| 147 | int err; |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 148 | int nfrags; |
| 149 | int ihl; |
| 150 | u8 *icv; |
| 151 | struct sk_buff *trailer; |
| 152 | struct crypto_ahash *ahash; |
| 153 | struct ahash_request *req; |
| 154 | struct scatterlist *sg; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 155 | struct iphdr *iph, *top_iph; |
| 156 | struct ip_auth_hdr *ah; |
| 157 | struct ah_data *ahp; |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 158 | |
| 159 | ahp = x->data; |
| 160 | ahash = ahp->ahash; |
| 161 | |
| 162 | if ((err = skb_cow_data(skb, 0, &trailer)) < 0) |
| 163 | goto out; |
| 164 | nfrags = err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 165 | |
Herbert Xu | 7b277b1 | 2007-10-10 15:44:06 -0700 | [diff] [blame] | 166 | skb_push(skb, -skb_network_offset(skb)); |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 167 | ah = ip_auth_hdr(skb); |
| 168 | ihl = ip_hdrlen(skb); |
| 169 | |
| 170 | err = -ENOMEM; |
| 171 | iph = ah_alloc_tmp(ahash, nfrags, ihl); |
| 172 | if (!iph) |
| 173 | goto out; |
| 174 | |
| 175 | icv = ah_tmp_icv(ahash, iph, ihl); |
| 176 | req = ah_tmp_req(ahash, icv); |
| 177 | sg = ah_req_sg(ahash, req); |
| 178 | |
| 179 | memset(ah->auth_data, 0, ahp->icv_trunc_len); |
| 180 | |
Arnaldo Carvalho de Melo | eddc9ec | 2007-04-20 22:47:35 -0700 | [diff] [blame] | 181 | top_iph = ip_hdr(skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 182 | |
| 183 | iph->tos = top_iph->tos; |
| 184 | iph->ttl = top_iph->ttl; |
| 185 | iph->frag_off = top_iph->frag_off; |
| 186 | |
| 187 | if (top_iph->ihl != 5) { |
| 188 | iph->daddr = top_iph->daddr; |
| 189 | memcpy(iph+1, top_iph+1, top_iph->ihl*4 - sizeof(struct iphdr)); |
| 190 | err = ip_clear_mutable_options(top_iph, &top_iph->daddr); |
| 191 | if (err) |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 192 | goto out_free; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 193 | } |
| 194 | |
Herbert Xu | 37fedd3 | 2007-10-10 15:44:44 -0700 | [diff] [blame] | 195 | ah->nexthdr = *skb_mac_header(skb); |
| 196 | *skb_mac_header(skb) = IPPROTO_AH; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 197 | |
| 198 | top_iph->tos = 0; |
| 199 | top_iph->tot_len = htons(skb->len); |
| 200 | top_iph->frag_off = 0; |
| 201 | top_iph->ttl = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 202 | top_iph->check = 0; |
| 203 | |
Nicolas Dichtel | fa9921e | 2011-02-02 06:29:02 +0000 | [diff] [blame] | 204 | if (x->props.flags & XFRM_STATE_ALIGN4) |
| 205 | ah->hdrlen = (XFRM_ALIGN4(sizeof(*ah) + ahp->icv_trunc_len) >> 2) - 2; |
| 206 | else |
| 207 | ah->hdrlen = (XFRM_ALIGN8(sizeof(*ah) + ahp->icv_trunc_len) >> 2) - 2; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 208 | |
| 209 | ah->reserved = 0; |
| 210 | ah->spi = x->id.spi; |
Steffen Klassert | 1ce3644 | 2011-03-08 00:06:31 +0000 | [diff] [blame] | 211 | ah->seq_no = htonl(XFRM_SKB_CB(skb)->seq.output.low); |
Herbert Xu | b7c6538c | 2007-10-09 13:33:35 -0700 | [diff] [blame] | 212 | |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 213 | sg_init_table(sg, nfrags); |
| 214 | skb_to_sgvec(skb, sg, 0, skb->len); |
Herbert Xu | b7c6538c | 2007-10-09 13:33:35 -0700 | [diff] [blame] | 215 | |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 216 | ahash_request_set_crypt(req, sg, icv, skb->len); |
| 217 | ahash_request_set_callback(req, 0, ah_output_done, skb); |
| 218 | |
| 219 | AH_SKB_CB(skb)->tmp = iph; |
| 220 | |
| 221 | err = crypto_ahash_digest(req); |
| 222 | if (err) { |
| 223 | if (err == -EINPROGRESS) |
| 224 | goto out; |
| 225 | |
| 226 | if (err == -EBUSY) |
| 227 | err = NET_XMIT_DROP; |
| 228 | goto out_free; |
| 229 | } |
| 230 | |
| 231 | memcpy(ah->auth_data, icv, ahp->icv_trunc_len); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 232 | |
| 233 | top_iph->tos = iph->tos; |
| 234 | top_iph->ttl = iph->ttl; |
| 235 | top_iph->frag_off = iph->frag_off; |
| 236 | if (top_iph->ihl != 5) { |
| 237 | top_iph->daddr = iph->daddr; |
| 238 | memcpy(top_iph+1, iph+1, top_iph->ihl*4 - sizeof(struct iphdr)); |
| 239 | } |
| 240 | |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 241 | out_free: |
| 242 | kfree(iph); |
| 243 | out: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 244 | return err; |
| 245 | } |
| 246 | |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 247 | static void ah_input_done(struct crypto_async_request *base, int err) |
| 248 | { |
| 249 | u8 *auth_data; |
| 250 | u8 *icv; |
| 251 | struct iphdr *work_iph; |
| 252 | struct sk_buff *skb = base->data; |
| 253 | struct xfrm_state *x = xfrm_input_state(skb); |
| 254 | struct ah_data *ahp = x->data; |
| 255 | struct ip_auth_hdr *ah = ip_auth_hdr(skb); |
| 256 | int ihl = ip_hdrlen(skb); |
| 257 | int ah_hlen = (ah->hdrlen + 2) << 2; |
| 258 | |
| 259 | work_iph = AH_SKB_CB(skb)->tmp; |
| 260 | auth_data = ah_tmp_auth(work_iph, ihl); |
| 261 | icv = ah_tmp_icv(ahp->ahash, auth_data, ahp->icv_trunc_len); |
| 262 | |
| 263 | err = memcmp(icv, auth_data, ahp->icv_trunc_len) ? -EBADMSG: 0; |
| 264 | if (err) |
| 265 | goto out; |
| 266 | |
Nick Bowler | b7ea81a | 2011-11-08 12:12:45 +0000 | [diff] [blame] | 267 | err = ah->nexthdr; |
| 268 | |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 269 | skb->network_header += ah_hlen; |
| 270 | memcpy(skb_network_header(skb), work_iph, ihl); |
| 271 | __skb_pull(skb, ah_hlen + ihl); |
Li RongQing | 7143dfa | 2012-12-28 16:07:16 +0800 | [diff] [blame] | 272 | |
| 273 | if (x->props.mode == XFRM_MODE_TUNNEL) |
| 274 | skb_reset_transport_header(skb); |
| 275 | else |
| 276 | skb_set_transport_header(skb, -ihl); |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 277 | out: |
| 278 | kfree(AH_SKB_CB(skb)->tmp); |
| 279 | xfrm_input_resume(skb, err); |
| 280 | } |
| 281 | |
Herbert Xu | e695633 | 2006-04-01 00:52:46 -0800 | [diff] [blame] | 282 | static int ah_input(struct xfrm_state *x, struct sk_buff *skb) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 283 | { |
| 284 | int ah_hlen; |
Herbert Xu | 31a4ab9 | 2006-05-27 23:06:13 -0700 | [diff] [blame] | 285 | int ihl; |
Herbert Xu | 631a6698 | 2007-10-10 15:46:21 -0700 | [diff] [blame] | 286 | int nexthdr; |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 287 | int nfrags; |
| 288 | u8 *auth_data; |
| 289 | u8 *icv; |
| 290 | struct sk_buff *trailer; |
| 291 | struct crypto_ahash *ahash; |
| 292 | struct ahash_request *req; |
| 293 | struct scatterlist *sg; |
| 294 | struct iphdr *iph, *work_iph; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 295 | struct ip_auth_hdr *ah; |
| 296 | struct ah_data *ahp; |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 297 | int err = -ENOMEM; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 298 | |
Herbert Xu | 87bdc48 | 2007-10-10 15:45:25 -0700 | [diff] [blame] | 299 | if (!pskb_may_pull(skb, sizeof(*ah))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 300 | goto out; |
| 301 | |
Herbert Xu | 87bdc48 | 2007-10-10 15:45:25 -0700 | [diff] [blame] | 302 | ah = (struct ip_auth_hdr *)skb->data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 303 | ahp = x->data; |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 304 | ahash = ahp->ahash; |
| 305 | |
Herbert Xu | 631a6698 | 2007-10-10 15:46:21 -0700 | [diff] [blame] | 306 | nexthdr = ah->nexthdr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 307 | ah_hlen = (ah->hdrlen + 2) << 2; |
YOSHIFUJI Hideaki | e905a9e | 2007-02-09 23:24:47 +0900 | [diff] [blame] | 308 | |
Nicolas Dichtel | fa9921e | 2011-02-02 06:29:02 +0000 | [diff] [blame] | 309 | if (x->props.flags & XFRM_STATE_ALIGN4) { |
| 310 | if (ah_hlen != XFRM_ALIGN4(sizeof(*ah) + ahp->icv_full_len) && |
| 311 | ah_hlen != XFRM_ALIGN4(sizeof(*ah) + ahp->icv_trunc_len)) |
| 312 | goto out; |
| 313 | } else { |
| 314 | if (ah_hlen != XFRM_ALIGN8(sizeof(*ah) + ahp->icv_full_len) && |
| 315 | ah_hlen != XFRM_ALIGN8(sizeof(*ah) + ahp->icv_trunc_len)) |
| 316 | goto out; |
| 317 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 318 | |
| 319 | if (!pskb_may_pull(skb, ah_hlen)) |
| 320 | goto out; |
| 321 | |
| 322 | /* We are going to _remove_ AH header to keep sockets happy, |
| 323 | * so... Later this can change. */ |
| 324 | if (skb_cloned(skb) && |
| 325 | pskb_expand_head(skb, 0, 0, GFP_ATOMIC)) |
| 326 | goto out; |
| 327 | |
| 328 | skb->ip_summed = CHECKSUM_NONE; |
| 329 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 330 | |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 331 | if ((err = skb_cow_data(skb, 0, &trailer)) < 0) |
| 332 | goto out; |
| 333 | nfrags = err; |
| 334 | |
Dang Hongwu | 4b0ef1f2 | 2011-01-11 07:13:33 +0000 | [diff] [blame] | 335 | ah = (struct ip_auth_hdr *)skb->data; |
| 336 | iph = ip_hdr(skb); |
| 337 | ihl = ip_hdrlen(skb); |
| 338 | |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 339 | work_iph = ah_alloc_tmp(ahash, nfrags, ihl + ahp->icv_trunc_len); |
| 340 | if (!work_iph) |
| 341 | goto out; |
| 342 | |
| 343 | auth_data = ah_tmp_auth(work_iph, ihl); |
| 344 | icv = ah_tmp_icv(ahash, auth_data, ahp->icv_trunc_len); |
| 345 | req = ah_tmp_req(ahash, icv); |
| 346 | sg = ah_req_sg(ahash, req); |
| 347 | |
| 348 | memcpy(work_iph, iph, ihl); |
| 349 | memcpy(auth_data, ah->auth_data, ahp->icv_trunc_len); |
| 350 | memset(ah->auth_data, 0, ahp->icv_trunc_len); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 351 | |
| 352 | iph->ttl = 0; |
| 353 | iph->tos = 0; |
| 354 | iph->frag_off = 0; |
| 355 | iph->check = 0; |
Herbert Xu | 31a4ab9 | 2006-05-27 23:06:13 -0700 | [diff] [blame] | 356 | if (ihl > sizeof(*iph)) { |
Al Viro | d5a0a1e | 2006-11-08 00:23:14 -0800 | [diff] [blame] | 357 | __be32 dummy; |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 358 | err = ip_clear_mutable_options(iph, &dummy); |
Herbert Xu | 07d4ee5 | 2006-08-20 14:24:50 +1000 | [diff] [blame] | 359 | if (err) |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 360 | goto out_free; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 361 | } |
Herbert Xu | 0ebea8e | 2007-11-13 21:45:58 -0800 | [diff] [blame] | 362 | |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 363 | skb_push(skb, ihl); |
| 364 | |
| 365 | sg_init_table(sg, nfrags); |
| 366 | skb_to_sgvec(skb, sg, 0, skb->len); |
| 367 | |
| 368 | ahash_request_set_crypt(req, sg, icv, skb->len); |
| 369 | ahash_request_set_callback(req, 0, ah_input_done, skb); |
| 370 | |
| 371 | AH_SKB_CB(skb)->tmp = work_iph; |
| 372 | |
| 373 | err = crypto_ahash_digest(req); |
| 374 | if (err) { |
| 375 | if (err == -EINPROGRESS) |
| 376 | goto out; |
| 377 | |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 378 | goto out_free; |
| 379 | } |
| 380 | |
| 381 | err = memcmp(icv, auth_data, ahp->icv_trunc_len) ? -EBADMSG: 0; |
Herbert Xu | 0ebea8e | 2007-11-13 21:45:58 -0800 | [diff] [blame] | 382 | if (err) |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 383 | goto out_free; |
Herbert Xu | 0ebea8e | 2007-11-13 21:45:58 -0800 | [diff] [blame] | 384 | |
Arnaldo Carvalho de Melo | b0e380b1 | 2007-04-10 21:21:55 -0700 | [diff] [blame] | 385 | skb->network_header += ah_hlen; |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 386 | memcpy(skb_network_header(skb), work_iph, ihl); |
Herbert Xu | 31a4ab9 | 2006-05-27 23:06:13 -0700 | [diff] [blame] | 387 | __skb_pull(skb, ah_hlen + ihl); |
Li RongQing | 7143dfa | 2012-12-28 16:07:16 +0800 | [diff] [blame] | 388 | if (x->props.mode == XFRM_MODE_TUNNEL) |
| 389 | skb_reset_transport_header(skb); |
| 390 | else |
| 391 | skb_set_transport_header(skb, -ihl); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 392 | |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 393 | err = nexthdr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 394 | |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 395 | out_free: |
| 396 | kfree (work_iph); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 397 | out: |
Herbert Xu | 07d4ee5 | 2006-08-20 14:24:50 +1000 | [diff] [blame] | 398 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 399 | } |
| 400 | |
| 401 | static void ah4_err(struct sk_buff *skb, u32 info) |
| 402 | { |
Alexey Dobriyan | 4fb236b | 2008-11-25 17:59:27 -0800 | [diff] [blame] | 403 | struct net *net = dev_net(skb->dev); |
Eric Dumazet | b71d1d4 | 2011-04-22 04:53:02 +0000 | [diff] [blame] | 404 | const struct iphdr *iph = (const struct iphdr *)skb->data; |
Jianjun Kong | d9319100 | 2008-11-03 00:23:42 -0800 | [diff] [blame] | 405 | struct ip_auth_hdr *ah = (struct ip_auth_hdr *)(skb->data+(iph->ihl<<2)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 406 | struct xfrm_state *x; |
| 407 | |
David S. Miller | 55be7a9 | 2012-07-11 21:27:49 -0700 | [diff] [blame] | 408 | switch (icmp_hdr(skb)->type) { |
| 409 | case ICMP_DEST_UNREACH: |
| 410 | if (icmp_hdr(skb)->code != ICMP_FRAG_NEEDED) |
| 411 | return; |
| 412 | case ICMP_REDIRECT: |
| 413 | break; |
| 414 | default: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 415 | return; |
David S. Miller | 55be7a9 | 2012-07-11 21:27:49 -0700 | [diff] [blame] | 416 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 417 | |
Eric Dumazet | b71d1d4 | 2011-04-22 04:53:02 +0000 | [diff] [blame] | 418 | x = xfrm_state_lookup(net, skb->mark, (const xfrm_address_t *)&iph->daddr, |
| 419 | ah->spi, IPPROTO_AH, AF_INET); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 420 | if (!x) |
| 421 | return; |
David S. Miller | 55be7a9 | 2012-07-11 21:27:49 -0700 | [diff] [blame] | 422 | |
Steffen Klassert | 05ab86c | 2013-01-15 13:38:53 +0100 | [diff] [blame] | 423 | if (icmp_hdr(skb)->type == ICMP_DEST_UNREACH) { |
| 424 | atomic_inc(&flow_cache_genid); |
| 425 | rt_genid_bump(net); |
| 426 | |
David S. Miller | 55be7a9 | 2012-07-11 21:27:49 -0700 | [diff] [blame] | 427 | ipv4_update_pmtu(skb, net, info, 0, 0, IPPROTO_AH, 0); |
Steffen Klassert | 05ab86c | 2013-01-15 13:38:53 +0100 | [diff] [blame] | 428 | } else |
David S. Miller | 55be7a9 | 2012-07-11 21:27:49 -0700 | [diff] [blame] | 429 | ipv4_redirect(skb, net, 0, 0, IPPROTO_AH, 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 430 | xfrm_state_put(x); |
| 431 | } |
| 432 | |
Herbert Xu | 72cb696 | 2005-06-20 13:18:08 -0700 | [diff] [blame] | 433 | static int ah_init_state(struct xfrm_state *x) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 434 | { |
| 435 | struct ah_data *ahp = NULL; |
| 436 | struct xfrm_algo_desc *aalg_desc; |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 437 | struct crypto_ahash *ahash; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 438 | |
| 439 | if (!x->aalg) |
| 440 | goto error; |
| 441 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 442 | if (x->encap) |
| 443 | goto error; |
| 444 | |
Panagiotis Issaris | 0da974f | 2006-07-21 14:51:30 -0700 | [diff] [blame] | 445 | ahp = kzalloc(sizeof(*ahp), GFP_KERNEL); |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 446 | if (!ahp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 447 | return -ENOMEM; |
| 448 | |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 449 | ahash = crypto_alloc_ahash(x->aalg->alg_name, 0, 0); |
| 450 | if (IS_ERR(ahash)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 451 | goto error; |
Herbert Xu | 07d4ee5 | 2006-08-20 14:24:50 +1000 | [diff] [blame] | 452 | |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 453 | ahp->ahash = ahash; |
| 454 | if (crypto_ahash_setkey(ahash, x->aalg->alg_key, |
| 455 | (x->aalg->alg_key_len + 7) / 8)) |
Herbert Xu | 07d4ee5 | 2006-08-20 14:24:50 +1000 | [diff] [blame] | 456 | goto error; |
YOSHIFUJI Hideaki | e905a9e | 2007-02-09 23:24:47 +0900 | [diff] [blame] | 457 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 458 | /* |
| 459 | * Lookup the algorithm description maintained by xfrm_algo, |
| 460 | * verify crypto transform properties, and store information |
| 461 | * we need for AH processing. This lookup cannot fail here |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 462 | * after a successful crypto_alloc_ahash(). |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 463 | */ |
| 464 | aalg_desc = xfrm_aalg_get_byname(x->aalg->alg_name, 0); |
| 465 | BUG_ON(!aalg_desc); |
| 466 | |
| 467 | if (aalg_desc->uinfo.auth.icv_fullbits/8 != |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 468 | crypto_ahash_digestsize(ahash)) { |
Joe Perches | afd46503 | 2012-03-12 07:03:32 +0000 | [diff] [blame] | 469 | pr_info("%s: %s digestsize %u != %hu\n", |
| 470 | __func__, x->aalg->alg_name, |
| 471 | crypto_ahash_digestsize(ahash), |
| 472 | aalg_desc->uinfo.auth.icv_fullbits / 8); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 473 | goto error; |
| 474 | } |
YOSHIFUJI Hideaki | e905a9e | 2007-02-09 23:24:47 +0900 | [diff] [blame] | 475 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 476 | ahp->icv_full_len = aalg_desc->uinfo.auth.icv_fullbits/8; |
Martin Willi | 8f8a088 | 2009-11-25 00:29:53 +0000 | [diff] [blame] | 477 | ahp->icv_trunc_len = x->aalg->alg_trunc_len/8; |
YOSHIFUJI Hideaki | e905a9e | 2007-02-09 23:24:47 +0900 | [diff] [blame] | 478 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 479 | BUG_ON(ahp->icv_trunc_len > MAX_AH_AUTH_LEN); |
YOSHIFUJI Hideaki | e905a9e | 2007-02-09 23:24:47 +0900 | [diff] [blame] | 480 | |
Nicolas Dichtel | fa9921e | 2011-02-02 06:29:02 +0000 | [diff] [blame] | 481 | if (x->props.flags & XFRM_STATE_ALIGN4) |
| 482 | x->props.header_len = XFRM_ALIGN4(sizeof(struct ip_auth_hdr) + |
| 483 | ahp->icv_trunc_len); |
| 484 | else |
| 485 | x->props.header_len = XFRM_ALIGN8(sizeof(struct ip_auth_hdr) + |
| 486 | ahp->icv_trunc_len); |
Masahide NAKAMURA | 7e49e6d | 2006-09-22 15:05:15 -0700 | [diff] [blame] | 487 | if (x->props.mode == XFRM_MODE_TUNNEL) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 488 | x->props.header_len += sizeof(struct iphdr); |
| 489 | x->data = ahp; |
| 490 | |
| 491 | return 0; |
| 492 | |
| 493 | error: |
| 494 | if (ahp) { |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 495 | crypto_free_ahash(ahp->ahash); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 496 | kfree(ahp); |
| 497 | } |
| 498 | return -EINVAL; |
| 499 | } |
| 500 | |
| 501 | static void ah_destroy(struct xfrm_state *x) |
| 502 | { |
| 503 | struct ah_data *ahp = x->data; |
| 504 | |
| 505 | if (!ahp) |
| 506 | return; |
| 507 | |
Steffen Klassert | dff3bb0 | 2009-10-07 22:48:17 +0000 | [diff] [blame] | 508 | crypto_free_ahash(ahp->ahash); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 509 | kfree(ahp); |
| 510 | } |
| 511 | |
| 512 | |
Eric Dumazet | 533cb5b | 2008-01-30 19:11:50 -0800 | [diff] [blame] | 513 | static const struct xfrm_type ah_type = |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 514 | { |
| 515 | .description = "AH4", |
| 516 | .owner = THIS_MODULE, |
| 517 | .proto = IPPROTO_AH, |
Herbert Xu | 436a0a4 | 2007-10-08 17:25:53 -0700 | [diff] [blame] | 518 | .flags = XFRM_TYPE_REPLAY_PROT, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 519 | .init_state = ah_init_state, |
| 520 | .destructor = ah_destroy, |
| 521 | .input = ah_input, |
| 522 | .output = ah_output |
| 523 | }; |
| 524 | |
Alexey Dobriyan | 3261309 | 2009-09-14 12:21:47 +0000 | [diff] [blame] | 525 | static const struct net_protocol ah4_protocol = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 526 | .handler = xfrm4_rcv, |
| 527 | .err_handler = ah4_err, |
| 528 | .no_policy = 1, |
Alexey Dobriyan | 4fb236b | 2008-11-25 17:59:27 -0800 | [diff] [blame] | 529 | .netns_ok = 1, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 530 | }; |
| 531 | |
| 532 | static int __init ah4_init(void) |
| 533 | { |
| 534 | if (xfrm_register_type(&ah_type, AF_INET) < 0) { |
Joe Perches | 058bd4d | 2012-03-11 18:36:11 +0000 | [diff] [blame] | 535 | pr_info("%s: can't add xfrm type\n", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 536 | return -EAGAIN; |
| 537 | } |
| 538 | if (inet_add_protocol(&ah4_protocol, IPPROTO_AH) < 0) { |
Joe Perches | 058bd4d | 2012-03-11 18:36:11 +0000 | [diff] [blame] | 539 | pr_info("%s: can't add protocol\n", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 540 | xfrm_unregister_type(&ah_type, AF_INET); |
| 541 | return -EAGAIN; |
| 542 | } |
| 543 | return 0; |
| 544 | } |
| 545 | |
| 546 | static void __exit ah4_fini(void) |
| 547 | { |
| 548 | if (inet_del_protocol(&ah4_protocol, IPPROTO_AH) < 0) |
Joe Perches | 058bd4d | 2012-03-11 18:36:11 +0000 | [diff] [blame] | 549 | pr_info("%s: can't remove protocol\n", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 550 | if (xfrm_unregister_type(&ah_type, AF_INET) < 0) |
Joe Perches | 058bd4d | 2012-03-11 18:36:11 +0000 | [diff] [blame] | 551 | pr_info("%s: can't remove xfrm type\n", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 552 | } |
| 553 | |
| 554 | module_init(ah4_init); |
| 555 | module_exit(ah4_fini); |
| 556 | MODULE_LICENSE("GPL"); |
Masahide NAKAMURA | d3d6dd3 | 2007-06-26 23:57:49 -0700 | [diff] [blame] | 557 | MODULE_ALIAS_XFRM_TYPE(AF_INET, XFRM_PROTO_AH); |