1 #include <linux/err.h> 2 #include <linux/module.h> 3 #include <net/ip.h> 4 #include <net/xfrm.h> 5 #include <net/ah.h> 6 #include <linux/crypto.h> 7 #include <linux/pfkeyv2.h> 8 #include <linux/spinlock.h> 9 #include <net/icmp.h> 10 #include <net/protocol.h> 11 12 13 /* Clear mutable options and find final destination to substitute 14 * into IP header for icv calculation. Options are already checked 15 * for validity, so paranoia is not required. */ 16 17 static int ip_clear_mutable_options(struct iphdr *iph, __be32 *daddr) 18 { 19 unsigned char * optptr = (unsigned char*)(iph+1); 20 int l = iph->ihl*4 - sizeof(struct iphdr); 21 int optlen; 22 23 while (l > 0) { 24 switch (*optptr) { 25 case IPOPT_END: 26 return 0; 27 case IPOPT_NOOP: 28 l--; 29 optptr++; 30 continue; 31 } 32 optlen = optptr[1]; 33 if (optlen<2 || optlen>l) 34 return -EINVAL; 35 switch (*optptr) { 36 case IPOPT_SEC: 37 case 0x85: /* Some "Extended Security" crap. */ 38 case IPOPT_CIPSO: 39 case IPOPT_RA: 40 case 0x80|21: /* RFC1770 */ 41 break; 42 case IPOPT_LSRR: 43 case IPOPT_SSRR: 44 if (optlen < 6) 45 return -EINVAL; 46 memcpy(daddr, optptr+optlen-4, 4); 47 /* Fall through */ 48 default: 49 memset(optptr, 0, optlen); 50 } 51 l -= optlen; 52 optptr += optlen; 53 } 54 return 0; 55 } 56 57 static int ah_output(struct xfrm_state *x, struct sk_buff *skb) 58 { 59 int err; 60 struct iphdr *iph, *top_iph; 61 struct ip_auth_hdr *ah; 62 struct ah_data *ahp; 63 union { 64 struct iphdr iph; 65 char buf[60]; 66 } tmp_iph; 67 68 skb_push(skb, -skb_network_offset(skb)); 69 top_iph = ip_hdr(skb); 70 iph = &tmp_iph.iph; 71 72 iph->tos = top_iph->tos; 73 iph->ttl = top_iph->ttl; 74 iph->frag_off = top_iph->frag_off; 75 76 if (top_iph->ihl != 5) { 77 iph->daddr = top_iph->daddr; 78 memcpy(iph+1, top_iph+1, top_iph->ihl*4 - sizeof(struct iphdr)); 79 err = ip_clear_mutable_options(top_iph, &top_iph->daddr); 80 if (err) 81 goto error; 82 } 83 84 ah = ip_auth_hdr(skb); 85 ah->nexthdr = *skb_mac_header(skb); 86 *skb_mac_header(skb) = IPPROTO_AH; 87 88 top_iph->tos = 0; 89 top_iph->tot_len = htons(skb->len); 90 top_iph->frag_off = 0; 91 top_iph->ttl = 0; 92 top_iph->check = 0; 93 94 ahp = x->data; 95 ah->hdrlen = (XFRM_ALIGN8(sizeof(*ah) + ahp->icv_trunc_len) >> 2) - 2; 96 97 ah->reserved = 0; 98 ah->spi = x->id.spi; 99 ah->seq_no = htonl(XFRM_SKB_CB(skb)->seq.output); 100 101 spin_lock_bh(&x->lock); 102 err = ah_mac_digest(ahp, skb, ah->auth_data); 103 memcpy(ah->auth_data, ahp->work_icv, ahp->icv_trunc_len); 104 spin_unlock_bh(&x->lock); 105 106 if (err) 107 goto error; 108 109 top_iph->tos = iph->tos; 110 top_iph->ttl = iph->ttl; 111 top_iph->frag_off = iph->frag_off; 112 if (top_iph->ihl != 5) { 113 top_iph->daddr = iph->daddr; 114 memcpy(top_iph+1, iph+1, top_iph->ihl*4 - sizeof(struct iphdr)); 115 } 116 117 err = 0; 118 119 error: 120 return err; 121 } 122 123 static int ah_input(struct xfrm_state *x, struct sk_buff *skb) 124 { 125 int ah_hlen; 126 int ihl; 127 int nexthdr; 128 int err = -EINVAL; 129 struct iphdr *iph; 130 struct ip_auth_hdr *ah; 131 struct ah_data *ahp; 132 char work_buf[60]; 133 134 if (!pskb_may_pull(skb, sizeof(*ah))) 135 goto out; 136 137 ah = (struct ip_auth_hdr *)skb->data; 138 ahp = x->data; 139 nexthdr = ah->nexthdr; 140 ah_hlen = (ah->hdrlen + 2) << 2; 141 142 if (ah_hlen != XFRM_ALIGN8(sizeof(*ah) + ahp->icv_full_len) && 143 ah_hlen != XFRM_ALIGN8(sizeof(*ah) + ahp->icv_trunc_len)) 144 goto out; 145 146 if (!pskb_may_pull(skb, ah_hlen)) 147 goto out; 148 149 /* We are going to _remove_ AH header to keep sockets happy, 150 * so... Later this can change. */ 151 if (skb_cloned(skb) && 152 pskb_expand_head(skb, 0, 0, GFP_ATOMIC)) 153 goto out; 154 155 skb->ip_summed = CHECKSUM_NONE; 156 157 ah = (struct ip_auth_hdr *)skb->data; 158 iph = ip_hdr(skb); 159 160 ihl = skb->data - skb_network_header(skb); 161 memcpy(work_buf, iph, ihl); 162 163 iph->ttl = 0; 164 iph->tos = 0; 165 iph->frag_off = 0; 166 iph->check = 0; 167 if (ihl > sizeof(*iph)) { 168 __be32 dummy; 169 if (ip_clear_mutable_options(iph, &dummy)) 170 goto out; 171 } 172 173 spin_lock(&x->lock); 174 { 175 u8 auth_data[MAX_AH_AUTH_LEN]; 176 177 memcpy(auth_data, ah->auth_data, ahp->icv_trunc_len); 178 skb_push(skb, ihl); 179 err = ah_mac_digest(ahp, skb, ah->auth_data); 180 if (err) 181 goto unlock; 182 if (memcmp(ahp->work_icv, auth_data, ahp->icv_trunc_len)) 183 err = -EBADMSG; 184 } 185 unlock: 186 spin_unlock(&x->lock); 187 188 if (err) 189 goto out; 190 191 skb->network_header += ah_hlen; 192 memcpy(skb_network_header(skb), work_buf, ihl); 193 skb->transport_header = skb->network_header; 194 __skb_pull(skb, ah_hlen + ihl); 195 196 return nexthdr; 197 198 out: 199 return err; 200 } 201 202 static void ah4_err(struct sk_buff *skb, u32 info) 203 { 204 struct iphdr *iph = (struct iphdr*)skb->data; 205 struct ip_auth_hdr *ah = (struct ip_auth_hdr*)(skb->data+(iph->ihl<<2)); 206 struct xfrm_state *x; 207 208 if (icmp_hdr(skb)->type != ICMP_DEST_UNREACH || 209 icmp_hdr(skb)->code != ICMP_FRAG_NEEDED) 210 return; 211 212 x = xfrm_state_lookup((xfrm_address_t *)&iph->daddr, ah->spi, IPPROTO_AH, AF_INET); 213 if (!x) 214 return; 215 printk(KERN_DEBUG "pmtu discovery on SA AH/%08x/%08x\n", 216 ntohl(ah->spi), ntohl(iph->daddr)); 217 xfrm_state_put(x); 218 } 219 220 static int ah_init_state(struct xfrm_state *x) 221 { 222 struct ah_data *ahp = NULL; 223 struct xfrm_algo_desc *aalg_desc; 224 struct crypto_hash *tfm; 225 226 if (!x->aalg) 227 goto error; 228 229 if (x->encap) 230 goto error; 231 232 ahp = kzalloc(sizeof(*ahp), GFP_KERNEL); 233 if (ahp == NULL) 234 return -ENOMEM; 235 236 tfm = crypto_alloc_hash(x->aalg->alg_name, 0, CRYPTO_ALG_ASYNC); 237 if (IS_ERR(tfm)) 238 goto error; 239 240 ahp->tfm = tfm; 241 if (crypto_hash_setkey(tfm, x->aalg->alg_key, 242 (x->aalg->alg_key_len + 7) / 8)) 243 goto error; 244 245 /* 246 * Lookup the algorithm description maintained by xfrm_algo, 247 * verify crypto transform properties, and store information 248 * we need for AH processing. This lookup cannot fail here 249 * after a successful crypto_alloc_hash(). 250 */ 251 aalg_desc = xfrm_aalg_get_byname(x->aalg->alg_name, 0); 252 BUG_ON(!aalg_desc); 253 254 if (aalg_desc->uinfo.auth.icv_fullbits/8 != 255 crypto_hash_digestsize(tfm)) { 256 printk(KERN_INFO "AH: %s digestsize %u != %hu\n", 257 x->aalg->alg_name, crypto_hash_digestsize(tfm), 258 aalg_desc->uinfo.auth.icv_fullbits/8); 259 goto error; 260 } 261 262 ahp->icv_full_len = aalg_desc->uinfo.auth.icv_fullbits/8; 263 ahp->icv_trunc_len = aalg_desc->uinfo.auth.icv_truncbits/8; 264 265 BUG_ON(ahp->icv_trunc_len > MAX_AH_AUTH_LEN); 266 267 ahp->work_icv = kmalloc(ahp->icv_full_len, GFP_KERNEL); 268 if (!ahp->work_icv) 269 goto error; 270 271 x->props.header_len = XFRM_ALIGN8(sizeof(struct ip_auth_hdr) + 272 ahp->icv_trunc_len); 273 if (x->props.mode == XFRM_MODE_TUNNEL) 274 x->props.header_len += sizeof(struct iphdr); 275 x->data = ahp; 276 277 return 0; 278 279 error: 280 if (ahp) { 281 kfree(ahp->work_icv); 282 crypto_free_hash(ahp->tfm); 283 kfree(ahp); 284 } 285 return -EINVAL; 286 } 287 288 static void ah_destroy(struct xfrm_state *x) 289 { 290 struct ah_data *ahp = x->data; 291 292 if (!ahp) 293 return; 294 295 kfree(ahp->work_icv); 296 ahp->work_icv = NULL; 297 crypto_free_hash(ahp->tfm); 298 ahp->tfm = NULL; 299 kfree(ahp); 300 } 301 302 303 static const struct xfrm_type ah_type = 304 { 305 .description = "AH4", 306 .owner = THIS_MODULE, 307 .proto = IPPROTO_AH, 308 .flags = XFRM_TYPE_REPLAY_PROT, 309 .init_state = ah_init_state, 310 .destructor = ah_destroy, 311 .input = ah_input, 312 .output = ah_output 313 }; 314 315 static struct net_protocol ah4_protocol = { 316 .handler = xfrm4_rcv, 317 .err_handler = ah4_err, 318 .no_policy = 1, 319 }; 320 321 static int __init ah4_init(void) 322 { 323 if (xfrm_register_type(&ah_type, AF_INET) < 0) { 324 printk(KERN_INFO "ip ah init: can't add xfrm type\n"); 325 return -EAGAIN; 326 } 327 if (inet_add_protocol(&ah4_protocol, IPPROTO_AH) < 0) { 328 printk(KERN_INFO "ip ah init: can't add protocol\n"); 329 xfrm_unregister_type(&ah_type, AF_INET); 330 return -EAGAIN; 331 } 332 return 0; 333 } 334 335 static void __exit ah4_fini(void) 336 { 337 if (inet_del_protocol(&ah4_protocol, IPPROTO_AH) < 0) 338 printk(KERN_INFO "ip ah close: can't remove protocol\n"); 339 if (xfrm_unregister_type(&ah_type, AF_INET) < 0) 340 printk(KERN_INFO "ip ah close: can't remove xfrm type\n"); 341 } 342 343 module_init(ah4_init); 344 module_exit(ah4_fini); 345 MODULE_LICENSE("GPL"); 346 MODULE_ALIAS_XFRM_TYPE(AF_INET, XFRM_PROTO_AH); 347