cvs.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 //-----------------------------------------------------------------------------

9 #include <string.h>

10 #include <inttypes.h>

11 #include <stdio.h>

12 #include "cmdlfpresco.h"

13 #include "proxmark3.h"

14 #include "ui.h"

15 #include "util.h"

16 #include "graph.h"

17 #include "cmdparser.h"

18 #include "cmddata.h"

19 #include "cmdmain.h"

20 #include "cmdlf.h"

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

 #include "lfdemod.h"    // parityTest

 static int CmdHelp(const char *Cmd);

 int usage_lf_presco_clone(void){

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

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

29 PrintAndLog("Options :");

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

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

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

33 PrintAndLog("");

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

35 return 0;

36 }

 int usage_lf_presco_sim(void) {

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

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

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

42 PrintAndLog("");

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

44 PrintAndLog("Options :");

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

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

47 PrintAndLog("");

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

49 return 0;

50 }

52 // 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) {

55 uint8_t val = 0;

         bool hex = false, errors = false;

57 uint8_t cmdp = 0;

58 char id[11];

59 int stringlen = 0;

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

                 switch(param_getchar(Cmd, cmdp)) {

62 case 'h':

63 return -1;

64 case 'H':

65 hex = true;

66 //get hex

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

68 cmdp+=2;

69 break;

70 case 'P':

71 case 'p':

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

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

                                 if (stringlen < 2) return -1;

75 cmdp+=2;

76 break;

77 case 'Q':

78 case 'q':

79 *Q5 = true;

80 cmdp++;

81 break;

82 default:

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

84 errors = 1;

85 break;

86 }

                 if(errors) break;

88 }

89 // No args

         if(cmdp == 0) errors = 1;

92 //Validations

         if(errors) return -1;

95 if (!hex) {

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

97 // 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;

102

103 *fullcode += val;

104

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

                         if ( index < strlen(id)-1 ) 

107 *fullcode *= 12;

108 }

109 }

110

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

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

113 return 0;

114 }

115

116 // 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);

122 return 1;

123 }

124

125 //see ASKDemod for what args are accepted

 int CmdPrescoDemod(const char *Cmd) {

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

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

129 return 0;

130 }

131 size_t size = DemodBufferLen;

132 //call lfdemod.c demod for Viking

         int ans = PrescoDemod(DemodBuffer, &size);

         if (ans < 0) {

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

136 return 0;

137 }

138 //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);

143 uint32_t cardid = raw4;

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

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

         setDemodBuf(DemodBuffer+ans, 128, 0);

147

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

149 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);

154

155 return 1;

156 }

157

158 //see ASKDemod for what args are accepted

 int CmdPrescoRead(const char *Cmd) {

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

161

162 // read lf silently

163 CmdLFRead("s");

164 // get samples silently

         getSamples("30000",false);

166 // demod and output Presco ID

167 return CmdPrescoDemod(Cmd);

168 }

169

170 // takes base 12 ID converts to hex

171 // Or takes 8 digit hex ID

 int CmdPrescoClone(const char *Cmd) {

173

174 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};

177

178 // get wiegand from printed number.

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

180

181 if (Q5)

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

183

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

185 sitecode &= 0xFF;

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

187 }

188

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

190 usercode &= 0xFFFF;

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

192 }

193

         blocks[1] = 0x10D00000; //preamble

         blocks[2] = 0x00000000;

         blocks[3] = 0x00000000;

197 blocks[4] = fullcode;

198

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

200 PrintAndLog("Blk | Data ");

201 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]); 

207

208 UsbCommand resp;

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

210

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

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

                 c.arg[1] = i;

214 clearCommandBuffer();

215 SendCommand(&c);

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

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

218 return -1;

219 }

220 }

221 return 0;

222 }

223

224 // takes base 12 ID converts to hex

225 // Or takes 8 digit hex ID

 int CmdPrescoSim(const char *Cmd) {

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

228 bool Q5=false;

229 // get wiegand from printed number.

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

231

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

233 uint16_t arg1, arg2;

234 size_t size = 128;

         arg1 = clk << 8 | encoding;

         arg2 = invert << 8 | separator;

237

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

239

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

         GetPrescoBits(fullcode, c.d.asBytes);

242 clearCommandBuffer();

243 SendCommand(&c);

244 return 0;

245 }

246

247 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}

253 };

254

 int CmdLFPresco(const char *Cmd) {

256 clearCommandBuffer();

257 CmdsParse(CommandTable, Cmd);

258 return 0;

259 }

260

 int CmdHelp(const char *Cmd) {

262 CmdsHelp(CommandTable);

263 return 0;

264 }