]>
Commit | Line | Data |
---|---|---|
6923d3f1 | 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 Farpoint / Pyramid tag commands | |
b9957414 | 8 | // FSK2a, rf/50, 128 bits (complete) |
6923d3f1 | 9 | //----------------------------------------------------------------------------- |
10 | #include <string.h> | |
11 | #include <inttypes.h> | |
acf0582d | 12 | #include <stdio.h> |
2b4898ec | 13 | #include "cmdlfpyramid.h" |
29ada8fc | 14 | #include "proxmark3.h" |
15 | #include "ui.h" | |
16 | #include "util.h" | |
17 | #include "graph.h" | |
18 | #include "cmdparser.h" | |
cf4640b9 | 19 | #include "cmddata.h" // setDemodBuf + |
29ada8fc | 20 | #include "cmdmain.h" |
21 | #include "cmdlf.h" | |
22 | #include "protocols.h" // for T55xx config register definitions | |
23 | #include "lfdemod.h" // parityTest | |
24 | #include "crc.h" | |
25 | ||
6923d3f1 | 26 | static int CmdHelp(const char *Cmd); |
27 | ||
28 | int usage_lf_pyramid_clone(void){ | |
29 | PrintAndLog("clone a Farpointe/Pyramid tag to a T55x7 tag."); | |
30 | PrintAndLog("The facility-code is 8-bit and the card number is 16-bit. Larger values are truncated. "); | |
cf4640b9 | 31 | PrintAndLog("Currently only works on 26bit"); |
6923d3f1 | 32 | PrintAndLog(""); |
33 | PrintAndLog("Usage: lf pyramid clone <Facility-Code> <Card-Number>"); | |
34 | PrintAndLog("Options :"); | |
35 | PrintAndLog(" <Facility-Code> : 8-bit value facility code"); | |
36 | PrintAndLog(" <Card Number> : 16-bit value card number"); | |
29ada8fc | 37 | PrintAndLog(" Q5 : optional - clone to Q5 (T5555) instead of T55x7 chip"); |
6923d3f1 | 38 | PrintAndLog(""); |
39 | PrintAndLog("Sample : lf pyramid clone 123 11223"); | |
40 | return 0; | |
41 | } | |
42 | ||
43 | int usage_lf_pyramid_sim(void) { | |
44 | PrintAndLog("Enables simulation of Farpointe/Pyramid card with specified card number."); | |
45 | PrintAndLog("Simulation runs until the button is pressed or another USB command is issued."); | |
46 | PrintAndLog("The facility-code is 8-bit and the card number is 16-bit. Larger values are truncated."); | |
47 | PrintAndLog("Currently work only on 26bit"); | |
48 | PrintAndLog(""); | |
49 | PrintAndLog("Usage: lf pyramid sim <Card-Number>"); | |
50 | PrintAndLog("Options :"); | |
51 | PrintAndLog(" <Facility-Code> : 8-bit value facility code"); | |
52 | PrintAndLog(" <Card Number> : 16-bit value card number"); | |
53 | PrintAndLog(""); | |
54 | PrintAndLog("Sample : lf pyramid sim 123 11223"); | |
55 | return 0; | |
56 | } | |
57 | ||
58 | // Works for 26bits. | |
59 | int GetPyramidBits(uint32_t fc, uint32_t cn, uint8_t *pyramidBits) { | |
60 | ||
61 | uint8_t pre[128]; | |
62 | memset(pre, 0x00, sizeof(pre)); | |
63 | ||
64 | // format start bit | |
65 | pre[79] = 1; | |
66 | ||
67 | // Get 26 wiegand from FacilityCode, CardNumber | |
68 | uint8_t wiegand[24]; | |
69 | memset(wiegand, 0x00, sizeof(wiegand)); | |
70 | num_to_bytebits(fc, 8, wiegand); | |
71 | num_to_bytebits(cn, 16, wiegand+8); | |
72 | ||
73 | // add wiegand parity bits (dest, source, len) | |
74 | wiegand_add_parity(pre+80, wiegand, 24); | |
75 | ||
76 | // add paritybits (bitsource, dest, sourcelen, paritylen, parityType (odd, even,) | |
77 | addParity(pre+8, pyramidBits+8, 102, 8, 1); | |
78 | ||
79 | // add checksum | |
80 | uint8_t csBuff[13]; | |
81 | for (uint8_t i = 0; i < 13; i++) | |
82 | csBuff[i] = bytebits_to_byte(pyramidBits + 16 + (i*8), 8); | |
83 | ||
84 | uint32_t crc = CRC8Maxim(csBuff, 13); | |
85 | num_to_bytebits(crc, 8, pyramidBits+120); | |
86 | return 1; | |
87 | } | |
88 | ||
cf4640b9 | 89 | //by marshmellow |
90 | //Pyramid Prox demod - FSK RF/50 with preamble of 0000000000000001 (always a 128 bit data stream) | |
91 | //print full Farpointe Data/Pyramid Prox ID and some bit format details if found | |
92 | int CmdFSKdemodPyramid(const char *Cmd) | |
93 | { | |
94 | //raw fsk demod no manchester decoding no start bit finding just get binary from wave | |
95 | uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; | |
96 | size_t size = getFromGraphBuf(BitStream); | |
97 | if (size==0) return 0; | |
98 | ||
1c70664a | 99 | int waveIdx=0; |
cf4640b9 | 100 | //get binary from fsk wave |
1c70664a | 101 | int idx = PyramiddemodFSK(BitStream, &size, &waveIdx); |
cf4640b9 | 102 | if (idx < 0){ |
103 | if (g_debugMode){ | |
104 | if (idx == -5) | |
105 | PrintAndLog("DEBUG: Error - not enough samples"); | |
106 | else if (idx == -1) | |
107 | PrintAndLog("DEBUG: Error - only noise found"); | |
108 | else if (idx == -2) | |
109 | PrintAndLog("DEBUG: Error - problem during FSK demod"); | |
110 | else if (idx == -3) | |
111 | PrintAndLog("DEBUG: Error - Size not correct: %d", size); | |
112 | else if (idx == -4) | |
113 | PrintAndLog("DEBUG: Error - Pyramid preamble not found"); | |
114 | else | |
115 | PrintAndLog("DEBUG: Error - idx: %d",idx); | |
116 | } | |
117 | return 0; | |
118 | } | |
119 | // Index map | |
120 | // 0 10 20 30 40 50 60 | |
121 | // | | | | | | | | |
122 | // 0123456 7 8901234 5 6789012 3 4567890 1 2345678 9 0123456 7 8901234 5 6789012 3 | |
123 | // ----------------------------------------------------------------------------- | |
124 | // 0000000 0 0000000 1 0000000 1 0000000 1 0000000 1 0000000 1 0000000 1 0000000 1 | |
125 | // premable xxxxxxx o xxxxxxx o xxxxxxx o xxxxxxx o xxxxxxx o xxxxxxx o xxxxxxx o | |
126 | ||
127 | // 64 70 80 90 100 110 120 | |
128 | // | | | | | | | | |
129 | // 4567890 1 2345678 9 0123456 7 8901234 5 6789012 3 4567890 1 2345678 9 0123456 7 | |
130 | // ----------------------------------------------------------------------------- | |
131 | // 0000000 1 0000000 1 0000000 1 0110111 0 0011000 1 0000001 0 0001100 1 1001010 0 | |
132 | // xxxxxxx o xxxxxxx o xxxxxxx o xswffff o ffffccc o ccccccc o ccccccw o ppppppp o | |
133 | // |---115---||---------71---------| | |
134 | // s = format start bit, o = odd parity of last 7 bits | |
135 | // f = facility code, c = card number | |
136 | // w = wiegand parity, x = extra space for other formats | |
137 | // p = unknown checksum | |
138 | // (26 bit format shown) | |
139 | ||
140 | //get bytes for checksum calc | |
141 | uint8_t checksum = bytebits_to_byte(BitStream + idx + 120, 8); | |
142 | uint8_t csBuff[14] = {0x00}; | |
143 | for (uint8_t i = 0; i < 13; i++){ | |
144 | csBuff[i] = bytebits_to_byte(BitStream + idx + 16 + (i*8), 8); | |
145 | } | |
146 | //check checksum calc | |
147 | //checksum calc thanks to ICEMAN!! | |
148 | uint32_t checkCS = CRC8Maxim(csBuff,13); | |
149 | ||
150 | //get raw ID before removing parities | |
151 | uint32_t rawLo = bytebits_to_byte(BitStream+idx+96,32); | |
152 | uint32_t rawHi = bytebits_to_byte(BitStream+idx+64,32); | |
153 | uint32_t rawHi2 = bytebits_to_byte(BitStream+idx+32,32); | |
154 | uint32_t rawHi3 = bytebits_to_byte(BitStream+idx,32); | |
155 | setDemodBuf(BitStream,128,idx); | |
1c70664a | 156 | setClockGrid(50, waveIdx + (idx*50)); |
cf4640b9 | 157 | |
158 | size = removeParity(BitStream, idx+8, 8, 1, 120); | |
159 | if (size != 105){ | |
160 | if (g_debugMode) | |
161 | PrintAndLog("DEBUG: Error at parity check - tag size does not match Pyramid format, SIZE: %d, IDX: %d, hi3: %x",size, idx, rawHi3); | |
162 | return 0; | |
163 | } | |
164 | ||
165 | // ok valid card found! | |
166 | ||
167 | // Index map | |
168 | // 0 10 20 30 40 50 60 70 | |
169 | // | | | | | | | | | |
170 | // 01234567890123456789012345678901234567890123456789012345678901234567890 | |
171 | // ----------------------------------------------------------------------- | |
172 | // 00000000000000000000000000000000000000000000000000000000000000000000000 | |
173 | // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx | |
174 | ||
175 | // 71 80 90 100 | |
176 | // | | | | | |
177 | // 1 2 34567890 1234567890123456 7 8901234 | |
178 | // --------------------------------------- | |
179 | // 1 1 01110011 0000000001000110 0 1001010 | |
180 | // s w ffffffff cccccccccccccccc w ppppppp | |
181 | // |--115-| |------71------| | |
182 | // s = format start bit, o = odd parity of last 7 bits | |
183 | // f = facility code, c = card number | |
184 | // w = wiegand parity, x = extra space for other formats | |
185 | // p = unknown checksum | |
186 | // (26 bit format shown) | |
187 | ||
188 | //find start bit to get fmtLen | |
189 | int j; | |
190 | for (j=0; j<size; j++){ | |
191 | if(BitStream[j]) break; | |
192 | } | |
193 | uint8_t fmtLen = size-j-8; | |
194 | uint32_t fc = 0; | |
195 | uint32_t cardnum = 0; | |
196 | uint32_t code1 = 0; | |
197 | if (fmtLen==26){ | |
198 | fc = bytebits_to_byte(BitStream+73, 8); | |
199 | cardnum = bytebits_to_byte(BitStream+81, 16); | |
200 | code1 = bytebits_to_byte(BitStream+72,fmtLen); | |
201 | PrintAndLog("Pyramid ID Found - BitLength: %d, FC: %d, Card: %d - Wiegand: %x, Raw: %08x%08x%08x%08x", fmtLen, fc, cardnum, code1, rawHi3, rawHi2, rawHi, rawLo); | |
202 | } else if (fmtLen==45){ | |
203 | fmtLen=42; //end = 10 bits not 7 like 26 bit fmt | |
204 | fc = bytebits_to_byte(BitStream+53, 10); | |
205 | cardnum = bytebits_to_byte(BitStream+63, 32); | |
206 | PrintAndLog("Pyramid ID Found - BitLength: %d, FC: %d, Card: %d - Raw: %08x%08x%08x%08x", fmtLen, fc, cardnum, rawHi3, rawHi2, rawHi, rawLo); | |
207 | } else { | |
208 | cardnum = bytebits_to_byte(BitStream+81, 16); | |
209 | if (fmtLen>32){ | |
210 | //code1 = bytebits_to_byte(BitStream+(size-fmtLen),fmtLen-32); | |
211 | //code2 = bytebits_to_byte(BitStream+(size-32),32); | |
212 | PrintAndLog("Pyramid ID Found - BitLength: %d -unknown BitLength- (%d), Raw: %08x%08x%08x%08x", fmtLen, cardnum, rawHi3, rawHi2, rawHi, rawLo); | |
213 | } else{ | |
214 | //code1 = bytebits_to_byte(BitStream+(size-fmtLen),fmtLen); | |
215 | PrintAndLog("Pyramid ID Found - BitLength: %d -unknown BitLength- (%d), Raw: %08x%08x%08x%08x", fmtLen, cardnum, rawHi3, rawHi2, rawHi, rawLo); | |
216 | } | |
217 | } | |
218 | if (checksum == checkCS) | |
219 | PrintAndLog("Checksum %02x passed", checksum); | |
220 | else | |
221 | PrintAndLog("Checksum %02x failed - should have been %02x", checksum, checkCS); | |
222 | ||
223 | if (g_debugMode){ | |
224 | PrintAndLog("DEBUG: idx: %d, Len: %d, Printing Demod Buffer:", idx, 128); | |
225 | printDemodBuff(); | |
226 | } | |
227 | return 1; | |
228 | } | |
229 | ||
6923d3f1 | 230 | int CmdPyramidRead(const char *Cmd) { |
b9957414 | 231 | lf_read(true, 15000); |
6923d3f1 | 232 | return CmdFSKdemodPyramid(""); |
233 | } | |
234 | ||
235 | int CmdPyramidClone(const char *Cmd) { | |
236 | ||
237 | char cmdp = param_getchar(Cmd, 0); | |
238 | if (strlen(Cmd) == 0 || cmdp == 'h' || cmdp == 'H') return usage_lf_pyramid_clone(); | |
239 | ||
240 | uint32_t facilitycode=0, cardnumber=0, fc = 0, cn = 0; | |
241 | uint32_t blocks[5]; | |
242 | uint8_t i; | |
243 | uint8_t bs[128]; | |
244 | memset(bs, 0x00, sizeof(bs)); | |
245 | ||
246 | if (sscanf(Cmd, "%u %u", &fc, &cn ) != 2) return usage_lf_pyramid_clone(); | |
247 | ||
248 | facilitycode = (fc & 0x000000FF); | |
249 | cardnumber = (cn & 0x0000FFFF); | |
250 | ||
251 | if ( !GetPyramidBits(facilitycode, cardnumber, bs)) { | |
252 | PrintAndLog("Error with tag bitstream generation."); | |
253 | return 1; | |
29ada8fc | 254 | } |
6923d3f1 | 255 | |
256 | //Pyramid - compat mode, FSK2a, data rate 50, 4 data blocks | |
257 | blocks[0] = T55x7_MODULATION_FSK2a | T55x7_BITRATE_RF_50 | 4<<T55x7_MAXBLOCK_SHIFT; | |
29ada8fc | 258 | |
259 | if (param_getchar(Cmd, 3) == 'Q' || param_getchar(Cmd, 3) == 'q') | |
260 | blocks[0] = T5555_MODULATION_FSK2 | T5555_INVERT_OUTPUT | 50<<T5555_BITRATE_SHIFT | 4<<T5555_MAXBLOCK_SHIFT; | |
261 | ||
6923d3f1 | 262 | blocks[1] = bytebits_to_byte(bs,32); |
263 | blocks[2] = bytebits_to_byte(bs+32,32); | |
264 | blocks[3] = bytebits_to_byte(bs+64,32); | |
265 | blocks[4] = bytebits_to_byte(bs+96,32); | |
266 | ||
267 | PrintAndLog("Preparing to clone Farpointe/Pyramid to T55x7 with Facility Code: %u, Card Number: %u", facilitycode, cardnumber); | |
268 | PrintAndLog("Blk | Data "); | |
269 | PrintAndLog("----+------------"); | |
270 | for ( i = 0; i<5; ++i ) | |
271 | PrintAndLog(" %02d | %08" PRIx32, i, blocks[i]); | |
272 | ||
273 | UsbCommand resp; | |
274 | UsbCommand c = {CMD_T55XX_WRITE_BLOCK, {0,0,0}}; | |
275 | ||
276 | for ( i = 0; i<5; ++i ) { | |
277 | c.arg[0] = blocks[i]; | |
278 | c.arg[1] = i; | |
279 | clearCommandBuffer(); | |
280 | SendCommand(&c); | |
281 | if (!WaitForResponseTimeout(CMD_ACK, &resp, 1000)){ | |
282 | PrintAndLog("Error occurred, device did not respond during write operation."); | |
283 | return -1; | |
284 | } | |
285 | } | |
29ada8fc | 286 | return 0; |
6923d3f1 | 287 | } |
288 | ||
289 | int CmdPyramidSim(const char *Cmd) { | |
290 | ||
291 | char cmdp = param_getchar(Cmd, 0); | |
292 | if (strlen(Cmd) == 0 || cmdp == 'h' || cmdp == 'H') return usage_lf_pyramid_sim(); | |
293 | ||
294 | uint32_t facilitycode = 0, cardnumber = 0, fc = 0, cn = 0; | |
29ada8fc | 295 | |
6923d3f1 | 296 | uint8_t bs[128]; |
297 | size_t size = sizeof(bs); | |
298 | memset(bs, 0x00, size); | |
29ada8fc | 299 | |
6923d3f1 | 300 | // Pyramid uses: fcHigh: 10, fcLow: 8, clk: 50, invert: 0 |
301 | uint64_t arg1, arg2; | |
302 | arg1 = (10 << 8) + 8; | |
303 | arg2 = 50 | 0; | |
304 | ||
305 | if (sscanf(Cmd, "%u %u", &fc, &cn ) != 2) return usage_lf_pyramid_sim(); | |
306 | ||
307 | facilitycode = (fc & 0x000000FF); | |
308 | cardnumber = (cn & 0x0000FFFF); | |
29ada8fc | 309 | |
6923d3f1 | 310 | if ( !GetPyramidBits(facilitycode, cardnumber, bs)) { |
311 | PrintAndLog("Error with tag bitstream generation."); | |
312 | return 1; | |
29ada8fc | 313 | } |
6923d3f1 | 314 | |
315 | PrintAndLog("Simulating Farpointe/Pyramid - Facility Code: %u, CardNumber: %u", facilitycode, cardnumber ); | |
29ada8fc | 316 | |
6923d3f1 | 317 | UsbCommand c = {CMD_FSK_SIM_TAG, {arg1, arg2, size}}; |
318 | memcpy(c.d.asBytes, bs, size); | |
319 | clearCommandBuffer(); | |
320 | SendCommand(&c); | |
321 | return 0; | |
322 | } | |
323 | ||
324 | static command_t CommandTable[] = { | |
cf4640b9 | 325 | {"help", CmdHelp, 1, "This help"}, |
326 | {"demod", CmdFSKdemodPyramid, 1, "Demodulate a Pyramid FSK tag from the GraphBuffer"}, | |
327 | {"read", CmdPyramidRead, 0, "Attempt to read and extract tag data"}, | |
328 | {"clone", CmdPyramidClone, 0, "<Facility-Code> <Card Number> clone pyramid tag"}, | |
329 | {"sim", CmdPyramidSim, 0, "<Facility-Code> <Card Number> simulate pyramid tag"}, | |
29ada8fc | 330 | {NULL, NULL, 0, NULL} |
6923d3f1 | 331 | }; |
332 | ||
333 | int CmdLFPyramid(const char *Cmd) { | |
334 | clearCommandBuffer(); | |
29ada8fc | 335 | CmdsParse(CommandTable, Cmd); |
336 | return 0; | |
6923d3f1 | 337 | } |
338 | ||
339 | int CmdHelp(const char *Cmd) { | |
29ada8fc | 340 | CmdsHelp(CommandTable); |
341 | return 0; | |
6923d3f1 | 342 | } |