ADD: `analyse nuid` - generates NUID 4byte from a UID 7byte. Mifare Classic Ev1...

[proxmark3-svn] / common / crc.c

diff --git a/common/crc.c b/common/crc.c
index 21019da9c0b97891d8717779e0bf7d5538924f7b..f9a15234ed951da5f95e739e2ebf7c2c150b4eb1 100644 (file)
--- a/common/crc.c
+++ b/common/crc.c
@@ -5,25 +5,60 @@
 //-----------------------------------------------------------------------------
 // Generic CRC calculation code.
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // Generic CRC calculation code.
 //-----------------------------------------------------------------------------

+// the Check value below in the comments is CRC of the string '123456789' 
+//

 #include "crc.h"
 #include "crc.h"

-#include "util.h"
-#include <stdio.h>
-#include <stdint.h>
-#include <stddef.h>

 
 

-void crc_init(crc_t *crc, int order, uint32_t polynom, uint32_t initial_value, uint32_t final_xor)
-{
+void crc_init_ref(crc_t *crc, int order, uint32_t polynom, uint32_t initial_value, uint32_t final_xor, bool refin, bool refout) {
+       crc_init(crc, order, polynom, initial_value, final_xor);
+       crc->refin = refin;
+       crc->refout = refout;
+       crc_clear(crc);
+}
+
+void crc_init(crc_t *crc, int order, uint32_t polynom, uint32_t initial_value, uint32_t final_xor) {

        crc->order = order;
        crc->order = order;

+       crc->topbit = BITMASK( order-1 );

        crc->polynom = polynom;
        crc->initial_value = initial_value;
        crc->final_xor = final_xor;
        crc->mask = (1L<<order)-1;
        crc->polynom = polynom;
        crc->initial_value = initial_value;
        crc->final_xor = final_xor;
        crc->mask = (1L<<order)-1;

+       crc->refin = FALSE;
+       crc->refout = FALSE;

        crc_clear(crc);
 }
 
        crc_clear(crc);
 }
 

