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