[infiniband] Use "%#lx" as format specifier for queue pair numbers
[ipxe.git] / src / net / 80211 / wep.c
1 /*
2 * Copyright (c) 2009 Joshua Oreman <oremanj@rwcr.net>.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License as
6 * published by the Free Software Foundation; either version 2 of the
7 * License, or any later version.
8 *
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17 * 02110-1301, USA.
18 */
19
20 FILE_LICENCE ( GPL2_OR_LATER );
21
22 #include <ipxe/net80211.h>
23 #include <ipxe/sec80211.h>
24 #include <ipxe/crypto.h>
25 #include <ipxe/arc4.h>
26 #include <ipxe/crc32.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <errno.h>
30
31 /** @file
32 *
33 * The WEP wireless encryption method (insecure!)
34 *
35 * The data field in a WEP-encrypted packet contains a 3-byte
36 * initialisation vector, one-byte Key ID field (only the bottom two
37 * bits are ever used), encrypted data, and a 4-byte encrypted CRC of
38 * the plaintext data, called the ICV. To decrypt it, the IV is
39 * prepended to the shared key and the data stream (including ICV) is
40 * run through the ARC4 stream cipher; if the ICV matches a CRC32
41 * calculated on the plaintext, the packet is valid.
42 *
43 * For efficiency and code-size reasons, this file assumes it is
44 * running on a little-endian machine.
45 */
46
47 /** Length of WEP initialisation vector */
48 #define WEP_IV_LEN 3
49
50 /** Length of WEP key ID byte */
51 #define WEP_KID_LEN 1
52
53 /** Length of WEP ICV checksum */
54 #define WEP_ICV_LEN 4
55
56 /** Maximum length of WEP key */
57 #define WEP_MAX_KEY 16
58
59 /** Amount of data placed before the encrypted bytes */
60 #define WEP_HEADER_LEN 4
61
62 /** Amount of data placed after the encrypted bytes */
63 #define WEP_TRAILER_LEN 4
64
65 /** Total WEP overhead bytes */
66 #define WEP_OVERHEAD 8
67
68 /** Context for WEP encryption and decryption */
69 struct wep_ctx
70 {
71 /** Encoded WEP key
72 *
73 * The actual key bytes are stored beginning at offset 3, to
74 * leave room for easily inserting the IV before a particular
75 * operation.
76 */
77 u8 key[WEP_IV_LEN + WEP_MAX_KEY];
78
79 /** Length of WEP key (not including IV bytes) */
80 int keylen;
81
82 /** ARC4 context */
83 struct arc4_ctx arc4;
84 };
85
86 /**
87 * Initialize WEP algorithm
88 *
89 * @v crypto 802.11 cryptographic algorithm
90 * @v key WEP key to use
91 * @v keylen Length of WEP key
92 * @v rsc Initial receive sequence counter (unused)
93 * @ret rc Return status code
94 *
95 * Standard key lengths are 5 and 13 bytes; 16-byte keys are
96 * occasionally supported as an extension to the standard.
97 */
98 static int wep_init ( struct net80211_crypto *crypto, const void *key,
99 int keylen, const void *rsc __unused )
100 {
101 struct wep_ctx *ctx = crypto->priv;
102
103 ctx->keylen = ( keylen > WEP_MAX_KEY ? WEP_MAX_KEY : keylen );
104 memcpy ( ctx->key + WEP_IV_LEN, key, ctx->keylen );
105
106 return 0;
107 }
108
109 /**
110 * Encrypt packet using WEP
111 *
112 * @v crypto 802.11 cryptographic algorithm
113 * @v iob I/O buffer of plaintext packet
114 * @ret eiob Newly allocated I/O buffer for encrypted packet, or NULL
115 *
116 * If memory allocation fails, @c NULL is returned.
117 */
118 static struct io_buffer * wep_encrypt ( struct net80211_crypto *crypto,
119 struct io_buffer *iob )
120 {
121 struct wep_ctx *ctx = crypto->priv;
122 struct io_buffer *eiob;
123 struct ieee80211_frame *hdr;
124 const int hdrlen = IEEE80211_TYP_FRAME_HEADER_LEN;
125 int datalen = iob_len ( iob ) - hdrlen;
126 int newlen = hdrlen + datalen + WEP_OVERHEAD;
127 u32 iv, icv;
128
129 eiob = alloc_iob ( newlen );
130 if ( ! eiob )
131 return NULL;
132
133 memcpy ( iob_put ( eiob, hdrlen ), iob->data, hdrlen );
134 hdr = eiob->data;
135 hdr->fc |= IEEE80211_FC_PROTECTED;
136
137 /* Calculate IV, put it in the header (with key ID byte = 0), and
138 set it up at the start of the encryption key. */
139 iv = random() & 0xffffff; /* IV in bottom 3 bytes, top byte = KID = 0 */
140 memcpy ( iob_put ( eiob, WEP_HEADER_LEN ), &iv, WEP_HEADER_LEN );
141 memcpy ( ctx->key, &iv, WEP_IV_LEN );
142
143 /* Encrypt the data using RC4 */
144 cipher_setkey ( &arc4_algorithm, &ctx->arc4, ctx->key,
145 ctx->keylen + WEP_IV_LEN );
146 cipher_encrypt ( &arc4_algorithm, &ctx->arc4, iob->data + hdrlen,
147 iob_put ( eiob, datalen ), datalen );
148
149 /* Add ICV */
150 icv = ~crc32_le ( ~0, iob->data + hdrlen, datalen );
151 cipher_encrypt ( &arc4_algorithm, &ctx->arc4, &icv,
152 iob_put ( eiob, WEP_ICV_LEN ), WEP_ICV_LEN );
153
154 return eiob;
155 }
156
157 /**
158 * Decrypt packet using WEP
159 *
160 * @v crypto 802.11 cryptographic algorithm
161 * @v eiob I/O buffer of encrypted packet
162 * @ret iob Newly allocated I/O buffer for plaintext packet, or NULL
163 *
164 * If a consistency check for the decryption fails (usually indicating
165 * an invalid key), @c NULL is returned.
166 */
167 static struct io_buffer * wep_decrypt ( struct net80211_crypto *crypto,
168 struct io_buffer *eiob )
169 {
170 struct wep_ctx *ctx = crypto->priv;
171 struct io_buffer *iob;
172 struct ieee80211_frame *hdr;
173 const int hdrlen = IEEE80211_TYP_FRAME_HEADER_LEN;
174 int datalen = iob_len ( eiob ) - hdrlen - WEP_OVERHEAD;
175 int newlen = hdrlen + datalen;
176 u32 iv, icv, crc;
177
178 iob = alloc_iob ( newlen );
179 if ( ! iob )
180 return NULL;
181
182 memcpy ( iob_put ( iob, hdrlen ), eiob->data, hdrlen );
183 hdr = iob->data;
184 hdr->fc &= ~IEEE80211_FC_PROTECTED;
185
186 /* Strip off IV and use it to initialize cryptosystem */
187 memcpy ( &iv, eiob->data + hdrlen, 4 );
188 iv &= 0xffffff; /* ignore key ID byte */
189 memcpy ( ctx->key, &iv, WEP_IV_LEN );
190
191 /* Decrypt the data using RC4 */
192 cipher_setkey ( &arc4_algorithm, &ctx->arc4, ctx->key,
193 ctx->keylen + WEP_IV_LEN );
194 cipher_decrypt ( &arc4_algorithm, &ctx->arc4, eiob->data + hdrlen +
195 WEP_HEADER_LEN, iob_put ( iob, datalen ), datalen );
196
197 /* Strip off ICV and verify it */
198 cipher_decrypt ( &arc4_algorithm, &ctx->arc4, eiob->data + hdrlen +
199 WEP_HEADER_LEN + datalen, &icv, WEP_ICV_LEN );
200 crc = ~crc32_le ( ~0, iob->data + hdrlen, datalen );
201 if ( crc != icv ) {
202 DBGC ( crypto, "WEP %p CRC mismatch: expect %08x, get %08x\n",
203 crypto, icv, crc );
204 free_iob ( iob );
205 return NULL;
206 }
207 return iob;
208 }
209
210 /** WEP cryptosystem for 802.11 */
211 struct net80211_crypto wep_crypto __net80211_crypto = {
212 .algorithm = NET80211_CRYPT_WEP,
213 .init = wep_init,
214 .encrypt = wep_encrypt,
215 .decrypt = wep_decrypt,
216 .priv_len = sizeof ( struct wep_ctx ),
217 };
218
219 /**
220 * Initialize trivial 802.11 security handshaker
221 *
222 * @v dev 802.11 device
223 * @v ctx Security handshaker
224 *
225 * This simply fetches a WEP key from netX/key, and if it exists,
226 * installs WEP cryptography on the 802.11 device. No real handshaking
227 * is performed.
228 */
229 static int trivial_init ( struct net80211_device *dev )
230 {
231 u8 key[WEP_MAX_KEY]; /* support up to 128-bit keys */
232 int len;
233 int rc;
234
235 if ( dev->associating &&
236 dev->associating->crypto == NET80211_CRYPT_NONE )
237 return 0; /* no crypto? OK. */
238
239 len = fetch_raw_setting ( netdev_settings ( dev->netdev ),
240 &net80211_key_setting, key, WEP_MAX_KEY );
241
242 if ( len <= 0 ) {
243 DBGC ( dev, "802.11 %p cannot do WEP without a key\n", dev );
244 return -EACCES;
245 }
246
247 /* Full 128-bit keys are a nonstandard extension, but they're
248 utterly trivial to support, so we do. */
249 if ( len != 5 && len != 13 && len != 16 ) {
250 DBGC ( dev, "802.11 %p invalid WEP key length %d\n",
251 dev, len );
252 return -EINVAL;
253 }
254
255 DBGC ( dev, "802.11 %p installing %d-bit WEP\n", dev, len * 8 );
256
257 rc = sec80211_install ( &dev->crypto, NET80211_CRYPT_WEP, key, len,
258 NULL );
259 if ( rc < 0 )
260 return rc;
261
262 return 0;
263 }
264
265 /**
266 * Check for key change on trivial 802.11 security handshaker
267 *
268 * @v dev 802.11 device
269 * @v ctx Security handshaker
270 */
271 static int trivial_change_key ( struct net80211_device *dev )
272 {
273 u8 key[WEP_MAX_KEY];
274 int len;
275 int change = 0;
276
277 /* If going from WEP to clear, or something else to WEP, reassociate. */
278 if ( ! dev->crypto || ( dev->crypto->init != wep_init ) )
279 change ^= 1;
280
281 len = fetch_raw_setting ( netdev_settings ( dev->netdev ),
282 &net80211_key_setting, key, WEP_MAX_KEY );
283 if ( len <= 0 )
284 change ^= 1;
285
286 /* Changing crypto type => return nonzero to reassociate. */
287 if ( change )
288 return -EINVAL;
289
290 /* Going from no crypto to still no crypto => nothing to do. */
291 if ( len <= 0 )
292 return 0;
293
294 /* Otherwise, reinitialise WEP with new key. */
295 return wep_init ( dev->crypto, key, len, NULL );
296 }
297
298 /** Trivial 802.11 security handshaker */
299 struct net80211_handshaker trivial_handshaker __net80211_handshaker = {
300 .protocol = NET80211_SECPROT_NONE,
301 .init = trivial_init,
302 .change_key = trivial_change_key,
303 .priv_len = 0,
304 };