]> git.zerfleddert.de Git - proxmark3-svn/blob - client/scripting.c
Adding homebrew tap method for macOS
[proxmark3-svn] / client / scripting.c
1 //-----------------------------------------------------------------------------
2 // Copyright (C) 2013 m h swende <martin at swende.se>
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 // Some lua scripting glue to proxmark core.
9 //-----------------------------------------------------------------------------
10
11 #include <lua.h>
12 #include <lualib.h>
13 #include <lauxlib.h>
14 #include "proxmark3.h"
15 #include "usb_cmd.h"
16 #include "cmdmain.h"
17 #include "scripting.h"
18 #include "util.h"
19 #include "nonce2key/nonce2key.h"
20 #include "../common/iso15693tools.h"
21 #include "iso14443crc.h"
22 #include "../common/crc16.h"
23 #include "../common/crc64.h"
24 #include "../common/sha1.h"
25 #include "aes.h"
26 #include "cmdcrc.h"
27 /**
28 * The following params expected:
29 * UsbCommand c
30 *@brief l_SendCommand
31 * @param L
32 * @return
33 */
34 static int l_SendCommand(lua_State *L){
35
36 /*
37 *
38 The SendCommand (native) expects the following structure:
39
40 typedef struct {
41 uint64_t cmd; //8 bytes
42 uint64_t arg[3]; // 8*3 bytes = 24 bytes
43 union {
44 uint8_t asBytes[USB_CMD_DATA_SIZE]; // 1 byte * 512 = 512 bytes (OR)
45 uint32_t asDwords[USB_CMD_DATA_SIZE/4]; // 4 byte * 128 = 512 bytes
46 } d;
47 } PACKED UsbCommand;
48
49 ==> A 544 byte buffer will do.
50 **/
51 //Pop cmd
52 size_t size;
53 const char *data = luaL_checklstring(L, 1, &size);
54 if(size != sizeof(UsbCommand))
55 {
56 printf("Got data size %d, expected %d" , (int) size,(int) sizeof(UsbCommand));
57 lua_pushstring(L,"Wrong data size");
58 return 1;
59 }
60
61 // UsbCommand c = (*data);
62 SendCommand((UsbCommand* )data);
63 return 0; // no return values
64 }
65 /**
66 * @brief The following params expected:
67 * uint32_t cmd
68 * size_t ms_timeout
69 * @param L
70 * @return
71 */
72 static int l_WaitForResponseTimeout(lua_State *L){
73
74 uint32_t cmd = 0;
75 size_t ms_timeout = -1;
76
77 //Check number of arguments
78 int n = lua_gettop(L);
79 if(n == 0)
80 {
81 //signal error by returning Nil, errorstring
82 lua_pushnil(L);
83 lua_pushstring(L,"You need to supply at least command to wait for");
84 return 2; // two return values
85 }
86 if(n >= 1)
87 {
88 //pop cmd
89 cmd = luaL_checkunsigned(L,1);
90 }
91 if(n >= 2)
92 {
93 //Did the user send a timeout ?
94 //Check if the current top of stack is an integer
95 ms_timeout = luaL_checkunsigned(L,2);
96 //printf("Timeout set to %dms\n" , (int) ms_timeout);
97 }
98
99 UsbCommand response;
100
101 if(WaitForResponseTimeout(cmd, &response, ms_timeout))
102 {
103 //Push it as a string
104 lua_pushlstring(L,(const char *)&response,sizeof(UsbCommand));
105
106 return 1;// return 1 to signal one return value
107 }else{
108 //Push a Nil instead
109 lua_pushnil(L);
110 return 1;// one return value
111 }
112 }
113
114 static int returnToLuaWithError(lua_State *L, const char* fmt, ...)
115 {
116 char buffer[200];
117 va_list args;
118 va_start(args,fmt);
119 vsnprintf(buffer, sizeof(buffer), fmt,args);
120 va_end(args);
121
122 lua_pushnil(L);
123 lua_pushstring(L,buffer);
124 return 2;
125 }
126
127 static int l_nonce2key(lua_State *L){
128
129 size_t size;
130 const char *p_uid = luaL_checklstring(L, 1, &size);
131 if(size != 4) return returnToLuaWithError(L,"Wrong size of uid, got %d bytes, expected 4", (int) size);
132
133 const char *p_nt = luaL_checklstring(L, 2, &size);
134 if(size != 4) return returnToLuaWithError(L,"Wrong size of nt, got %d bytes, expected 4", (int) size);
135
136 const char *p_nr = luaL_checklstring(L, 3, &size);
137 if(size != 4) return returnToLuaWithError(L,"Wrong size of nr, got %d bytes, expected 4", (int) size);
138
139 const char *p_par_info = luaL_checklstring(L, 4, &size);
140 if(size != 8) return returnToLuaWithError(L,"Wrong size of par_info, got %d bytes, expected 8", (int) size);
141
142 const char *p_pks_info = luaL_checklstring(L, 5, &size);
143 if(size != 8) return returnToLuaWithError(L,"Wrong size of ks_info, got %d bytes, expected 8", (int) size);
144
145
146 uint32_t uid = bytes_to_num(( uint8_t *)p_uid,4);
147 uint32_t nt = bytes_to_num(( uint8_t *)p_nt,4);
148
149 uint32_t nr = bytes_to_num(( uint8_t*)p_nr,4);
150 uint64_t par_info = bytes_to_num(( uint8_t *)p_par_info,8);
151 uint64_t ks_info = bytes_to_num(( uint8_t *)p_pks_info,8);
152
153 uint64_t key = 0;
154
155 int retval = nonce2key(uid,nt, nr, par_info,ks_info, &key);
156
157 //Push the retval on the stack
158 lua_pushinteger(L,retval);
159
160 //Push the key onto the stack
161 uint8_t dest_key[8];
162 num_to_bytes(key,sizeof(dest_key),dest_key);
163
164 //printf("Pushing to lua stack: %012" PRIx64 "\n",key);
165 lua_pushlstring(L,(const char *) dest_key,sizeof(dest_key));
166
167 return 2; //Two return values
168 }
169 //static int l_PrintAndLog(lua_State *L){ return CmdHF14AMfDump(luaL_checkstring(L, 1));}
170 static int l_clearCommandBuffer(lua_State *L){
171 clearCommandBuffer();
172 return 0;
173 }
174 /**
175 * @brief l_foobar is a dummy function to test lua-integration with
176 * @param L
177 * @return
178 */
179 static int l_foobar(lua_State *L)
180 {
181 //Check number of arguments
182 int n = lua_gettop(L);
183 printf("foobar called with %d arguments" , n);
184 lua_settop(L, 0);
185 printf("Arguments discarded, stack now contains %d elements", lua_gettop(L));
186
187 // todo: this is not used, where was it intended for?
188 // UsbCommand response = {CMD_MIFARE_READBL, {1337, 1338, 1339}};
189
190 printf("Now returning a uint64_t as a string");
191 uint64_t x = 0xDEADBEEF;
192 uint8_t destination[8];
193 num_to_bytes(x,sizeof(x),destination);
194 lua_pushlstring(L,(const char *)&x,sizeof(x));
195 lua_pushlstring(L,(const char *)destination,sizeof(destination));
196
197 return 2;
198 }
199
200
201 /**
202 * @brief Utility to check if a key has been pressed by the user. This method does not block.
203 * @param L
204 * @return boolean, true if kbhit, false otherwise.
205 */
206 static int l_ukbhit(lua_State *L)
207 {
208 lua_pushboolean(L,ukbhit() ? true : false);
209 return 1;
210 }
211 /**
212 * @brief Calls the command line parser to deal with the command. This enables
213 * lua-scripts to do stuff like "core.console('hf mf mifare')"
214 * @param L
215 * @return
216 */
217 static int l_CmdConsole(lua_State *L)
218 {
219 CommandReceived((char *)luaL_checkstring(L, 1));
220 return 0;
221 }
222
223 static int l_iso15693_crc(lua_State *L)
224 {
225 // uint16_t Iso15693Crc(uint8_t *v, int n);
226 size_t size;
227 const char *v = luaL_checklstring(L, 1, &size);
228 uint16_t retval = Iso15693Crc((uint8_t *) v, size);
229 lua_pushinteger(L, (int) retval);
230 return 1;
231 }
232
233 static int l_iso14443b_crc(lua_State *L)
234 {
235 /* void ComputeCrc14443(int CrcType,
236 const unsigned char *Data, int Length,
237 unsigned char *TransmitFirst,
238 unsigned char *TransmitSecond)
239 */
240 unsigned char buf[USB_CMD_DATA_SIZE];
241 size_t len = 0;
242 const char *data = luaL_checklstring(L, 1, &len);
243 if (USB_CMD_DATA_SIZE < len)
244 len = USB_CMD_DATA_SIZE-2;
245
246 for (int i = 0; i < len; i += 2) {
247 sscanf(&data[i], "%02x", (unsigned int *)&buf[i / 2]);
248 }
249 ComputeCrc14443(CRC_14443_B, buf, len, &buf[len], &buf[len+1]);
250
251 lua_pushlstring(L, (const char *)&buf, len+2);
252 return 1;
253 }
254 /*
255 Simple AES 128 cbc hook up to OpenSSL.
256 params: key, input
257 */
258 static int l_aes128decrypt_cbc(lua_State *L)
259 {
260 //Check number of arguments
261 int i;
262 size_t size;
263 const char *p_key = luaL_checklstring(L, 1, &size);
264 if(size != 32) return returnToLuaWithError(L,"Wrong size of key, got %d bytes, expected 32", (int) size);
265
266 const char *p_encTxt = luaL_checklstring(L, 2, &size);
267
268 unsigned char indata[16] = {0x00};
269 unsigned char outdata[16] = {0x00};
270 unsigned char aes_key[16] = {0x00};
271 unsigned char iv[16] = {0x00};
272
273 // convert key to bytearray and convert input to bytearray
274 for (i = 0; i < 32; i += 2) {
275 sscanf(&p_encTxt[i], "%02x", (unsigned int *)&indata[i / 2]);
276 sscanf(&p_key[i], "%02x", (unsigned int *)&aes_key[i / 2]);
277 }
278
279 aes_context ctx;
280 aes_init(&ctx);
281 aes_setkey_dec(&ctx, aes_key, 128);
282 aes_crypt_cbc(&ctx,AES_DECRYPT,sizeof(indata), iv, indata,outdata );
283 //Push decrypted array as a string
284 lua_pushlstring(L,(const char *)&outdata, sizeof(outdata));
285 return 1;// return 1 to signal one return value
286 }
287 static int l_aes128decrypt_ecb(lua_State *L)
288 {
289 //Check number of arguments
290 int i;
291 size_t size;
292 const char *p_key = luaL_checklstring(L, 1, &size);
293 if(size != 32) return returnToLuaWithError(L,"Wrong size of key, got %d bytes, expected 32", (int) size);
294
295 const char *p_encTxt = luaL_checklstring(L, 2, &size);
296
297 unsigned char indata[16] = {0x00};
298 unsigned char outdata[16] = {0x00};
299 unsigned char aes_key[16] = {0x00};
300
301 // convert key to bytearray and convert input to bytearray
302 for (i = 0; i < 32; i += 2) {
303 sscanf(&p_encTxt[i], "%02x", (unsigned int *)&indata[i / 2]);
304 sscanf(&p_key[i], "%02x", (unsigned int *)&aes_key[i / 2]);
305 }
306 aes_context ctx;
307 aes_init(&ctx);
308 aes_setkey_dec(&ctx, aes_key, 128);
309 aes_crypt_ecb(&ctx, AES_DECRYPT, indata, outdata );
310
311 //Push decrypted array as a string
312 lua_pushlstring(L,(const char *)&outdata, sizeof(outdata));
313 return 1;// return 1 to signal one return value
314 }
315
316 static int l_aes128encrypt_cbc(lua_State *L)
317 {
318 //Check number of arguments
319 int i;
320 size_t size;
321 const char *p_key = luaL_checklstring(L, 1, &size);
322 if(size != 32) return returnToLuaWithError(L,"Wrong size of key, got %d bytes, expected 32", (int) size);
323
324 const char *p_txt = luaL_checklstring(L, 2, &size);
325
326 unsigned char indata[16] = {0x00};
327 unsigned char outdata[16] = {0x00};
328 unsigned char aes_key[16] = {0x00};
329 unsigned char iv[16] = {0x00};
330
331 for (i = 0; i < 32; i += 2) {
332 sscanf(&p_txt[i], "%02x", (unsigned int *)&indata[i / 2]);
333 sscanf(&p_key[i], "%02x", (unsigned int *)&aes_key[i / 2]);
334 }
335
336 aes_context ctx;
337 aes_init(&ctx);
338 aes_setkey_enc(&ctx, aes_key, 128);
339 aes_crypt_cbc(&ctx, AES_ENCRYPT, sizeof(indata), iv, indata, outdata );
340 //Push encrypted array as a string
341 lua_pushlstring(L,(const char *)&outdata, sizeof(outdata));
342 return 1;// return 1 to signal one return value
343 }
344
345 static int l_aes128encrypt_ecb(lua_State *L)
346 {
347 //Check number of arguments
348 int i;
349 size_t size;
350 const char *p_key = luaL_checklstring(L, 1, &size);
351 if(size != 32) return returnToLuaWithError(L,"Wrong size of key, got %d bytes, expected 32", (int) size);
352
353 const char *p_txt = luaL_checklstring(L, 2, &size);
354
355 unsigned char indata[16] = {0x00};
356 unsigned char outdata[16] = {0x00};
357 unsigned char aes_key[16] = {0x00};
358
359 for (i = 0; i < 32; i += 2) {
360 sscanf(&p_txt[i], "%02x", (unsigned int *)&indata[i / 2]);
361 sscanf(&p_key[i], "%02x", (unsigned int *)&aes_key[i / 2]);
362 }
363 aes_context ctx;
364 aes_init(&ctx);
365 aes_setkey_enc(&ctx, aes_key, 128);
366 aes_crypt_ecb(&ctx, AES_ENCRYPT, indata, outdata );
367 //Push encrypted array as a string
368 lua_pushlstring(L,(const char *)&outdata, sizeof(outdata));
369 return 1;// return 1 to signal one return value
370 }
371
372 static int l_crc16(lua_State *L)
373 {
374 size_t size;
375 const char *p_str = luaL_checklstring(L, 1, &size);
376
377 uint16_t retval = crc16_ccitt( (uint8_t*) p_str, size);
378 lua_pushinteger(L, (int) retval);
379 return 1;
380 }
381
382 static int l_crc64(lua_State *L)
383 {
384 size_t size;
385 uint64_t crc = 0;
386 unsigned char outdata[8] = {0x00};
387
388 const char *p_str = luaL_checklstring(L, 1, &size);
389
390 crc64( (uint8_t*) p_str, size, &crc);
391
392 outdata[0] = (uint8_t)(crc >> 56) & 0xff;
393 outdata[1] = (uint8_t)(crc >> 48) & 0xff;
394 outdata[2] = (uint8_t)(crc >> 40) & 0xff;
395 outdata[3] = (uint8_t)(crc >> 32) & 0xff;
396 outdata[4] = (uint8_t)(crc >> 24) & 0xff;
397 outdata[5] = (uint8_t)(crc >> 16) & 0xff;
398 outdata[6] = (uint8_t)(crc >> 8) & 0xff;
399 outdata[7] = crc & 0xff;
400 lua_pushlstring(L,(const char *)&outdata, sizeof(outdata));
401 return 1;
402 }
403
404 static int l_sha1(lua_State *L)
405 {
406 size_t size;
407 const char *p_str = luaL_checklstring(L, 1, &size);
408 unsigned char outdata[20] = {0x00};
409 sha1( (uint8_t*) p_str, size, outdata);
410 lua_pushlstring(L,(const char *)&outdata, sizeof(outdata));
411 return 1;
412 }
413
414 static int l_reveng_models(lua_State *L){
415
416 char *models[80];
417 int count = 0;
418 int in_width = luaL_checkinteger(L, 1);
419
420 if( in_width > 89 ) return returnToLuaWithError(L,"Width cannot exceed 89, got %d", in_width);
421
422 uint8_t width[80];
423 width[0] = (uint8_t)in_width;
424 int ans = GetModels(models, &count, width);
425 if (!ans) return 0;
426
427 lua_newtable(L);
428
429 for (int i = 0; i < count; i++){
430 lua_pushstring(L, (const char*)models[i]);
431 lua_rawseti(L,-2,i+1);
432 free(models[i]);
433 }
434
435 return 1;
436 }
437
438 //Called with 4 parameters.
439 // inModel ,string containing the crc model name: 'CRC-8'
440 // inHexStr ,string containing the hex representation of the data that will be used for CRC calculations.
441 // reverse ,int 0/1 (bool) if 1, calculate the reverse CRC
442 // endian ,char, 'B','b','L','l','t','r' describing if Big-Endian or Little-Endian should be used in different combinations.
443 //
444 // outputs: string with hex representation of the CRC result
445 static int l_reveng_RunModel(lua_State *L){
446 //-c || -v
447 //inModel = valid model name string - CRC-8
448 //inHexStr = input hex string to calculate crc on
449 //reverse = reverse calc option if true
450 //endian = {0 = calc default endian input and output, b = big endian input and output, B = big endian output, r = right justified
451 // l = little endian input and output, L = little endian output only, t = left justified}
452 //result = calculated crc hex string
453 char result[50];
454
455 const char *inModel = luaL_checkstring(L, 1);
456 const char *inHexStr = luaL_checkstring(L, 2);
457 bool reverse = lua_toboolean(L, 3);
458 const char endian = luaL_checkstring(L, 4)[0];
459
460 //PrintAndLog("mod: %s, hex: %s, rev %d", inModel, inHexStr, reverse);
461 //int RunModel(char *inModel, char *inHexStr, bool reverse, char endian, char *result)
462 int ans = RunModel( (char *)inModel, (char *)inHexStr, reverse, endian, result);
463 if (!ans)
464 return returnToLuaWithError(L,"Reveng failed");
465
466 lua_pushstring(L, (const char*)result);
467 return 1;
468 }
469
470 /**
471 * @brief Sets the lua path to include "./lualibs/?.lua", in order for a script to be
472 * able to do "require('foobar')" if foobar.lua is within lualibs folder.
473 * Taken from http://stackoverflow.com/questions/4125971/setting-the-global-lua-path-variable-from-c-c
474 * @param L
475 * @param path
476 * @return
477 */
478 int setLuaPath( lua_State* L, const char* path )
479 {
480 lua_getglobal( L, "package" );
481 lua_getfield( L, -1, "path" ); // get field "path" from table at top of stack (-1)
482 const char* cur_path = lua_tostring( L, -1 ); // grab path string from top of stack
483 int requiredLength = strlen(cur_path)+ strlen(path)+10; //A few bytes too many, whatever we can afford it
484 char * buf = malloc(requiredLength);
485 snprintf(buf, requiredLength, "%s;%s", cur_path, path);
486 lua_pop( L, 1 ); // get rid of the string on the stack we just pushed on line 5
487 lua_pushstring( L, buf ); // push the new one
488 lua_setfield( L, -2, "path" ); // set the field "path" in table at -2 with value at top of stack
489 lua_pop( L, 1 ); // get rid of package table from top of stack
490 free(buf);
491 return 0; // all done!
492 }
493
494
495 int set_pm3_libraries(lua_State *L)
496 {
497
498 static const luaL_Reg libs[] = {
499 {"SendCommand", l_SendCommand},
500 {"WaitForResponseTimeout", l_WaitForResponseTimeout},
501 {"nonce2key", l_nonce2key},
502 //{"PrintAndLog", l_PrintAndLog},
503 {"foobar", l_foobar},
504 {"ukbhit", l_ukbhit},
505 {"clearCommandBuffer", l_clearCommandBuffer},
506 {"console", l_CmdConsole},
507 {"iso15693_crc", l_iso15693_crc},
508 {"iso14443b_crc", l_iso14443b_crc},
509 {"aes128_decrypt", l_aes128decrypt_cbc},
510 {"aes128_decrypt_ecb", l_aes128decrypt_ecb},
511 {"aes128_encrypt", l_aes128encrypt_cbc},
512 {"aes128_encrypt_ecb", l_aes128encrypt_ecb},
513 {"crc16", l_crc16},
514 {"crc64", l_crc64},
515 {"sha1", l_sha1},
516 {"reveng_models", l_reveng_models},
517 {"reveng_runmodel", l_reveng_RunModel},
518 {NULL, NULL}
519 };
520
521 lua_pushglobaltable(L);
522 // Core library is in this table. Contains '
523 //this is 'pm3' table
524 lua_newtable(L);
525
526 //Put the function into the hash table.
527 for (int i = 0; libs[i].name; i++) {
528 lua_pushcfunction(L, libs[i].func);
529 lua_setfield(L, -2, libs[i].name);//set the name, pop stack
530 }
531 //Name of 'core'
532 lua_setfield(L, -2, "core");
533
534 //-- remove the global environment table from the stack
535 lua_pop(L, 1);
536
537 //-- Last but not least, add to the LUA_PATH (package.path in lua)
538 // so we can load libraries from the ./lualib/ - directory
539 char libraries_path[strlen(get_my_executable_directory()) + strlen(LUA_LIBRARIES_DIRECTORY) + strlen(LUA_LIBRARIES_WILDCARD) + 1];
540 strcpy(libraries_path, get_my_executable_directory());
541 strcat(libraries_path, LUA_LIBRARIES_DIRECTORY);
542 strcat(libraries_path, LUA_LIBRARIES_WILDCARD);
543 setLuaPath(L, libraries_path);
544
545 return 1;
546 }
Impressum, Datenschutz