1
2
3
4
5
6
7
8
9
10
11
12#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13
14
15#include <linux/module.h>
16#include <linux/init.h>
17#include <linux/slab.h>
18#include <linux/random.h>
19#include <linux/skbuff.h>
20#include <linux/string.h>
21
22#include "ieee80211.h"
23
24#include <linux/crypto.h>
25#include <linux/scatterlist.h>
26#include <linux/crc32.h>
27
28MODULE_AUTHOR("Jouni Malinen");
29MODULE_DESCRIPTION("Host AP crypt: WEP");
30MODULE_LICENSE("GPL");
31
32
33
34struct prism2_wep_data {
35 u32 iv;
36#define WEP_KEY_LEN 13
37 u8 key[WEP_KEY_LEN + 1];
38 u8 key_len;
39 u8 key_idx;
40 struct crypto_blkcipher *tx_tfm;
41 struct crypto_blkcipher *rx_tfm;
42};
43
44
45static void *prism2_wep_init(int keyidx)
46{
47 struct prism2_wep_data *priv;
48
49 priv = kzalloc(sizeof(*priv), GFP_ATOMIC);
50 if (priv == NULL)
51 goto fail;
52 priv->key_idx = keyidx;
53 priv->tx_tfm = crypto_alloc_blkcipher("ecb(arc4)", 0, CRYPTO_ALG_ASYNC);
54 if (IS_ERR(priv->tx_tfm)) {
55 pr_debug("could not allocate crypto API arc4\n");
56 priv->tx_tfm = NULL;
57 goto fail;
58 }
59 priv->rx_tfm = crypto_alloc_blkcipher("ecb(arc4)", 0, CRYPTO_ALG_ASYNC);
60 if (IS_ERR(priv->rx_tfm)) {
61 pr_debug("could not allocate crypto API arc4\n");
62 priv->rx_tfm = NULL;
63 goto fail;
64 }
65
66
67 get_random_bytes(&priv->iv, 4);
68
69 return priv;
70
71fail:
72 if (priv) {
73 if (priv->tx_tfm)
74 crypto_free_blkcipher(priv->tx_tfm);
75 if (priv->rx_tfm)
76 crypto_free_blkcipher(priv->rx_tfm);
77 kfree(priv);
78 }
79
80 return NULL;
81}
82
83
84static void prism2_wep_deinit(void *priv)
85{
86 struct prism2_wep_data *_priv = priv;
87
88 if (_priv) {
89 if (_priv->tx_tfm)
90 crypto_free_blkcipher(_priv->tx_tfm);
91 if (_priv->rx_tfm)
92 crypto_free_blkcipher(_priv->rx_tfm);
93 }
94
95 kfree(priv);
96}
97
98
99
100
101
102
103
104
105static int prism2_wep_encrypt(struct sk_buff *skb, int hdr_len, void *priv)
106{
107 struct prism2_wep_data *wep = priv;
108 struct blkcipher_desc desc = { .tfm = wep->tx_tfm };
109 u32 klen, len;
110 u8 key[WEP_KEY_LEN + 3];
111 u8 *pos;
112 u32 crc;
113 u8 *icv;
114 struct scatterlist sg;
115
116 if (skb_headroom(skb) < 4 || skb_tailroom(skb) < 4 ||
117 skb->len < hdr_len)
118 return -1;
119
120 len = skb->len - hdr_len;
121 pos = skb_push(skb, 4);
122 memmove(pos, pos + 4, hdr_len);
123 pos += hdr_len;
124
125 klen = 3 + wep->key_len;
126
127 wep->iv++;
128
129
130
131
132 if ((wep->iv & 0xff00) == 0xff00) {
133 u8 B = (wep->iv >> 16) & 0xff;
134 if (B >= 3 && B < klen)
135 wep->iv += 0x0100;
136 }
137
138
139 *pos++ = key[0] = (wep->iv >> 16) & 0xff;
140 *pos++ = key[1] = (wep->iv >> 8) & 0xff;
141 *pos++ = key[2] = wep->iv & 0xff;
142 *pos++ = wep->key_idx << 6;
143
144
145 memcpy(key + 3, wep->key, wep->key_len);
146
147
148 crc = ~crc32_le(~0, pos, len);
149 icv = skb_put(skb, 4);
150 icv[0] = crc;
151 icv[1] = crc >> 8;
152 icv[2] = crc >> 16;
153 icv[3] = crc >> 24;
154
155 crypto_blkcipher_setkey(wep->tx_tfm, key, klen);
156 sg_init_one(&sg, pos, len + 4);
157
158 return crypto_blkcipher_encrypt(&desc, &sg, &sg, len + 4);
159}
160
161
162
163
164
165
166
167
168
169static int prism2_wep_decrypt(struct sk_buff *skb, int hdr_len, void *priv)
170{
171 struct prism2_wep_data *wep = priv;
172 struct blkcipher_desc desc = { .tfm = wep->rx_tfm };
173 u32 klen, plen;
174 u8 key[WEP_KEY_LEN + 3];
175 u8 keyidx, *pos;
176 u32 crc;
177 u8 icv[4];
178 struct scatterlist sg;
179
180 if (skb->len < hdr_len + 8)
181 return -1;
182
183 pos = skb->data + hdr_len;
184 key[0] = *pos++;
185 key[1] = *pos++;
186 key[2] = *pos++;
187 keyidx = *pos++ >> 6;
188 if (keyidx != wep->key_idx)
189 return -1;
190
191 klen = 3 + wep->key_len;
192
193
194 memcpy(key + 3, wep->key, wep->key_len);
195
196
197 plen = skb->len - hdr_len - 8;
198
199 crypto_blkcipher_setkey(wep->rx_tfm, key, klen);
200 sg_init_one(&sg, pos, plen + 4);
201
202 if (crypto_blkcipher_decrypt(&desc, &sg, &sg, plen + 4))
203 return -7;
204
205 crc = ~crc32_le(~0, pos, plen);
206 icv[0] = crc;
207 icv[1] = crc >> 8;
208 icv[2] = crc >> 16;
209 icv[3] = crc >> 24;
210
211 if (memcmp(icv, pos + plen, 4) != 0) {
212
213 return -2;
214 }
215
216
217 memmove(skb->data + 4, skb->data, hdr_len);
218 skb_pull(skb, 4);
219 skb_trim(skb, skb->len - 4);
220 return 0;
221}
222
223
224static int prism2_wep_set_key(void *key, int len, u8 *seq, void *priv)
225{
226 struct prism2_wep_data *wep = priv;
227
228 if (len < 0 || len > WEP_KEY_LEN)
229 return -1;
230
231 memcpy(wep->key, key, len);
232 wep->key_len = len;
233
234 return 0;
235}
236
237
238static int prism2_wep_get_key(void *key, int len, u8 *seq, void *priv)
239{
240 struct prism2_wep_data *wep = priv;
241
242 if (len < wep->key_len)
243 return -1;
244
245 memcpy(key, wep->key, wep->key_len);
246
247 return wep->key_len;
248}
249
250
251static char *prism2_wep_print_stats(char *p, void *priv)
252{
253 struct prism2_wep_data *wep = priv;
254 p += sprintf(p, "key[%d] alg=WEP len=%d\n",
255 wep->key_idx, wep->key_len);
256 return p;
257}
258
259
260static struct ieee80211_crypto_ops ieee80211_crypt_wep = {
261 .name = "WEP",
262 .init = prism2_wep_init,
263 .deinit = prism2_wep_deinit,
264 .encrypt_mpdu = prism2_wep_encrypt,
265 .decrypt_mpdu = prism2_wep_decrypt,
266 .encrypt_msdu = NULL,
267 .decrypt_msdu = NULL,
268 .set_key = prism2_wep_set_key,
269 .get_key = prism2_wep_get_key,
270 .print_stats = prism2_wep_print_stats,
271 .extra_prefix_len = 4,
272 .extra_postfix_len = 4,
273 .owner = THIS_MODULE,
274};
275
276
277int ieee80211_crypto_wep_init(void)
278{
279 return ieee80211_register_crypto_ops(&ieee80211_crypt_wep);
280}
281
282
283void ieee80211_crypto_wep_exit(void)
284{
285 ieee80211_unregister_crypto_ops(&ieee80211_crypt_wep);
286}
287
288
289void ieee80211_wep_null(void)
290{
291
292 return;
293}
294