MIC_CALC
[ME]

The MIC Calculator's structure and methods declarations. More...

Collaboration diagram for MIC_CALC:

Data Structures
struct	mic_calc
	========================== Context Definition =========================== This structure contains the attributes that defines the current state of the MIC key Calculator More...
Defines
#define	MIC_END_SIGNATURE (0x0000005A)
	At the end of the MIC Calculation, a padding is added that consists of the signature byte 0x5A and number of padding bytes that are set to zeroes.
#define	MIC_TID_MASK (0x00000007)
	Mask to be applied to the received TID value (three lower bits).
#define	ROR32(L, Q) ( ( (uint32_t)(L) >> (Q) ) \| ( (uint32_t)(L) << (32-(Q)) ) )
	A macro for the right rotation instruction.
#define	ROL32(L, Q) ( ( (uint32_t)(L) << (Q) ) \| ( (uint32_t)(L) >> (32-(Q)) ) )
	A macro for the right rotation instruction.
#define	XSWAP32(L)
	A macro for swap operation.
#define	LEN_IN_BITS(X) ( (X) << 3 )
	A macro for multiplication by 8.
#define	SHIFTR(X, S) (((S) == 32)? 0 : ((X) >> (S)) )
	This macro is used to right shift a value by another value.
Functions
static void	michael_block (struct mic_calc *mic_calc_ptr, uint32_t block)
	Michael block function implementation Implement the Feistel-type Michael block function b as defined in the IEEE standard 802.11-2012 (section 11.4.2.3 - Figure 11-10 and 11-11).
static void	michael_init (struct mic_calc mic_calc_ptr, uint32_t mic_key_ptr, uint32_t *aad)
	Initializes TKIP MIC computation (Software implementation).
static void	michael_calc (struct mic_calc *mic_calc_ptr, uint32_t start_ptr, uint32_t data_len)
	Continues TKIP MIC computation (Software implementation).
static void	michael_end (struct mic_calc *mic_calc_ptr)
	Ends TKIP MIC computation (Software implementation).
void	me_mic_init (struct mic_calc mic_calc_ptr, uint32_t mic_key_ptr, struct mac_addr da, struct mac_addr sa, uint8_t tid)
	Initializes mic_calc attributes before proceeding with MIC key calculations.
void	me_mic_calc (struct mic_calc *mic_calc_ptr, uint32_t start_ptr, uint32_t data_len)
	Performs MIC Key calculations over a continuous block in memory with an arbitrary starting point and length.
void	me_mic_end (struct mic_calc *mic_calc_ptr)
	Used to terminate the MIC calculation session and retrieve the resultant MIC key.
Variables
uint32_t	mic_aad [4]
	Additional Authentication Data vector for MIC computation Must be in SHARED RAM when HSU is used.

Detailed Description

The MIC Calculator's structure and methods declarations.

Define Documentation

#define LEN_IN_BITS ( X ) ( (X) << 3 )

A macro for multiplication by 8.

This macro is used to convert the lengths from the byte unit to the bit unit

Parameters:

[in] X the length in bytes

Returns:: the length in bits (i.e. X << 3) This macro is used to convert the lengths from the byte unit to the bit unit

Parameters:

[in] X The number of bytes to be converted in bits

Returns:: The provided value converted in bits

Definition at line 111 of file me_mic.c.

Referenced by michael_calc(), and michael_end().

#define MIC_END_SIGNATURE (0x0000005A)

At the end of the MIC Calculation, a padding is added that consists of the signature byte 0x5A and number of padding bytes that are set to zeroes.

to make sure the over all length of the message can be divided by 4 without remainder.

Definition at line 39 of file me_mic.c.

Referenced by michael_end().

#define ROL32	(	L,
		Q		)	( ( (uint32_t)(L) << (Q) ) \| ( (uint32_t)(L) >> (32-(Q)) ) )

A macro for the right rotation instruction.

Rotates L by Q bits to the right

Parameters:

`[in]`	L	The value to be rotated.
`[in]`	Q	The number of bits to rotate L with.

Returns:: The value of L after being rotated Q bits to the right.

Definition at line 78 of file me_mic.c.

Referenced by michael_block().

#define ROR32	(	L,
		Q		)	( ( (uint32_t)(L) >> (Q) ) \| ( (uint32_t)(L) << (32-(Q)) ) )

A macro for the right rotation instruction.

Rotates L by Q bits to the right

Parameters:

`[in]`	L	The value to be rotated.
`[in]`	Q	The number of bits to rotate L with.

Returns:: The value of L after being rotated Q bits to the right.

Definition at line 65 of file me_mic.c.

Referenced by michael_block().

#define SHIFTR	(	X,
		S		)	(((S) == 32)? 0 : ((X) >> (S)) )

This macro is used to right shift a value by another value.

Parameters:

`[in]`	X	The value to be right shifted
`[in]`	S	The number by which X has to be right shifted

Returns:: The right shifted value

Definition at line 123 of file me_mic.c.

Referenced by michael_calc().

#define XSWAP32 ( L )

Value:

( ( ( L & 0xFF00FF00 ) >> 8 ) | \
                        ( ( L & 0x00FF00FF ) << 8 ) )

A macro for swap operation.

Swaps the 1st and 2nd bytes, and swaps the 3rd and 4th bytes

Parameters:

[in] L The value to apply swap on

Returns:: The value of L after swapping as described above

Definition at line 90 of file me_mic.c.

Referenced by michael_block().

Function Documentation

