aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/wireless/hostap/hostap_crypt_wep.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/net/wireless/hostap/hostap_crypt_wep.c')
-rw-r--r--drivers/net/wireless/hostap/hostap_crypt_wep.c283
1 files changed, 0 insertions, 283 deletions
diff --git a/drivers/net/wireless/hostap/hostap_crypt_wep.c b/drivers/net/wireless/hostap/hostap_crypt_wep.c
deleted file mode 100644
index 66c403f17631..000000000000
--- a/drivers/net/wireless/hostap/hostap_crypt_wep.c
+++ /dev/null
@@ -1,283 +0,0 @@
1/*
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 "hostap_crypt.h"
22#include "hostap_config.h"
23
24#ifndef CONFIG_CRYPTO
25#error CONFIG_CRYPTO is required to build this module.
26#endif
27#include <linux/crypto.h>
28#include <asm/scatterlist.h>
29#include <linux/crc32.h>
30
31MODULE_AUTHOR("Jouni Malinen");
32MODULE_DESCRIPTION("Host AP crypt: WEP");
33MODULE_LICENSE("GPL");
34MODULE_VERSION(PRISM2_VERSION);
35
36
37struct prism2_wep_data {
38 u32 iv;
39#define WEP_KEY_LEN 13
40 u8 key[WEP_KEY_LEN + 1];
41 u8 key_len;
42 u8 key_idx;
43 struct crypto_tfm *tfm;
44};
45
46
47static void * prism2_wep_init(int keyidx)
48{
49 struct prism2_wep_data *priv;
50
51 if (!try_module_get(THIS_MODULE))
52 return NULL;
53
54 priv = (struct prism2_wep_data *) kmalloc(sizeof(*priv), GFP_ATOMIC);
55 if (priv == NULL)
56 goto fail;
57 memset(priv, 0, sizeof(*priv));
58 priv->key_idx = keyidx;
59
60 priv->tfm = crypto_alloc_tfm("arc4", 0);
61 if (priv->tfm == NULL) {
62 printk(KERN_DEBUG "hostap_crypt_wep: could not allocate "
63 "crypto API arc4\n");
64 goto fail;
65 }
66
67 /* start WEP IV from a random value */
68 get_random_bytes(&priv->iv, 4);
69
70 return priv;
71
72fail:
73 if (priv) {
74 if (priv->tfm)
75 crypto_free_tfm(priv->tfm);
76 kfree(priv);
77 }
78 module_put(THIS_MODULE);
79 return NULL;
80}
81
82
83static void prism2_wep_deinit(void *priv)
84{
85 struct prism2_wep_data *_priv = priv;
86 if (_priv && _priv->tfm)
87 crypto_free_tfm(_priv->tfm);
88 kfree(priv);
89 module_put(THIS_MODULE);
90}
91
92
93/* Perform WEP encryption on given skb that has at least 4 bytes of headroom
94 * for IV and 4 bytes of tailroom for ICV. Both IV and ICV will be transmitted,
95 * so the payload length increases with 8 bytes.
96 *
97 * WEP frame payload: IV + TX key idx, RC4(data), ICV = RC4(CRC32(data))
98 */
99static int prism2_wep_encrypt(struct sk_buff *skb, int hdr_len, void *priv)
100{
101 struct prism2_wep_data *wep = priv;
102 u32 crc, klen, len;
103 u8 key[WEP_KEY_LEN + 3];
104 u8 *pos, *icv;
105 struct scatterlist sg;
106
107 if (skb_headroom(skb) < 4 || skb_tailroom(skb) < 4 ||
108 skb->len < hdr_len)
109 return -1;
110
111 len = skb->len - hdr_len;
112 pos = skb_push(skb, 4);
113 memmove(pos, pos + 4, hdr_len);
114 pos += hdr_len;
115
116 klen = 3 + wep->key_len;
117
118 wep->iv++;
119
120 /* Fluhrer, Mantin, and Shamir have reported weaknesses in the key
121 * scheduling algorithm of RC4. At least IVs (KeyByte + 3, 0xff, N)
122 * can be used to speedup attacks, so avoid using them. */
123 if ((wep->iv & 0xff00) == 0xff00) {
124 u8 B = (wep->iv >> 16) & 0xff;
125 if (B >= 3 && B < klen)
126 wep->iv += 0x0100;
127 }
128
129 /* Prepend 24-bit IV to RC4 key and TX frame */
130 *pos++ = key[0] = (wep->iv >> 16) & 0xff;
131 *pos++ = key[1] = (wep->iv >> 8) & 0xff;
132 *pos++ = key[2] = wep->iv & 0xff;
133 *pos++ = wep->key_idx << 6;
134
135 /* Copy rest of the WEP key (the secret part) */
136 memcpy(key + 3, wep->key, wep->key_len);
137
138 /* Append little-endian CRC32 and encrypt it to produce ICV */
139 crc = ~crc32_le(~0, pos, len);
140 icv = skb_put(skb, 4);
141 icv[0] = crc;
142 icv[1] = crc >> 8;
143 icv[2] = crc >> 16;
144 icv[3] = crc >> 24;
145
146 crypto_cipher_setkey(wep->tfm, key, klen);
147 sg.page = virt_to_page(pos);
148 sg.offset = offset_in_page(pos);
149 sg.length = len + 4;
150 crypto_cipher_encrypt(wep->tfm, &sg, &sg, len + 4);
151
152 return 0;
153}
154
155
156/* Perform WEP decryption on given buffer. Buffer includes whole WEP part of
157 * the frame: IV (4 bytes), encrypted payload (including SNAP header),
158 * ICV (4 bytes). len includes both IV and ICV.
159 *
160 * Returns 0 if frame was decrypted successfully and ICV was correct and -1 on
161 * failure. If frame is OK, IV and ICV will be removed.
162 */
163static int prism2_wep_decrypt(struct sk_buff *skb, int hdr_len, void *priv)
164{
165 struct prism2_wep_data *wep = priv;
166 u32 crc, klen, plen;
167 u8 key[WEP_KEY_LEN + 3];
168 u8 keyidx, *pos, icv[4];
169 struct scatterlist sg;
170
171 if (skb->len < hdr_len + 8)
172 return -1;
173
174 pos = skb->data + hdr_len;
175 key[0] = *pos++;
176 key[1] = *pos++;
177 key[2] = *pos++;
178 keyidx = *pos++ >> 6;
179 if (keyidx != wep->key_idx)
180 return -1;
181
182 klen = 3 + wep->key_len;
183
184 /* Copy rest of the WEP key (the secret part) */
185 memcpy(key + 3, wep->key, wep->key_len);
186
187 /* Apply RC4 to data and compute CRC32 over decrypted data */
188 plen = skb->len - hdr_len - 8;
189
190 crypto_cipher_setkey(wep->tfm, key, klen);
191 sg.page = virt_to_page(pos);
192 sg.offset = offset_in_page(pos);
193 sg.length = plen + 4;
194 crypto_cipher_decrypt(wep->tfm, &sg, &sg, plen + 4);
195
196 crc = ~crc32_le(~0, pos, plen);
197 icv[0] = crc;
198 icv[1] = crc >> 8;
199 icv[2] = crc >> 16;
200 icv[3] = crc >> 24;
201 if (memcmp(icv, pos + plen, 4) != 0) {
202 /* ICV mismatch - drop frame */
203 return -2;
204 }
205
206 /* Remove IV and ICV */
207 memmove(skb->data + 4, skb->data, hdr_len);
208 skb_pull(skb, 4);
209 skb_trim(skb, skb->len - 4);
210
211 return 0;
212}
213
214
215static int prism2_wep_set_key(void *key, int len, u8 *seq, void *priv)
216{
217 struct prism2_wep_data *wep = priv;
218
219 if (len < 0 || len > WEP_KEY_LEN)
220 return -1;
221
222 memcpy(wep->key, key, len);
223 wep->key_len = len;
224
225 return 0;
226}
227
228
229static int prism2_wep_get_key(void *key, int len, u8 *seq, void *priv)
230{
231 struct prism2_wep_data *wep = priv;
232
233 if (len < wep->key_len)
234 return -1;
235
236 memcpy(key, wep->key, wep->key_len);
237
238 return wep->key_len;
239}
240
241
242static char * prism2_wep_print_stats(char *p, void *priv)
243{
244 struct prism2_wep_data *wep = priv;
245 p += sprintf(p, "key[%d] alg=WEP len=%d\n",
246 wep->key_idx, wep->key_len);
247 return p;
248}
249
250
251static struct hostap_crypto_ops hostap_crypt_wep = {
252 .name = "WEP",
253 .init = prism2_wep_init,
254 .deinit = prism2_wep_deinit,
255 .encrypt_mpdu = prism2_wep_encrypt,
256 .decrypt_mpdu = prism2_wep_decrypt,
257 .encrypt_msdu = NULL,
258 .decrypt_msdu = NULL,
259 .set_key = prism2_wep_set_key,
260 .get_key = prism2_wep_get_key,
261 .print_stats = prism2_wep_print_stats,
262 .extra_prefix_len = 4 /* IV */,
263 .extra_postfix_len = 4 /* ICV */
264};
265
266
267static int __init hostap_crypto_wep_init(void)
268{
269 if (hostap_register_crypto_ops(&hostap_crypt_wep) < 0)
270 return -1;
271
272 return 0;
273}
274
275
276static void __exit hostap_crypto_wep_exit(void)
277{
278 hostap_unregister_crypto_ops(&hostap_crypt_wep);
279}
280
281
282module_init(hostap_crypto_wep_init);
283module_exit(hostap_crypto_wep_exit);
generated by cgit v1.2.2 (git 2.25.0) at 2025-10-15 14:09:14 -0400