]> cvs.zerfleddert.de Git - proxmark3-svn/blob - client/cmdhficlass.c
6c92893ae9ab1559d983723489ecf2d496dcf5b1
[proxmark3-svn] / client / cmdhficlass.c
1 //-----------------------------------------------------------------------------
2 // Copyright (C) 2010 iZsh <izsh at fail0verflow.com>, Hagen Fritsch
3 // Copyright (C) 2011 Gerhard de Koning Gans
4 // Copyright (C) 2014 Midnitesnake & Andy Davies & Martin Holst Swende
5 //
6 // This code is licensed to you under the terms of the GNU GPL, version 2 or,
7 // at your option, any later version. See the LICENSE.txt file for the text of
8 // the license.
9 //-----------------------------------------------------------------------------
10 // High frequency iClass commands
11 //-----------------------------------------------------------------------------
12
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <string.h>
16 #include <sys/stat.h>
17 #include "iso14443crc.h" // Can also be used for iClass, using 0xE012 as CRC-type
18 #include "data.h"
19 #include "proxmark3.h"
20 #include "ui.h"
21 #include "cmdparser.h"
22 #include "cmdhficlass.h"
23 #include "common.h"
24 #include "util.h"
25 #include "cmdmain.h"
26 #include "loclass/des.h"
27 #include "loclass/cipherutils.h"
28 #include "loclass/cipher.h"
29 #include "loclass/ikeys.h"
30 #include "loclass/elite_crack.h"
31 #include "loclass/fileutils.h"
32
33 static int CmdHelp(const char *Cmd);
34
35 int xorbits_8(uint8_t val)
36 {
37 uint8_t res = val ^ (val >> 1); //1st pass
38 res = res ^ (res >> 1); // 2nd pass
39 res = res ^ (res >> 2); // 3rd pass
40 res = res ^ (res >> 4); // 4th pass
41 return res & 1;
42 }
43
44 int CmdHFiClassList(const char *Cmd)
45 {
46 PrintAndLog("Deprecated command, use 'hf list iclass' instead");
47 return 0;
48 }
49
50 int CmdHFiClassSnoop(const char *Cmd)
51 {
52 UsbCommand c = {CMD_SNOOP_ICLASS};
53 SendCommand(&c);
54 return 0;
55 }
56 #define NUM_CSNS 15
57 int CmdHFiClassSim(const char *Cmd)
58 {
59 uint8_t simType = 0;
60 uint8_t CSN[8] = {0, 0, 0, 0, 0, 0, 0, 0};
61
62 if (strlen(Cmd)<1) {
63 PrintAndLog("Usage: hf iclass sim [0 <CSN>] | x");
64 PrintAndLog(" options");
65 PrintAndLog(" 0 <CSN> simulate the given CSN");
66 PrintAndLog(" 1 simulate default CSN");
67 PrintAndLog(" 2 iterate CSNs, gather MACs");
68 PrintAndLog(" sample: hf iclass sim 0 031FEC8AF7FF12E0");
69 PrintAndLog(" sample: hf iclass sim 2");
70 return 0;
71 }
72
73 simType = param_get8(Cmd, 0);
74
75 if(simType == 0)
76 {
77 if (param_gethex(Cmd, 1, CSN, 16)) {
78 PrintAndLog("A CSN should consist of 16 HEX symbols");
79 return 1;
80 }
81 PrintAndLog("--simtype:%02x csn:%s", simType, sprint_hex(CSN, 8));
82
83 }
84 if(simType > 2)
85 {
86 PrintAndLog("Undefined simptype %d", simType);
87 return 1;
88 }
89 uint8_t numberOfCSNs=0;
90
91 if(simType == 2)
92 {
93 UsbCommand c = {CMD_SIMULATE_TAG_ICLASS, {simType,NUM_CSNS}};
94 UsbCommand resp = {0};
95
96 /*uint8_t csns[8 * NUM_CSNS] = {
97 0x00,0x0B,0x0F,0xFF,0xF7,0xFF,0x12,0xE0 ,
98 0x00,0x13,0x94,0x7e,0x76,0xff,0x12,0xe0 ,
99 0x2a,0x99,0xac,0x79,0xec,0xff,0x12,0xe0 ,
100 0x17,0x12,0x01,0xfd,0xf7,0xff,0x12,0xe0 ,
101 0xcd,0x56,0x01,0x7c,0x6f,0xff,0x12,0xe0 ,
102 0x4b,0x5e,0x0b,0x72,0xef,0xff,0x12,0xe0 ,
103 0x00,0x73,0xd8,0x75,0x58,0xff,0x12,0xe0 ,
104 0x0c,0x90,0x32,0xf3,0x5d,0xff,0x12,0xe0 };
105 */
106
107 uint8_t csns[8*NUM_CSNS] = {
108 0x00, 0x0B, 0x0F, 0xFF, 0xF7, 0xFF, 0x12, 0xE0,
109 0x00, 0x04, 0x0E, 0x08, 0xF7, 0xFF, 0x12, 0xE0,
110 0x00, 0x09, 0x0D, 0x05, 0xF7, 0xFF, 0x12, 0xE0,
111 0x00, 0x0A, 0x0C, 0x06, 0xF7, 0xFF, 0x12, 0xE0,
112 0x00, 0x0F, 0x0B, 0x03, 0xF7, 0xFF, 0x12, 0xE0,
113 0x00, 0x08, 0x0A, 0x0C, 0xF7, 0xFF, 0x12, 0xE0,
114 0x00, 0x0D, 0x09, 0x09, 0xF7, 0xFF, 0x12, 0xE0,
115 0x00, 0x0E, 0x08, 0x0A, 0xF7, 0xFF, 0x12, 0xE0,
116 0x00, 0x03, 0x07, 0x17, 0xF7, 0xFF, 0x12, 0xE0,
117 0x00, 0x3C, 0x06, 0xE0, 0xF7, 0xFF, 0x12, 0xE0,
118 0x00, 0x01, 0x05, 0x1D, 0xF7, 0xFF, 0x12, 0xE0,
119 0x00, 0x02, 0x04, 0x1E, 0xF7, 0xFF, 0x12, 0xE0,
120 0x00, 0x07, 0x03, 0x1B, 0xF7, 0xFF, 0x12, 0xE0,
121 0x00, 0x00, 0x02, 0x24, 0xF7, 0xFF, 0x12, 0xE0,
122 0x00, 0x05, 0x01, 0x21, 0xF7, 0xFF, 0x12, 0xE0 };
123
124 memcpy(c.d.asBytes, csns, 8*NUM_CSNS);
125
126 SendCommand(&c);
127 if (!WaitForResponseTimeout(CMD_ACK, &resp, -1)) {
128 PrintAndLog("Command timed out");
129 return 0;
130 }
131
132 uint8_t num_mac_responses = resp.arg[1];
133 PrintAndLog("Mac responses: %d MACs obtained (should be %d)", num_mac_responses,NUM_CSNS);
134
135 size_t datalen = NUM_CSNS*24;
136 /*
137 * Now, time to dump to file. We'll use this format:
138 * <8-byte CSN><8-byte CC><4 byte NR><4 byte MAC>....
139 * So, it should wind up as
140 * 8 * 24 bytes.
141 *
142 * The returndata from the pm3 is on the following format
143 * <4 byte NR><4 byte MAC>
144 * CC are all zeroes, CSN is the same as was sent in
145 **/
146 void* dump = malloc(datalen);
147 memset(dump,0,datalen);//<-- Need zeroes for the CC-field
148 uint8_t i = 0;
149 for(i = 0 ; i < NUM_CSNS ; i++)
150 {
151 memcpy(dump+i*24, csns+i*8,8); //CSN
152 //8 zero bytes here...
153 //Then comes NR_MAC (eight bytes from the response)
154 memcpy(dump+i*24+16,resp.d.asBytes+i*8,8);
155
156 }
157 /** Now, save to dumpfile **/
158 saveFile("iclass_mac_attack", "bin", dump,datalen);
159 free(dump);
160 }else
161 {
162 UsbCommand c = {CMD_SIMULATE_TAG_ICLASS, {simType,numberOfCSNs}};
163 memcpy(c.d.asBytes, CSN, 8);
164 SendCommand(&c);
165 }
166
167 return 0;
168 }
169
170 int CmdHFiClassReader(const char *Cmd)
171 {
172 UsbCommand c = {CMD_READER_ICLASS, {0}};
173 SendCommand(&c);
174 UsbCommand resp;
175 while(!ukbhit()){
176 if (WaitForResponseTimeout(CMD_ACK,&resp,4500)) {
177 uint8_t isOK = resp.arg[0] & 0xff;
178 uint8_t * data = resp.d.asBytes;
179
180 PrintAndLog("isOk:%02x", isOK);
181 if( isOK == 0){
182 //Aborted
183 PrintAndLog("Quitting...");
184 return 0;
185 }
186 if(isOK > 0)
187 {
188 PrintAndLog("CSN: %s",sprint_hex(data,8));
189 }
190 if(isOK >= 1)
191 {
192 PrintAndLog("CC: %s",sprint_hex(data+8,8));
193 }else{
194 PrintAndLog("No CC obtained");
195 }
196 } else {
197 PrintAndLog("Command execute timeout");
198 }
199 }
200
201 return 0;
202 }
203
204 int CmdHFiClassReader_Replay(const char *Cmd)
205 {
206 uint8_t readerType = 0;
207 uint8_t MAC[4]={0x00, 0x00, 0x00, 0x00};
208
209 if (strlen(Cmd)<1) {
210 PrintAndLog("Usage: hf iclass replay <MAC>");
211 PrintAndLog(" sample: hf iclass replay 00112233");
212 return 0;
213 }
214
215 if (param_gethex(Cmd, 0, MAC, 8)) {
216 PrintAndLog("MAC must include 8 HEX symbols");
217 return 1;
218 }
219
220 UsbCommand c = {CMD_READER_ICLASS_REPLAY, {readerType}};
221 memcpy(c.d.asBytes, MAC, 4);
222 SendCommand(&c);
223
224 return 0;
225 }
226
227 int CmdHFiClassReader_Dump(const char *Cmd)
228 {
229 uint8_t readerType = 0;
230 uint8_t MAC[4]={0x00,0x00,0x00,0x00};
231 uint8_t KEY[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
232 uint8_t CSN[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
233 uint8_t CCNR[12]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
234 //uint8_t CC_temp[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
235 uint8_t div_key[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
236 uint8_t keytable[128] = {0};
237 int elite = 0;
238 uint8_t *used_key;
239 int i;
240 if (strlen(Cmd)<1)
241 {
242 PrintAndLog("Usage: hf iclass dump <Key> [e]");
243 PrintAndLog(" Key - A 16 byte master key");
244 PrintAndLog(" e - If 'e' is specified, the key is interpreted as the 16 byte");
245 PrintAndLog(" Custom Key (KCus), which can be obtained via reader-attack");
246 PrintAndLog(" See 'hf iclass sim 2'. This key should be on iclass-format");
247 PrintAndLog(" sample: hf iclass dump 0011223344556677");
248
249
250 return 0;
251 }
252
253 if (param_gethex(Cmd, 0, KEY, 16))
254 {
255 PrintAndLog("KEY must include 16 HEX symbols");
256 return 1;
257 }
258
259 if (param_getchar(Cmd, 1) == 'e')
260 {
261 PrintAndLog("Elite switch on");
262 elite = 1;
263
264 //calc h2
265 hash2(KEY, keytable);
266 printarr_human_readable("keytable", keytable, 128);
267
268 }
269
270 UsbCommand resp;
271 uint8_t key_sel[8] = {0};
272 uint8_t key_sel_p[8] = { 0 };
273
274 UsbCommand c = {CMD_READER_ICLASS, {0}};
275 c.arg[0] = FLAG_ICLASS_READER_ONLY_ONCE| FLAG_ICLASS_READER_GET_CC;
276 SendCommand(&c);
277
278
279
280 if (!WaitForResponseTimeout(CMD_ACK,&resp,4500))
281 {
282 PrintAndLog("Command execute timeout");
283 return 0;
284 }
285
286 uint8_t isOK = resp.arg[0] & 0xff;
287 uint8_t * data = resp.d.asBytes;
288
289 memcpy(CSN,data,8);
290 memcpy(CCNR,data+8,8);
291
292 PrintAndLog("isOk:%02x", isOK);
293
294 if(isOK > 0)
295 {
296 PrintAndLog("CSN: %s",sprint_hex(CSN,8));
297 }
298 if(isOK <= 1){
299 PrintAndLog("Failed to obtain CC! Aborting");
300 return 0;
301 }
302 //Status 2 or higher
303
304 if(elite)
305 {
306 //Get the key index (hash1)
307 uint8_t key_index[8] = {0};
308
309 hash1(CSN, key_index);
310 printvar("hash1", key_index,8);
311 for(i = 0; i < 8 ; i++)
312 key_sel[i] = keytable[key_index[i]] & 0xFF;
313 PrintAndLog("Pre-fortified 'permuted' HS key that would be needed by an iclass reader to talk to above CSN:");
314 printvar("k_sel", key_sel,8);
315 //Permute from iclass format to standard format
316 permutekey_rev(key_sel,key_sel_p);
317 used_key = key_sel_p;
318 }else{
319 used_key = KEY;
320 }
321
322 PrintAndLog("Pre-fortified key that would be needed by the OmniKey reader to talk to above CSN:");
323 printvar("Used key",used_key,8);
324 diversifyKey(CSN,used_key, div_key);
325 PrintAndLog("Hash0, a.k.a diversified key, that is computed using Ksel and stored in the card (Block 3):");
326 printvar("Div key", div_key, 8);
327 printvar("CC_NR:",CCNR,12);
328 doMAC(CCNR,12,div_key, MAC);
329 printvar("MAC", MAC, 4);
330
331 uint8_t iclass_data[32000] = {0};
332 uint32_t iclass_datalen = 0;
333 uint32_t iclass_blocksFailed = 0;//Set to 1 if dump was incomplete
334
335 UsbCommand d = {CMD_READER_ICLASS_REPLAY, {readerType}};
336 memcpy(d.d.asBytes, MAC, 4);
337 clearCommandBuffer();
338 SendCommand(&d);
339 PrintAndLog("Waiting for device to dump data. Press button on device and key on keyboard to abort...");
340 while (true) {
341 printf(".");
342 if (ukbhit()) {
343 getchar();
344 printf("\naborted via keyboard!\n");
345 break;
346 }
347 if(WaitForResponseTimeout(CMD_ACK,&resp,4500))
348 {
349 uint32_t dataLength = resp.arg[0];
350 iclass_blocksFailed |= resp.arg[1];
351 if(dataLength > 0)
352 {
353 PrintAndLog("Got %d bytes data (total so far %d)" ,dataLength,iclass_datalen);
354 memcpy(iclass_data, resp.d.asBytes,dataLength);
355 iclass_datalen += dataLength;
356 }else
357 {//Last transfer, datalength 0 means the dump is finished
358 PrintAndLog("Dumped %d bytes of data from tag. ", iclass_datalen);
359 if(iclass_blocksFailed)
360 {
361 PrintAndLog("OBS! Some blocks failed to be dumped correctly!");
362 }
363 if(iclass_datalen > 0)
364 {
365 char filename[100] = {0};
366 //create a preferred filename
367 snprintf(filename, 100,"iclass_tagdump-%02x%02x%02x%02x%02x%02x%02x%02x",
368 CSN[0],CSN[1],CSN[2],CSN[3],
369 CSN[4],CSN[5],CSN[6],CSN[7]);
370 saveFile(filename,"bin",iclass_data, iclass_datalen );
371 }
372 //Aaaand we're finished
373 return 0;
374 }
375 }
376 }
377
378
379 return 0;
380 }
381
382 int hf_iclass_eload_usage()
383 {
384 PrintAndLog("Loads iclass tag-dump into emulator memory on device");
385 PrintAndLog("Usage: hf iclass eload f <filename>");
386 PrintAndLog("");
387 PrintAndLog("Example: hf iclass eload f iclass_tagdump-aa162d30f8ff12f1.bin");
388 return 0;
389
390 }
391
392 int iclassEmlSetMem(uint8_t *data, int blockNum, int blocksCount) {
393 UsbCommand c = {CMD_MIFARE_EML_MEMSET, {blockNum, blocksCount, 0}};
394 memcpy(c.d.asBytes, data, blocksCount * 16);
395 SendCommand(&c);
396 return 0;
397 }
398 int CmdHFiClassELoad(const char *Cmd)
399 {
400
401 char opt = param_getchar(Cmd, 0);
402 if (strlen(Cmd)<1 || opt == 'h')
403 return hf_iclass_eload_usage();
404
405 //File handling and reading
406 FILE *f;
407 char filename[FILE_PATH_SIZE];
408 if(opt == 'f' && param_getstr(Cmd, 1, filename) > 0)
409 {
410 f = fopen(filename, "rb");
411 }else{
412 return hf_iclass_eload_usage();
413 }
414
415 if(!f) {
416 PrintAndLog("Failed to read from file '%s'", filename);
417 return 1;
418 }
419
420 fseek(f, 0, SEEK_END);
421 long fsize = ftell(f);
422 fseek(f, 0, SEEK_SET);
423
424 uint8_t *dump = malloc(fsize);
425 size_t bytes_read = fread(dump, 1, fsize, f);
426 fclose(f);
427
428 //Validate
429
430 if (bytes_read < fsize)
431 {
432 prnlog("Error, could only read %d bytes (should be %d)",bytes_read, fsize );
433 free(dump);
434 return 1;
435 }
436 //Send to device
437 uint32_t bytes_sent = 0;
438 uint32_t bytes_remaining = bytes_read;
439
440 while(bytes_remaining > 0){
441 uint32_t bytes_in_packet = MIN(USB_CMD_DATA_SIZE, bytes_remaining);
442 UsbCommand c = {CMD_ICLASS_EML_MEMSET, {bytes_sent,bytes_in_packet,0}};
443 memcpy(c.d.asBytes, dump, bytes_in_packet);
444 SendCommand(&c);
445 bytes_remaining -= bytes_in_packet;
446 bytes_sent += bytes_in_packet;
447 }
448 free(dump);
449 PrintAndLog("Sent %d bytes of data to device emulator memory", bytes_sent);
450 return 0;
451 }
452
453
454 int CmdHFiClass_iso14443A_write(const char *Cmd)
455 {
456 uint8_t readerType = 0;
457 uint8_t MAC[4]={0x00,0x00,0x00,0x00};
458 uint8_t KEY[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
459 uint8_t CSN[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
460 uint8_t CCNR[12]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
461 uint8_t div_key[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
462
463 uint8_t blockNo=0;
464 uint8_t bldata[8]={0};
465
466 if (strlen(Cmd)<3)
467 {
468 PrintAndLog("Usage: hf iclass write <Key> <Block> <Data>");
469 PrintAndLog(" sample: hf iclass write 0011223344556677 10 AAAAAAAAAAAAAAAA");
470 return 0;
471 }
472
473 if (param_gethex(Cmd, 0, KEY, 16))
474 {
475 PrintAndLog("KEY must include 16 HEX symbols");
476 return 1;
477 }
478
479 blockNo = param_get8(Cmd, 1);
480 if (blockNo>32)
481 {
482 PrintAndLog("Error: Maximum number of blocks is 32 for iClass 2K Cards!");
483 return 1;
484 }
485 if (param_gethex(Cmd, 2, bldata, 8))
486 {
487 PrintAndLog("Block data must include 8 HEX symbols");
488 return 1;
489 }
490
491 UsbCommand c = {CMD_ICLASS_ISO14443A_WRITE, {0}};
492 SendCommand(&c);
493 UsbCommand resp;
494
495 if (WaitForResponseTimeout(CMD_ACK,&resp,4500)) {
496 uint8_t isOK = resp.arg[0] & 0xff;
497 uint8_t * data = resp.d.asBytes;
498
499 memcpy(CSN,data,8);
500 memcpy(CCNR,data+8,8);
501 PrintAndLog("DEBUG: %s",sprint_hex(CSN,8));
502 PrintAndLog("DEBUG: %s",sprint_hex(CCNR,8));
503 PrintAndLog("isOk:%02x", isOK);
504 } else {
505 PrintAndLog("Command execute timeout");
506 }
507
508 diversifyKey(CSN,KEY, div_key);
509
510 PrintAndLog("Div Key: %s",sprint_hex(div_key,8));
511 doMAC(CCNR, 12,div_key, MAC);
512
513 UsbCommand c2 = {CMD_ICLASS_ISO14443A_WRITE, {readerType,blockNo}};
514 memcpy(c2.d.asBytes, bldata, 8);
515 memcpy(c2.d.asBytes+8, MAC, 4);
516 SendCommand(&c2);
517
518 if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {
519 uint8_t isOK = resp.arg[0] & 0xff;
520 uint8_t * data = resp.d.asBytes;
521
522 if (isOK)
523 PrintAndLog("isOk:%02x data:%s", isOK, sprint_hex(data, 4));
524 else
525 PrintAndLog("isOk:%02x", isOK);
526 } else {
527 PrintAndLog("Command execute timeout");
528 }
529 return 0;
530 }
531 int CmdHFiClass_loclass(const char *Cmd)
532 {
533 char opt = param_getchar(Cmd, 0);
534
535 if (strlen(Cmd)<1 || opt == 'h') {
536 PrintAndLog("Usage: hf iclass loclass [options]");
537 PrintAndLog("Options:");
538 PrintAndLog("h Show this help");
539 PrintAndLog("t Perform self-test");
540 PrintAndLog("f <filename> Bruteforce iclass dumpfile");
541 PrintAndLog(" An iclass dumpfile is assumed to consist of an arbitrary number of");
542 PrintAndLog(" malicious CSNs, and their protocol responses");
543 PrintAndLog(" The the binary format of the file is expected to be as follows: ");
544 PrintAndLog(" <8 byte CSN><8 byte CC><4 byte NR><4 byte MAC>");
545 PrintAndLog(" <8 byte CSN><8 byte CC><4 byte NR><4 byte MAC>");
546 PrintAndLog(" <8 byte CSN><8 byte CC><4 byte NR><4 byte MAC>");
547 PrintAndLog(" ... totalling N*24 bytes");
548 return 0;
549 }
550 char fileName[255] = {0};
551 if(opt == 'f')
552 {
553 if(param_getstr(Cmd, 1, fileName) > 0)
554 {
555 return bruteforceFileNoKeys(fileName);
556 }else
557 {
558 PrintAndLog("You must specify a filename");
559 }
560 }
561 else if(opt == 't')
562 {
563 int errors = testCipherUtils();
564 errors += testMAC();
565 errors += doKeyTests(0);
566 errors += testElite();
567 if(errors)
568 {
569 prnlog("OBS! There were errors!!!");
570 }
571 return errors;
572 }
573
574 return 0;
575 }
576
577 static command_t CommandTable[] =
578 {
579 {"help", CmdHelp, 1, "This help"},
580 {"list", CmdHFiClassList, 0, "[Deprecated] List iClass history"},
581 {"snoop", CmdHFiClassSnoop, 0, "Eavesdrop iClass communication"},
582 {"sim", CmdHFiClassSim, 0, "Simulate iClass tag"},
583 {"reader",CmdHFiClassReader, 0, "Read an iClass tag"},
584 {"replay",CmdHFiClassReader_Replay, 0, "Read an iClass tag via Reply Attack"},
585 {"dump", CmdHFiClassReader_Dump, 0, "Authenticate and Dump iClass tag"},
586 // {"write", CmdHFiClass_iso14443A_write, 0, "Authenticate and Write iClass block"},
587 {"loclass", CmdHFiClass_loclass, 1, "Use loclass to perform bruteforce of reader attack dump"},
588 {"eload", CmdHFiClassELoad, 0, "[experimental] Load data into iclass emulator memory"},
589 {NULL, NULL, 0, NULL}
590 };
591
592 int CmdHFiClass(const char *Cmd)
593 {
594 CmdsParse(CommandTable, Cmd);
595 return 0;
596 }
597
598 int CmdHelp(const char *Cmd)
599 {
600 CmdsHelp(CommandTable);
601 return 0;
602 }
Impressum, Datenschutz