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

1 //-----------------------------------------------------------------------------

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 // Commands related to the German electronic Identification Card

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

11 #include "cmdhfepa.h"

13 #include <inttypes.h>

14 #include <stdlib.h>

15 #include <string.h>

16 #include <unistd.h>

17 #include <stdio.h>

18 #include "util.h"

19 #include "util_posix.h"

20 #include "proxmark3.h"

21 #include "ui.h"

22 #include "cmdparser.h"

23 #include "common.h"

24 #include "cmdmain.h"

 static int CmdHelp(const char *Cmd);

28 // Perform (part of) the PACE protocol

 int CmdHFEPACollectPACENonces(const char *Cmd)

30 {

31 // requested nonce size

32 unsigned int m = 0;

33 // requested number of Nonces

34 unsigned int n = 0;

35 // delay between requests

36 unsigned int d = 0;

         sscanf(Cmd, "%u %u %u", &m, &n, &d);

40 // values are expected to be > 0

         m = m > 0 ? m : 1;

         n = n > 0 ? n : 1;

         PrintAndLog("Collecting %u %u-byte nonces", n, m);

         PrintAndLog("Start: %" PRIu64 , msclock()/1000);

46 // repeat n times

         for (unsigned int i = 0; i < n; i++) {

48 // execute PACE

                 UsbCommand c = {CMD_EPA_PACE_COLLECT_NONCE, {(int)m, 0, 0}};

50 SendCommand(&c);

51 UsbCommand resp;

53 WaitForResponse(CMD_ACK,&resp);

55 // check if command failed

                 if (resp.arg[0] != 0) {

                         PrintAndLog("Error in step %d, Return code: %d",resp.arg[0],(int)resp.arg[1]);

58 } else {

                         size_t nonce_length = resp.arg[1];

                         char *nonce = (char *) malloc(2 * nonce_length + 1);

                         for(int j = 0; j < nonce_length; j++) {

                                 sprintf(nonce + (2 * j), "%02X", resp.d.asBytes[j]);

63 }

64 // print nonce

                         PrintAndLog("Length: %d, Nonce: %s", nonce_length, nonce);

66 free(nonce);

67 }

                 if (i < n - 1) {

69 sleep(d);

70 }

71 }

         PrintAndLog("End: %" PRIu64, msclock()/1000);

74 return 1;

75 }

77 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

78 ////////////////////////////////The commands lie below here/////////////////////////////////////////////////////////////////////////////////////////

80 // perform the PACE protocol by replaying APDUs

 int CmdHFEPAPACEReplay(const char *Cmd)

