2 * Host AP crypt: host-based CCMP encryption implementation for Host AP driver
4 * Copyright (c) 2003-2004, Jouni Malinen <jkmaline@cc.hut.fi>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation. See README and COPYING for
12 //#include <linux/config.h>
13 #include <linux/version.h>
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <linux/slab.h>
17 #include <linux/random.h>
18 #include <linux/skbuff.h>
19 #include <linux/netdevice.h>
20 #include <linux/if_ether.h>
21 #include <linux/if_arp.h>
22 #include <asm/string.h>
23 #include <linux/wireless.h>
25 #include "ieee80211.h"
27 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
28 #include "rtl_crypto.h"
30 #include <linux/crypto.h>
33 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
34 #include <asm/scatterlist.h>
36 #include <linux/scatterlist.h>
38 //#include <asm/scatterlist.h>
40 MODULE_AUTHOR("Jouni Malinen");
41 MODULE_DESCRIPTION("Host AP crypt: CCMP");
42 MODULE_LICENSE("GPL");
45 #define OPENSUSE_SLED 0
48 #define AES_BLOCK_LEN 16
49 #define CCMP_HDR_LEN 8
50 #define CCMP_MIC_LEN 8
51 #define CCMP_TK_LEN 16
54 struct ieee80211_ccmp_data {
58 u8 tx_pn[CCMP_PN_LEN];
59 u8 rx_pn[CCMP_PN_LEN];
61 u32 dot11RSNAStatsCCMPFormatErrors;
62 u32 dot11RSNAStatsCCMPReplays;
63 u32 dot11RSNAStatsCCMPDecryptErrors;
67 struct crypto_tfm *tfm;
69 /* scratch buffers for virt_to_page() (crypto API) */
70 u8 tx_b0[AES_BLOCK_LEN], tx_b[AES_BLOCK_LEN],
71 tx_e[AES_BLOCK_LEN], tx_s0[AES_BLOCK_LEN];
72 u8 rx_b0[AES_BLOCK_LEN], rx_b[AES_BLOCK_LEN], rx_a[AES_BLOCK_LEN];
75 void ieee80211_ccmp_aes_encrypt(struct crypto_tfm *tfm,
76 const u8 pt[16], u8 ct[16])
78 #if((LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)) && (!OPENSUSE_SLED))
79 struct scatterlist src, dst;
81 src.page = virt_to_page(pt);
82 src.offset = offset_in_page(pt);
83 src.length = AES_BLOCK_LEN;
85 dst.page = virt_to_page(ct);
86 dst.offset = offset_in_page(ct);
87 dst.length = AES_BLOCK_LEN;
89 crypto_cipher_encrypt(tfm, &dst, &src, AES_BLOCK_LEN);
91 crypto_cipher_encrypt_one((void*)tfm, ct, pt);
95 static void * ieee80211_ccmp_init(int key_idx)
97 struct ieee80211_ccmp_data *priv;
99 priv = kmalloc(sizeof(*priv), GFP_ATOMIC);
102 memset(priv, 0, sizeof(*priv));
103 priv->key_idx = key_idx;
105 #if((LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)) && (!OPENSUSE_SLED))
106 priv->tfm = crypto_alloc_tfm("aes", 0);
107 if (priv->tfm == NULL) {
108 printk(KERN_DEBUG "ieee80211_crypt_ccmp: could not allocate "
113 priv->tfm = (void*)crypto_alloc_cipher("aes", 0, CRYPTO_ALG_ASYNC);
114 if (IS_ERR(priv->tfm)) {
115 printk(KERN_DEBUG "ieee80211_crypt_ccmp: could not allocate "
126 #if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21))
127 crypto_free_tfm(priv->tfm);
129 crypto_free_cipher((void*)priv->tfm);
138 static void ieee80211_ccmp_deinit(void *priv)
140 struct ieee80211_ccmp_data *_priv = priv;
141 if (_priv && _priv->tfm)
142 #if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21))
143 crypto_free_tfm(_priv->tfm);
145 crypto_free_cipher((void*)_priv->tfm);
151 static inline void xor_block(u8 *b, u8 *a, size_t len)
154 for (i = 0; i < len; i++)
160 static void ccmp_init_blocks(struct crypto_tfm *tfm,
161 struct ieee80211_hdr_4addr *hdr,
162 u8 *pn, size_t dlen, u8 *b0, u8 *auth,
168 int a4_included, qc_included;
169 u8 aad[2 * AES_BLOCK_LEN];
171 fc = le16_to_cpu(hdr->frame_ctl);
172 a4_included = ((fc & (IEEE80211_FCTL_TODS | IEEE80211_FCTL_FROMDS)) ==
173 (IEEE80211_FCTL_TODS | IEEE80211_FCTL_FROMDS));
175 qc_included = ((WLAN_FC_GET_TYPE(fc) == IEEE80211_FTYPE_DATA) &&
176 (WLAN_FC_GET_STYPE(fc) & 0x08));
178 // fixed by David :2006.9.6
179 qc_included = ((WLAN_FC_GET_TYPE(fc) == IEEE80211_FTYPE_DATA) &&
180 (WLAN_FC_GET_STYPE(fc) & 0x80));
185 pos = (u8 *) &hdr->addr4;
191 /* CCM Initial Block:
192 * Flag (Include authentication header, M=3 (8-octet MIC),
193 * L=1 (2-octet Dlen))
194 * Nonce: 0x00 | A2 | PN
198 memcpy(b0 + 2, hdr->addr2, ETH_ALEN);
199 memcpy(b0 + 8, pn, CCMP_PN_LEN);
200 b0[14] = (dlen >> 8) & 0xff;
201 b0[15] = dlen & 0xff;
204 * FC with bits 4..6 and 11..13 masked to zero; 14 is always one
206 * SC with bits 4..15 (seq#) masked to zero
211 aad[0] = 0; /* aad_len >> 8 */
212 aad[1] = aad_len & 0xff;
213 aad[2] = pos[0] & 0x8f;
214 aad[3] = pos[1] & 0xc7;
215 memcpy(aad + 4, hdr->addr1, 3 * ETH_ALEN);
216 pos = (u8 *) &hdr->seq_ctl;
217 aad[22] = pos[0] & 0x0f;
218 aad[23] = 0; /* all bits masked */
219 memset(aad + 24, 0, 8);
221 memcpy(aad + 24, hdr->addr4, ETH_ALEN);
223 aad[a4_included ? 30 : 24] = qc;
224 /* rest of QC masked */
227 /* Start with the first block and AAD */
228 ieee80211_ccmp_aes_encrypt(tfm, b0, auth);
229 xor_block(auth, aad, AES_BLOCK_LEN);
230 ieee80211_ccmp_aes_encrypt(tfm, auth, auth);
231 xor_block(auth, &aad[AES_BLOCK_LEN], AES_BLOCK_LEN);
232 ieee80211_ccmp_aes_encrypt(tfm, auth, auth);
235 ieee80211_ccmp_aes_encrypt(tfm, b0, s0);
240 static int ieee80211_ccmp_encrypt(struct sk_buff *skb, int hdr_len, void *priv)
242 struct ieee80211_ccmp_data *key = priv;
245 struct ieee80211_hdr_4addr *hdr;
246 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
248 if (skb_headroom(skb) < CCMP_HDR_LEN ||
249 skb_tailroom(skb) < CCMP_MIC_LEN ||
253 data_len = skb->len - hdr_len;
254 pos = skb_push(skb, CCMP_HDR_LEN);
255 memmove(pos, pos + CCMP_HDR_LEN, hdr_len);
257 // mic = skb_put(skb, CCMP_MIC_LEN);
262 if (key->tx_pn[i] != 0)
267 *pos++ = key->tx_pn[5];
268 *pos++ = key->tx_pn[4];
270 *pos++ = (key->key_idx << 6) | (1 << 5) /* Ext IV included */;
271 *pos++ = key->tx_pn[3];
272 *pos++ = key->tx_pn[2];
273 *pos++ = key->tx_pn[1];
274 *pos++ = key->tx_pn[0];
277 hdr = (struct ieee80211_hdr_4addr *) skb->data;
278 if (!tcb_desc->bHwSec)
280 int blocks, last, len;
287 //mic is moved to here by john
288 mic = skb_put(skb, CCMP_MIC_LEN);
290 ccmp_init_blocks(key->tfm, hdr, key->tx_pn, data_len, b0, b, s0);
292 blocks = (data_len + AES_BLOCK_LEN - 1) / AES_BLOCK_LEN;
293 last = data_len % AES_BLOCK_LEN;
295 for (i = 1; i <= blocks; i++) {
296 len = (i == blocks && last) ? last : AES_BLOCK_LEN;
298 xor_block(b, pos, len);
299 ieee80211_ccmp_aes_encrypt(key->tfm, b, b);
300 /* Encryption, with counter */
301 b0[14] = (i >> 8) & 0xff;
303 ieee80211_ccmp_aes_encrypt(key->tfm, b0, e);
304 xor_block(pos, e, len);
308 for (i = 0; i < CCMP_MIC_LEN; i++)
309 mic[i] = b[i] ^ s0[i];
315 static int ieee80211_ccmp_decrypt(struct sk_buff *skb, int hdr_len, void *priv)
317 struct ieee80211_ccmp_data *key = priv;
319 struct ieee80211_hdr_4addr *hdr;
320 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
323 if (skb->len < hdr_len + CCMP_HDR_LEN + CCMP_MIC_LEN) {
324 key->dot11RSNAStatsCCMPFormatErrors++;
328 hdr = (struct ieee80211_hdr_4addr *) skb->data;
329 pos = skb->data + hdr_len;
331 if (!(keyidx & (1 << 5))) {
332 if (net_ratelimit()) {
333 printk(KERN_DEBUG "CCMP: received packet without ExtIV"
334 " flag from %pM\n", hdr->addr2);
336 key->dot11RSNAStatsCCMPFormatErrors++;
340 if (key->key_idx != keyidx) {
341 printk(KERN_DEBUG "CCMP: RX tkey->key_idx=%d frame "
342 "keyidx=%d priv=%p\n", key->key_idx, keyidx, priv);
346 if (net_ratelimit()) {
347 printk(KERN_DEBUG "CCMP: received packet from %pM"
348 " with keyid=%d that does not have a configured"
349 " key\n", hdr->addr2, keyidx);
362 if (memcmp(pn, key->rx_pn, CCMP_PN_LEN) <= 0) {
363 if (net_ratelimit()) {
364 //printk(KERN_DEBUG "CCMP: replay detected: STA=%pM"
365 // " previous PN %pm received PN %pm\n",
366 // hdr->addr2, key->rx_pn, pn);
368 key->dot11RSNAStatsCCMPReplays++;
371 if (!tcb_desc->bHwSec)
373 size_t data_len = skb->len - hdr_len - CCMP_HDR_LEN - CCMP_MIC_LEN;
374 u8 *mic = skb->data + skb->len - CCMP_MIC_LEN;
378 int i, blocks, last, len;
381 ccmp_init_blocks(key->tfm, hdr, pn, data_len, b0, a, b);
382 xor_block(mic, b, CCMP_MIC_LEN);
384 blocks = (data_len + AES_BLOCK_LEN - 1) / AES_BLOCK_LEN;
385 last = data_len % AES_BLOCK_LEN;
387 for (i = 1; i <= blocks; i++) {
388 len = (i == blocks && last) ? last : AES_BLOCK_LEN;
389 /* Decrypt, with counter */
390 b0[14] = (i >> 8) & 0xff;
392 ieee80211_ccmp_aes_encrypt(key->tfm, b0, b);
393 xor_block(pos, b, len);
395 xor_block(a, pos, len);
396 ieee80211_ccmp_aes_encrypt(key->tfm, a, a);
400 if (memcmp(mic, a, CCMP_MIC_LEN) != 0) {
401 if (net_ratelimit()) {
402 printk(KERN_DEBUG "CCMP: decrypt failed: STA="
403 "%pM\n", hdr->addr2);
405 key->dot11RSNAStatsCCMPDecryptErrors++;
409 memcpy(key->rx_pn, pn, CCMP_PN_LEN);
411 /* Remove hdr and MIC */
412 memmove(skb->data + CCMP_HDR_LEN, skb->data, hdr_len);
413 skb_pull(skb, CCMP_HDR_LEN);
414 skb_trim(skb, skb->len - CCMP_MIC_LEN);
420 static int ieee80211_ccmp_set_key(void *key, int len, u8 *seq, void *priv)
422 struct ieee80211_ccmp_data *data = priv;
424 struct crypto_tfm *tfm = data->tfm;
426 keyidx = data->key_idx;
427 memset(data, 0, sizeof(*data));
428 data->key_idx = keyidx;
430 if (len == CCMP_TK_LEN) {
431 memcpy(data->key, key, CCMP_TK_LEN);
434 data->rx_pn[0] = seq[5];
435 data->rx_pn[1] = seq[4];
436 data->rx_pn[2] = seq[3];
437 data->rx_pn[3] = seq[2];
438 data->rx_pn[4] = seq[1];
439 data->rx_pn[5] = seq[0];
441 crypto_cipher_setkey((void*)data->tfm, data->key, CCMP_TK_LEN);
451 static int ieee80211_ccmp_get_key(void *key, int len, u8 *seq, void *priv)
453 struct ieee80211_ccmp_data *data = priv;
455 if (len < CCMP_TK_LEN)
460 memcpy(key, data->key, CCMP_TK_LEN);
463 seq[0] = data->tx_pn[5];
464 seq[1] = data->tx_pn[4];
465 seq[2] = data->tx_pn[3];
466 seq[3] = data->tx_pn[2];
467 seq[4] = data->tx_pn[1];
468 seq[5] = data->tx_pn[0];
475 static char * ieee80211_ccmp_print_stats(char *p, void *priv)
477 struct ieee80211_ccmp_data *ccmp = priv;
480 p += sprintf(p, "key[%d] alg=CCMP key_set=%d tx_pn=",
481 ccmp->key_idx, ccmp->key_set);
483 for (i = 0; i < ARRAY_SIZE(ccmp->tx_pn); i++)
484 p += sprintf(p, "%02x", ccmp->tx_pn[i]);
486 sprintf(p, " rx_pn=");
487 for (i = 0; i < ARRAY_SIZE(ccmp->rx_pn); i++)
488 p += sprintf(p, "%02x", ccmp->tx_pn[i]);
490 p += sprintf(p, " format_errors=%d replays=%d decrypt_errors=%d\n",
491 ccmp->dot11RSNAStatsCCMPFormatErrors,
492 ccmp->dot11RSNAStatsCCMPReplays,
493 ccmp->dot11RSNAStatsCCMPDecryptErrors);
498 void ieee80211_ccmp_null(void)
500 // printk("============>%s()\n", __FUNCTION__);
504 static struct ieee80211_crypto_ops ieee80211_crypt_ccmp = {
506 .init = ieee80211_ccmp_init,
507 .deinit = ieee80211_ccmp_deinit,
508 .encrypt_mpdu = ieee80211_ccmp_encrypt,
509 .decrypt_mpdu = ieee80211_ccmp_decrypt,
510 .encrypt_msdu = NULL,
511 .decrypt_msdu = NULL,
512 .set_key = ieee80211_ccmp_set_key,
513 .get_key = ieee80211_ccmp_get_key,
514 .print_stats = ieee80211_ccmp_print_stats,
515 .extra_prefix_len = CCMP_HDR_LEN,
516 .extra_postfix_len = CCMP_MIC_LEN,
517 .owner = THIS_MODULE,
521 int __init ieee80211_crypto_ccmp_init(void)
523 return ieee80211_register_crypto_ops(&ieee80211_crypt_ccmp);
527 void __exit ieee80211_crypto_ccmp_exit(void)
529 ieee80211_unregister_crypto_ops(&ieee80211_crypt_ccmp);
532 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
533 //EXPORT_SYMBOL(ieee80211_ccmp_null);
535 EXPORT_SYMBOL_NOVERS(ieee80211_ccmp_null);
538 //module_init(ieee80211_crypto_ccmp_init);
539 //module_exit(ieee80211_crypto_ccmp_exit);