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 {
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:282
Error codes.
Dummy value used when the cryptosystem can't be detected.
Definition: net80211.h:177
#define DBG_HD(...)
Definition: compiler.h:500
struct golan_inbox_hdr hdr
Message header.
Definition: CIB_PRM.h:28
#define IEEE80211_CAPAB_PRIVACY
Set if the network is encrypted (by any method)
Definition: ieee80211.h:401
static unsigned short vendor
Definition: davicom.c:128
Constants and data structures defined in IEEE 802.11, subsetted according to what iPXE knows how to u...
uint64_t desc
Microcode descriptor list physical address.
Definition: ucode.h:12
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:50
#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:385
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
static __always_inline int struct dma_mapping * map
Definition: dma.h:181
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
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
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:48
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:308
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:321
String functions.
struct bofm_section_header done
Definition: bofm_test.c:46
uint8_t u8
Definition: stdint.h:19
union @382 key
Sense key.
Definition: crypto.h:284
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:33