]> git.zerfleddert.de Git - proxmark3-svn/blame - client/cmdhf14b.c
First check in.
[proxmark3-svn] / client / cmdhf14b.c
CommitLineData
a553f267 1//-----------------------------------------------------------------------------
2// Copyright (C) 2010 iZsh <izsh at fail0verflow.com>
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// High frequency ISO14443B commands
9//-----------------------------------------------------------------------------
10
7fe9b0b7 11#include <stdio.h>
12#include <stdlib.h>
13#include <stdbool.h>
14#include <string.h>
15#include <stdint.h>
f38a1528 16#include "../common/iso14443crc.h"
902cb3c0 17#include "proxmark3.h"
7fe9b0b7 18#include "data.h"
19#include "graph.h"
20#include "ui.h"
21#include "cmdparser.h"
22#include "cmdhf14b.h"
7cf3ef20 23#include "cmdmain.h"
7fe9b0b7 24
25static int CmdHelp(const char *Cmd);
26
27int CmdHF14BDemod(const char *Cmd)
28{
29 int i, j, iold;
30 int isum, qsum;
31 int outOfWeakAt;
32 bool negateI, negateQ;
33
34 uint8_t data[256];
35 int dataLen = 0;
36
37 // As received, the samples are pairs, correlations against I and Q
38 // square waves. So estimate angle of initial carrier (or just
39 // quadrant, actually), and then do the demod.
40
41 // First, estimate where the tag starts modulating.
42 for (i = 0; i < GraphTraceLen; i += 2) {
43 if (abs(GraphBuffer[i]) + abs(GraphBuffer[i + 1]) > 40) {
44 break;
45 }
46 }
47 if (i >= GraphTraceLen) {
48 PrintAndLog("too weak to sync");
49 return 0;
50 }
51 PrintAndLog("out of weak at %d", i);
52 outOfWeakAt = i;
53
54 // Now, estimate the phase in the initial modulation of the tag
55 isum = 0;
56 qsum = 0;
57 for (; i < (outOfWeakAt + 16); i += 2) {
58 isum += GraphBuffer[i + 0];
59 qsum += GraphBuffer[i + 1];
60 }
61 negateI = (isum < 0);
62 negateQ = (qsum < 0);
63
64 // Turn the correlation pairs into soft decisions on the bit.
65 j = 0;
66 for (i = 0; i < GraphTraceLen / 2; i++) {
67 int si = GraphBuffer[j];
68 int sq = GraphBuffer[j + 1];
69 if (negateI) si = -si;
70 if (negateQ) sq = -sq;
71 GraphBuffer[i] = si + sq;
72 j += 2;
73 }
74 GraphTraceLen = i;
75
76 i = outOfWeakAt / 2;
77 while (GraphBuffer[i] > 0 && i < GraphTraceLen)
78 i++;
79 if (i >= GraphTraceLen) goto demodError;
80
81 iold = i;
82 while (GraphBuffer[i] < 0 && i < GraphTraceLen)
83 i++;
84 if (i >= GraphTraceLen) goto demodError;
85 if ((i - iold) > 23) goto demodError;
86
87 PrintAndLog("make it to demod loop");
88
89 for (;;) {
90 iold = i;
91 while (GraphBuffer[i] >= 0 && i < GraphTraceLen)
92 i++;
93 if (i >= GraphTraceLen) goto demodError;
94 if ((i - iold) > 6) goto demodError;
95
96 uint16_t shiftReg = 0;
97 if (i + 20 >= GraphTraceLen) goto demodError;
98
99 for (j = 0; j < 10; j++) {
100 int soft = GraphBuffer[i] + GraphBuffer[i + 1];
101
102 if (abs(soft) < (abs(isum) + abs(qsum)) / 20) {
103 PrintAndLog("weak bit");
104 }
105
106 shiftReg >>= 1;
107 if(GraphBuffer[i] + GraphBuffer[i+1] >= 0) {
108 shiftReg |= 0x200;
109 }
110
111 i+= 2;
112 }
113
114 if ((shiftReg & 0x200) && !(shiftReg & 0x001))
115 {
116 // valid data byte, start and stop bits okay
117 PrintAndLog(" %02x", (shiftReg >> 1) & 0xff);
118 data[dataLen++] = (shiftReg >> 1) & 0xff;
119 if (dataLen >= sizeof(data)) {
120 return 0;
121 }
122 } else if (shiftReg == 0x000) {
123 // this is EOF
124 break;
125 } else {
126 goto demodError;
127 }
128 }
129
130 uint8_t first, second;
131 ComputeCrc14443(CRC_14443_B, data, dataLen-2, &first, &second);
132 PrintAndLog("CRC: %02x %02x (%s)\n", first, second,
133 (first == data[dataLen-2] && second == data[dataLen-1]) ?
134 "ok" : "****FAIL****");
135
136 RepaintGraphWindow();
137 return 0;
138
139demodError:
140 PrintAndLog("demod error");
141 RepaintGraphWindow();
142 return 0;
143}
144
145int CmdHF14BList(const char *Cmd)
146{
147 uint8_t got[960];
db09cb3a 148 GetFromBigBuf(got,sizeof(got),0);
869cabf7 149 WaitForResponse(CMD_ACK,NULL);
7fe9b0b7 150
151 PrintAndLog("recorded activity:");
152 PrintAndLog(" time :rssi: who bytes");
153 PrintAndLog("---------+----+----+-----------");
154
155 int i = 0;
156 int prev = -1;
157
158 for(;;) {
159 if(i >= 900) {
160 break;
161 }
162
163 bool isResponse;
164 int timestamp = *((uint32_t *)(got+i));
165 if(timestamp & 0x80000000) {
166 timestamp &= 0x7fffffff;
167 isResponse = 1;
168 } else {
169 isResponse = 0;
170 }
171 int metric = *((uint32_t *)(got+i+4));
172
173 int len = got[i+8];
174
175 if(len > 100) {
176 break;
177 }
178 if(i + len >= 900) {
179 break;
180 }
181
182 uint8_t *frame = (got+i+9);
183
7bc95e2e 184 // Break and stick with current result if buffer was not completely full
185 if (frame[0] == 0x44 && frame[1] == 0x44 && frame[2] == 0x44 && frame[3] == 0x44) break;
186
7fe9b0b7 187 char line[1000] = "";
188 int j;
189 for(j = 0; j < len; j++) {
190 sprintf(line+(j*3), "%02x ", frame[j]);
191 }
192
193 char *crc;
194 if(len > 2) {
195 uint8_t b1, b2;
196 ComputeCrc14443(CRC_14443_B, frame, len-2, &b1, &b2);
197 if(b1 != frame[len-2] || b2 != frame[len-1]) {
198 crc = "**FAIL CRC**";
199 } else {
200 crc = "";
201 }
202 } else {
203 crc = "(SHORT)";
204 }
205
206 char metricString[100];
207 if(isResponse) {
208 sprintf(metricString, "%3d", metric);
209 } else {
210 strcpy(metricString, " ");
211 }
212
213 PrintAndLog(" +%7d: %s: %s %s %s",
214 (prev < 0 ? 0 : timestamp - prev),
215 metricString,
216 (isResponse ? "TAG" : " "), line, crc);
217
218 prev = timestamp;
219 i += (len + 9);
220 }
221 return 0;
222}
223
224int CmdHF14BRead(const char *Cmd)
225{
226 UsbCommand c = {CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443, {strtol(Cmd, NULL, 0), 0, 0}};
227 SendCommand(&c);
228 return 0;
229}
230
231int CmdHF14Sim(const char *Cmd)
232{
233 UsbCommand c={CMD_SIMULATE_TAG_ISO_14443};
234 SendCommand(&c);
235 return 0;
236}
237
238int CmdHFSimlisten(const char *Cmd)
239{
240 UsbCommand c = {CMD_SIMULATE_TAG_HF_LISTEN};
241 SendCommand(&c);
242 return 0;
243}
244
245int CmdHF14BSnoop(const char *Cmd)
246{
247 UsbCommand c = {CMD_SNOOP_ISO_14443};
248 SendCommand(&c);
249 return 0;
250}
251
252/* New command to read the contents of a SRI512 tag
253 * SRI512 tags are ISO14443-B modulated memory tags,
254 * this command just dumps the contents of the memory
255 */
256int CmdSri512Read(const char *Cmd)
257{
258 UsbCommand c = {CMD_READ_SRI512_TAG, {strtol(Cmd, NULL, 0), 0, 0}};
259 SendCommand(&c);
260 return 0;
261}
262
263/* New command to read the contents of a SRIX4K tag
264 * SRIX4K tags are ISO14443-B modulated memory tags,
265 * this command just dumps the contents of the memory/
266 */
267int CmdSrix4kRead(const char *Cmd)
268{
269 UsbCommand c = {CMD_READ_SRIX4K_TAG, {strtol(Cmd, NULL, 0), 0, 0}};
270 SendCommand(&c);
271 return 0;
272}
273
7cf3ef20 274int CmdHF14BCmdRaw (const char *cmd) {
275 UsbCommand resp;
276 uint8_t *recv;
277 UsbCommand c = {CMD_ISO_14443B_COMMAND, {0, 0, 0}}; // len,recv?
278 uint8_t reply=1;
279 uint8_t crc=0;
280 uint8_t power=0;
281 char buf[5]="";
282 int i=0;
283 uint8_t data[100];
284 unsigned int datalen=0, temp;
285 char *hexout;
286
287 if (strlen(cmd)<3) {
288 PrintAndLog("Usage: hf 14b raw [-r] [-c] [-p] <0A 0B 0C ... hex>");
289 PrintAndLog(" -r do not read response");
290 PrintAndLog(" -c calculate and append CRC");
291 PrintAndLog(" -p leave the field on after receive");
292 return 0;
293 }
294
295 // strip
296 while (*cmd==' ' || *cmd=='\t') cmd++;
297
298 while (cmd[i]!='\0') {
299 if (cmd[i]==' ' || cmd[i]=='\t') { i++; continue; }
300 if (cmd[i]=='-') {
301 switch (cmd[i+1]) {
302 case 'r':
303 case 'R':
304 reply=0;
305 break;
306 case 'c':
307 case 'C':
308 crc=1;
309 break;
310 case 'p':
311 case 'P':
312 power=1;
313 break;
314 default:
315 PrintAndLog("Invalid option");
316 return 0;
317 }
318 i+=2;
319 continue;
320 }
321 if ((cmd[i]>='0' && cmd[i]<='9') ||
322 (cmd[i]>='a' && cmd[i]<='f') ||
323 (cmd[i]>='A' && cmd[i]<='F') ) {
324 buf[strlen(buf)+1]=0;
325 buf[strlen(buf)]=cmd[i];
326 i++;
327
328 if (strlen(buf)>=2) {
329 sscanf(buf,"%x",&temp);
330 data[datalen]=(uint8_t)(temp & 0xff);
331 datalen++;
332 *buf=0;
333 }
334 continue;
335 }
336 PrintAndLog("Invalid char on input");
337 return 0;
338 }
06b82e6a 339 if (datalen == 0)
340 {
341 PrintAndLog("Missing data input");
342 return 0;
343 }
7cf3ef20 344 if(crc)
345 {
346 uint8_t first, second;
347 ComputeCrc14443(CRC_14443_B, data, datalen, &first, &second);
348 data[datalen++] = first;
349 data[datalen++] = second;
350 }
351
352 c.arg[0] = datalen;
353 c.arg[1] = reply;
354 c.arg[2] = power;
355 memcpy(c.d.asBytes,data,datalen);
356
357 SendCommand(&c);
358
359 if (reply) {
360 if (WaitForResponseTimeout(CMD_ACK,&resp,1000)) {
361 recv = resp.d.asBytes;
362 PrintAndLog("received %i octets",resp.arg[0]);
363 if(!resp.arg[0])
364 return 0;
365 hexout = (char *)malloc(resp.arg[0] * 3 + 1);
366 if (hexout != NULL) {
367 uint8_t first, second;
368 for (int i = 0; i < resp.arg[0]; i++) { // data in hex
7bb9d33e 369 sprintf(&hexout[i * 3], "%02X ", recv[i]);
7cf3ef20 370 }
371 PrintAndLog("%s", hexout);
372 free(hexout);
373 ComputeCrc14443(CRC_14443_B, recv, resp.arg[0]-2, &first, &second);
374 if(recv[resp.arg[0]-2]==first && recv[resp.arg[0]-1]==second) {
375 PrintAndLog("CRC OK");
376 } else {
377 PrintAndLog("CRC failed");
378 }
379 } else {
380 PrintAndLog("malloc failed your client has low memory?");
381 }
382 } else {
383 PrintAndLog("timeout while waiting for reply.");
384 }
385 } // if reply
386 return 0;
387}
388
7fe9b0b7 389static command_t CommandTable[] =
390{
391 {"help", CmdHelp, 1, "This help"},
392 {"demod", CmdHF14BDemod, 1, "Demodulate ISO14443 Type B from tag"},
393 {"list", CmdHF14BList, 0, "List ISO 14443 history"},
394 {"read", CmdHF14BRead, 0, "Read HF tag (ISO 14443)"},
395 {"sim", CmdHF14Sim, 0, "Fake ISO 14443 tag"},
396 {"simlisten", CmdHFSimlisten, 0, "Get HF samples as fake tag"},
397 {"snoop", CmdHF14BSnoop, 0, "Eavesdrop ISO 14443"},
7cf3ef20 398 {"sri512read", CmdSri512Read, 0, "Read contents of a SRI512 tag"},
399 {"srix4kread", CmdSrix4kRead, 0, "Read contents of a SRIX4K tag"},
400 {"raw", CmdHF14BCmdRaw, 0, "Send raw hex data to tag"},
7fe9b0b7 401 {NULL, NULL, 0, NULL}
402};
403
404int CmdHF14B(const char *Cmd)
405{
406 CmdsParse(CommandTable, Cmd);
407 return 0;
408}
409
410int CmdHelp(const char *Cmd)
411{
412 CmdsHelp(CommandTable);
413 return 0;
414}
Impressum, Datenschutz