git.zerfleddert.de Git - proxmark3-svn/blob

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 Presco tag commands

8 // ASK/Manchester, rf/32, 128 bits (complete)

9 //-----------------------------------------------------------------------------

11 #include "cmdlfpresco.h"

13 #include <string.h>

14 #include <inttypes.h>

15 #include <stdio.h>

16 #include "comms.h"

17 #include "ui.h"

18 #include "util.h"

19 #include "graph.h"

20 #include "cmdparser.h"

21 #include "cmddata.h"

22 #include "cmdmain.h"

23 #include "cmdlf.h"

24 #include "protocols.h" // for T55xx config register definitions

 #include "lfdemod.h"    // parityTest

 static int CmdHelp(const char *Cmd);

 int usage_lf_presco_clone(void){

30 PrintAndLog("clone a Presco tag to a T55x7 tag.");

31 PrintAndLog("Usage: lf presco clone d <Card-ID> H <hex-ID> <Q5>");

32 PrintAndLog("Options :");

33 PrintAndLog(" d <Card-ID> : 9 digit presco card ID");

34 PrintAndLog(" H <hex-ID> : 8 digit hex card number");

35 PrintAndLog(" <Q5> : specify write to Q5 (t5555 instead of t55x7)");

36 PrintAndLog("");

37 PrintAndLog("Sample : lf presco clone d 123456789");

38 return 0;

39 }

 int usage_lf_presco_sim(void) {

42 PrintAndLog("Enables simulation of presco card with specified card number.");

43 PrintAndLog("Simulation runs until the button is pressed or another USB command is issued.");

44 PrintAndLog("Per presco format, the card number is 9 digit number and can contain *# chars. Larger values are truncated.");

45 PrintAndLog("");

46 PrintAndLog("Usage: lf presco sim d <Card-ID> or H <hex-ID>");

47 PrintAndLog("Options :");

48 PrintAndLog(" d <Card-ID> : 9 digit presco card number");

49 PrintAndLog(" H <hex-ID> : 8 digit hex card number");

50 PrintAndLog("");

51 PrintAndLog("Sample : lf presco sim d 123456789");

52 return 0;

53 }

55 // convert base 12 ID to sitecode & usercode & 8 bit other unknown code

 int GetWiegandFromPresco(const char *Cmd, uint32_t *sitecode, uint32_t *usercode, uint32_t *fullcode, bool *Q5) {

58 uint8_t val = 0;

         bool hex = false, errors = false;

60 uint8_t cmdp = 0;

61 char id[11];

62 int stringlen = 0;

         while(param_getchar(Cmd, cmdp) != 0x00) {

                 switch(param_getchar(Cmd, cmdp)) {

65 case 'h':

66 return -1;

67 case 'H':

68 hex = true;

69 //get hex

                                 *fullcode = param_get32ex(Cmd, cmdp+1, 0, 10);

71 cmdp+=2;

72 break;

73 case 'D':

74 case 'd':

75 //param get string int param_getstr(const char *line, int paramnum, char * str)

                                 stringlen = param_getstr(Cmd, cmdp+1, id, sizeof(id));

                                 if (stringlen < 2) return -1;

78 cmdp+=2;

79 break;

80 case 'Q':

81 case 'q':

82 *Q5 = true;

83 cmdp++;

84 break;

85 default:

                                 PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd, cmdp));

87 errors = 1;

88 break;

89 }

                 if(errors) break;

91 }

92 // No args

         if(cmdp == 0) errors = 1;

95 //Validations

         if(errors || (stringlen == 0 && !hex) ) return -1;

98 if (!hex) {

                 for (int index =0; index < strlen(id); ++index) {

100 // Get value from number string.

                         if ( id[index] == '*' ) val = 10;

                         if ( id[index] == '#')  val = 11;               

                         if ( id[index] >= 0x30 && id[index] <= 0x39 )

                                 val = id[index] - 0x30;

105

106 *fullcode += val;

107

108 // last digit is only added, not multipled.

                         if ( index < strlen(id)-1 ) 

110 *fullcode *= 12;

111 }

112 }

113

         *usercode = *fullcode & 0x0000FFFF; //% 65566

         *sitecode = (*fullcode >> 24) & 0x000000FF;  // /= 16777216;

116 return 0;

117 }

118

119 // calc not certain - intended to get bitstream for programming / sim

 int GetPrescoBits(uint32_t fullcode, uint8_t *prescoBits) {

         num_to_bytebits(0x10D00000, 32, prescoBits);

         num_to_bytebits(0x00000000, 32, prescoBits+32);

         num_to_bytebits(0x00000000, 32, prescoBits+64);

         num_to_bytebits(fullcode  , 32, prescoBits+96);

125 return 1;

126 }

127

128 //see ASKDemod for what args are accepted

 int CmdPrescoDemod(const char *Cmd) {

         if (!ASKDemod(Cmd, false, false, 1)) {

                 if (g_debugMode) PrintAndLog("ASKDemod failed");

132 return 0;

133 }

134 size_t size = DemodBufferLen;

135 //call lfdemod.c demod for presco

         int ans = PrescoDemod(DemodBuffer, &size);

         if (ans < 0) {

                 if (g_debugMode) PrintAndLog("Error Presco_Demod %d", ans);

139 return 0;

140 }

141 //got a good demod

         uint32_t raw1 = bytebits_to_byte(DemodBuffer+ans, 32);

         uint32_t raw2 = bytebits_to_byte(DemodBuffer+ans+32, 32);

         uint32_t raw3 = bytebits_to_byte(DemodBuffer+ans+64, 32);

         uint32_t raw4 = bytebits_to_byte(DemodBuffer+ans+96, 32);

146 uint32_t cardid = raw4;

         PrintAndLog("Presco Tag Found: Card ID %08X", cardid);

         PrintAndLog("Raw: %08X%08X%08X%08X", raw1,raw2,raw3,raw4);

         setDemodBuf(DemodBuffer, 128, ans);

         setClockGrid(g_DemodClock, g_DemodStartIdx + (ans*g_DemodClock));

151

         uint32_t sitecode = 0, usercode = 0, fullcode = 0;

153 bool Q5=false;

         char cmd[12] = {0};

         sprintf(cmd, "H %08X", cardid);

         GetWiegandFromPresco(cmd, &sitecode, &usercode, &fullcode, &Q5);

         PrintAndLog("SiteCode %u, UserCode %u, FullCode, %08X", sitecode, usercode, fullcode);

158

159 return 1;

160 }

