]> git.zerfleddert.de Git - proxmark3-svn/blob - client/reveng/cli.c
projects / proxmark3-svn / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
add first attempt at lf miller decoding
[proxmark3-svn] / client / reveng / cli.c
1 /* cli.c
2 * Greg Cook, 9/Apr/2015
3 */
4
5 /* CRC RevEng, an arbitrary-precision CRC calculator and algorithm finder
6 * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015 Gregory Cook
7 *
8 * This file is part of CRC RevEng.
9 *
10 * CRC RevEng is free software: you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation, either version 3 of the License, or
13 * (at your option) any later version.
14 *
15 * CRC RevEng is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with CRC RevEng. If not, see <http://www.gnu.org/licenses/>.
22 */
23
24 /* 2015-04-03: added -z
25 * 2013-09-16: do not search with -M
26 * 2013-06-11: uprog() suppresses first progress report
27 * 2013-04-22: uprog() prints poly same as mtostr()
28 * 2013-02-07: added -q, uprog(), removed -W, R_ODDLY
29 * 2012-05-24: -D dumps parameters of all models
30 * 2012-03-03: added code to test sort order of model table
31 * 2012-02-20: set stdin to binary (MinGW). offer -D if preset unknown.
32 * 2011-09-06: -s reads arguments once. stdin not closed.
33 * 2011-09-06: fixed bad argument-freeing loops.
34 * 2011-08-27: validates BMP_C()
35 * 2011-08-26: validates BMPBIT and BMPSUB
36 * 2011-08-25: fixed Init/Xorout reflection logic in -V and -v
37 * 2011-01-17: fixed ANSI C warnings
38 * 2011-01-15: added NOFORCE
39 * 2011-01-14: added -k, -P
40 * 2011-01-10: reorganised switches, added -V, -X
41 * 2010-12-26: renamed CRC RevEng
42 * 2010-12-18: implemented -c, -C
43 * 2010-12-14: added and implemented -d, -D, fixed -ipx entry
44 * 2010-12-11: implemented -e. first tests
45 * 2010-12-10: finalised option processing. started input validation
46 * 2010-12-07: started cli
47 */
48
49 #include <stdio.h>
50 #include <stdlib.h>
51 #include "getopt.h"
52 #ifdef _WIN32
53 # include <io.h>
54 # include <fcntl.h>
55 # ifndef STDIN_FILENO
56 # define STDIN_FILENO 0
57 # endif /* STDIN_FILENO */
58 #endif /* _WIN32 */
59
60 #include "reveng.h"
61
62 static FILE *oread(const char *);
63 static poly_t rdpoly(const char *, int, int);
64 static void usage(void);
65
66 static const char *myname = "reveng"; /* name of our program */
67
68 int reveng_main(int argc, char *argv[]) {
69 /* Command-line interface for CRC RevEng.
70 * Process options and switches in the argument list and
71 * run the required function.
72 */
73
74 /* default values */
75 model_t model = {
76 PZERO, /* no CRC polynomial, user must specify */
77 PZERO, /* Init = 0 */
78 P_BE, /* RefIn = false, RefOut = false, plus P_RTJUST setting in reveng.h */
79 PZERO, /* XorOut = 0 */
80 PZERO, /* check value unused */
81 NULL /* no model name */
82 };
83 int ibperhx = 8, obperhx = 8;
84 int rflags = 0, uflags = 0; /* search and UI flags */
85
86 unsigned long width = 0UL;
87 int c, mode = 0, args, psets, pass;
88 poly_t apoly, crc, qpoly = PZERO, *apolys, *pptr = NULL, *qptr = NULL;
89 model_t pset = model, *candmods, *mptr;
90 char *string;
91
92 myname = argv[0];
93
94 /* stdin must be binary */
95 #ifdef _WIN32
96 _setmode(STDIN_FILENO, _O_BINARY);
97 #endif /* _WIN32 */
98
99 SETBMP();
100
101 pos=0;
102 optind=1;
103 do {
104 c=getopt(argc, argv, "?A:BDFLMP:SVXa:bcdefhi:k:lm:p:q:rstuvw:x:yz");
105 switch(c) {
106 case 'A': /* A: bits per output character */
107 case 'a': /* a: bits per character */
108 if((obperhx = atoi(optarg)) > BMP_BIT) {
109 fprintf(stderr,"%s: argument to -%c must be between 1 and %d\n", myname, c, BMP_BIT);
110 return 0;
111 //exit(EXIT_FAILURE);
112 }
113 if(c == 'a') ibperhx = obperhx;
114 break;
115 case 'b': /* b big-endian (RefIn = false, RefOut = false ) */
116 model.flags &= ~P_REFIN;
117 rflags |= R_HAVERI;
118 /* fall through: */
119 case 'B': /* B big-endian output (RefOut = false) */
120 model.flags &= ~P_REFOUT;
121 rflags |= R_HAVERO;
122 mnovel(&model);
123 /* fall through: */
124 case 'r': /* r right-justified */
125 model.flags |= P_RTJUST;
126 break;
127 case 'c': /* c calculate CRC */
128 case 'D': /* D list primary model names */
129 case 'd': /* d dump CRC model */
130 case 'e': /* e echo arguments */
131 case 's': /* s search for algorithm */
132 case 'v': /* v calculate reversed CRC */
133 if(mode) {
134 fprintf(stderr,"%s: more than one mode switch specified. Use %s -h for help.\n", myname, myname);
135 return 0;
136 //exit(EXIT_FAILURE);
137 }
138 mode = c;
139 break;
140 case 'F': /* F force search */
141 #ifndef NOFORCE
142 uflags |= C_FORCE;
143 #endif
144 break;
145 case 'f': /* f arguments are filenames */
146 uflags |= C_INFILE;
147 break;
148 case 'h': /* h get help / usage */
149 case 'u': /* u get help / usage */
150 case '?': /* ? get help / usage */
151 default:
152 usage();
153 return 0;
154 //exit(EXIT_FAILURE);
155 break;
156 case 'i': /* i: Init value */
157 pptr = &model.init;
158 rflags |= R_HAVEI;
159 goto ippx;
160 case 'k': /* k: polynomial in Koopman notation */
161 pfree(&model.spoly);
162 model.spoly = strtop(optarg, 0, 4);
163 pkchop(&model.spoly);
164 width = plen(model.spoly);
165 rflags |= R_HAVEP;
166 mnovel(&model);
167 break;
168 case 'l': /* l little-endian input and output */
169 model.flags |= P_REFIN;
170 rflags |= R_HAVERI;
171 /* fall through: */
172 case 'L': /* L little-endian output */
173 model.flags |= P_REFOUT;
174 rflags |= R_HAVERO;
175 mnovel(&model);
176 /* fall through: */
177 case 't': /* t left-justified */
178 model.flags &= ~P_RTJUST;
179 break;
180 case 'm': /* m: select preset CRC model */
181 if(!(c = mbynam(&model, optarg))) {
182 fprintf(stderr,"%s: preset model '%s' not found. Use %s -D to list presets.\n", myname, optarg, myname);
183 return 0;
184 //exit(EXIT_FAILURE);
185 }
186 if(c < 0){
187 uerror("no preset models available");
188 return 0;
189 }
190 /* must set width so that parameter to -ipx is not zeroed */
191 width = plen(model.spoly);
192 rflags |= R_HAVEP | R_HAVEI | R_HAVERI | R_HAVERO | R_HAVEX;
193 break;
194 case 'M': /* M non-augmenting algorithm */
195 model.flags &= ~P_MULXN;
196 break;
197 case 'P': /* P: reversed polynomial */
198 case 'p': /* p: polynomial */
199 pptr = &model.spoly;
200 rflags &= ~R_HAVEQ;
201 rflags |= R_HAVEP;
202 ippx:
203 pfree(pptr);
204 *pptr = strtop(optarg, 0, 4);
205 pright(pptr, width);
206 if(c == 'P')
207 prev(pptr);
208 mnovel(&model);
209 break;
210 case 'q': /* q: range end polynomial */
211 pptr = &qpoly;
212 rflags &= ~R_HAVEP;
213 rflags |= R_HAVEQ;
214 goto ippx;
215 case 'S': /* s space between output characters */
216 model.flags |= P_SPACE;
217 break;
218 case 'V': /* v reverse algorithm */
219 /* Distinct from the -v switch as the
220 * user will have to reverse his or her
221 * own arguments. The user cannot dump
222 * the model generated by -v either.
223 */
224 mrev(&model);
225 break;
226 case 'w': /* w: CRC width = order - 1 */
227 width = (unsigned long) atol(optarg);
228 break;
229 case 'X': /* X print uppercase hex */
230 model.flags |= P_UPPER;
231 break;
232 case 'x': /* x: XorOut value */
233 pptr = &model.xorout;
234 rflags |= R_HAVEX;
235 goto ippx;
236 case 'y': /* y little-endian byte order in files */
237 model.flags |= P_LTLBYT;
238 break;
239 case 'z': /* z raw binary arguments */
240 model.flags |= P_DIRECT;
241 break;
242 case -1: /* no more options, continue */
243 ;
244 }
245 } while(c != -1);
246
247 /* canonicalise the model, so the one we dump is the one we
248 * calculate with (not with -s, spoly may be blank which will
249 * normalise to zero and clear init and xorout.)
250 */
251 if(mode != 's')
252 mcanon(&model);
253
254 switch(mode) {
255 case 'v': /* v calculate reversed CRC */
256 /* Distinct from the -V switch as this causes
257 * the arguments and output to be reversed as well.
258 */
259 /* reciprocate Poly */
260 prcp(&model.spoly);
261
262 /* mrev() does:
263 * if(refout) prev(init); else prev(xorout);
264 * but here the entire argument polynomial is
265 * reflected, not just the characters, so RefIn
266 * and RefOut are not inverted as with -V.
267 * Consequently Init is the mirror image of the
268 * one resulting from -V, and so we have:
269 */
270 if(~model.flags & P_REFOUT) {
271 prev(&model.init);
272 prev(&model.xorout);
273 }
274
275 /* swap init and xorout */
276 apoly = model.init;
277 model.init = model.xorout;
278 model.xorout = apoly;
279
280 /* fall through: */
281 case 'c': /* c calculate CRC */
282
283 /* validate inputs */
284 /* if(plen(model.spoly) == 0) {
285 * fprintf(stderr,"%s: no polynomial specified for -%c (add -w WIDTH -p POLY)\n", myname, mode);
286 * exit(EXIT_FAILURE);
287 * }
288 */
289
290 /* in the Williams model, xorout is applied after the refout stage.
291 * as refout is part of ptostr(), we reverse xorout here.
292 */
293 if(model.flags & P_REFOUT)
294 prev(&model.xorout);
295
296 for(; optind < argc; ++optind) {
297 if(uflags & C_INFILE)
298 apoly = rdpoly(argv[optind], model.flags, ibperhx);
299 else
300 apoly = strtop(argv[optind], model.flags, ibperhx);
301
302 if(mode == 'v')
303 prev(&apoly);
304
305 crc = pcrc(apoly, model.spoly, model.init, model.xorout, model.flags);
306
307 if(mode == 'v')
308 prev(&crc);
309
310 string = ptostr(crc, model.flags, obperhx);
311 puts(string);
312 free(string);
313 pfree(&crc);
314 pfree(&apoly);
315 }
316 break;
317 case 'D': /* D dump all models */
318 args = mcount();
319 if(!args){
320 uerror("no preset models available");
321 return 0;
322 }
323 for(mode = 0; mode < args; ++mode) {
324 mbynum(&model, mode);
325 mcanon(&model);
326 ufound(&model);
327 }
328 break;
329 case 'd': /* d dump CRC model */
330 /* maybe we don't want to do this:
331 * either attaching names to arbitrary models or forcing to a preset
332 * mmatch(&model, M_OVERWR);
333 */
334 if(~model.flags & P_MULXN){
335 uerror("not a Williams model compliant algorithm");
336 return 0;
337 }
338 string = mtostr(&model);
339 puts(string);
340 free(string);
341 break;
342 case 'e': /* e echo arguments */
343 for(; optind < argc; ++optind) {
344 if(uflags & C_INFILE)
345 apoly = rdpoly(argv[optind], model.flags, ibperhx);
346 else
347 apoly = strtop(argv[optind], model.flags, ibperhx);
348
349 psum(&apoly, model.init, 0UL);
350 string = ptostr(apoly, model.flags, obperhx);
351 puts(string);
352 free(string);
353 pfree(&apoly);
354 }
355 break;
356 case 's': /* s search for algorithm */
357 if(!width){
358 uerror("must specify positive -k or -w before -s");
359 return 0;
360 }
361 if(~model.flags & P_MULXN){
362 uerror("cannot search for non-Williams compliant models");
363 return 0;
364 }
365 praloc(&model.spoly, width);
366 praloc(&model.init, width);
367 praloc(&model.xorout, width);
368 if(!plen(model.spoly))
369 palloc(&model.spoly, width);
370 else
371 width = plen(model.spoly);
372
373 /* special case if qpoly is zero, search to end of range */
374 if(!ptst(qpoly))
375 rflags &= ~R_HAVEQ;
376
377 /* allocate argument array */
378 args = argc - optind;
379 if(!(apolys = malloc(args * sizeof(poly_t)))){
380 uerror("cannot allocate memory for argument list");
381 return 0;
382 }
383
384 for(pptr = apolys; optind < argc; ++optind) {
385 if(uflags & C_INFILE)
386 *pptr++ = rdpoly(argv[optind], model.flags, ibperhx);
387 else
388 *pptr++ = strtop(argv[optind], model.flags, ibperhx);
389 }
390 /* exit value of pptr is used hereafter! */
391
392 /* if endianness not specified, try
393 * little-endian then big-endian.
394 * NB: crossed-endian algorithms will not be
395 * searched.
396 */
397
398 /* scan against preset models */
399 if(~uflags & C_FORCE) {
400 pass = 0;
401 do {
402 psets = mcount();
403 while(psets) {
404 mbynum(&pset, --psets);
405 /* skip if different width, or refin or refout don't match */
406 if(plen(pset.spoly) != width || (model.flags ^ pset.flags) & (P_REFIN | P_REFOUT))
407 continue;
408 /* skip if the preset doesn't match specified parameters */
409 if(rflags & R_HAVEP && pcmp(&model.spoly, &pset.spoly))
410 continue;
411 if(rflags & R_HAVEI && psncmp(&model.init, &pset.init))
412 continue;
413 if(rflags & R_HAVEX && psncmp(&model.xorout, &pset.xorout))
414 continue;
415 apoly = pclone(pset.xorout);
416 if(pset.flags & P_REFOUT)
417 prev(&apoly);
418 for(qptr = apolys; qptr < pptr; ++qptr) {
419 crc = pcrc(*qptr, pset.spoly, pset.init, apoly, 0);
420 if(ptst(crc)) {
421 pfree(&crc);
422 break;
423 } else
424 pfree(&crc);
425 }
426 pfree(&apoly);
427 if(qptr == pptr) {
428 /* the selected model solved all arguments */
429 mcanon(&pset);
430 ufound(&pset);
431 uflags |= C_RESULT;
432 }
433 }
434 mfree(&pset);
435
436 /* toggle refIn/refOut and reflect arguments */
437 if(~rflags & R_HAVERI) {
438 model.flags ^= P_REFIN | P_REFOUT;
439 for(qptr = apolys; qptr < pptr; ++qptr)
440 prevch(qptr, ibperhx);
441 }
442 } while(~rflags & R_HAVERI && ++pass < 2);
443 }
444 if(uflags & C_RESULT) {
445 for(qptr = apolys; qptr < pptr; ++qptr)
446 pfree(qptr);
447 //return 1;
448 //exit(EXIT_SUCCESS);
449 }
450 if(!(model.flags & P_REFIN) != !(model.flags & P_REFOUT)){
451 uerror("cannot search for crossed-endian models");
452 return 0;
453 }
454 pass = 0;
455 do {
456 mptr = candmods = reveng(&model, qpoly, rflags, args, apolys);
457 if(mptr && plen(mptr->spoly))
458 uflags |= C_RESULT;
459 while(mptr && plen(mptr->spoly)) {
460 /* results were printed by the callback
461 * string = mtostr(mptr);
462 * puts(string);
463 * free(string);
464 */
465 mfree(mptr++);
466 }
467 free(candmods);
468 if(~rflags & R_HAVERI) {
469 model.flags ^= P_REFIN | P_REFOUT;
470 for(qptr = apolys; qptr < pptr; ++qptr)
471 prevch(qptr, ibperhx);
472 }
473 } while(~rflags & R_HAVERI && ++pass < 2);
474 for(qptr = apolys; qptr < pptr; ++qptr)
475 pfree(qptr);
476 free(apolys);
477 if(~uflags & C_RESULT)
478 uerror("no models found");
479 break;
480 default: /* no mode specified */
481 fprintf(stderr, "%s: no mode switch specified. Use %s -h for help.\n", myname, myname);
482 //exit(EXIT_FAILURE);
483 }
484
485 return 1;
486 //exit(EXIT_SUCCESS);
487 }
488
489 void
490 ufound(const model_t *model) {
491 /* Callback function to report each model found */
492 char *string;
493
494 if(!model) return;
495 /* generated models will be canonical */
496 string = mtostr(model);
497 puts(string);
498 free(string);
499 }
500
501 void
502 uerror(const char *msg) {
503 /* Callback function to report fatal errors */
504 fprintf(stderr, "%s: %s\n", myname, msg);
505 return;
506 //exit(EXIT_FAILURE);
507 }
508
509 void
510 uprog(const poly_t gpoly, int flags, unsigned long seq) {
511 /* Callback function to report search progress */
512 char *string;
513
514 /* Suppress first report in CLI */
515 if(!seq)
516 return;
517 string = ptostr(gpoly, P_RTJUST, 4);
518 fprintf(stderr, "%s: searching: width=%ld poly=0x%s refin=%s refout=%s\n",
519 myname, plen(gpoly), string,
520 (flags & P_REFIN ? "true" : "false"),
521 (flags & P_REFOUT ? "true" : "false")
522 );
523 free(string);
524 }
525
526 static poly_t
527 rdpoly(const char *name, int flags, int bperhx) {
528 /* read poly from file in chunks and report errors */
529
530 poly_t apoly = PZERO, chunk = PZERO;
531 FILE *input;
532
533 input = oread(name);
534 while(!feof(input) && !ferror(input)) {
535 chunk = filtop(input, BUFFER, flags, bperhx);
536 psum(&apoly, chunk, plen(apoly));
537 pfree(&chunk);
538 }
539 if(ferror(input)) {
540 fprintf(stderr,"%s: error condition on file '%s'\n", myname, name);
541 exit(EXIT_FAILURE);
542 }
543 /* close file unless stdin */
544 if(input == stdin)
545 /* reset EOF condition */
546 clearerr(input);
547 else if(fclose(input)) {
548 fprintf(stderr,"%s: error closing file '%s'\n", myname, name);
549 exit(EXIT_FAILURE);
550 }
551 return(apoly);
552 }
553
554 static FILE *
555 oread(const char *name) {
556 /* open file for reading and report errors */
557 FILE *handle;
558
559 /* recognise special name '-' as standard input */
560 if(*name == '-' && name[1] == '\0')
561 return(stdin);
562 if(!(handle = fopen(name, "rb"))) {
563 fprintf(stderr, "%s: cannot open '%s' for reading\n", myname, name);
564 return 0;
565 //exit(EXIT_FAILURE);
566 }
567 return(handle);
568 }
569
570 static void
571 usage(void) {
572 /* print usage if asked, or if syntax incorrect */
573 fprintf(stderr,
574 "CRC RevEng, an arbitrary-precision CRC calculator and algorithm finder\n"
575 "Usage:\t");
576 fputs(myname, stderr);
577 fprintf(stderr,
578 "\t-cdDesvhu? [-bBfFlLMrStVXyz]\n"
579 "\t\t[-a BITS] [-A OBITS] [-i INIT] [-k KPOLY] [-m MODEL]\n"
580 "\t\t[-p POLY] [-P RPOLY] [-q QPOLY] [-w WIDTH] [-x XOROUT]\n"
581 "\t\t[STRING...]\n"
582 "Options:\n"
583 "\t-a BITS\t\tbits per character (1 to %d)\n"
584 "\t-A OBITS\tbits per output character (1 to %d)\n"
585 "\t-i INIT\t\tinitial register value\n"
586 "\t-k KPOLY\tgenerator in Koopman notation (implies WIDTH)\n"
587 "\t-m MODEL\tpreset CRC algorithm\n"
588 "\t-p POLY\t\tgenerator or search range start polynomial\n"
589 "\t-P RPOLY\treversed generator polynomial\n",
590 BMP_BIT, BMP_BIT);
591 fprintf(stderr,
592 "\t-q QPOLY\tsearch range end polynomial\n"
593 "\t-w WIDTH\tregister size, in bits\n"
594 "\t-x XOROUT\tfinal register XOR value\n"
595 "Modifier switches:\n"
596 "\t-b big-endian CRC\t\t-B big-endian CRC output\n"
597 "\t-f read files named in STRINGs\t-F find presets less quickly\n"
598 "\t-l little-endian CRC\t\t-L little-endian CRC output\n"
599 "\t-M non-augmenting algorithm\t-r right-justified output\n"
600 "\t-S print spaces between chars\t-t left-justified output\n"
601 "\t-V reverse algorithm only\t-X print uppercase hex\n"
602 "\t-y low bytes first in files\t-z raw binary STRINGs\n");
603 fprintf(stderr,
604 "Mode switches:\n"
605 "\t-c calculate CRCs\t\t-d dump algorithm parameters\n"
606 "\t-D list preset algorithms\t-e echo (and reformat) input\n"
607 "\t-s search for algorithm\t\t-v calculate reversed CRCs\n"
608 "\t-g search for alg given hex+crc\t-h | -u | -? show this help\n"
609 "Common Use Examples:\n"
610 "\t reveng -g 01020304e3\n"
611 "\t Searches for a known/common crc preset that computes the crc\n"
612 "\t on the end of the given hex string\n"
613 "\t reveng -w 8 -s 01020304e3 010204039d\n"
614 "\t Searches for any possible 8 bit width crc calc that computes\n"
615 "\t the crc on the end of the given hex string(s)\n"
616 "\t reveng -m CRC-8 -c 01020304\n"
617 "\t Calculates the crc-8 of the given hex string\n"
618 "\t reveng -D\n"
619 "\t Outputs a list of all known/common crc models with their\n"
620 "\t preset values\n"
621 "\n"
622 "Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015 Gregory Cook\n"
623 "This is free software; see the source for copying conditions. There is NO\n"
624 "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
625 "Version "
626 VERSION
627 "\t\t\t\t <http://reveng.sourceforge.net/>\n");
628 }
Proxmark3 GIT tracking
Impressum, Datenschutz