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

10 #include <string.h>

11 #include <inttypes.h>

12 #include <stdio.h>

13 #include "cmdlfpresco.h"

14 #include "proxmark3.h"

15 #include "ui.h"

16 #include "util.h"

17 #include "graph.h"

18 #include "cmdparser.h"

19 #include "cmddata.h"

20 #include "cmdmain.h"

21 #include "cmdlf.h"

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

 #include "lfdemod.h"    // parityTest

 static int CmdHelp(const char *Cmd);

 int usage_lf_presco_clone(void){

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

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

30 PrintAndLog("Options :");

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

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

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

34 PrintAndLog("");

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

36 return 0;

37 }

 int usage_lf_presco_sim(void) {

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

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

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

43 PrintAndLog("");

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

45 PrintAndLog("Options :");

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

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

48 PrintAndLog("");

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

50 return 0;

51 }

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

56 uint8_t val = 0;

         bool hex = false, errors = false;

58 uint8_t cmdp = 0;

59 char id[11];

60 int stringlen = 0;

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

                 switch(param_getchar(Cmd, cmdp)) {

63 case 'h':

64 return -1;

65 case 'H':

66 hex = true;

67 //get hex

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

69 cmdp+=2;

70 break;

71 case 'D':

72 case 'd':

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

76 cmdp+=2;

77 break;

78 case 'Q':

79 case 'q':

80 *Q5 = true;

81 cmdp++;

82 break;

83 default:

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

85 errors = 1;

86 break;

87 }

                 if(errors) break;

89 }

90 // No args

         if(cmdp == 0) errors = 1;

93 //Validations

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

96 if (!hex) {

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

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

103

104 *fullcode += val;

105

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

                         if ( index < strlen(id)-1 ) 

108 *fullcode *= 12;

109 }

110 }

111

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

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

114 return 0;

115 }

116

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

123 return 1;

124 }

125

126 //see ASKDemod for what args are accepted

 int CmdPrescoDemod(const char *Cmd) {

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

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

130 return 0;

131 }

132 size_t size = DemodBufferLen;

133 //call lfdemod.c demod for presco

         int ans = PrescoDemod(DemodBuffer, &size);

         if (ans < 0) {

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

137 return 0;

138 }

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

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

149

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

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

156

157 return 1;

158 }

159

160 //see ASKDemod for what args are accepted

 int CmdPrescoRead(const char *Cmd) {

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

163

164 // read lf silently

         lf_read(true, 10000);

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 }