161

162 //see ASKDemod for what args are accepted

 int CmdPrescoRead(const char *Cmd) {

164 // Presco Number: 123456789 --> Sitecode 30 | usercode 8665

165

166 // read lf silently

         lf_read(true, 10000);

168 // demod and output Presco ID

169 return CmdPrescoDemod(Cmd);

170 }

171

172 // takes base 12 ID converts to hex

173 // Or takes 8 digit hex ID

 int CmdPrescoClone(const char *Cmd) {

175

176 bool Q5 = false;

         uint32_t sitecode=0, usercode=0, fullcode=0;

         uint32_t blocks[5] = {T55x7_MODULATION_MANCHESTER | T55x7_BITRATE_RF_32 | 4<<T55x7_MAXBLOCK_SHIFT | T55x7_ST_TERMINATOR, 0, 0, 0, 5};

179

180 // get wiegand from printed number.

         if (GetWiegandFromPresco(Cmd, &sitecode, &usercode, &fullcode, &Q5) == -1) return usage_lf_presco_clone();

182

183 if (Q5)

                 blocks[0] = T5555_MODULATION_MANCHESTER | ((32-2)>>1)<<T5555_BITRATE_SHIFT | 4<<T5555_MAXBLOCK_SHIFT | T5555_ST_TERMINATOR;

185

         if ((sitecode & 0xFF) != sitecode) {

187 sitecode &= 0xFF;

                 PrintAndLog("Facility-Code Truncated to 8-bits (Presco): %u", sitecode);

189 }

190

         if ((usercode & 0xFFFF) != usercode) {

192 usercode &= 0xFFFF;

                 PrintAndLog("Card Number Truncated to 16-bits (Presco): %u", usercode);

194 }

195

         blocks[1] = 0x10D00000; //preamble

         blocks[2] = 0x00000000;

         blocks[3] = 0x00000000;

199 blocks[4] = fullcode;

200

         PrintAndLog("Preparing to clone Presco to T55x7 with SiteCode: %u, UserCode: %u, FullCode: %08x", sitecode, usercode, fullcode);

202 PrintAndLog("Blk | Data ");

203 PrintAndLog("----+------------");

         PrintAndLog(" 00 | 0x%08x", blocks[0]);

         PrintAndLog(" 01 | 0x%08x", blocks[1]);

         PrintAndLog(" 02 | 0x%08x", blocks[2]);

         PrintAndLog(" 03 | 0x%08x", blocks[3]); 

         PrintAndLog(" 04 | 0x%08x", blocks[4]); 

209

210 UsbCommand resp;

         UsbCommand c = {CMD_T55XX_WRITE_BLOCK, {0,0,0}};

212

         for (int i=4; i>=0; i--) {

                 c.arg[0] = blocks[i];

                 c.arg[1] = i;

216 clearCommandBuffer();

217 SendCommand(&c);

                 if (!WaitForResponseTimeout(CMD_ACK, &resp, 1000)){

219 PrintAndLog("Error occurred, device did not respond during write operation.");

220 return -1;

221 }

222 }

223 return 0;

224 }

225

226 // takes base 12 ID converts to hex

227 // Or takes 8 digit hex ID

 int CmdPrescoSim(const char *Cmd) {

         uint32_t sitecode=0, usercode=0, fullcode=0;

230 bool Q5=false;

231 // get wiegand from printed number.

         if (GetWiegandFromPresco(Cmd, &sitecode, &usercode, &fullcode, &Q5) == -1) return usage_lf_presco_sim();

233

         uint8_t clk = 32, encoding = 1, separator = 1, invert = 0;

235 uint16_t arg1, arg2;

236 size_t size = 128;

         arg1 = clk << 8 | encoding;

         arg2 = invert << 8 | separator;

239

         PrintAndLog("Simulating Presco - SiteCode: %u, UserCode: %u, FullCode: %08X",sitecode, usercode, fullcode);

241

         UsbCommand c = {CMD_ASK_SIM_TAG, {arg1, arg2, size}};

         GetPrescoBits(fullcode, c.d.asBytes);

244 clearCommandBuffer();

245 SendCommand(&c);

246 return 0;

247 }

248

249 static command_t CommandTable[] = {

         {"help",  CmdHelp,        1, "This help"},

         {"read",  CmdPrescoRead,  0, "Attempt to read and Extract tag data"},

         {"clone", CmdPrescoClone, 0, "d <9 digit ID> or h <hex> [Q5] clone presco tag"},

         {"sim",   CmdPrescoSim,   0, "d <9 digit ID> or h <hex> simulate presco tag"},

         {NULL, NULL, 0, NULL}

255 };

256

 int CmdLFPresco(const char *Cmd) {

258 clearCommandBuffer();

259 CmdsParse(CommandTable, Cmd);

260 return 0;

261 }

262

 int CmdHelp(const char *Cmd) {

264 CmdsHelp(CommandTable);

265 return 0;

266 }