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); 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 u8 auth_data[MAX_AH_AUTH_LEN]; 174 175 memcpy(auth_data, ah->auth_data, ahp->icv_trunc_len); 176 skb_push(skb, ihl); 177 err = ah_mac_digest(ahp, skb, ah->auth_data); 178 if (err) 179 goto out; 180 err = -EINVAL; 181 if (memcmp(ahp->work_icv, auth_data, ahp->icv_trunc_len)) { 182 x->stats.integrity_failed++; 183 goto out; 184 } 185 } 186 skb->network_header += ah_hlen; 187 memcpy(skb_network_header(skb), work_buf, ihl); 188 skb->transport_header = skb->network_header; 189 __skb_pull(skb, ah_hlen + ihl); 190 191 return nexthdr; 192 193 out: 194 return err; 195 } 196 197 static void ah4_err(struct sk_buff *skb, u32 info) 198 { 199 struct iphdr *iph = (struct iphdr*)skb->data; 200 struct ip_auth_hdr *ah = (struct ip_auth_hdr*)(skb->data+(iph->ihl<<2)); 201 struct xfrm_state *x; 202 203 if (icmp_hdr(skb)->type != ICMP_DEST_UNREACH || 204 icmp_hdr(skb)->code != ICMP_FRAG_NEEDED) 205 return; 206 207 x = xfrm_state_lookup((xfrm_address_t *)&iph->daddr, ah->spi, IPPROTO_AH, AF_INET); 208 if (!x) 209 return; 210 printk(KERN_DEBUG "pmtu discovery on SA AH/%08x/%08x\n", 211 ntohl(ah->spi), ntohl(iph->daddr)); 212 xfrm_state_put(x); 213 } 214 215 static int ah_init_state(struct xfrm_state *x) 216 { 217 struct ah_data *ahp = NULL; 218 struct xfrm_algo_desc *aalg_desc; 219 struct crypto_hash *tfm; 220 221 if (!x->aalg) 222 goto error; 223 224 if (x->encap) 225 goto error; 226 227 ahp = kzalloc(sizeof(*ahp), GFP_KERNEL); 228 if (ahp == NULL) 229 return -ENOMEM; 230 231 tfm = crypto_alloc_hash(x->aalg->alg_name, 0, CRYPTO_ALG_ASYNC); 232 if (IS_ERR(tfm)) 233 goto error; 234 235 ahp->tfm = tfm; 236 if (crypto_hash_setkey(tfm, x->aalg->alg_key, 237 (x->aalg->alg_key_len + 7) / 8)) 238 goto error; 239 240 /* 241 * Lookup the algorithm description maintained by xfrm_algo, 242 * verify crypto transform properties, and store information 243 * we need for AH processing. This lookup cannot fail here 244 * after a successful crypto_alloc_hash(). 245 */ 246 aalg_desc = xfrm_aalg_get_byname(x->aalg->alg_name, 0); 247 BUG_ON(!aalg_desc); 248 249 if (aalg_desc->uinfo.auth.icv_fullbits/8 != 250 crypto_hash_digestsize(tfm)) { 251 printk(KERN_INFO "AH: %s digestsize %u != %hu\n", 252 x->aalg->alg_name, crypto_hash_digestsize(tfm), 253 aalg_desc->uinfo.auth.icv_fullbits/8); 254 goto error; 255 } 256 257 ahp->icv_full_len = aalg_desc->uinfo.auth.icv_fullbits/8; 258 ahp->icv_trunc_len = aalg_desc->uinfo.auth.icv_truncbits/8; 259 260 BUG_ON(ahp->icv_trunc_len > MAX_AH_AUTH_LEN); 261 262 ahp->work_icv = kmalloc(ahp->icv_full_len, GFP_KERNEL); 263 if (!ahp->work_icv) 264 goto error; 265 266 x->props.header_len = XFRM_ALIGN8(sizeof(struct ip_auth_hdr) + 267 ahp->icv_trunc_len); 268 if (x->props.mode == XFRM_MODE_TUNNEL) 269 x->props.header_len += sizeof(struct iphdr); 270 x->data = ahp; 271 272 return 0; 273 274 error: 275 if (ahp) { 276 kfree(ahp->work_icv); 277 crypto_free_hash(ahp->tfm); 278 kfree(ahp); 279 } 280 return -EINVAL; 281 } 282 283 static void ah_destroy(struct xfrm_state *x) 284 { 285 struct ah_data *ahp = x->data; 286 287 if (!ahp) 288 return; 289 290 kfree(ahp->work_icv); 291 ahp->work_icv = NULL; 292 crypto_free_hash(ahp->tfm); 293 ahp->tfm = NULL; 294 kfree(ahp); 295 } 296 297 298 static struct xfrm_type ah_type = 299 { 300 .description = "AH4", 301 .owner = THIS_MODULE, 302 .proto = IPPROTO_AH, 303 .flags = XFRM_TYPE_REPLAY_PROT, 304 .init_state = ah_init_state, 305 .destructor = ah_destroy, 306 .input = ah_input, 307 .output = ah_output 308 }; 309 310 static struct net_protocol ah4_protocol = { 311 .handler = xfrm4_rcv, 312 .err_handler = ah4_err, 313 .no_policy = 1, 314 }; 315 316 static int __init ah4_init(void) 317 { 318 if (xfrm_register_type(&ah_type, AF_INET) < 0) { 319 printk(KERN_INFO "ip ah init: can't add xfrm type\n"); 320 return -EAGAIN; 321 } 322 if (inet_add_protocol(&ah4_protocol, IPPROTO_AH) < 0) { 323 printk(KERN_INFO "ip ah init: can't add protocol\n"); 324 xfrm_unregister_type(&ah_type, AF_INET); 325 return -EAGAIN; 326 } 327 return 0; 328 } 329 330 static void __exit ah4_fini(void) 331 { 332 if (inet_del_protocol(&ah4_protocol, IPPROTO_AH) < 0) 333 printk(KERN_INFO "ip ah close: can't remove protocol\n"); 334 if (xfrm_unregister_type(&ah_type, AF_INET) < 0) 335 printk(KERN_INFO "ip ah close: can't remove xfrm type\n"); 336 } 337 338 module_init(ah4_init); 339 module_exit(ah4_fini); 340 MODULE_LICENSE("GPL"); 341 MODULE_ALIAS_XFRM_TYPE(AF_INET, XFRM_PROTO_AH); 342