Spacegate%2F1.Crap.mw

   1 1. Implementation von SHA256 inkl. UART gelaber (noch mit human Stuff)
   2
   3 <syntaxhighlight lang="cpp">
   4 #include <sha256.h>
   5 #define LITTLE_ENDIAN
   6
   7 uint8_t summed[32];
   8 char input[32];
   9 int poscnt = 0;
  10 byte recdata;
  11
  12 void setup() {
  13   // put your setup code here, to run once:
  14   Serial.begin(9600);
  15   Serial.println("Input");
  16 }
  17
  18 void serialEvent() {
  19   recdata = Serial.read();
  20   if (recdata == 0x0D && poscnt == 0) {
  21     Serial.println();
  22     Serial.println("Input");
  23   }
  24
  25   if (poscnt >=32 || recdata == 0x0D) {
  26     Serial.println();
  27     Serial.print("Received: ");
  28     Serial.println(input);
  29     sha256(&summed, input, poscnt*8);
  30     Serial.print("SHA256: ");
  31     for (int i = 0; i <= 31; i++) {
  32       Serial.print(summed[i], HEX);
  33       input[i] = NULL;
  34     }
  35     Serial.println();
  36     poscnt = 0;
  37     Serial.print("Input");
  38   }
  39   else {
  40     input[poscnt] = recdata;
  41     Serial.println(input);
  42     poscnt++;
  43   }
  44
  45
  46 }
  47
  48 void loop() {
  49
  50 }
  51
  52
  53
  54 // AVR crypto lib
  55 uint32_t sha256_init_vector[]={
  56   0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,
  57   0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19 };
  58
  59
  60 /*************************************************************************/
  61
  62 /**
  63  * \brief \c sh256_init initialises a sha256 context for hashing.
  64  * \c sh256_init c initialises the given sha256 context for hashing
  65  * @param state pointer to a sha256 context
  66  * @return none
  67  */
  68 void sha256_init(sha256_ctx_t *state){
  69   state->length=0;
  70   memcpy(state->h, sha256_init_vector, 8*4);
  71 }
  72
  73 /*************************************************************************/
  74
  75 /**
  76  * rotate x right by n positions
  77  */
  78 uint32_t rotr32( uint32_t x, uint8_t n){
  79   return ((x>>n) | (x<<(32-n)));
  80 }
  81
  82
  83 /*************************************************************************/
  84
  85 // #define CHANGE_ENDIAN32(x) (((x)<<24) | ((x)>>24) | (((x)& 0x0000ff00)<<8) | (((x)& 0x00ff0000)>>8))
  86
  87 uint32_t change_endian32(uint32_t x){
  88   return (((x)<<24) | ((x)>>24) | (((x)& 0x0000ff00)<<8) | (((x)& 0x00ff0000)>>8));
  89 }
  90
  91
  92 /*************************************************************************/
  93
  94 /* sha256 functions as macros for speed and size, cause they are called only once */
  95
  96 #define CH(x,y,z)  (((x)&(y)) ^ ((~(x))&(z)))
  97 #define MAJ(x,y,z) (((x)&(y)) ^ ((x)&(z)) ^ ((y)&(z)))
  98
  99 #define SIGMA0(x) (rotr32((x),2) ^ rotr32((x),13) ^ rotr32((x),22))
 100 #define SIGMA1(x) (rotr32((x),6) ^ rotr32((x),11) ^ rotr32((x),25))
 101 #define SIGMA_a(x) (rotr32((x),7)  ^ rotr32((x),18) ^ ((x)>>3))
 102 #define SIGMA_b(x) (rotr32((x),17) ^ rotr32((x),19) ^ ((x)>>10))
 103
 104
 105 uint32_t k[]={
 106   0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
 107   0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
 108   0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
 109   0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
 110   0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
 111   0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
 112   0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
 113   0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
 114 };
 115
 116
 117 /*************************************************************************/
 118
 119 /**
 120  * block must be, 512, Bit = 64, Byte, long !!!
 121  */
 122 void sha256_nextBlock (sha256_ctx_t *state, const void* block){
 123   uint32_t w[64];       /* this is 256, byte, large, */
 124   uint8_t  i;
 125   uint32_t a[8],t1,t2;
 126
 127   /* init w */
 128 #if defined LITTLE_ENDIAN
 129   for (i=0; i<16; ++i){
 130     w[i]= change_endian32(((uint32_t*)block)[i]);
 131   }
 132 #elif defined BIG_ENDIAN
 133   memcpy((void*)w, block, 64);
 134 #endif
 135   for (i=16; i<64; ++i){
 136     w[i] = SIGMA_b(w[i-2]) + w[i-7] + SIGMA_a(w[i-15]) + w[i-16];
 137   }
 138
 139   /* init working variables */
 140   memcpy((void*)a,(void*)(state->h), 8*4);
 141
 142   /* do the, fun stuff, */
 143   for (i=0; i<64; ++i){
 144     t1 = a[7] + SIGMA1(a[4]) + CH(a[4],a[5],a[6]) + k[i] + w[i];
 145     t2 = SIGMA0(a[0]) + MAJ(a[0],a[1],a[2]);
 146     memmove(&(a[1]), &(a[0]), 7*4);     /* a[7]=a[6]; a[6]=a[5]; a[5]=a[4]; a[4]=a[3]; a[3]=a[2]; a[2]=a[1]; a[1]=a[0]; */
 147     a[4] += t1;
 148     a[0] = t1 + t2;
 149   }
 150
 151   /* update, the, state, */
 152   for (i=0; i<8; ++i){
 153     state->h[i] += a[i];
 154   }
 155   state->length += 512;
 156 }
 157
 158
 159 /*************************************************************************/
 160
 161 /**
 162  * \brief function to process the last block being hashed
 163  * @param state Pointer to the context in which this block should be processed.
 164  * @param block Pointer to the message wich should be hashed.
 165  * @param length is the length of only THIS block in BITS not in bytes!
 166  *  bits are big endian, meaning high bits come first.
 167  *      if you have a message with bits at the end, the byte must be padded with zeros
 168  */
 169 void sha256_lastBlock(sha256_ctx_t *state, const void* block, uint16_t length){
 170   uint8_t lb[SHA256_BLOCK_BITS/8]; /* local block */
 171   while(length>=SHA256_BLOCK_BITS){
 172     sha256_nextBlock(state, block);
 173     length -= SHA256_BLOCK_BITS;
 174     block = (uint8_t*)block+SHA256_BLOCK_BYTES;
 175   }
 176
 177   state->length += length;
 178   memcpy (&(lb[0]), block, length/8);
 179
 180   /* set the final one bit */
 181   if (length & 0x7){ // if we have single bits at the end
 182     lb[length/8] = ((uint8_t*)(block))[length/8];
 183   }
 184   else {
 185     lb[length/8] = 0;
 186   }
 187   lb[length/8] |= 0x80>>(length & 0x7);
 188   length =(length >> 3) + 1; /* from now on length contains the number of BYTES in lb*/
 189   /* pad with zeros */
 190   if (length>64-8){ /* not enouth space for 64bit length value */
 191     memset((void*)(&(lb[length])), 0, 64-length);
 192     sha256_nextBlock(state, lb);
 193     state->length -= 512;
 194     length = 0;
 195   }
 196   memset((void*)(&(lb[length])), 0, 56-length);
 197   /* store the 64bit length value */
 198 #if defined LITTLE_ENDIAN
 199   /* this is now rolled up */
 200   uint8_t i;
 201   for (i=1; i<=8; ++i){
 202     lb[55+i] = (uint8_t)(state->length>>(64- 8*i));
 203   }
 204 #elif defined BIG_ENDIAN
 205   *((uint64_t)&(lb[56])) = state->length;
 206 #endif
 207   sha256_nextBlock(state, lb);
 208 }
 209
 210
 211 /*************************************************************************/
 212
 213 /*
 214  * length in bits!
 215  */
 216 void sha256(sha256_hash_t *dest, const void* msg, uint32_t length){ /* length could be choosen longer but this is for µC */
 217   sha256_ctx_t s;
 218   sha256_init(&s);
 219   while(length >= SHA256_BLOCK_BITS){
 220     sha256_nextBlock(&s, msg);
 221     msg = (uint8_t*)msg + SHA256_BLOCK_BITS/8;
 222     length -= SHA256_BLOCK_BITS;
 223   }
 224   sha256_lastBlock(&s, msg, length);
 225   sha256_ctx2hash(dest,&s);
 226 }
 227
 228
 229
 230 /*************************************************************************/
 231
 232 void sha256_ctx2hash(sha256_hash_t *dest, const sha256_ctx_t *state){
 233 #if defined LITTLE_ENDIAN
 234   uint8_t i;
 235   for(i=0; i<8; ++i){
 236     ((uint32_t*)dest)[i] = change_endian32(state->h[i]);
 237   }
 238 #elif BIG_ENDIAN
 239   if (dest != state->h)
 240     memcpy(dest, state->h, SHA256_HASH_BITS/8);
 241 #else
 242
 243 #endif
 244 }
 245
 246
 247
 248
 249 </syntaxhighlight>