cvs.zerfleddert.de Git - proxmark3-svn/blob - common/crc.c

   1 //-----------------------------------------------------------------------------
   2 // This code is licensed to you under the terms of the GNU GPL, version 2 or,
   3 // at your option, any later version. See the LICENSE.txt file for the text of
   4 // the license.
   5 //-----------------------------------------------------------------------------
   6 // Generic CRC calculation code.
   7 //-----------------------------------------------------------------------------
   8 // the Check value below in the comments is CRC of the string '123456789'
   9 //
  10 #include "crc.h"
  11
  12 void crc_init_ref(crc_t *crc, int order, uint32_t polynom, uint32_t initial_value, uint32_t final_xor, bool refin, bool refout) {
  13         crc_init(crc, order, polynom, initial_value, final_xor);
  14         crc->refin = refin;
  15         crc->refout = refout;
  16         crc_clear(crc);
  17 }
  18
  19 void crc_init(crc_t *crc, int order, uint32_t polynom, uint32_t initial_value, uint32_t final_xor) {
  20         crc->order = order;
  21         crc->topbit = BITMASK( order-1 );
  22         crc->polynom = polynom;
  23         crc->initial_value = initial_value;
  24         crc->final_xor = final_xor;
  25         crc->mask = (1L<<order)-1;
  26         crc->refin = FALSE;
  27         crc->refout = FALSE;
  28         crc_clear(crc);
  29 }
  30
  31 void crc_clear(crc_t *crc) {
  32
  33         crc->state = crc->initial_value & crc->mask;
  34         if (crc->refin)
  35                 crc->state = reflect(crc->state, crc->order);
  36 }
  37
  38 void crc_update(crc_t *crc, uint32_t indata, int data_width){
  39
  40         uint32_t poly = crc->polynom;
  41
  42         // if requested, return the initial CRC */
  43     if (indata == 0)
  44         return crc->initial_value;
  45
  46         //reflected
  47         if (crc->refin)
  48                 indata = reflect(indata, data_width);
  49
  50         // Bring the next byte into the remainder.
  51         crc->state ^= indata << (crc->order - data_width);
  52
  53         for( uint8_t bit = data_width; bit > 0; --bit) {
  54                  // Try to divide the current data bit.
  55                 if (crc->state & crc->topbit)
  56                         crc->state = (crc->state << 1) ^ poly;
  57                 else
  58                         crc->state = (crc->state << 1);
  59         }
  60     return crc ^ model->xorout;
  61 }
  62
  63 void crc_update2(crc_t *crc, uint32_t data, int data_width)
  64 {
  65         if (crc->refin)
  66                 data = reflect(data, data_width);
  67
  68         int i;
  69         for(i=0; i<data_width; i++) {
  70                 int oldstate = crc->state;
  71                 crc->state = crc->state >> 1;
  72                 if( (oldstate^data) & 1 ) {
  73                         crc->state ^= crc->polynom;
  74                 }
  75                 data >>= 1;
  76         }
  77 }
  78
  79
  80 uint32_t crc_finish(crc_t *crc) {
  81         uint32_t val = crc->state;
  82         if (crc->refout) val = reflect(val, crc->order);
  83         return ( val ^ crc->final_xor ) & crc->mask;
  84 }
  85
  86 /*
  87 static void print_crc(crc_t *crc) {
  88         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",
  89                 crc->order,
  90                 crc->polynom,
  91                 crc->initial_value,
  92                 crc->final_xor,
  93                 crc->mask,
  94                 crc->topbit,
  95                 (crc->refin) ? "TRUE":"FALSE",
  96                 (crc->refout) ? "TRUE":"FALSE",
  97                 crc->state
  98         );
  99 }
 100 */
 101
 102 // width=8  poly=0x31  init=0x00  refin=true  refout=true  xorout=0x00  check=0xA1  name="CRC-8/MAXIM"
 103 uint32_t CRC8Maxim(uint8_t *buff, size_t size) {
 104         crc_t crc;
 105         crc_init_ref(&crc, 8, 0x31, 0, 0, TRUE, TRUE);
 106         for ( int i=0; i < size; ++i)
 107                 crc_update(&crc, buff[i], 8);
 108         return crc_finish(&crc);
 109 }
 110
 111 // width=4  poly=0xC, reversed poly=0x7  init=0x5   refin=true  refout=true  xorout=0x0000  check=  name="CRC-4/LEGIC"
 112 uint32_t CRC4Legic(uint8_t *cmd, size_t size) {
 113         crc_t crc;
 114         crc_init_ref(&crc, 4, 0x19 >> 1, 0x5, 0, TRUE, TRUE);
 115         crc_update2(&crc, 1, 1); /* CMD_READ */
 116         crc_update2(&crc, cmd[0], 8);
 117         crc_update2(&crc, cmd[1], 8);
 118         return reflect(crc_finish(&crc), 4);
 119 }
 120 // width=8  poly=0x63, reversed poly=0x8D  init=0x55  refin=true  refout=true  xorout=0x0000  check=0xC6  name="CRC-8/LEGIC"
 121 // the CRC needs to be reversed before returned.
 122 uint32_t CRC8Legic(uint8_t *buff, size_t size) {
 123         crc_t crc;
 124         crc_init_ref(&crc, 8, 0x63, 0x55, 0, TRUE, TRUE);
 125         for ( int i = 0; i < size; ++i)
 126                 crc_update(&crc, buff[i], 8);
 127         return reflect(crc_finish(&crc), 8);
 128 }
 129
 130 // This CRC-16 is used in Legic Advant systems.
 131 // width=8  poly=0xB400, reversed poly=0x  init=depends  refin=true  refout=true  xorout=0x0000  check=  name="CRC-16/LEGIC"
 132 uint32_t CRC16Legic(uint8_t *buff, size_t size, uint8_t uidcrc) {
 133
 134         #define CRC16_POLY_LEGIC 0xB400
 135         uint16_t initial = reflect(uidcrc, 8);
 136         //uint16_t initial = uidcrc;
 137         initial |= initial << 8;
 138         crc_t crc;
 139         crc_init_ref(&crc, 16, CRC16_POLY_LEGIC, initial, 0, TRUE, TRUE);
 140         for ( int i=0; i < size; ++i)
 141                 crc_update(&crc, buff[i], 8);
 142         return reflect(crc_finish(&crc), 16);
 143 }
 144
 145 //w=16  poly=0x3d65  init=0x0000  refin=true  refout=true  xorout=0xffff  check=0xea82  name="CRC-16/DNP"
 146 uint32_t CRC16_DNP(uint8_t *buff, size_t size) {
 147         crc_t crc;
 148         crc_init_ref(&crc, 16, 0x3d65, 0, 0xffff, TRUE, TRUE);
 149         for ( int i=0; i < size; ++i)
 150                 crc_update(&crc, buff[i], 8);
 151
 152         return BSWAP_16(crc_finish(&crc));
 153 }
 154
 155 //width=16  poly=0x1021  init=0x1d0f  refin=false  refout=false  xorout=0x0000  check=0xe5cc  name="CRC-16/AUG-CCITT"
 156 uint32_t CRC16_CCITT(uint8_t *buff, size_t size) {
 157         crc_t crc;
 158         crc_init(&crc, 16, 0x1021, 0x1d0f, 0);
 159         for ( int i=0; i < size; ++i)
 160                 crc_update(&crc, buff[i], 8);
 161         return  crc_finish(&crc);
 162 }
 163 //width=16  poly=0x8408  init=0xffff  refin=false  refout=true  xorout=0xffff  check=0xF0B8  name="CRC-16/ISO/IEC 13239"
 164 uint32_t CRC16_Iso15693(uint8_t *buff, size_t size) {
 165         crc_t crc;
 166         crc_init_ref(&crc, 16, 0x8408, 0xFFFF, 0xFFFF, true, false);
 167         for ( int i=0; i < size; ++i)
 168                 crc_update(&crc, buff[i], 8);
 169         return reflect(crc_finish(&crc), 16);
 170 }
 171 //width=16  poly=0x8408  init=0xffff  refin=true  refout=true  xorout=0x0BC3  check=0xF0B8  name="CRC-16/ICLASS"
 172 uint32_t CRC16_ICLASS(uint8_t *buff, size_t size) {
 173
 174         crc_t crc;
 175         crc_init_ref(&crc, 16, 0x8408, 0xFFFF, 0x0BC3, false, false);
 176         for ( int i=0; i < size; ++i)
 177                 crc_update(&crc, buff[i], 8);
 178         return  crc_finish(&crc);
 179 }