82 {

83 // the 4 APDUs which are replayed + their lengths

         uint8_t msesa_apdu[41], gn_apdu[8], map_apdu[75];

         uint8_t pka_apdu[75], ma_apdu[18], apdu_lengths[5] = {0};

86 // pointers to the arrays to be able to iterate

         uint8_t *apdus[] = {msesa_apdu, gn_apdu, map_apdu, pka_apdu, ma_apdu};

89 // usage message

90 static const char *usage_msg =

91 "Please specify 5 APDUs separated by spaces. "

92 "Example:\n preplay 0022C1A4 1068000000 1086000002 1234ABCDEF 1A2B3C4D";

94 // Proxmark response

95 UsbCommand resp;

         int skip = 0, skip_add = 0, scan_return = 0;

98 // for each APDU

         for (int i = 0; i < sizeof(apdu_lengths); i++) {

100 // scan to next space or end of string

                 while (Cmd[skip] != ' ' && Cmd[skip] != '\0') {

102 // convert

                         scan_return = sscanf(Cmd + skip, "%2X%n",

                                              (unsigned int *) (apdus[i] + apdu_lengths[i]),

105 &skip_add);

                         if (scan_return < 1) {

                                 PrintAndLog((char *)usage_msg);

108 PrintAndLog("Not enough APDUs! Try again!");

109 return 0;

110 }

111 skip += skip_add;

112 apdu_lengths[i]++;

113 }

114

115 // break on EOF

                 if (Cmd[skip] == '\0') {

                         if (i < sizeof(apdu_lengths) - 1) {

118

                                 PrintAndLog((char *)usage_msg);

120 return 0;

121 }

122 break;

123 }

124 // skip the space

125 skip++;

126 }

127

128 // transfer the APDUs to the Proxmark

129 UsbCommand usb_cmd;

130 usb_cmd.cmd = CMD_EPA_PACE_REPLAY;

         for (int i = 0; i < sizeof(apdu_lengths); i++) {

132 // APDU number

                 usb_cmd.arg[0] = i + 1;

134 // transfer the APDU in several parts if necessary

                 for (int j = 0; j * sizeof(usb_cmd.d.asBytes) < apdu_lengths[i]; j++) {

136 // offset into the APDU

                         usb_cmd.arg[1] = j * sizeof(usb_cmd.d.asBytes);

138 // amount of data in this packet

                         int packet_length = apdu_lengths[i] - (j * sizeof(usb_cmd.d.asBytes));

                         if (packet_length > sizeof(usb_cmd.d.asBytes)) {

                                 packet_length = sizeof(usb_cmd.d.asBytes);

142 }

                         usb_cmd.arg[2] = packet_length;

144

                         memcpy(usb_cmd.d.asBytes, // + (j * sizeof(usb_cmd.d.asBytes)),

                                apdus[i] + (j * sizeof(usb_cmd.d.asBytes)),

147 packet_length);

148 SendCommand(&usb_cmd);

149 WaitForResponse(CMD_ACK, &resp);

                         if (resp.arg[0] != 0) {

                                 PrintAndLog("Transfer of APDU #%d Part %d failed!", i, j);

152 return 0;

153 }

154 }

155 }

156

157 // now perform the replay

         usb_cmd.arg[0] = 0;

159 SendCommand(&usb_cmd);

160 WaitForResponse(CMD_ACK, &resp);

         if (resp.arg[0] != 0) {

                 PrintAndLog("\nPACE replay failed in step %u!", (uint32_t)resp.arg[0]);

163 PrintAndLog("Measured times:");

                 PrintAndLog("MSE Set AT: %u us", resp.d.asDwords[0]);

                 PrintAndLog("GA Get Nonce: %u us", resp.d.asDwords[1]);

                 PrintAndLog("GA Map Nonce: %u us", resp.d.asDwords[2]);

                 PrintAndLog("GA Perform Key Agreement: %u us", resp.d.asDwords[3]);

                 PrintAndLog("GA Mutual Authenticate: %u us", resp.d.asDwords[4]);

169 } else {

170 PrintAndLog("PACE replay successfull!");

                 PrintAndLog("MSE Set AT: %u us", resp.d.asDwords[0]);

                 PrintAndLog("GA Get Nonce: %u us", resp.d.asDwords[1]);

                 PrintAndLog("GA Map Nonce: %u us", resp.d.asDwords[2]);

                 PrintAndLog("GA Perform Key Agreement: %u us", resp.d.asDwords[3]);

                 PrintAndLog("GA Mutual Authenticate: %u us", resp.d.asDwords[4]);

176 }

177

178

179 return 1;

180 }

181

182 ////////////////////////////////The new commands lie above here/////////////////////////////////////////////////////////////////////////////////////

183 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

184

185 // UI-related stuff

186

187 static const command_t CommandTable[] =

188 {

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

   {"cnonces", CmdHFEPACollectPACENonces, 0,

191 "<m> <n> <d> Acquire n>0 encrypted PACE nonces of size m>0 with d sec pauses"},

   {"preplay", CmdHFEPAPACEReplay,        0,

193 "<mse> <get> <map> <pka> <ma> Perform PACE protocol by replaying given APDUs"},

   {NULL, NULL, 0, NULL}

195 };

196

 int CmdHelp(const char *Cmd)

198 {

199 CmdsHelp(CommandTable);

200 return 0;

201 }

202

 int CmdHFEPA(const char *Cmd)

204 {

205 // flush

         WaitForResponseTimeout(CMD_ACK,NULL,100);

207

208 // parse

209 CmdsParse(CommandTable, Cmd);

210 return 0;

211 }