void me_mic_calc	(	struct mic_calc *	mic_calc_ptr,
		uint32_t	start_ptr,
		uint32_t	data_len
	)

Performs MIC Key calculations over a continuous block in memory with an arbitrary starting point and length.

Parameters:

`[in,out]`	mic_calc_ptr
`[in]`	start_ptr	Pointer to the data
`[in]`	data_len	Length of the provided data

Referenced by rxu_cntrl_mic_check(), and txl_buffer_mic_compute().

void me_mic_end ( struct mic_calc * mic_calc_ptr )

Used to terminate the MIC calculation session and retrieve the resultant MIC key.

As specified in IEEE 802.11-2012 specification, section 11.4.2.3.3, the message is padded at the end with a single octet with value 0x5A, followed by between 4 and 7 zero octets. The padding in not transmitted with the MSDU; it is used to simplify the computation over the final block. By construction M(n-1) = 0 and M(n-2) != 0

Parameters:

[in,out] mic_calc_ptr

Referenced by rxu_cntrl_mic_check(), and txl_buffer_mic_compute().

void me_mic_init	(	struct mic_calc *	mic_calc_ptr,
		uint32_t *	mic_key_ptr,
		struct mac_addr *	da,
		struct mac_addr *	sa,
		uint8_t	tid
	)

Initializes mic_calc attributes before proceeding with MIC key calculations.

As exposed in the IEEE 802.11-2012 specification, section 11.4.2.3.2, figure 11-9, the MIC is computed on a MSDU including the Priority field, 3 reserved octets, SA field and DA field. The total length of these fields is 16 bytes. Hence the MIC generation can be started by providing the 4 first blocks to the Michael block function.

Parameters:

`[in,out]`	mic_calc_ptr
`[in]`	mic_key_ptr	Initial MIC key
`[in]`	da	Destination Address to use as part of the MIC header
`[in]`	sa	Source Address to use as part of the MIC header
`[in]`	tid	Packet priority to use as part of the MIC header

Referenced by rxu_cntrl_mic_check(), and txl_buffer_mic_compute().

static void michael_block	(	struct mic_calc *	mic_calc_ptr,
		uint32_t	block
	)			`[static]`

Michael block function implementation Implement the Feistel-type Michael block function b as defined in the IEEE standard 802.11-2012 (section 11.4.2.3 - Figure 11-10 and 11-11).

Input (l, r, M(i)) Output (l, r) b(l, r, M(i)) l <- l XOR M(i) r <- r XOR (l <<< 17) l <- (l + r) mod 2^32 r <- r XOR XSWAP(l) l <- (l + r) mod 2^32 r <- r XOR (l <<< 3) l <- (l + r) mod 2^32 r <- r XOR (l >>> 2) l <- (l + r) mod 2^32 return (l, r)

where <<< denotes the rotate-left operator on 32-bit >>> the rotate-right operator XSWAP a function that swaps the position of the 2 least significant octets.

Parameters:

`[in]`	mic_calc_ptr	A pointer to an array of two 32-bit words that holds the MIC key.
`[in]`	block	32-bit word M(i) on which function has to be applied

Definition at line 159 of file me_mic.c.

References mic_calc::mic_key_least, mic_calc::mic_key_most, ROL32, ROR32, and XSWAP32.

Referenced by michael_calc(), michael_end(), and michael_init().

static void michael_calc	(	struct mic_calc *	mic_calc_ptr,
		uint32_t	start_ptr,
		uint32_t	data_len
	)			`[static]`

Continues TKIP MIC computation (Software implementation).

Continue MIC computation with the provided data.

Parameters:

`[in,out]`	mic_calc_ptr	Pointer to Mic structure
`[in]`	start_ptr	Address of the data buffer (HW address)
`[in]`	data_len	Length, in bytes, of the data buffer

Definition at line 215 of file me_mic.c.

References HW2CPU, mic_calc::last_m_i, mic_calc::last_m_i_len, LEN_IN_BITS, michael_block(), and SHIFTR.

static void michael_end ( struct mic_calc * mic_calc_ptr ) [static]

Ends TKIP MIC computation (Software implementation).

Ends TKIP computation by adding padding data

Parameters:

[in,out] mic_calc_ptr Pointer to Mic structure that will be initialize

Definition at line 316 of file me_mic.c.

References ASSERT_ERR, mic_calc::last_m_i, mic_calc::last_m_i_len, LEN_IN_BITS, MIC_END_SIGNATURE, and michael_block().

static void michael_init	(	struct mic_calc *	mic_calc_ptr,
		uint32_t *	mic_key_ptr,
		uint32_t *	aad
	)			`[static]`

Initializes TKIP MIC computation (Software implementation).

Parameters:

`[out]`	mic_calc_ptr	Pointer to Mic structure that will be initialize
`[in]`	mic_key_ptr	Key to use for MIC computation
`[in]`	aad	Additional Authentication Data vector (CPU address, 16 bytes long)

Definition at line 188 of file me_mic.c.

References mic_calc::last_m_i, mic_calc::last_m_i_len, mic_calc::mic_key_least, mic_calc::mic_key_most, and michael_block().

Variable Documentation

uint32_t mic_aad[4]

Additional Authentication Data vector for MIC computation Must be in SHARED RAM when HSU is used.

Definition at line 340 of file me_mic.c.

MIC_CALC [ME]

Data Structures

Defines

Functions

Variables

Detailed Description

Define Documentation

Function Documentation

Variable Documentation

MIC_CALC
[ME]