iPXE
sec80211.c
Go to the documentation of this file.
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 <stdlib.h>
23 #include <string.h>
24 #include <errno.h>
25 #include <ipxe/ieee80211.h>
26 #include <ipxe/net80211.h>
27 #include <ipxe/sec80211.h>
28 
29 /** @file
30  *
31  * General secured-network routines required whenever any secure
32  * network support at all is compiled in. This involves things like
33  * installing keys, determining the type of security used by a probed
34  * network, and some small helper functions that take advantage of
35  * static data in this file.
36  */
37 
38 /* Unsupported cryptosystem error numbers */
39 #define ENOTSUP_WEP __einfo_error ( EINFO_ENOTSUP_WEP )
40 #define EINFO_ENOTSUP_WEP __einfo_uniqify ( EINFO_ENOTSUP, \
41  ( 0x10 | NET80211_CRYPT_WEP ), "WEP not supported" )
42 #define ENOTSUP_TKIP __einfo_error ( EINFO_ENOTSUP_TKIP )
43 #define EINFO_ENOTSUP_TKIP __einfo_uniqify ( EINFO_ENOTSUP, \
44  ( 0x10 | NET80211_CRYPT_TKIP ), "TKIP not supported" )
45 #define ENOTSUP_CCMP __einfo_error ( EINFO_ENOTSUP_CCMP )
46 #define EINFO_ENOTSUP_CCMP __einfo_uniqify ( EINFO_ENOTSUP, \
47  ( 0x10 | NET80211_CRYPT_CCMP ), "CCMP not supported" )
48 #define ENOTSUP_CRYPT( crypt ) \
49  EUNIQ ( EINFO_ENOTSUP, ( 0x10 | (crypt) ), \
50  ENOTSUP_WEP, ENOTSUP_TKIP, ENOTSUP_CCMP )
51 
52 /** Mapping from net80211 crypto/secprot types to RSN OUI descriptors */
54  /** Value of net80211_crypto_alg or net80211_security_proto */
56 
57  /** OUI+type in appropriate byte order, masked to exclude vendor */
59 };
60 
61 /** Magic number in @a oui_type showing end of list */
62 #define END_MAGIC 0xFFFFFFFF
63 
64 /** Mapping between net80211 cryptosystems and 802.11i cipher IDs */
65 static struct descriptor_map rsn_cipher_map[] = {
67  .oui_type = IEEE80211_RSN_CTYPE_WEP40 },
68 
69  { .net80211_type = NET80211_CRYPT_WEP,
70  .oui_type = IEEE80211_RSN_CTYPE_WEP104 },
71 
72  { .net80211_type = NET80211_CRYPT_TKIP,
73  .oui_type = IEEE80211_RSN_CTYPE_TKIP },
74 
75  { .net80211_type = NET80211_CRYPT_CCMP,
76  .oui_type = IEEE80211_RSN_CTYPE_CCMP },
77 
78  { .net80211_type = NET80211_CRYPT_UNKNOWN,
79  .oui_type = END_MAGIC },
80 };
81 
82 /** Mapping between net80211 handshakers and 802.11i AKM IDs */
83 static struct descriptor_map rsn_akm_map[] = {
85  .oui_type = IEEE80211_RSN_ATYPE_8021X },
86 
87  { .net80211_type = NET80211_SECPROT_PSK,
88  .oui_type = IEEE80211_RSN_ATYPE_PSK },
89 
90  { .net80211_type = NET80211_SECPROT_UNKNOWN,
91  .oui_type = END_MAGIC },
92 };
93 
94 
95 /**
96  * Install 802.11 cryptosystem
97  *
98  * @v which Pointer to the cryptosystem structure to install in
99  * @v crypt Cryptosystem ID number
100  * @v key Encryption key to use
101  * @v len Length of encryption key
102  * @v rsc Initial receive sequence counter, if applicable
103  * @ret rc Return status code
104  *
105  * The encryption key will not be accessed via the provided pointer
106  * after this function returns, so you may keep it on the stack.
107  *
108  * @a which must point to either @c dev->crypto (for the normal case
109  * of installing a unicast cryptosystem) or @c dev->gcrypto (to
110  * install a cryptosystem that will be used only for decrypting
111  * group-source frames).
112  */
113 int sec80211_install ( struct net80211_crypto **which,
114  enum net80211_crypto_alg crypt,
115  const void *key, int len, const void *rsc )
116 {
117  struct net80211_crypto *crypto = *which;
118  struct net80211_crypto *tbl_crypto;
119 
120  /* Remove old crypto if it exists */
121  free ( *which );
122  *which = NULL;
123 
124  if ( crypt == NET80211_CRYPT_NONE ) {
125  DBG ( "802.11-Sec not installing null cryptography\n" );
126  return 0;
127  }
128 
129  /* Find cryptosystem to use */
130  for_each_table_entry ( tbl_crypto, NET80211_CRYPTOS ) {
131  if ( tbl_crypto->algorithm == crypt ) {
132  crypto = zalloc ( sizeof ( *crypto ) +
133  tbl_crypto->priv_len );
134  if ( ! crypto ) {
135  DBG ( "802.11-Sec out of memory\n" );
136  return -ENOMEM;
137  }
138 
139  memcpy ( crypto, tbl_crypto, sizeof ( *crypto ) );
140  crypto->priv = ( ( void * ) crypto +
141  sizeof ( *crypto ) );
142  break;
143  }
144  }
145 
146  if ( ! crypto ) {
147  DBG ( "802.11-Sec no support for cryptosystem %d\n", crypt );
148  return -ENOTSUP_CRYPT ( crypt );
149  }
150 
151  *which = crypto;
152 
153  DBG ( "802.11-Sec installing cryptosystem %d as %p with key of "
154  "length %d\n", crypt, crypto, len );
155 
156  return crypto->init ( crypto, key, len, rsc );
157 }
158 
159 
160 /**
161  * Determine net80211 crypto or handshaking type value to return for RSN info
162  *
163  * @v rsnp Pointer to next descriptor count field in RSN IE
164  * @v rsn_end Pointer to end of RSN IE
165  * @v map Descriptor map to use
166  * @v tbl_start Start of linker table to examine for iPXE support
167  * @v tbl_end End of linker table to examine for iPXE support
168  * @ret rsnp Updated to point to first byte after descriptors
169  * @ret map_ent Descriptor map entry of translation to use
170  *
171  * The entries in the linker table must be either net80211_crypto or
172  * net80211_handshaker structures, and @a tbl_stride must be set to
173  * sizeof() the appropriate one.
174  *
175  * This function expects @a rsnp to point at a two-byte descriptor
176  * count followed by a list of four-byte cipher or AKM descriptors; it
177  * will return @c NULL if the input packet is malformed, and otherwise
178  * set @a rsnp to the first byte it has not looked at. It will return
179  * the first cipher in the list that is supported by the current build
180  * of iPXE, or the first of all if none are supported.
181  *
182  * We play rather fast and loose with type checking, because this
183  * function is only called from two well-defined places in the
184  * RSN-checking code. Don't try to use it for anything else.
185  */
186 static struct descriptor_map * rsn_pick_desc ( u8 **rsnp, u8 *rsn_end,
187  struct descriptor_map *map,
188  void *tbl_start, void *tbl_end )
189 {
190  int ndesc;
191  int ok = 0;
192  struct descriptor_map *map_ent, *map_ret = NULL;
193  u8 *rsn = *rsnp;
194  void *tblp;
195  size_t tbl_stride = ( map == rsn_cipher_map ?
196  sizeof ( struct net80211_crypto ) :
197  sizeof ( struct net80211_handshaker ) );
198 
199  if ( map != rsn_cipher_map && map != rsn_akm_map )
200  return NULL;
201 
202  /* Determine which types we support */
203  for ( tblp = tbl_start; tblp < tbl_end; tblp += tbl_stride ) {
204  struct net80211_crypto *crypto = tblp;
205  struct net80211_handshaker *hs = tblp;
206 
207  if ( map == rsn_cipher_map )
208  ok |= ( 1 << crypto->algorithm );
209  else
210  ok |= ( 1 << hs->protocol );
211  }
212 
213  /* RSN sanity checks */
214  if ( rsn + 2 > rsn_end ) {
215  DBG ( "RSN detect: malformed descriptor count\n" );
216  return NULL;
217  }
218 
219  ndesc = *( u16 * ) rsn;
220  rsn += 2;
221 
222  if ( ! ndesc ) {
223  DBG ( "RSN detect: no descriptors\n" );
224  return NULL;
225  }
226 
227  /* Determine which net80211 crypto types are listed */
228  while ( ndesc-- ) {
229  u32 desc;
230 
231  if ( rsn + 4 > rsn_end ) {
232  DBG ( "RSN detect: malformed descriptor (%d left)\n",
233  ndesc );
234  return NULL;
235  }
236 
237  desc = *( u32 * ) rsn;
238  rsn += 4;
239 
240  for ( map_ent = map; map_ent->oui_type != END_MAGIC; map_ent++ )
241  if ( map_ent->oui_type == ( desc & OUI_TYPE_MASK ) )
242  break;
243 
244  /* Use first cipher as a fallback */
245  if ( ! map_ret )
246  map_ret = map_ent;
247 
248  /* Once we find one we support, use it */
249  if ( ok & ( 1 << map_ent->net80211_type ) ) {
250  map_ret = map_ent;
251  break;
252  }
253  }
254 
255  if ( ndesc > 0 )
256  rsn += 4 * ndesc;
257 
258  *rsnp = rsn;
259  return map_ret;
260 }
261 
262 
263 /**
264  * Find the RSN or WPA information element in the provided beacon frame
265  *
266  * @v ie Pointer to first information element to check
267  * @v ie_end Pointer to end of information element space
268  * @ret is_rsn TRUE if returned IE is RSN, FALSE if it's WPA
269  * @ret end Pointer to byte immediately after last byte of data
270  * @ret data Pointer to first byte of data (the `version' field)
271  *
272  * If both an RSN and a WPA information element are found, this
273  * function will return the first one seen, which by ordering rules
274  * should always prefer the newer RSN IE.
275  *
276  * If no RSN or WPA infomration element is found, returns @c NULL and
277  * leaves @a is_rsn and @a end in an undefined state.
278  *
279  * This function will not return a pointer to an information element
280  * that states it extends past the tail of the io_buffer, or whose @a
281  * version field is incorrect.
282  */
283 u8 * sec80211_find_rsn ( union ieee80211_ie *ie, void *ie_end,
284  int *is_rsn, u8 **end )
285 {
286  u8 *rsn = NULL;
287 
288  if ( ! ieee80211_ie_bound ( ie, ie_end ) )
289  return NULL;
290 
291  while ( ie ) {
292  if ( ie->id == IEEE80211_IE_VENDOR &&
293  ie->vendor.oui == IEEE80211_WPA_OUI_VEN ) {
294  DBG ( "RSN detect: old-style WPA IE found\n" );
295  rsn = &ie->vendor.data[0];
296  *end = rsn + ie->len - 4;
297  *is_rsn = 0;
298  } else if ( ie->id == IEEE80211_IE_RSN ) {
299  DBG ( "RSN detect: 802.11i RSN IE found\n" );
300  rsn = ( u8 * ) &ie->rsn.version;
301  *end = rsn + ie->len;
302  *is_rsn = 1;
303  }
304 
305  if ( rsn && ( *end > ( u8 * ) ie_end || rsn >= *end ||
306  *( u16 * ) rsn != IEEE80211_RSN_VERSION ) ) {
307  DBG ( "RSN detect: malformed RSN IE or unknown "
308  "version, keep trying\n" );
309  rsn = NULL;
310  }
311 
312  if ( rsn )
313  break;
314 
315  ie = ieee80211_next_ie ( ie, ie_end );
316  }
317 
318  if ( ! ie ) {
319  DBG ( "RSN detect: no RSN IE found\n" );
320  return NULL;
321  }
322 
323  return rsn;
324 }
325 
326 
327 /**
328  * Detect crypto and AKM types from RSN information element
329  *
330  * @v is_rsn If TRUE, IE is a new-style RSN information element
331  * @v start Pointer to first byte of @a version field
332  * @v end Pointer to first byte not in the RSN IE
333  * @ret secprot Security handshaking protocol used by network
334  * @ret crypt Cryptosystem used by network
335  * @ret rc Return status code
336  *
337  * If the IE cannot be parsed, returns an error indication and leaves
338  * @a secprot and @a crypt unchanged.
339  */
340 int sec80211_detect_ie ( int is_rsn, u8 *start, u8 *end,
341  enum net80211_security_proto *secprot,
342  enum net80211_crypto_alg *crypt )
343 {
345  enum net80211_crypto_alg cr;
346  struct descriptor_map *map;
347  u8 *rsn = start;
348 
349  /* Set some defaults */
350  cr = ( is_rsn ? NET80211_CRYPT_CCMP : NET80211_CRYPT_TKIP );
352 
353  rsn += 2; /* version - already checked */
354  rsn += 4; /* group cipher - we don't use it here */
355 
356  if ( rsn >= end )
357  goto done;
358 
359  /* Pick crypto algorithm */
360  map = rsn_pick_desc ( &rsn, end, rsn_cipher_map,
363  if ( ! map )
364  goto invalid_rsn;
365 
366  cr = map->net80211_type;
367 
368  if ( rsn >= end )
369  goto done;
370 
371  /* Pick handshaking algorithm */
372  map = rsn_pick_desc ( &rsn, end, rsn_akm_map,
375  if ( ! map )
376  goto invalid_rsn;
377 
378  sp = map->net80211_type;
379 
380  done:
381  DBG ( "RSN detect: OK, crypto type %d, secprot type %d\n", cr, sp );
382  *secprot = sp;
383  *crypt = cr;
384  return 0;
385 
386  invalid_rsn:
387  DBG ( "RSN detect: invalid RSN IE\n" );
388  return -EINVAL;
389 }
390 
391 
392 /**
393  * Detect the cryptosystem and handshaking protocol used by an 802.11 network
394  *
395  * @v iob I/O buffer containing beacon frame
396  * @ret secprot Security handshaking protocol used by network
397  * @ret crypt Cryptosystem used by network
398  * @ret rc Return status code
399  *
400  * This function uses weak linkage, as it must be called from generic
401  * contexts but should only be linked in if some encryption is
402  * supported; you must test its address against @c NULL before calling
403  * it. If it does not exist, any network with the PRIVACY bit set in
404  * beacon->capab should be considered unknown.
405  */
406 int sec80211_detect ( struct io_buffer *iob,
407  enum net80211_security_proto *secprot,
408  enum net80211_crypto_alg *crypt )
409 {
410  struct ieee80211_frame *hdr = iob->data;
411  struct ieee80211_beacon *beacon =
412  ( struct ieee80211_beacon * ) hdr->data;
413  u8 *rsn, *rsn_end;
414  int is_rsn, rc;
415 
416  *crypt = NET80211_CRYPT_UNKNOWN;
417  *secprot = NET80211_SECPROT_UNKNOWN;
418 
419  /* Find RSN or WPA IE */
420  if ( ! ( rsn = sec80211_find_rsn ( beacon->info_element, iob->tail,
421  &is_rsn, &rsn_end ) ) ) {
422  /* No security IE at all; either WEP or no security. */
423  *secprot = NET80211_SECPROT_NONE;
424 
425  if ( beacon->capability & IEEE80211_CAPAB_PRIVACY )
426  *crypt = NET80211_CRYPT_WEP;
427  else
428  *crypt = NET80211_CRYPT_NONE;
429 
430  return 0;
431  }
432 
433  /* Determine type of security */
434  if ( ( rc = sec80211_detect_ie ( is_rsn, rsn, rsn_end, secprot,
435  crypt ) ) == 0 )
436  return 0;
437 
438  /* If we get here, the RSN IE was invalid */
439 
440  *crypt = NET80211_CRYPT_UNKNOWN;
441  *secprot = NET80211_SECPROT_UNKNOWN;
442  DBG ( "Failed to handle RSN IE:\n" );
443  DBG_HD ( rsn, rsn_end - rsn );
444  return rc;
445 }
446 
447 
448 /**
449  * Determine RSN descriptor for specified net80211 ID
450  *
451  * @v id net80211 ID value
452  * @v rsnie Whether to return a new-format (RSN IE) descriptor
453  * @v map Map to use in translation
454  * @ret desc RSN descriptor, or 0 on error
455  *
456  * If @a rsnie is false, returns an old-format (WPA vendor IE)
457  * descriptor.
458  */
459 static u32 rsn_get_desc ( unsigned id, int rsnie, struct descriptor_map *map )
460 {
462 
463  for ( ; map->oui_type != END_MAGIC; map++ ) {
464  if ( map->net80211_type == id )
465  return map->oui_type | vendor;
466  }
467 
468  return 0;
469 }
470 
471 /**
472  * Determine RSN descriptor for specified net80211 cryptosystem number
473  *
474  * @v crypt Cryptosystem number
475  * @v rsnie Whether to return a new-format (RSN IE) descriptor
476  * @ret desc RSN descriptor
477  *
478  * If @a rsnie is false, returns an old-format (WPA vendor IE)
479  * descriptor.
480  */
482 {
483  return rsn_get_desc ( crypt, rsnie, rsn_cipher_map );
484 }
485 
486 /**
487  * Determine RSN descriptor for specified net80211 handshaker number
488  *
489  * @v secprot Handshaker number
490  * @v rsnie Whether to return a new-format (RSN IE) descriptor
491  * @ret desc RSN descriptor
492  *
493  * If @a rsnie is false, returns an old-format (WPA vendor IE)
494  * descriptor.
495  */
497  int rsnie )
498 {
499  return rsn_get_desc ( secprot, rsnie, rsn_akm_map );
500 }
501 
502 /**
503  * Determine net80211 cryptosystem number from RSN descriptor
504  *
505  * @v desc RSN descriptor
506  * @ret crypt net80211 cryptosystem enumeration value
507  */
509 {
510  struct descriptor_map *map = rsn_cipher_map;
511 
512  for ( ; map->oui_type != END_MAGIC; map++ ) {
513  if ( map->oui_type == ( desc & OUI_TYPE_MASK ) )
514  break;
515  }
516 
517  return map->net80211_type;
518 }
#define IEEE80211_RSN_CTYPE_CCMP
802.11 RSN IE: cipher type for CCMP ("WPA2")
Definition: ieee80211.h:885
#define IEEE80211_RSN_OUI
Organization part for OUIs in standard RSN IE.
Definition: ieee80211.h:863
uint16_t u16
Definition: stdint.h:21
#define EINVAL
Invalid argument.
Definition: errno.h:428
u32 oui_type
OUI+type in appropriate byte order, masked to exclude vendor.
Definition: sec80211.c:58
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
Network protected with CCMP (AES-based system)
Definition: net80211.h:174
#define IEEE80211_RSN_ATYPE_8021X
802.11 RSN IE: auth method type for using an 802.1X server
Definition: ieee80211.h:895
No security handshaking.
Definition: net80211.h:102
#define OUI_TYPE_MASK
Definition: ieee80211.h:859
static union ieee80211_ie * ieee80211_next_ie(union ieee80211_ie *ie, void *end)
Advance to next 802.11 information element.
Definition: ieee80211.h:1028
#define table_start(table)
Get start of linker table.
Definition: tables.h:271
Error codes.
Dummy value used when the cryptosystem can't be detected.
Definition: net80211.h:177
#define DBG_HD(...)
Definition: compiler.h:500
#define IEEE80211_CAPAB_PRIVACY
Set if the network is encrypted (by any method)
Definition: ieee80211.h:401
Constants and data structures defined in IEEE 802.11, subsetted according to what iPXE knows how to u...
An 802.11 data or management frame without QoS or WDS header fields.
Definition: ieee80211.h:300
net80211_security_proto
An 802.11 security handshaking protocol.
Definition: net80211.h:96
Full EAP 802.1X handshaking.
Definition: net80211.h:121
#define IEEE80211_RSN_CTYPE_WEP104
802.11 RSN IE: cipher type for 104-bit WEP
Definition: ieee80211.h:879
FILE_LICENCE(GPL2_OR_LATER)
#define IEEE80211_RSN_CTYPE_WEP40
802.11 RSN IE: cipher type for 40-bit WEP
Definition: ieee80211.h:876
Network protected with WEP (awful RC4-based system)
Definition: net80211.h:145
int(* init)(struct net80211_crypto *crypto, const void *key, int keylen, const void *rsc)
Initialize cryptosystem using a given key.
Definition: net80211.h:707
int priv_len
Length of private data requested to be allocated.
Definition: net80211.h:763
Dummy value used when the handshaking type can't be detected.
Definition: net80211.h:124
#define END_MAGIC
Magic number in oui_type showing end of list.
Definition: sec80211.c:62
Definitions for general secured-network routines.
static struct descriptor_map * rsn_pick_desc(u8 **rsnp, u8 *rsn_end, struct descriptor_map *map, void *tbl_start, void *tbl_end)
Determine net80211 crypto or handshaking type value to return for RSN info.
Definition: sec80211.c:186
#define IEEE80211_RSN_ATYPE_PSK
802.11 RSN IE: auth method type for using a pre-shared key
Definition: ieee80211.h:898
#define ENOTSUP_CRYPT(crypt)
Definition: sec80211.c:48
uint32_t start
Starting offset.
Definition: netvsc.h:12
void * tail
End of data.
Definition: iobuf.h:46
#define ENOMEM
Not enough space.
Definition: errno.h:534
enum net80211_crypto_alg algorithm
The cryptographic algorithm implemented.
Definition: net80211.h:692
void * memcpy(void *dest, const void *src, size_t len) __nonnull
static u32 rsn_get_desc(unsigned id, int rsnie, struct descriptor_map *map)
Determine RSN descriptor for specified net80211 ID.
Definition: sec80211.c:459
#define IEEE80211_WPA_OUI_VEN
Old vendor-type WPA IE OUI type + subtype.
Definition: ieee80211.h:869
Pre-shared key handshaking.
Definition: net80211.h:112
u8 rsc[8]
Receive sequence counter for GTK.
Definition: wpa.h:69
#define NET80211_CRYPTOS
Definition: net80211.h:769
#define IEEE80211_WPA_OUI
Organization part for OUIs in old WPA IE.
Definition: ieee80211.h:866
#define ieee80211_beacon
Definition: ieee80211.h:1069
int sec80211_install(struct net80211_crypto **which, enum net80211_crypto_alg crypt, const void *key, int len, const void *rsc)
Install 802.11 cryptosystem.
Definition: sec80211.c:113
Mapping from net80211 crypto/secprot types to RSN OUI descriptors.
Definition: sec80211.c:53
#define IEEE80211_IE_VENDOR
Information element ID for Vendor Specific information element.
Definition: ieee80211.h:960
static void(* free)(struct refcnt *refcnt))
Definition: refcnt.h:54
void * zalloc(size_t size)
Allocate cleared memory.
Definition: malloc.c:624
#define NET80211_HANDSHAKERS
Definition: net80211.h:675
The iPXE 802.11 MAC layer.
#define IEEE80211_IE_RSN
Information element ID for Robust Security Network information element.
Definition: ieee80211.h:834
static struct descriptor_map rsn_cipher_map[]
Mapping between net80211 cryptosystems and 802.11i cipher IDs.
Definition: sec80211.c:65
No security, an "Open" network.
Definition: net80211.h:131
#define for_each_table_entry(pointer, table)
Iterate through all entries within a linker table.
Definition: tables.h:358
static int ieee80211_ie_bound(union ieee80211_ie *ie, void *end)
Check that 802.11 information element is bounded by buffer.
Definition: ieee80211.h:1012
#define IEEE80211_RSN_CTYPE_TKIP
802.11 RSN IE: cipher type for TKIP ("WPA")
Definition: ieee80211.h:882
u32 oui_type
OUI + type byte.
Definition: wpa.h:34
void * priv
Private data for the algorithm to store key and state info.
Definition: net80211.h:766
uint32_t hdr
Message header.
Definition: intelvf.h:12
int sec80211_detect_ie(int is_rsn, u8 *start, u8 *end, enum net80211_security_proto *secprot, enum net80211_crypto_alg *crypt)
Detect crypto and AKM types from RSN information element.
Definition: sec80211.c:340
Definition: sis900.h:22
u32 sec80211_rsn_get_crypto_desc(enum net80211_crypto_alg crypt, int rsnie)
Determine RSN descriptor for specified net80211 cryptosystem number.
Definition: sec80211.c:481
union bootph_vendor vendor
u32 sec80211_rsn_get_akm_desc(enum net80211_security_proto secprot, int rsnie)
Determine RSN descriptor for specified net80211 handshaker number.
Definition: sec80211.c:496
uint32_t len
Length.
Definition: ena.h:14
static struct descriptor_map rsn_akm_map[]
Mapping between net80211 handshakers and 802.11i AKM IDs.
Definition: sec80211.c:83
net80211_crypto_alg
An 802.11 data encryption algorithm.
Definition: net80211.h:129
void * data
Start of data.
Definition: iobuf.h:44
u32 net80211_type
Value of net80211_crypto_alg or net80211_security_proto.
Definition: sec80211.c:55
uint32_t end
Ending offset.
Definition: netvsc.h:18
#define IEEE80211_RSN_VERSION
802.11 RSN IE: expected version number
Definition: ieee80211.h:873
enum net80211_crypto_alg sec80211_rsn_get_net80211_crypt(u32 desc)
Determine net80211 cryptosystem number from RSN descriptor.
Definition: sec80211.c:508
#define table_end(table)
Get end of linker table.
Definition: tables.h:289
int sec80211_detect(struct io_buffer *iob, enum net80211_security_proto *secprot, enum net80211_crypto_alg *crypt)
Detect the cryptosystem and handshaking protocol used by an 802.11 network.
Definition: sec80211.c:406
return
Definition: natsemi.h:326
Network protected with TKIP (better RC4-based system)
Definition: net80211.h:163
#define DBG(...)
Print a debugging message.
Definition: compiler.h:498
Interface to an 802.11 cryptosystem.
Definition: net80211.h:689
#define ok(success)
Definition: test.h:46
u8 * sec80211_find_rsn(union ieee80211_ie *ie, void *ie_end, int *is_rsn, u8 **end)
Find the RSN or WPA information element in the provided beacon frame.
Definition: sec80211.c:283
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362
String functions.
struct bofm_section_header done
Definition: bofm_test.c:46
uint8_t u8
Definition: stdint.h:19
union @375 key
Sense key.
Definition: scsi.h:18
uint32_t u32
Definition: stdint.h:23
uint16_t sp
Definition: registers.h:27
if(natsemi->flags &NATSEMI_64BIT) return 1
A persistent I/O buffer.
Definition: iobuf.h:32