]>
Commit | Line | Data |
---|---|---|
56bbb25a | 1 | //----------------------------------------------------------------------------- |
2 | // | |
3 | // This code is licensed to you under the terms of the GNU GPL, version 2 or, | |
4 | // at your option, any later version. See the LICENSE.txt file for the text of | |
5 | // the license. | |
6 | //----------------------------------------------------------------------------- | |
7 | // Low frequency NEDAP tag commands | |
8 | //----------------------------------------------------------------------------- | |
9 | #include <string.h> | |
10 | #include <inttypes.h> | |
11 | #include "cmdlfnedap.h" | |
12 | static int CmdHelp(const char *Cmd); | |
13 | ||
14 | int usage_lf_nedap_clone(void){ | |
15 | PrintAndLog("clone a NEDAP tag to a T55x7 tag."); | |
16 | PrintAndLog(""); | |
17 | PrintAndLog("Usage: lf nedap clone <Card-Number>"); | |
18 | PrintAndLog("Options :"); | |
19 | PrintAndLog(" <Card Number> : 24-bit value card number"); | |
20 | // PrintAndLog(" Q5 : optional - clone to Q5 (T5555) instead of T55x7 chip"); | |
21 | PrintAndLog(""); | |
22 | PrintAndLog("Sample : lf nedap clone 112233"); | |
23 | return 0; | |
24 | } | |
25 | ||
26 | int usage_lf_nedap_sim(void) { | |
27 | PrintAndLog("Enables simulation of NEDAP card with specified card number."); | |
28 | PrintAndLog("Simulation runs until the button is pressed or another USB command is issued."); | |
29 | PrintAndLog(""); | |
30 | PrintAndLog("Usage: lf nedap sim <Card-Number>"); | |
31 | PrintAndLog("Options :"); | |
32 | PrintAndLog(" <Card Number> : 24-bit value card number"); | |
33 | PrintAndLog(""); | |
34 | PrintAndLog("Sample : lf nedap sim 112233"); | |
35 | return 0; | |
36 | } | |
37 | ||
38 | int GetNedapBits(uint32_t cn, uint8_t *nedapBits) { | |
39 | ||
40 | uint8_t pre[128]; | |
41 | memset(pre, 0x00, sizeof(pre)); | |
42 | ||
43 | // preamble 1111 1111 10 = 0XF8 | |
44 | num_to_bytebits(0xF8, 10, pre); | |
45 | ||
46 | // fixed tagtype code? 0010 1101 = 0x2D | |
47 | num_to_bytebits(0x2D, 8, pre+10); | |
48 | ||
49 | // 46 encrypted bits - UNKNOWN ALGO | |
50 | // -- 16 bits checksum. Should be 4x4 checksum, based on UID and 2 constant values. | |
51 | // -- 30 bits undocumented? | |
52 | num_to_bytebits(cn, 46, pre+18); | |
53 | ||
54 | //----from this part, the UID in clear text, with a 1bit ZERO as separator between bytes. | |
55 | pre[64] = 0; | |
56 | ||
2d1885f1 | 57 | // cardnumber (uid) |
56bbb25a | 58 | num_to_bytebits(cn, 24, pre+64); |
59 | ||
60 | pre[73] = 0; | |
61 | pre[82] = 0; | |
62 | pre[91] = 0; | |
63 | pre[100] = 0; | |
64 | pre[109] = 0; | |
65 | pre[118] = 0; | |
66 | ||
67 | // add paritybits (bitsource, dest, sourcelen, paritylen, parityType (odd, even,) | |
68 | addParity(pre+64, pre+64, 128, 8, 1); | |
c71f4da9 | 69 | |
56bbb25a | 70 | //1111111110001011010000010110100011001001000010110101001101011001000110011010010000000000100001110001001000000001000101011100111 |
71 | return 1; | |
72 | } | |
2d1885f1 | 73 | /* |
74 | - UID: 001630 | |
75 | - i: 4071 | |
76 | - Checksum2 BE21 | |
77 | */ | |
c71f4da9 | 78 | //GetParity( uint8_t *bits, uint8_t type, int length) |
79 | ||
2d1885f1 | 80 | //NEDAP demod - ASK/Biphase (or Diphase), RF/64 with preamble of 1111111110 (always a 128 bit data stream) |
56bbb25a | 81 | //print NEDAP Prox ID, encoding, encrypted ID, |
c71f4da9 | 82 | |
83 | int CmdLFNedapDemod(const char *Cmd) { | |
56bbb25a | 84 | //raw ask demod no start bit finding just get binary from wave |
c71f4da9 | 85 | if (!ASKbiphaseDemod("0 64 0 0", FALSE)) { |
96faed21 | 86 | if (g_debugMode) PrintAndLog("Error NEDAP: ASKbiphaseDemod failed"); |
87 | return 0; | |
88 | } | |
6c283951 | 89 | size_t size = DemodBufferLen; |
c71f4da9 | 90 | int idx = NedapDemod(DemodBuffer, &size); |
56bbb25a | 91 | if (idx < 0){ |
92 | if (g_debugMode){ | |
2d1885f1 | 93 | // if (idx == -5) |
94 | // PrintAndLog("DEBUG: Error - not enough samples"); | |
95 | // else if (idx == -1) | |
96 | // PrintAndLog("DEBUG: Error - only noise found"); | |
97 | // else if (idx == -2) | |
98 | // PrintAndLog("DEBUG: Error - problem during ASK/Biphase demod"); | |
99 | if (idx == -3) | |
56bbb25a | 100 | PrintAndLog("DEBUG: Error - Size not correct: %d", size); |
101 | else if (idx == -4) | |
102 | PrintAndLog("DEBUG: Error - NEDAP preamble not found"); | |
103 | else | |
104 | PrintAndLog("DEBUG: Error - idx: %d",idx); | |
105 | } | |
106 | return 0; | |
107 | } | |
108 | ||
2d1885f1 | 109 | /* Index map E E |
110 | preamble enc tag type encrypted uid P d 33 d 90 d 04 d 71 d 40 d 45 d E7 P | |
111 | 1111111110 00101101000001011010001100100100001011010100110101100 1 0 00110011 0 10010000 0 00000100 0 01110001 0 01000000 0 01000101 0 11100111 1 | |
532bcd71 | 112 | uid2 uid1 uid0 I I R R |
2d1885f1 | 113 | 1111111110 00101101000001011010001100100100001011010100110101100 1 |
114 | ||
115 | 0 00110011 | |
116 | 0 10010000 | |
117 | 0 00000100 | |
118 | 0 01110001 | |
119 | 0 01000000 | |
120 | 0 01000101 | |
121 | 0 11100111 | |
122 | 1 | |
123 | ||
56bbb25a | 124 | Tag ID is 049033 |
125 | I = Identical on all tags | |
126 | R = Random ? | |
127 | UID2, UID1, UID0 == card number | |
532bcd71 | 128 | |
56bbb25a | 129 | */ |
56bbb25a | 130 | //get raw ID before removing parities |
2d1885f1 | 131 | uint32_t raw[4] = {0,0,0,0}; |
132 | raw[0] = bytebits_to_byte(DemodBuffer+idx+96,32); | |
133 | raw[1] = bytebits_to_byte(DemodBuffer+idx+64,32); | |
134 | raw[2] = bytebits_to_byte(DemodBuffer+idx+32,32); | |
135 | raw[3] = bytebits_to_byte(DemodBuffer+idx,32); | |
c71f4da9 | 136 | setDemodBuf(DemodBuffer,128,idx); |
56bbb25a | 137 | |
2d1885f1 | 138 | uint8_t firstParity = GetParity( DemodBuffer, EVEN, 63); |
139 | if ( firstParity != DemodBuffer[63] ) { | |
140 | PrintAndLog("1st 64bit parity check failed: %d|%d ", DemodBuffer[63], firstParity); | |
6c283951 | 141 | return 0; |
532bcd71 | 142 | } |
143 | ||
2d1885f1 | 144 | uint8_t secondParity = GetParity( DemodBuffer+64, EVEN, 63); |
145 | if ( secondParity != DemodBuffer[127] ) { | |
146 | PrintAndLog("2st 64bit parity check failed: %d|%d ", DemodBuffer[127], secondParity); | |
6c283951 | 147 | return 0; |
2d1885f1 | 148 | } |
532bcd71 | 149 | |
56bbb25a | 150 | // ok valid card found! |
2d1885f1 | 151 | uint32_t uid = 0; |
152 | uid = bytebits_to_byte(DemodBuffer+65, 8); | |
153 | uid |= bytebits_to_byte(DemodBuffer+74, 8) << 8; | |
154 | uid |= bytebits_to_byte(DemodBuffer+83, 8) << 16; | |
155 | ||
156 | uint16_t two = 0; | |
157 | two = bytebits_to_byte(DemodBuffer+92, 8); | |
158 | two |= bytebits_to_byte(DemodBuffer+101, 8) << 8; | |
56bbb25a | 159 | |
2d1885f1 | 160 | uint16_t chksum2 = 0; |
161 | chksum2 = bytebits_to_byte(DemodBuffer+110, 8); | |
162 | chksum2 |= bytebits_to_byte(DemodBuffer+119, 8) << 8; | |
163 | ||
164 | PrintAndLog("NEDAP ID Found - Raw: %08x%08x%08x%08x", raw[3], raw[2], raw[1], raw[0]); | |
165 | PrintAndLog(" - UID: %06X", uid); | |
166 | PrintAndLog(" - i: %04X", two); | |
167 | PrintAndLog(" - Checksum2 %04X", chksum2); | |
168 | ||
56bbb25a | 169 | if (g_debugMode){ |
170 | PrintAndLog("DEBUG: idx: %d, Len: %d, Printing Demod Buffer:", idx, 128); | |
171 | printDemodBuff(); | |
2d1885f1 | 172 | PrintAndLog("BIN:\n%s", sprint_bin_break( DemodBuffer, 128, 64) ); |
56bbb25a | 173 | } |
c71f4da9 | 174 | |
56bbb25a | 175 | return 1; |
176 | } | |
c71f4da9 | 177 | /* |
2d1885f1 | 178 | configuration |
179 | lf t55xx wr b 0 d 00170082 | |
180 | ||
181 | 1) uid 049033 | |
c71f4da9 | 182 | lf t55 wr b 1 d FF8B4168 |
183 | lf t55 wr b 2 d C90B5359 | |
184 | lf t55 wr b 3 d 19A40087 | |
185 | lf t55 wr b 4 d 120115CF | |
56bbb25a | 186 | |
2d1885f1 | 187 | 2) uid 001630 |
c71f4da9 | 188 | lf t55 wr b 1 d FF8B6B20 |
189 | lf t55 wr b 2 d F19B84A3 | |
190 | lf t55 wr b 3 d 18058007 | |
191 | lf t55 wr b 4 d 1200857C | |
192 | ||
2d1885f1 | 193 | 3) uid 39feff |
194 | lf t55xx wr b 1 d ffbfa73e | |
195 | lf t55xx wr b 2 d 4c0003ff | |
196 | lf t55xx wr b 3 d ffbfa73e | |
197 | lf t55xx wr b 4 d 4c0003ff | |
198 | ||
c71f4da9 | 199 | */ |
56bbb25a | 200 | |
201 | int CmdLFNedapRead(const char *Cmd) { | |
202 | CmdLFRead("s"); | |
203 | getSamples("30000",false); | |
c71f4da9 | 204 | return CmdLFNedapDemod(""); |
56bbb25a | 205 | } |
206 | /* | |
207 | int CmdLFNedapClone(const char *Cmd) { | |
208 | ||
209 | char cmdp = param_getchar(Cmd, 0); | |
210 | if (strlen(Cmd) == 0 || cmdp == 'h' || cmdp == 'H') return usage_lf_nedap_clone(); | |
211 | ||
212 | uint32_t cardnumber=0, cn = 0; | |
213 | uint32_t blocks[5]; | |
214 | uint8_t i; | |
215 | uint8_t bs[128]; | |
216 | memset(bs, 0x00, sizeof(bs)); | |
217 | ||
218 | if (sscanf(Cmd, "%u", &cn ) != 1) return usage_lf_nedap_clone(); | |
219 | ||
220 | cardnumber = (cn & 0x00FFFFFF); | |
221 | ||
222 | if ( !GetNedapBits(cardnumber, bs)) { | |
223 | PrintAndLog("Error with tag bitstream generation."); | |
224 | return 1; | |
225 | } | |
226 | ||
227 | ((ASK/biphase data rawdemod ab 0 64 1 0 | |
228 | //NEDAP - compat mode, ASK/Biphase, data rate 64, 4 data blocks | |
229 | blocks[0] = T55x7_MODULATION_BIPHASE | T55x7_BITRATE_RF_64 | 4<<T55x7_MAXBLOCK_SHIFT; | |
230 | ||
231 | if (param_getchar(Cmd, 3) == 'Q' || param_getchar(Cmd, 3) == 'q') | |
890ae3dd | 232 | //t5555 (Q5) BITRATE = (RF-2)/2 (iceman) |
56bbb25a | 233 | blocks[0] = T5555_MODULATION_BIPHASE | T5555_INVERT_OUTPUT | 64<<T5555_BITRATE_SHIFT | 4<<T5555_MAXBLOCK_SHIFT; |
234 | ||
235 | blocks[1] = bytebits_to_byte(bs,32); | |
236 | blocks[2] = bytebits_to_byte(bs+32,32); | |
237 | blocks[3] = bytebits_to_byte(bs+64,32); | |
238 | blocks[4] = bytebits_to_byte(bs+96,32); | |
239 | ||
240 | PrintAndLog("Preparing to clone NEDAP to T55x7 with card number: %u", cardnumber); | |
241 | PrintAndLog("Blk | Data "); | |
242 | PrintAndLog("----+------------"); | |
243 | for ( i = 0; i<5; ++i ) | |
244 | PrintAndLog(" %02d | %08" PRIx32, i, blocks[i]); | |
245 | ||
246 | UsbCommand resp; | |
247 | UsbCommand c = {CMD_T55XX_WRITE_BLOCK, {0,0,0}}; | |
248 | ||
249 | for ( i = 0; i<5; ++i ) { | |
250 | c.arg[0] = blocks[i]; | |
251 | c.arg[1] = i; | |
252 | clearCommandBuffer(); | |
253 | SendCommand(&c); | |
254 | if (!WaitForResponseTimeout(CMD_ACK, &resp, 1000)){ | |
255 | PrintAndLog("Error occurred, device did not respond during write operation."); | |
256 | return -1; | |
257 | } | |
258 | } | |
259 | return 0; | |
260 | } | |
261 | */ | |
262 | ||
263 | int CmdLFNedapSim(const char *Cmd) { | |
264 | ||
265 | char cmdp = param_getchar(Cmd, 0); | |
266 | if (strlen(Cmd) == 0 || cmdp == 'h' || cmdp == 'H') return usage_lf_nedap_sim(); | |
267 | ||
268 | uint32_t cardnumber = 0, cn = 0; | |
269 | ||
270 | uint8_t bs[128]; | |
271 | size_t size = sizeof(bs); | |
272 | memset(bs, 0x00, size); | |
273 | ||
274 | // NEDAP, Bihase = 2, clock 64, inverted, | |
275 | uint8_t encoding = 2, separator = 0, clk=64, invert=1; | |
276 | uint16_t arg1, arg2; | |
277 | arg1 = clk << 8 | encoding; | |
278 | arg2 = invert << 8 | separator; | |
279 | ||
280 | if (sscanf(Cmd, "%u", &cn ) != 2) return usage_lf_nedap_sim(); | |
281 | cardnumber = (cn & 0x00FFFFFF); | |
282 | ||
283 | if ( !GetNedapBits(cardnumber, bs)) { | |
284 | PrintAndLog("Error with tag bitstream generation."); | |
285 | return 1; | |
286 | } | |
287 | ||
288 | PrintAndLog("Simulating Nedap - CardNumber: %u", cardnumber ); | |
289 | ||
290 | UsbCommand c = {CMD_ASK_SIM_TAG, {arg1, arg2, size}}; | |
291 | memcpy(c.d.asBytes, bs, size); | |
292 | clearCommandBuffer(); | |
293 | SendCommand(&c); | |
294 | return 0; | |
295 | } | |
296 | ||
812513bf | 297 | |
298 | ||
c71f4da9 | 299 | int CmdLFNedapChk(const char *Cmd){ |
300 | ||
532bcd71 | 301 | uint8_t data[256] = { 0x30, 0x16, 0x00, 0x71, 0x40, 0x21, 0xBE}; |
c71f4da9 | 302 | int len = 0; |
303 | param_gethex_ex(Cmd, 0, data, &len); | |
304 | ||
305 | len = ( len == 0 ) ? 5 : len>>1; | |
306 | ||
307 | PrintAndLog("Input: [%d] %s", len, sprint_hex(data, len)); | |
308 | ||
812513bf | 309 | //uint8_t last = GetParity(data, EVEN, 62); |
310 | //PrintAndLog("TEST PARITY:: %d | %d ", DemodBuffer[62], last); | |
532bcd71 | 311 | |
c71f4da9 | 312 | uint8_t cl = 0x1D, ch = 0x1D, carry = 0; |
313 | uint8_t al, bl, temp; | |
314 | ||
315 | for (int i = 0; i < len; ++i){ | |
316 | al = data[i]; | |
317 | for (int j = 8; j > 0; --j) { | |
318 | ||
319 | bl = al ^ ch; | |
320 | //printf("BL %02x | CH %02x \n", al, ch); | |
321 | ||
322 | carry = (cl & 0x80) ? 1 : 0; | |
323 | cl <<= 1; | |
324 | ||
325 | temp = (ch & 0x80) ? 1 : 0; | |
326 | ch = (ch << 1) | carry; | |
327 | carry = temp; | |
328 | ||
329 | carry = (al & 0x80) ? 1 : 0; | |
330 | al <<= 1; | |
331 | ||
332 | carry = (bl & 0x80) ? 1 : 0; | |
333 | bl <<= 1; | |
334 | ||
335 | if (carry) { | |
336 | cl ^= 0x21; | |
337 | ch ^= 0x10; | |
338 | } | |
339 | } | |
340 | } | |
341 | ||
342 | PrintAndLog("Nedap checksum: [ 0x21, 0xBE ] %x", ((ch << 8) | cl) ); | |
343 | return 0; | |
344 | } | |
345 | ||
346 | ||
56bbb25a | 347 | static command_t CommandTable[] = { |
348 | {"help", CmdHelp, 1, "This help"}, | |
c71f4da9 | 349 | {"read", CmdLFNedapRead, 0, "Attempt to read and extract tag data"}, |
350 | // {"clone", CmdLFNedapClone,0, "<Card Number> clone nedap tag"}, | |
351 | {"sim", CmdLFNedapSim, 0, "<Card Number> simulate nedap tag"}, | |
352 | {"chk", CmdLFNedapChk, 1, "Calculate Nedap Checksum <uid bytes>"}, | |
56bbb25a | 353 | {NULL, NULL, 0, NULL} |
354 | }; | |
355 | ||
356 | int CmdLFNedap(const char *Cmd) { | |
357 | clearCommandBuffer(); | |
358 | CmdsParse(CommandTable, Cmd); | |
359 | return 0; | |
360 | } | |
361 | ||
362 | int CmdHelp(const char *Cmd) { | |
363 | CmdsHelp(CommandTable); | |
364 | return 0; | |
365 | } |