+void crc_clear(crc_t *crc) {
+       
+       crc->state = crc->initial_value & crc->mask;
+       if (crc->refin) 
+               crc->state = reflect(crc->state, crc->order);
+}
+
+void crc_update2(crc_t *crc, uint32_t data, int data_width){
+       
+       if (crc->refin) 
+               data = reflect(data, data_width);
+       
+       // Bring the next byte into the remainder.
+       crc->state ^= data << (crc->order - data_width);
+       
+       for( uint8_t bit = data_width; bit > 0; --bit) {                
+
+               if (crc->state & crc->topbit)
+                       crc->state = (crc->state << 1) ^ crc->polynom;
+               else
+                       crc->state = (crc->state << 1);
+       }
+}
+

 void crc_update(crc_t *crc, uint32_t data, int data_width)
 {
 void crc_update(crc_t *crc, uint32_t data, int data_width)
 {

-       for( int i=0; i < data_width; i++) {
+       if (crc->refin) 
+               data = reflect(data, data_width);
+       
+       int i;
+       for(i=0; i<data_width; i++) {

                int oldstate = crc->state;
                crc->state = crc->state >> 1;
                if( (oldstate^data) & 1 ) {
                int oldstate = crc->state;
                crc->state = crc->state >> 1;
                if( (oldstate^data) & 1 ) {


@@ -33,45 +68,103 @@ void crc_update(crc_t *crc, uint32_t data, int data_width)
        }
 }
 
        }
 }
 

-void crc_clear(crc_t *crc)
-{
-       crc->state = crc->initial_value & crc->mask;
+uint32_t crc_finish(crc_t *crc) {
+       uint32_t val = crc->state;
+       if (crc->refout) val = reflect(val, crc->order);
+       return ( val ^ crc->final_xor ) & crc->mask;

 }
 
 }
 

-uint32_t crc_finish(crc_t *crc)
-{
-       return ( crc->state ^ crc->final_xor ) & crc->mask;
+/*
+static void print_crc(crc_t *crc) {
+       printf(" Order  %d\n Poly   %x\n Init   %x\n Final  %x\n Mask   %x\n topbit %x\n RefIn  %s\n RefOut %s\n State  %x\n",
+               crc->order,
+               crc->polynom,
+               crc->initial_value,
+               crc->final_xor,
+               crc->mask,
+               crc->topbit,
+               (crc->refin) ? "TRUE":"FALSE",
+               (crc->refout) ? "TRUE":"FALSE",
+               crc->state
+       );

 }
 }

+*/

 
 

-//credits to iceman
-uint32_t CRC8Maxim(uint8_t *buff, size_t size) 
-{
+// width=8  poly=0x31  init=0x00  refin=true  refout=true  xorout=0x00  check=0xA1  name="CRC-8/MAXIM"
+uint32_t CRC8Maxim(uint8_t *buff, size_t size) {

        crc_t crc;
        crc_t crc;

-       crc_init(&crc, 9, 0x8c, 0x00, 0x00);
-       crc_clear(&crc);
-
-       for (size_t i=0; i < size; ++i)
-               crc_update(&crc, buff[i], 8);
-
+       crc_init_ref(&crc, 8, 0x31, 0, 0, TRUE, TRUE);  
+       for ( int i=0; i < size; ++i)
+               crc_update2(&crc, buff[i], 8);

        return crc_finish(&crc);
 }
 
        return crc_finish(&crc);
 }
 

+// width=4  poly=0xC, reversed poly=0x7  init=0x5   refin=true  refout=true  xorout=0x0000  check=  name="CRC-4/LEGIC"
+uint32_t CRC4Legic(uint8_t *cmd, size_t size) {
+       crc_t crc;
+       crc_init_ref(&crc, 4, 0x19 >> 1, 0x5, 0, TRUE, TRUE);
+       crc_update2(&crc, 1, 1); /* CMD_READ */
+       crc_update2(&crc, cmd[0], 8);
+       crc_update2(&crc, cmd[1], 8);
+       return reflect(crc_finish(&crc), 4);    
+}
+// width=8  poly=0x63, reversed poly=0x8D  init=0x55  refin=true  refout=true  xorout=0x0000  check=0xC6  name="CRC-8/LEGIC"
+// the CRC needs to be reversed before returned.

 uint32_t CRC8Legic(uint8_t *buff, size_t size) {
 uint32_t CRC8Legic(uint8_t *buff, size_t size) {

-
-       // Poly 0x63,   reversed poly 0xC6,  Init 0x55,  Final 0x00

        crc_t crc;
        crc_t crc;

-       crc_init(&crc, 8, 0xC6, 0x55, 0);
-       crc_clear(&crc);
-       
+       crc_init_ref(&crc, 8, 0x63, 0x55, 0, TRUE, TRUE);

        for ( int i = 0; i < size; ++i)
        for ( int i = 0; i < size; ++i)

+               crc_update2(&crc, buff[i], 8);
+       return reflect(crc_finish(&crc), 8);
+}
+
+// This CRC-16 is used in Legic Advant systems. 
+// width=8  poly=0xB400, reversed poly=0x  init=depends  refin=true  refout=true  xorout=0x0000  check=  name="CRC-16/LEGIC"
+uint32_t CRC16Legic(uint8_t *buff, size_t size, uint8_t uidcrc) {
+
+       #define CRC16_POLY_LEGIC 0xB400
+       uint16_t initial = reflect(uidcrc, 8);
+       //uint16_t initial = uidcrc;
+       initial |= initial << 8;
+       crc_t crc;
+       crc_init_ref(&crc, 16, CRC16_POLY_LEGIC, initial, 0, TRUE, TRUE);
+       for ( int i=0; i < size; ++i)

                crc_update(&crc, buff[i], 8);
                crc_update(&crc, buff[i], 8);

-       return SwapBits(crc_finish(&crc), 8);
+       return reflect(crc_finish(&crc), 16);

 }
 
 }
 

-uint32_t SwapBits(uint32_t value, int nrbits) {
-       uint32_t newvalue = 0;
-       for(int i = 0; i < nrbits; i++) {
-               newvalue ^= ((value >> i) & 1) << (nrbits - 1 - i);
-       }
-       return newvalue;
+//w=16  poly=0x3d65  init=0x0000  refin=true  refout=true  xorout=0xffff  check=0xea82  name="CRC-16/DNP"
+uint32_t CRC16_DNP(uint8_t *buff, size_t size) {
+       crc_t crc;
+       crc_init_ref(&crc, 16, 0x3d65, 0, 0xffff, TRUE, TRUE);
+       for ( int i=0; i < size; ++i)
+               crc_update2(&crc, buff[i], 8);
+       
+       return BSWAP_16(crc_finish(&crc));

 }
 }

+
+//width=16  poly=0x1021  init=0x1d0f  refin=false  refout=false  xorout=0x0000  check=0xe5cc  name="CRC-16/AUG-CCITT"
+uint32_t CRC16_CCITT(uint8_t *buff, size_t size) {
+       crc_t crc;
+       crc_init(&crc, 16, 0x1021, 0x1d0f, 0);  
+       for ( int i=0; i < size; ++i)
+               crc_update(&crc, buff[i], 8);
+       return  crc_finish(&crc);
+}
+//width=16  poly=0x8408  init=0xffff  refin=false  refout=true  xorout=0xffff  check=0xF0B8  name="CRC-16/ISO/IEC 13239"
+uint32_t CRC16_Iso15693(uint8_t *buff, size_t size) {
+       crc_t crc;
+       crc_init_ref(&crc, 16, 0x8408, 0xFFFF, 0xFFFF, true, false);    
+       for ( int i=0; i < size; ++i)
+               crc_update(&crc, buff[i], 8);
+       return reflect(crc_finish(&crc), 16);
+}
+//width=16  poly=0x8408  init=0xffff  refin=true  refout=true  xorout=0x0BC3  check=0xF0B8  name="CRC-16/ICLASS"
+uint32_t CRC16_ICLASS(uint8_t *buff, size_t size) {
+
+       crc_t crc;
+       crc_init_ref(&crc, 16, 0x8408, 0xFFFF, 0x0BC3, false, false);   
+       for ( int i=0; i < size; ++i)
+               crc_update(&crc, buff[i], 8);
+       return  crc_finish(&crc);
+}
\ No newline at end of file