ah4.c 7.6 KB

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