blob: 7c08ed2f2628f4dd439465f0abdd90358a8e39a9 [file] [log] [blame]
Jeff Garzikb4538722005-05-12 22:48:20 -04001/*
2 * Host AP crypt: host-based WEP encryption implementation for Host AP driver
3 *
4 * Copyright (c) 2002-2004, Jouni Malinen <jkmaline@cc.hut.fi>
5 *
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
9 * more details.
10 */
11
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 <asm/string.h>
20
21#include <net/ieee80211.h>
22
Jeff Garzikb4538722005-05-12 22:48:20 -040023#include <linux/crypto.h>
24#include <asm/scatterlist.h>
25#include <linux/crc32.h>
26
27MODULE_AUTHOR("Jouni Malinen");
28MODULE_DESCRIPTION("Host AP crypt: WEP");
29MODULE_LICENSE("GPL");
30
Jeff Garzikb4538722005-05-12 22:48:20 -040031struct prism2_wep_data {
32 u32 iv;
33#define WEP_KEY_LEN 13
34 u8 key[WEP_KEY_LEN + 1];
35 u8 key_len;
36 u8 key_idx;
37 struct crypto_tfm *tfm;
38};
39
James Ketrenos6eb6edf2005-09-22 10:34:15 +000040static void *prism2_wep_init(int keyidx)
Jeff Garzikb4538722005-05-12 22:48:20 -040041{
42 struct prism2_wep_data *priv;
43
44 priv = kmalloc(sizeof(*priv), GFP_ATOMIC);
45 if (priv == NULL)
46 goto fail;
47 memset(priv, 0, sizeof(*priv));
48 priv->key_idx = keyidx;
49
50 priv->tfm = crypto_alloc_tfm("arc4", 0);
51 if (priv->tfm == NULL) {
52 printk(KERN_DEBUG "ieee80211_crypt_wep: could not allocate "
53 "crypto API arc4\n");
54 goto fail;
55 }
56
57 /* start WEP IV from a random value */
58 get_random_bytes(&priv->iv, 4);
59
60 return priv;
61
Jeff Garzik0edd5b42005-09-07 00:48:31 -040062 fail:
Jeff Garzikb4538722005-05-12 22:48:20 -040063 if (priv) {
64 if (priv->tfm)
65 crypto_free_tfm(priv->tfm);
66 kfree(priv);
67 }
68 return NULL;
69}
70
Jeff Garzikb4538722005-05-12 22:48:20 -040071static void prism2_wep_deinit(void *priv)
72{
73 struct prism2_wep_data *_priv = priv;
74 if (_priv && _priv->tfm)
75 crypto_free_tfm(_priv->tfm);
76 kfree(priv);
77}
78
Jeff Garzikb4538722005-05-12 22:48:20 -040079/* Perform WEP encryption on given skb that has at least 4 bytes of headroom
80 * for IV and 4 bytes of tailroom for ICV. Both IV and ICV will be transmitted,
81 * so the payload length increases with 8 bytes.
82 *
83 * WEP frame payload: IV + TX key idx, RC4(data), ICV = RC4(CRC32(data))
84 */
85static int prism2_wep_encrypt(struct sk_buff *skb, int hdr_len, void *priv)
86{
87 struct prism2_wep_data *wep = priv;
88 u32 crc, klen, len;
89 u8 key[WEP_KEY_LEN + 3];
90 u8 *pos, *icv;
91 struct scatterlist sg;
92
93 if (skb_headroom(skb) < 4 || skb_tailroom(skb) < 4 ||
94 skb->len < hdr_len)
95 return -1;
96
97 len = skb->len - hdr_len;
98 pos = skb_push(skb, 4);
99 memmove(pos, pos + 4, hdr_len);
100 pos += hdr_len;
101
102 klen = 3 + wep->key_len;
103
104 wep->iv++;
105
106 /* Fluhrer, Mantin, and Shamir have reported weaknesses in the key
107 * scheduling algorithm of RC4. At least IVs (KeyByte + 3, 0xff, N)
108 * can be used to speedup attacks, so avoid using them. */
109 if ((wep->iv & 0xff00) == 0xff00) {
110 u8 B = (wep->iv >> 16) & 0xff;
111 if (B >= 3 && B < klen)
112 wep->iv += 0x0100;
113 }
114
115 /* Prepend 24-bit IV to RC4 key and TX frame */
116 *pos++ = key[0] = (wep->iv >> 16) & 0xff;
117 *pos++ = key[1] = (wep->iv >> 8) & 0xff;
118 *pos++ = key[2] = wep->iv & 0xff;
119 *pos++ = wep->key_idx << 6;
120
121 /* Copy rest of the WEP key (the secret part) */
122 memcpy(key + 3, wep->key, wep->key_len);
123
124 /* Append little-endian CRC32 and encrypt it to produce ICV */
125 crc = ~crc32_le(~0, pos, len);
126 icv = skb_put(skb, 4);
127 icv[0] = crc;
128 icv[1] = crc >> 8;
129 icv[2] = crc >> 16;
130 icv[3] = crc >> 24;
131
132 crypto_cipher_setkey(wep->tfm, key, klen);
133 sg.page = virt_to_page(pos);
134 sg.offset = offset_in_page(pos);
135 sg.length = len + 4;
136 crypto_cipher_encrypt(wep->tfm, &sg, &sg, len + 4);
137
138 return 0;
139}
140
Jeff Garzikb4538722005-05-12 22:48:20 -0400141/* Perform WEP decryption on given buffer. Buffer includes whole WEP part of
142 * the frame: IV (4 bytes), encrypted payload (including SNAP header),
143 * ICV (4 bytes). len includes both IV and ICV.
144 *
145 * Returns 0 if frame was decrypted successfully and ICV was correct and -1 on
146 * failure. If frame is OK, IV and ICV will be removed.
147 */
148static int prism2_wep_decrypt(struct sk_buff *skb, int hdr_len, void *priv)
149{
150 struct prism2_wep_data *wep = priv;
151 u32 crc, klen, plen;
152 u8 key[WEP_KEY_LEN + 3];
153 u8 keyidx, *pos, icv[4];
154 struct scatterlist sg;
155
156 if (skb->len < hdr_len + 8)
157 return -1;
158
159 pos = skb->data + hdr_len;
160 key[0] = *pos++;
161 key[1] = *pos++;
162 key[2] = *pos++;
163 keyidx = *pos++ >> 6;
164 if (keyidx != wep->key_idx)
165 return -1;
166
167 klen = 3 + wep->key_len;
168
169 /* Copy rest of the WEP key (the secret part) */
170 memcpy(key + 3, wep->key, wep->key_len);
171
172 /* Apply RC4 to data and compute CRC32 over decrypted data */
173 plen = skb->len - hdr_len - 8;
174
175 crypto_cipher_setkey(wep->tfm, key, klen);
176 sg.page = virt_to_page(pos);
177 sg.offset = offset_in_page(pos);
178 sg.length = plen + 4;
179 crypto_cipher_decrypt(wep->tfm, &sg, &sg, plen + 4);
180
181 crc = ~crc32_le(~0, pos, plen);
182 icv[0] = crc;
183 icv[1] = crc >> 8;
184 icv[2] = crc >> 16;
185 icv[3] = crc >> 24;
186 if (memcmp(icv, pos + plen, 4) != 0) {
187 /* ICV mismatch - drop frame */
188 return -2;
189 }
190
191 /* Remove IV and ICV */
192 memmove(skb->data + 4, skb->data, hdr_len);
193 skb_pull(skb, 4);
194 skb_trim(skb, skb->len - 4);
195
196 return 0;
197}
198
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400199static int prism2_wep_set_key(void *key, int len, u8 * seq, void *priv)
Jeff Garzikb4538722005-05-12 22:48:20 -0400200{
201 struct prism2_wep_data *wep = priv;
202
203 if (len < 0 || len > WEP_KEY_LEN)
204 return -1;
205
206 memcpy(wep->key, key, len);
207 wep->key_len = len;
208
209 return 0;
210}
211
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400212static int prism2_wep_get_key(void *key, int len, u8 * seq, void *priv)
Jeff Garzikb4538722005-05-12 22:48:20 -0400213{
214 struct prism2_wep_data *wep = priv;
215
216 if (len < wep->key_len)
217 return -1;
218
219 memcpy(key, wep->key, wep->key_len);
220
221 return wep->key_len;
222}
223
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400224static char *prism2_wep_print_stats(char *p, void *priv)
Jeff Garzikb4538722005-05-12 22:48:20 -0400225{
226 struct prism2_wep_data *wep = priv;
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400227 p += sprintf(p, "key[%d] alg=WEP len=%d\n", wep->key_idx, wep->key_len);
Jeff Garzikb4538722005-05-12 22:48:20 -0400228 return p;
229}
230
Jeff Garzikb4538722005-05-12 22:48:20 -0400231static struct ieee80211_crypto_ops ieee80211_crypt_wep = {
James Ketrenos74079fd2005-09-13 17:35:21 -0500232 .name = "WEP",
233 .init = prism2_wep_init,
234 .deinit = prism2_wep_deinit,
235 .encrypt_mpdu = prism2_wep_encrypt,
236 .decrypt_mpdu = prism2_wep_decrypt,
237 .encrypt_msdu = NULL,
238 .decrypt_msdu = NULL,
239 .set_key = prism2_wep_set_key,
240 .get_key = prism2_wep_get_key,
241 .print_stats = prism2_wep_print_stats,
James Ketrenos1264fc02005-09-21 11:54:53 -0500242 .extra_mpdu_prefix_len = 4, /* IV */
243 .extra_mpdu_postfix_len = 4, /* ICV */
James Ketrenos74079fd2005-09-13 17:35:21 -0500244 .owner = THIS_MODULE,
Jeff Garzikb4538722005-05-12 22:48:20 -0400245};
246
Jeff Garzikb4538722005-05-12 22:48:20 -0400247static int __init ieee80211_crypto_wep_init(void)
248{
249 return ieee80211_register_crypto_ops(&ieee80211_crypt_wep);
250}
251
Jeff Garzikb4538722005-05-12 22:48:20 -0400252static void __exit ieee80211_crypto_wep_exit(void)
253{
254 ieee80211_unregister_crypto_ops(&ieee80211_crypt_wep);
255}
256
Jeff Garzikb4538722005-05-12 22:48:20 -0400257module_init(ieee80211_crypto_wep_init);
258module_exit(ieee80211_crypto_wep_exit);