]>
Commit | Line | Data |
---|---|---|
4f131b53 | 1 | //----------------------------------------------------------------------------- |
2 | // Copyright (C) Merlok - 2017 | |
3 | // | |
4 | // This code is licensed to you under the terms of the GNU GPL, version 2 or, | |
5 | // at your option, any later version. See the LICENSE.txt file for the text of | |
6 | // the license. | |
7 | //----------------------------------------------------------------------------- | |
8 | // Command: hf mf list. It shows data from arm buffer. | |
9 | //----------------------------------------------------------------------------- | |
10 | ||
11 | #include "cmdhflist.h" | |
12 | ||
13 | #include <stdlib.h> | |
14 | #include <stdio.h> | |
15 | #include <string.h> | |
6612a5a2 | 16 | #include <stdint.h> |
17 | #include <stdbool.h> | |
18 | #include "util.h" | |
19 | #include "data.h" | |
20 | #include "ui.h" | |
21 | #include "iso14443crc.h" | |
22 | #include "parity.h" | |
23 | #include "protocols.h" | |
7b215d14 OM |
24 | #include "crapto1/crapto1.h" |
25 | #include "mifarehost.h" | |
4f131b53 | 26 | |
27 | ||
6612a5a2 | 28 | enum MifareAuthSeq { |
29 | masNone, | |
30 | masNt, | |
31 | masNrAr, | |
32 | masAt, | |
aadc6bf1 | 33 | masFirstData, |
6612a5a2 | 34 | masData, |
35 | masDataNested, | |
36 | masError, | |
37 | }; | |
38 | static enum MifareAuthSeq MifareAuthState; | |
aadc6bf1 OM |
39 | static TAuthData AuthData; |
40 | ||
41 | void ClearAuthData() { | |
42 | AuthData.uid = 0; | |
43 | AuthData.nt = 0; | |
7b215d14 | 44 | AuthData.first_auth = true; |
aadc6bf1 | 45 | } |
6612a5a2 | 46 | |
47 | /** | |
48 | * @brief iso14443A_CRC_check Checks CRC in command or response | |
49 | * @param isResponse | |
50 | * @param data | |
51 | * @param len | |
52 | * @return 0 : CRC-command, CRC not ok | |
53 | * 1 : CRC-command, CRC ok | |
54 | * 2 : Not crc-command | |
55 | */ | |
56 | uint8_t iso14443A_CRC_check(bool isResponse, uint8_t* data, uint8_t len) | |
57 | { | |
58 | uint8_t b1,b2; | |
59 | ||
60 | if(len <= 2) return 2; | |
61 | ||
62 | if(isResponse & (len < 6)) return 2; | |
63 | ||
64 | ComputeCrc14443(CRC_14443_A, data, len-2, &b1, &b2); | |
65 | if (b1 != data[len-2] || b2 != data[len-1]) { | |
66 | return 0; | |
67 | } else { | |
68 | return 1; | |
69 | } | |
70 | } | |
71 | ||
72 | uint8_t mifare_CRC_check(bool isResponse, uint8_t* data, uint8_t len) | |
73 | { | |
74 | switch(MifareAuthState) { | |
75 | case masNone: | |
aadc6bf1 | 76 | case masFirstData: |
6612a5a2 | 77 | case masData: |
78 | case masDataNested: | |
79 | case masError: | |
80 | return iso14443A_CRC_check(isResponse, data, len); | |
81 | default: | |
82 | return 2; | |
83 | } | |
6612a5a2 | 84 | } |
85 | ||
86 | void annotateIso14443a(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize) | |
87 | { | |
88 | switch(cmd[0]) | |
89 | { | |
a31f7f89 OM |
90 | case ISO14443A_CMD_WUPA: |
91 | snprintf(exp,size,"WUPA"); | |
92 | MifareAuthState = masNone; | |
93 | break; | |
6612a5a2 | 94 | case ISO14443A_CMD_ANTICOLL_OR_SELECT:{ |
95 | // 93 20 = Anticollision (usage: 9320 - answer: 4bytes UID+1byte UID-bytes-xor) | |
96 | // 93 70 = Select (usage: 9370+5bytes 9320 answer - answer: 1byte SAK) | |
97 | if(cmd[1] == 0x70) | |
98 | { | |
99 | snprintf(exp,size,"SELECT_UID"); break; | |
100 | }else | |
101 | { | |
102 | snprintf(exp,size,"ANTICOLL"); break; | |
103 | } | |
104 | } | |
105 | case ISO14443A_CMD_ANTICOLL_OR_SELECT_2:{ | |
106 | //95 20 = Anticollision of cascade level2 | |
107 | //95 70 = Select of cascade level2 | |
108 | if(cmd[2] == 0x70) | |
109 | { | |
110 | snprintf(exp,size,"SELECT_UID-2"); break; | |
111 | }else | |
112 | { | |
113 | snprintf(exp,size,"ANTICOLL-2"); break; | |
114 | } | |
115 | } | |
a31f7f89 OM |
116 | case ISO14443A_CMD_REQA: |
117 | snprintf(exp,size,"REQA"); | |
118 | MifareAuthState = masNone; | |
119 | break; | |
6612a5a2 | 120 | case ISO14443A_CMD_READBLOCK: snprintf(exp,size,"READBLOCK(%d)",cmd[1]); break; |
121 | case ISO14443A_CMD_WRITEBLOCK: snprintf(exp,size,"WRITEBLOCK(%d)",cmd[1]); break; | |
122 | case ISO14443A_CMD_HALT: | |
123 | snprintf(exp,size,"HALT"); | |
124 | MifareAuthState = masNone; | |
125 | break; | |
126 | case ISO14443A_CMD_RATS: snprintf(exp,size,"RATS"); break; | |
127 | case MIFARE_CMD_INC: snprintf(exp,size,"INC(%d)",cmd[1]); break; | |
128 | case MIFARE_CMD_DEC: snprintf(exp,size,"DEC(%d)",cmd[1]); break; | |
129 | case MIFARE_CMD_RESTORE: snprintf(exp,size,"RESTORE(%d)",cmd[1]); break; | |
130 | case MIFARE_CMD_TRANSFER: snprintf(exp,size,"TRANSFER(%d)",cmd[1]); break; | |
131 | case MIFARE_AUTH_KEYA: | |
132 | if ( cmdsize > 3) { | |
133 | snprintf(exp,size,"AUTH-A(%d)",cmd[1]); | |
134 | MifareAuthState = masNt; | |
135 | } else { | |
136 | // case MIFARE_ULEV1_VERSION : both 0x60. | |
137 | snprintf(exp,size,"EV1 VERSION"); | |
138 | } | |
139 | break; | |
140 | case MIFARE_AUTH_KEYB: | |
141 | MifareAuthState = masNt; | |
142 | snprintf(exp,size,"AUTH-B(%d)",cmd[1]); | |
143 | break; | |
144 | case MIFARE_MAGICWUPC1: snprintf(exp,size,"MAGIC WUPC1"); break; | |
145 | case MIFARE_MAGICWUPC2: snprintf(exp,size,"MAGIC WUPC2"); break; | |
146 | case MIFARE_MAGICWIPEC: snprintf(exp,size,"MAGIC WIPEC"); break; | |
147 | case MIFARE_ULC_AUTH_1: snprintf(exp,size,"AUTH "); break; | |
148 | case MIFARE_ULC_AUTH_2: snprintf(exp,size,"AUTH_ANSW"); break; | |
149 | case MIFARE_ULEV1_AUTH: | |
150 | if ( cmdsize == 7 ) | |
151 | snprintf(exp,size,"PWD-AUTH KEY: 0x%02x%02x%02x%02x", cmd[1], cmd[2], cmd[3], cmd[4] ); | |
152 | else | |
153 | snprintf(exp,size,"PWD-AUTH"); | |
154 | break; | |
155 | case MIFARE_ULEV1_FASTREAD:{ | |
156 | if ( cmdsize >=3 && cmd[2] <= 0xE6) | |
157 | snprintf(exp,size,"READ RANGE (%d-%d)",cmd[1],cmd[2]); | |
158 | else | |
159 | snprintf(exp,size,"?"); | |
160 | break; | |
161 | } | |
162 | case MIFARE_ULC_WRITE:{ | |
163 | if ( cmd[1] < 0x21 ) | |
164 | snprintf(exp,size,"WRITEBLOCK(%d)",cmd[1]); | |
165 | else | |
166 | snprintf(exp,size,"?"); | |
167 | break; | |
168 | } | |
169 | case MIFARE_ULEV1_READ_CNT:{ | |
170 | if ( cmd[1] < 5 ) | |
171 | snprintf(exp,size,"READ CNT(%d)",cmd[1]); | |
172 | else | |
173 | snprintf(exp,size,"?"); | |
174 | break; | |
175 | } | |
176 | case MIFARE_ULEV1_INCR_CNT:{ | |
177 | if ( cmd[1] < 5 ) | |
178 | snprintf(exp,size,"INCR(%d)",cmd[1]); | |
179 | else | |
180 | snprintf(exp,size,"?"); | |
181 | break; | |
182 | } | |
183 | case MIFARE_ULEV1_READSIG: snprintf(exp,size,"READ_SIG"); break; | |
184 | case MIFARE_ULEV1_CHECKTEAR: snprintf(exp,size,"CHK_TEARING(%d)",cmd[1]); break; | |
185 | case MIFARE_ULEV1_VCSL: snprintf(exp,size,"VCSL"); break; | |
186 | default: snprintf(exp,size,"?"); break; | |
187 | } | |
188 | return; | |
189 | } | |
190 | ||
b957bcd3 | 191 | void annotateMifare(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize, uint8_t* parity, uint8_t paritysize, bool isResponse) { |
aadc6bf1 OM |
192 | // get UID |
193 | if (MifareAuthState == masNone) { | |
7b215d14 | 194 | if (cmdsize == 9 && cmd[0] == ISO14443A_CMD_ANTICOLL_OR_SELECT && cmd[1] == 0x70) { |
aadc6bf1 OM |
195 | ClearAuthData(); |
196 | AuthData.uid = bytes_to_num(&cmd[2], 4); | |
197 | } | |
7b215d14 | 198 | if (cmdsize == 9 && cmd[0] == ISO14443A_CMD_ANTICOLL_OR_SELECT_2 && cmd[1] == 0x70) { |
aadc6bf1 OM |
199 | ClearAuthData(); |
200 | AuthData.uid = bytes_to_num(&cmd[2], 4); | |
201 | } | |
202 | } | |
203 | ||
6612a5a2 | 204 | switch(MifareAuthState) { |
205 | case masNt: | |
fb30f5a1 | 206 | if (cmdsize == 4 && isResponse) { |
aadc6bf1 | 207 | snprintf(exp,size,"AUTH: nt %s", (AuthData.first_auth) ? "" : "(enc)"); |
6612a5a2 | 208 | MifareAuthState = masNrAr; |
aadc6bf1 | 209 | if (AuthData.first_auth) |
7b215d14 | 210 | AuthData.nt = bytes_to_num(cmd, 4); |
aadc6bf1 | 211 | else |
7b215d14 | 212 | AuthData.nt_enc = bytes_to_num(cmd, 4); |
b957bcd3 | 213 | AuthData.nt_enc_par = parity[0]; |
6612a5a2 | 214 | return; |
215 | } else { | |
216 | MifareAuthState = masError; | |
6612a5a2 | 217 | } |
218 | break; | |
219 | case masNrAr: | |
fb30f5a1 | 220 | if (cmdsize == 8 && !isResponse) { |
6c30a244 | 221 | snprintf(exp,size,"AUTH: nr ar (enc)"); |
6612a5a2 | 222 | MifareAuthState = masAt; |
7b215d14 OM |
223 | AuthData.nr_enc = bytes_to_num(cmd, 4); |
224 | AuthData.ar_enc = bytes_to_num(&cmd[4], 4); | |
b957bcd3 | 225 | AuthData.ar_enc_par = parity[0] << 4; |
6612a5a2 | 226 | return; |
227 | } else { | |
228 | MifareAuthState = masError; | |
229 | } | |
230 | break; | |
231 | case masAt: | |
fb30f5a1 | 232 | if (cmdsize == 4 && isResponse) { |
6c30a244 | 233 | snprintf(exp,size,"AUTH: at (enc)"); |
aadc6bf1 | 234 | MifareAuthState = masFirstData; |
7b215d14 | 235 | AuthData.at_enc = bytes_to_num(cmd, 4); |
b957bcd3 | 236 | AuthData.at_enc_par = parity[0]; |
6612a5a2 | 237 | return; |
238 | } else { | |
239 | MifareAuthState = masError; | |
240 | } | |
241 | break; | |
242 | default: | |
243 | break; | |
244 | } | |
245 | ||
246 | if (!isResponse) | |
247 | annotateIso14443a(exp, size, cmd, cmdsize); | |
248 | ||
249 | } | |
7b215d14 OM |
250 | |
251 | bool DecodeMifareData(uint8_t *cmd, uint8_t cmdsize, bool isResponse, uint8_t *mfData, size_t *mfDataLen) { | |
252 | *mfDataLen = 0; | |
253 | ||
254 | if (cmdsize > 32) | |
255 | return false; | |
256 | ||
257 | if (MifareAuthState == masFirstData) { | |
258 | if (AuthData.first_auth) { | |
259 | uint32_t ks2 = AuthData.ar_enc ^ prng_successor(AuthData.nt, 64); | |
260 | uint32_t ks3 = AuthData.at_enc ^ prng_successor(AuthData.nt, 96); | |
261 | struct Crypto1State *revstate = lfsr_recovery64(ks2, ks3); | |
262 | lfsr_rollback_word(revstate, 0, 0); | |
263 | lfsr_rollback_word(revstate, 0, 0); | |
264 | lfsr_rollback_word(revstate, AuthData.nr_enc, 1); | |
265 | lfsr_rollback_word(revstate, AuthData.uid ^ AuthData.nt, 0); | |
266 | ||
267 | uint64_t lfsr = 0; | |
268 | crypto1_get_lfsr(revstate, &lfsr); | |
269 | crypto1_destroy(revstate); | |
270 | // LastKey = lfsr; | |
28ee794f | 271 | PrintAndLog(" | * | key | probable key:%x%x Prng:%s ks2:%08x ks3:%08x | |", |
7b215d14 | 272 | (unsigned int)((lfsr & 0xFFFFFFFF00000000) >> 32), (unsigned int)(lfsr & 0xFFFFFFFF), |
28ee794f | 273 | validate_prng_nonce(AuthData.nt) ? "WEAK": "HARD", |
7b215d14 OM |
274 | ks2, |
275 | ks3); | |
276 | ||
277 | AuthData.first_auth = false; | |
278 | } else { | |
28ee794f | 279 | printf("uid:%x nt:%x ar_enc:%x at_enc:%x\n", AuthData.uid, AuthData.nt, AuthData.ar_enc, AuthData.at_enc); |
7b215d14 OM |
280 | } |
281 | ||
282 | ||
283 | ||
284 | MifareAuthState = masData; | |
285 | return true; | |
286 | } | |
287 | ||
288 | if (MifareAuthState == masData) { | |
289 | } | |
290 | ||
291 | return *mfDataLen > 0; | |
292 | } | |
293 |