1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
// SPDX-License-Identifier: GPL-2.0
/*
* Driver for KeyStream wireless LAN
*
* Copyright (C) 2005-2008 KeyStream Corp.
* Copyright (C) 2009 Renesas Technology Corp.
*/
#include <asm/unaligned.h>
#include <linux/bitops.h>
#include <linux/string.h>
#include "michael_mic.h"
// Reset the state to the empty message.
static inline void michael_clear(struct michael_mic *mic)
{
mic->l = mic->k0;
mic->r = mic->k1;
mic->m_bytes = 0;
}
static void michael_init(struct michael_mic *mic, u8 *key)
{
// Set the key
mic->k0 = get_unaligned_le32(key);
mic->k1 = get_unaligned_le32(key + 4);
//clear();
michael_clear(mic);
}
static inline void michael_block(struct michael_mic *mic)
{
mic->r ^= rol32(mic->l, 17);
mic->l += mic->r;
mic->r ^= ((mic->l & 0xff00ff00) >> 8) |
((mic->l & 0x00ff00ff) << 8);
mic->l += mic->r;
mic->r ^= rol32(mic->l, 3);
mic->l += mic->r;
mic->r ^= ror32(mic->l, 2);
mic->l += mic->r;
}
static void michael_append(struct michael_mic *mic, u8 *src, int bytes)
{
int addlen;
if (mic->m_bytes) {
addlen = 4 - mic->m_bytes;
if (addlen > bytes)
addlen = bytes;
memcpy(&mic->m[mic->m_bytes], src, addlen);
mic->m_bytes += addlen;
src += addlen;
bytes -= addlen;
if (mic->m_bytes < 4)
return;
mic->l ^= get_unaligned_le32(mic->m);
michael_block(mic);
mic->m_bytes = 0;
}
while (bytes >= 4) {
mic->l ^= get_unaligned_le32(src);
michael_block(mic);
src += 4;
bytes -= 4;
}
if (bytes > 0) {
mic->m_bytes = bytes;
memcpy(mic->m, src, bytes);
}
}
static void michael_get_mic(struct michael_mic *mic, u8 *dst)
{
u8 *data = mic->m;
switch (mic->m_bytes) {
case 0:
mic->l ^= 0x5a;
break;
case 1:
mic->l ^= data[0] | 0x5a00;
break;
case 2:
mic->l ^= data[0] | (data[1] << 8) | 0x5a0000;
break;
case 3:
mic->l ^= data[0] | (data[1] << 8) | (data[2] << 16) |
0x5a000000;
break;
}
michael_block(mic);
michael_block(mic);
// The appendByte function has already computed the result.
put_unaligned_le32(mic->l, dst);
put_unaligned_le32(mic->r, dst + 4);
// Reset to the empty message.
michael_clear(mic);
}
void michael_mic_function(struct michael_mic *mic, u8 *key,
u8 *data, unsigned int len, u8 priority, u8 *result)
{
u8 pad_data[4] = { priority, 0, 0, 0 };
// Compute the MIC value
/*
* IEEE802.11i page 47
* Figure 43g TKIP MIC processing format
* +--+--+--------+--+----+--+--+--+--+--+--+--+--+
* |6 |6 |1 |3 |M |1 |1 |1 |1 |1 |1 |1 |1 | Octet
* +--+--+--------+--+----+--+--+--+--+--+--+--+--+
* |DA|SA|Priority|0 |Data|M0|M1|M2|M3|M4|M5|M6|M7|
* +--+--+--------+--+----+--+--+--+--+--+--+--+--+
*/
michael_init(mic, key);
michael_append(mic, data, 12); /* |DA|SA| */
michael_append(mic, pad_data, 4); /* |Priority|0|0|0| */
michael_append(mic, data + 12, len - 12); /* |Data| */
michael_get_mic(mic, result);
}
|
