]> git.zerfleddert.de Git - proxmark3-svn/blobdiff - client/cmdcrc.c
FIX: @marshmellow42 's ST detection fix.
[proxmark3-svn] / client / cmdcrc.c
index 666b4a8e67d42c2de61377ea978be72b4d8076b3..249fdebc0e5887385eda4c5faf16a92c8360c6a3 100644 (file)
@@ -19,8 +19,6 @@
 
 #include <stdio.h>
 #include <string.h>
-//#include <stdlib.h>
-//#include <ctype.h>
 #include "cmdmain.h"
 #include "cmdcrc.h"
 #include "reveng/reveng.h"
@@ -41,13 +39,14 @@ int split(char *str, char *arr[MAX_ARGS]){
     int wordCnt = 0;
 
     while(1){
-        while(isspace(str[beginIndex])){
+        while(isspace(str[beginIndex])) {
             ++beginIndex;
         }
-        if(str[beginIndex] == '\0')
+        if(str[beginIndex] == '\0') {
             break;
+               }
         endIndex = beginIndex;
-        while (str[endIndex] && !isspace(str[endIndex])){
+        while (str[endIndex] && !isspace(str[endIndex])) {
             ++endIndex;
         }
         int len = endIndex - beginIndex;
@@ -74,10 +73,10 @@ int CmdCrc(const char *Cmd)
        if (argc == 3 && memcmp(argv[1],"-g",2)==0) {
                CmdrevengSearch(argv[2]);
        } else {
-       reveng_main(argc, argv);
+               reveng_main(argc, argv);
        }
        //PrintAndLog("DEBUG argc: %d, %s %s Cmd: %s",argc, argv[0], Cmd2, Cmd);
-       for(int i = 0; i < argc; ++i){
+       for(int i = 0; i < argc; ++i) {
                free(argv[i]);
        }
 
@@ -131,122 +130,131 @@ int GetModels(char *Models[], int *count, uint8_t *width){
                mfree(&model);
        } else { //reveng -s
 
-                       if(~model.flags & P_MULXN)
-                               return uerr("cannot search for non-Williams compliant models");
+               if(~model.flags & P_MULXN)
+                       return uerr("cannot search for non-Williams compliant models");
 
                praloc(&model.spoly, (unsigned long)width[0]);
                praloc(&model.init, (unsigned long)width[0]);
                praloc(&model.xorout, (unsigned long)width[0]);
-                       if(!plen(model.spoly))
+
+               if(!plen(model.spoly))
                        palloc(&model.spoly, (unsigned long)width[0]);
-                       else
+               else
                        width[0] = (uint8_t)plen(model.spoly);
 
-                       /* special case if qpoly is zero, search to end of range */
-                       if(!ptst(qpoly))
-                               rflags &= ~R_HAVEQ;
-
-                       /* if endianness not specified, try
-                        * little-endian then big-endian.
-                        * NB: crossed-endian algorithms will not be
-                        * searched.
-                        */
-                       /* scan against preset models */
-                       if(~uflags & C_FORCE) {
-                               pass = 0;
-                               Cnt = 0;
-                               do {
-                                       psets = mcount();
-
-                                       while(psets) {
-                                               mbynum(&pset, --psets);
-                                               
-                                               /* skip if different width, or refin or refout don't match */
-                                       if(plen(pset.spoly) != width[0] || (model.flags ^ pset.flags) & (P_REFIN | P_REFOUT))
-                                                       continue;
-                                               /* skip if the preset doesn't match specified parameters */
-                                               if(rflags & R_HAVEP && pcmp(&model.spoly, &pset.spoly))
-                                                       continue;
-                                               if(rflags & R_HAVEI && psncmp(&model.init, &pset.init))
-                                                       continue;
-                                               if(rflags & R_HAVEX && psncmp(&model.xorout, &pset.xorout))
-                                                       continue;
-                               
+               /* special case if qpoly is zero, search to end of range */
+               if(!ptst(qpoly))
+                       rflags &= ~R_HAVEQ;
+
+               /* if endianness not specified, try
+                * little-endian then big-endian.
+                * NB: crossed-endian algorithms will not be
+                * searched.
+                */
+               /* scan against preset models */
+               if (~uflags & C_FORCE) {
+                       pass = 0;
+                       Cnt = 0;
+                       do {
+                               psets = mcount();
+
+                               while(psets) {
+                                       mbynum(&pset, --psets);
+                                       
+                                       /* skip if different width, or refin or refout don't match */
+                                       if( plen(pset.spoly) != width[0] || (model.flags ^ pset.flags) & (P_REFIN | P_REFOUT))
+                                               continue;
+                                       /* skip if the preset doesn't match specified parameters */
+                                       if (rflags & R_HAVEP && pcmp(&model.spoly, &pset.spoly))
+                                               continue;
+                                       if (rflags & R_HAVEI && psncmp(&model.init, &pset.init))
+                                               continue;
+                                       if (rflags & R_HAVEX && psncmp(&model.xorout, &pset.xorout))
+                                               continue;
+                       
                                        //for additional args (not used yet, maybe future?)
-                                               apoly = pclone(pset.xorout);
-                                               if(pset.flags & P_REFOUT)
-                                                       prev(&apoly);
+                                       apoly = pclone(pset.xorout);
                                        
-                                               for(qptr = apolys; qptr < pptr; ++qptr) {
-                                                       crc = pcrc(*qptr, pset.spoly, pset.init, apoly, 0);
-                                                       if(ptst(crc)) {
-                                                               pfree(&crc);
-                                                               break;
-                                                       } else
-                                                               pfree(&crc);
-                                               }
-                                               pfree(&apoly);
-                                               if(qptr == pptr) {
-
-                                                       /* the selected model solved all arguments */
-
-                                                       mcanon(&pset);
-                                                       
-                                                       size_t size = (pset.name && *pset.name) ? strlen(pset.name) : 6;
-                                                       //PrintAndLog("Size: %d, %s, count: %d",size,pset.name, Cnt);
-                                                       char *tmp = calloc(size+1, sizeof(char));
-                                                       if (tmp == NULL){
-                                                               PrintAndLog("out of memory?");
-                                                               return 0;
-                                                       }
-                                               width[Cnt] = width[0];
-                                                       memcpy(tmp, pset.name, size);
-                                                       Models[Cnt++] = tmp;
-                                                       *count = Cnt;
-                                                       uflags |= C_RESULT;
+                                       if (pset.flags & P_REFOUT)
+                                               prev(&apoly);
+                                       
+                                       
+                                       for (qptr = apolys; qptr < pptr; ++qptr) {
+                                               crc = pcrc(*qptr, pset.spoly, pset.init, apoly, 0);
+                                               if (ptst(crc)) {
+                                                       pfree(&crc);
+                                                       break;
                                                }
+                                               pfree(&crc);
                                        }
-                                       mfree(&pset);
+                                       pfree(&apoly);
+                                       
+                                       if (qptr == pptr) {
 
-                                       /* toggle refIn/refOut and reflect arguments */
-                                       if(~rflags & R_HAVERI) {
-                                               model.flags ^= P_REFIN | P_REFOUT;
-                                               for(qptr = apolys; qptr < pptr; ++qptr)
-                                                       prevch(qptr, ibperhx);
+                                               /* the selected model solved all arguments */
+                                               mcanon(&pset);
+                                               
+                                               size_t size = (pset.name && *pset.name) ? strlen(pset.name) : 6;
+                                               //PrintAndLog("Size: %d, %s, count: %d",size,pset.name, Cnt);
+                                               char *tmp = calloc(size+1, sizeof(char));
+                                               if (tmp == NULL){
+                                                       PrintAndLog("out of memory?");
+                                                       return 0;
+                                               }
+                                               width[Cnt] = width[0];
+                                               memcpy(tmp, pset.name, size);
+                                               Models[Cnt++] = tmp;
+                                               *count = Cnt;
+                                               uflags |= C_RESULT;
                                        }
-                               } while(~rflags & R_HAVERI && ++pass < 2);
-                       }
-               //got everything now free the memory...
-
-                       if(uflags & C_RESULT) {
-                               for(qptr = apolys; qptr < pptr; ++qptr)
-                                       pfree(qptr);
-                       }
-                       if(!(model.flags & P_REFIN) != !(model.flags & P_REFOUT))
-                               return uerr("cannot search for crossed-endian models");
-
-                       pass = 0;
-                       do {
-                               mptr = candmods = reveng(&model, qpoly, rflags, args, apolys);
-                               if(mptr && plen(mptr->spoly))
-                                       uflags |= C_RESULT;
-                               while(mptr && plen(mptr->spoly)) {
-                                       mfree(mptr++);
                                }
-                               free(candmods);
-                               if(~rflags & R_HAVERI) {
+                               mfree(&pset);
+
+                               /* toggle refIn/refOut and reflect arguments */
+                               if (~rflags & R_HAVERI) {
                                        model.flags ^= P_REFIN | P_REFOUT;
-                                       for(qptr = apolys; qptr < pptr; ++qptr)
+                                       for (qptr = apolys; qptr < pptr; ++qptr) {
                                                prevch(qptr, ibperhx);
+                                       }
                                }
-                       } while(~rflags & R_HAVERI && ++pass < 2);
-                       for(qptr = apolys; qptr < pptr; ++qptr)
-                               pfree(qptr);
-                       free(apolys);
-                       if(~uflags & C_RESULT)
-                               return uerr("no models found");
-                       mfree(&model);
+                       } while (~rflags & R_HAVERI && ++pass < 2);
+               }
+               //got everything now free the memory...
 
+               if (uflags & C_RESULT) {
+                       for (qptr = apolys; qptr < pptr; ++qptr) {
+                               pfree(qptr);
+                       }
+               }
+               if (!(model.flags & P_REFIN) != !(model.flags & P_REFOUT))
+                       return uerr("cannot search for crossed-endian models");
+
+               pass = 0;
+               do {
+                       mptr = candmods = reveng(&model, qpoly, rflags, args, apolys);
+                       if (mptr && plen(mptr->spoly)) {
+                               uflags |= C_RESULT;
+                       }
+                       while (mptr && plen(mptr->spoly)) {
+                               mfree(mptr++);
+                       }
+                       free(candmods);
+                       if (~rflags & R_HAVERI) {
+                               model.flags ^= P_REFIN | P_REFOUT;
+                               for (qptr = apolys; qptr < pptr; ++qptr) {
+                                       prevch(qptr, ibperhx);
+                               }
+                       }
+               } while (~rflags & R_HAVERI && ++pass < 2);
+               
+               for (qptr = apolys; qptr < pptr; ++qptr) {
+                       pfree(qptr);
+               }
+               free(apolys);
+               if (~uflags & C_RESULT)
+                       return uerr("no models found");
+               
+               mfree(&model);
        }
        return 1;
 }
@@ -282,11 +290,11 @@ int RunModel(char *inModel, char *inHexStr, bool reverse, char endian, char *res
 
        SETBMP();
        //set model
-       if(!(c = mbynam(&model, inModel))) {
+       if (!(c = mbynam(&model, inModel))) {
                PrintAndLog("error: preset model '%s' not found.  Use reveng -D to list presets.", inModel);
                return 0;
        }
-       if(c < 0)
+       if (c < 0)
                return uerr("no preset models available");
 
        rflags |= R_HAVEP | R_HAVEI | R_HAVERI | R_HAVERO | R_HAVEX;
@@ -318,9 +326,13 @@ int RunModel(char *inModel, char *inHexStr, bool reverse, char endian, char *res
                        model.flags &= ~P_RTJUST;
                        break;
        }
-
+       /* canonicalise the model, so the one we dump is the one we
+        * calculate with (not with -s, spoly may be blank which will
+        * normalise to zero and clear init and xorout.)
+        */
        mcanon(&model);
 
+
        if (reverse) {
                // v  calculate reversed CRC
                /* Distinct from the -V switch as this causes
@@ -337,7 +349,7 @@ int RunModel(char *inModel, char *inHexStr, bool reverse, char endian, char *res
                 * Consequently Init is the mirror image of the
                 * one resulting from -V, and so we have:
                 */
-               if(~model.flags & P_REFOUT) {
+               if (~model.flags & P_REFOUT) {
                        prev(&model.init);
                        prev(&model.xorout);
                }
@@ -352,17 +364,17 @@ int RunModel(char *inModel, char *inHexStr, bool reverse, char endian, char *res
        /* in the Williams model, xorout is applied after the refout stage.
         * as refout is part of ptostr(), we reverse xorout here.
         */
-       if(model.flags & P_REFOUT)
+       if (model.flags & P_REFOUT)
                prev(&model.xorout);
 
        apoly = strtop(inHexStr, model.flags, ibperhx);
 
-       if(reverse)
+       if (reverse)
                prev(&apoly);
 
        crc = pcrc(apoly, model.spoly, model.init, model.xorout, model.flags);
 
-       if(reverse)
+       if (reverse)
                prev(&crc);
 
        string = ptostr(crc, model.flags, obperhx);
Impressum, Datenschutz