Lab2_web / Mbed 2 deprecated webserverBlinky

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependencies:   mbed

Fork of webserverBlinky by RealTimeCompLab2

SHA1/sha1.cpp@132:09b66cc5cf4a, 2017-08-14 (annotated)

Committer:
nixnax
Date:
Mon Aug 14 19:27:36 2017 +0000
Revision:
132:09b66cc5cf4a
Parent:
sha1.cpp@128:e5958d143e9d 
Reduced buffer size so NUCLEO-L053R8 (8k RAM) can work too.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
nixnax 128:e5958d143e9d 1 /*
nixnax 128:e5958d143e9d 2 SHA-1 in C
nixnax 128:e5958d143e9d 3 By Steve Reid <steve@edmweb.com>
nixnax 128:e5958d143e9d 4 100% Public Domain
nixnax 128:e5958d143e9d 5 */
nixnax 128:e5958d143e9d 6
nixnax 128:e5958d143e9d 7 #define SHA1HANDSOFF
nixnax 128:e5958d143e9d 8
nixnax 128:e5958d143e9d 9 #include <stdio.h>
nixnax 128:e5958d143e9d 10 #include <string.h>
nixnax 128:e5958d143e9d 11
nixnax 128:e5958d143e9d 12 /* for uint32_t */
nixnax 128:e5958d143e9d 13 #include <stdint.h>
nixnax 128:e5958d143e9d 14
nixnax 128:e5958d143e9d 15 #include "sha1.h"
nixnax 128:e5958d143e9d 16
nixnax 128:e5958d143e9d 17
nixnax 128:e5958d143e9d 18 #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
nixnax 128:e5958d143e9d 19
nixnax 128:e5958d143e9d 20 /* blk0() and blk() perform the initial expand. */
nixnax 128:e5958d143e9d 21 /* I got the idea of expanding during the round function from SSLeay */
nixnax 128:e5958d143e9d 22 #if BYTE_ORDER == LITTLE_ENDIAN
nixnax 128:e5958d143e9d 23 #define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
nixnax 128:e5958d143e9d 24 |(rol(block->l[i],8)&0x00FF00FF))
nixnax 128:e5958d143e9d 25 #elif BYTE_ORDER == BIG_ENDIAN
nixnax 128:e5958d143e9d 26 #define blk0(i) block->l[i]
nixnax 128:e5958d143e9d 27 #else
nixnax 128:e5958d143e9d 28 #error "Endianness not defined!"
nixnax 128:e5958d143e9d 29 #endif
nixnax 128:e5958d143e9d 30 #define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
nixnax 128:e5958d143e9d 31 ^block->l[(i+2)&15]^block->l[i&15],1))
nixnax 128:e5958d143e9d 32
nixnax 128:e5958d143e9d 33 /* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
nixnax 128:e5958d143e9d 34 #define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
nixnax 128:e5958d143e9d 35 #define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
nixnax 128:e5958d143e9d 36 #define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
nixnax 128:e5958d143e9d 37 #define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
nixnax 128:e5958d143e9d 38 #define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
nixnax 128:e5958d143e9d 39
nixnax 128:e5958d143e9d 40
nixnax 128:e5958d143e9d 41 /* Hash a single 512-bit block. This is the core of the algorithm. */
nixnax 128:e5958d143e9d 42
nixnax 128:e5958d143e9d 43 void SHA1Transform(
nixnax 128:e5958d143e9d 44 uint32_t state[5],
nixnax 128:e5958d143e9d 45 const unsigned char buffer[64]
nixnax 128:e5958d143e9d 46 )
nixnax 128:e5958d143e9d 47 {
nixnax 128:e5958d143e9d 48 uint32_t a, b, c, d, e;
nixnax 128:e5958d143e9d 49
nixnax 128:e5958d143e9d 50 typedef union
nixnax 128:e5958d143e9d 51 {
nixnax 128:e5958d143e9d 52 unsigned char c[64];
nixnax 128:e5958d143e9d 53 uint32_t l[16];
nixnax 128:e5958d143e9d 54 } CHAR64LONG16;
nixnax 128:e5958d143e9d 55
nixnax 128:e5958d143e9d 56 #ifdef SHA1HANDSOFF
nixnax 128:e5958d143e9d 57 CHAR64LONG16 block[1]; /* use array to appear as a pointer */
nixnax 128:e5958d143e9d 58
nixnax 128:e5958d143e9d 59 memcpy(block, buffer, 64);
nixnax 128:e5958d143e9d 60 #else
nixnax 128:e5958d143e9d 61 /* The following had better never be used because it causes the
nixnax 128:e5958d143e9d 62 * pointer-to-const buffer to be cast into a pointer to non-const.
nixnax 128:e5958d143e9d 63 * And the result is written through. I threw a "const" in, hoping
nixnax 128:e5958d143e9d 64 * this will cause a diagnostic.
nixnax 128:e5958d143e9d 65 */
nixnax 128:e5958d143e9d 66 CHAR64LONG16 *block = (const CHAR64LONG16 *) buffer;
nixnax 128:e5958d143e9d 67 #endif
nixnax 128:e5958d143e9d 68 /* Copy context->state[] to working vars */
nixnax 128:e5958d143e9d 69 a = state[0];
nixnax 128:e5958d143e9d 70 b = state[1];
nixnax 128:e5958d143e9d 71 c = state[2];
nixnax 128:e5958d143e9d 72 d = state[3];
nixnax 128:e5958d143e9d 73 e = state[4];
nixnax 128:e5958d143e9d 74 /* 4 rounds of 20 operations each. Loop unrolled. */
nixnax 128:e5958d143e9d 75 R0(a, b, c, d, e, 0);
nixnax 128:e5958d143e9d 76 R0(e, a, b, c, d, 1);
nixnax 128:e5958d143e9d 77 R0(d, e, a, b, c, 2);
nixnax 128:e5958d143e9d 78 R0(c, d, e, a, b, 3);
nixnax 128:e5958d143e9d 79 R0(b, c, d, e, a, 4);
nixnax 128:e5958d143e9d 80 R0(a, b, c, d, e, 5);
nixnax 128:e5958d143e9d 81 R0(e, a, b, c, d, 6);
nixnax 128:e5958d143e9d 82 R0(d, e, a, b, c, 7);
nixnax 128:e5958d143e9d 83 R0(c, d, e, a, b, 8);
nixnax 128:e5958d143e9d 84 R0(b, c, d, e, a, 9);
nixnax 128:e5958d143e9d 85 R0(a, b, c, d, e, 10);
nixnax 128:e5958d143e9d 86 R0(e, a, b, c, d, 11);
nixnax 128:e5958d143e9d 87 R0(d, e, a, b, c, 12);
nixnax 128:e5958d143e9d 88 R0(c, d, e, a, b, 13);
nixnax 128:e5958d143e9d 89 R0(b, c, d, e, a, 14);
nixnax 128:e5958d143e9d 90 R0(a, b, c, d, e, 15);
nixnax 128:e5958d143e9d 91 R1(e, a, b, c, d, 16);
nixnax 128:e5958d143e9d 92 R1(d, e, a, b, c, 17);
nixnax 128:e5958d143e9d 93 R1(c, d, e, a, b, 18);
nixnax 128:e5958d143e9d 94 R1(b, c, d, e, a, 19);
nixnax 128:e5958d143e9d 95 R2(a, b, c, d, e, 20);
nixnax 128:e5958d143e9d 96 R2(e, a, b, c, d, 21);
nixnax 128:e5958d143e9d 97 R2(d, e, a, b, c, 22);
nixnax 128:e5958d143e9d 98 R2(c, d, e, a, b, 23);
nixnax 128:e5958d143e9d 99 R2(b, c, d, e, a, 24);
nixnax 128:e5958d143e9d 100 R2(a, b, c, d, e, 25);
nixnax 128:e5958d143e9d 101 R2(e, a, b, c, d, 26);
nixnax 128:e5958d143e9d 102 R2(d, e, a, b, c, 27);
nixnax 128:e5958d143e9d 103 R2(c, d, e, a, b, 28);
nixnax 128:e5958d143e9d 104 R2(b, c, d, e, a, 29);
nixnax 128:e5958d143e9d 105 R2(a, b, c, d, e, 30);
nixnax 128:e5958d143e9d 106 R2(e, a, b, c, d, 31);
nixnax 128:e5958d143e9d 107 R2(d, e, a, b, c, 32);
nixnax 128:e5958d143e9d 108 R2(c, d, e, a, b, 33);
nixnax 128:e5958d143e9d 109 R2(b, c, d, e, a, 34);
nixnax 128:e5958d143e9d 110 R2(a, b, c, d, e, 35);
nixnax 128:e5958d143e9d 111 R2(e, a, b, c, d, 36);
nixnax 128:e5958d143e9d 112 R2(d, e, a, b, c, 37);
nixnax 128:e5958d143e9d 113 R2(c, d, e, a, b, 38);
nixnax 128:e5958d143e9d 114 R2(b, c, d, e, a, 39);
nixnax 128:e5958d143e9d 115 R3(a, b, c, d, e, 40);
nixnax 128:e5958d143e9d 116 R3(e, a, b, c, d, 41);
nixnax 128:e5958d143e9d 117 R3(d, e, a, b, c, 42);
nixnax 128:e5958d143e9d 118 R3(c, d, e, a, b, 43);
nixnax 128:e5958d143e9d 119 R3(b, c, d, e, a, 44);
nixnax 128:e5958d143e9d 120 R3(a, b, c, d, e, 45);
nixnax 128:e5958d143e9d 121 R3(e, a, b, c, d, 46);
nixnax 128:e5958d143e9d 122 R3(d, e, a, b, c, 47);
nixnax 128:e5958d143e9d 123 R3(c, d, e, a, b, 48);
nixnax 128:e5958d143e9d 124 R3(b, c, d, e, a, 49);
nixnax 128:e5958d143e9d 125 R3(a, b, c, d, e, 50);
nixnax 128:e5958d143e9d 126 R3(e, a, b, c, d, 51);
nixnax 128:e5958d143e9d 127 R3(d, e, a, b, c, 52);
nixnax 128:e5958d143e9d 128 R3(c, d, e, a, b, 53);
nixnax 128:e5958d143e9d 129 R3(b, c, d, e, a, 54);
nixnax 128:e5958d143e9d 130 R3(a, b, c, d, e, 55);
nixnax 128:e5958d143e9d 131 R3(e, a, b, c, d, 56);
nixnax 128:e5958d143e9d 132 R3(d, e, a, b, c, 57);
nixnax 128:e5958d143e9d 133 R3(c, d, e, a, b, 58);
nixnax 128:e5958d143e9d 134 R3(b, c, d, e, a, 59);
nixnax 128:e5958d143e9d 135 R4(a, b, c, d, e, 60);
nixnax 128:e5958d143e9d 136 R4(e, a, b, c, d, 61);
nixnax 128:e5958d143e9d 137 R4(d, e, a, b, c, 62);
nixnax 128:e5958d143e9d 138 R4(c, d, e, a, b, 63);
nixnax 128:e5958d143e9d 139 R4(b, c, d, e, a, 64);
nixnax 128:e5958d143e9d 140 R4(a, b, c, d, e, 65);
nixnax 128:e5958d143e9d 141 R4(e, a, b, c, d, 66);
nixnax 128:e5958d143e9d 142 R4(d, e, a, b, c, 67);
nixnax 128:e5958d143e9d 143 R4(c, d, e, a, b, 68);
nixnax 128:e5958d143e9d 144 R4(b, c, d, e, a, 69);
nixnax 128:e5958d143e9d 145 R4(a, b, c, d, e, 70);
nixnax 128:e5958d143e9d 146 R4(e, a, b, c, d, 71);
nixnax 128:e5958d143e9d 147 R4(d, e, a, b, c, 72);
nixnax 128:e5958d143e9d 148 R4(c, d, e, a, b, 73);
nixnax 128:e5958d143e9d 149 R4(b, c, d, e, a, 74);
nixnax 128:e5958d143e9d 150 R4(a, b, c, d, e, 75);
nixnax 128:e5958d143e9d 151 R4(e, a, b, c, d, 76);
nixnax 128:e5958d143e9d 152 R4(d, e, a, b, c, 77);
nixnax 128:e5958d143e9d 153 R4(c, d, e, a, b, 78);
nixnax 128:e5958d143e9d 154 R4(b, c, d, e, a, 79);
nixnax 128:e5958d143e9d 155 /* Add the working vars back into context.state[] */
nixnax 128:e5958d143e9d 156 state[0] += a;
nixnax 128:e5958d143e9d 157 state[1] += b;
nixnax 128:e5958d143e9d 158 state[2] += c;
nixnax 128:e5958d143e9d 159 state[3] += d;
nixnax 128:e5958d143e9d 160 state[4] += e;
nixnax 128:e5958d143e9d 161 /* Wipe variables */
nixnax 128:e5958d143e9d 162 a = b = c = d = e = 0;
nixnax 128:e5958d143e9d 163 #ifdef SHA1HANDSOFF
nixnax 128:e5958d143e9d 164 memset(block, '\0', sizeof(block));
nixnax 128:e5958d143e9d 165 #endif
nixnax 128:e5958d143e9d 166 }
nixnax 128:e5958d143e9d 167
nixnax 128:e5958d143e9d 168
nixnax 128:e5958d143e9d 169 /* SHA1Init - Initialize new context */
nixnax 128:e5958d143e9d 170
nixnax 128:e5958d143e9d 171 void SHA1Init(
nixnax 128:e5958d143e9d 172 SHA1_CTX * context
nixnax 128:e5958d143e9d 173 )
nixnax 128:e5958d143e9d 174 {
nixnax 128:e5958d143e9d 175 /* SHA1 initialization constants */
nixnax 128:e5958d143e9d 176 context->state[0] = 0x67452301;
nixnax 128:e5958d143e9d 177 context->state[1] = 0xEFCDAB89;
nixnax 128:e5958d143e9d 178 context->state[2] = 0x98BADCFE;
nixnax 128:e5958d143e9d 179 context->state[3] = 0x10325476;
nixnax 128:e5958d143e9d 180 context->state[4] = 0xC3D2E1F0;
nixnax 128:e5958d143e9d 181 context->count[0] = context->count[1] = 0;
nixnax 128:e5958d143e9d 182 }
nixnax 128:e5958d143e9d 183
nixnax 128:e5958d143e9d 184
nixnax 128:e5958d143e9d 185 /* Run your data through this. */
nixnax 128:e5958d143e9d 186
nixnax 128:e5958d143e9d 187 void SHA1Update(
nixnax 128:e5958d143e9d 188 SHA1_CTX * context,
nixnax 128:e5958d143e9d 189 const unsigned char *data,
nixnax 128:e5958d143e9d 190 uint32_t len
nixnax 128:e5958d143e9d 191 )
nixnax 128:e5958d143e9d 192 {
nixnax 128:e5958d143e9d 193 uint32_t i;
nixnax 128:e5958d143e9d 194
nixnax 128:e5958d143e9d 195 uint32_t j;
nixnax 128:e5958d143e9d 196
nixnax 128:e5958d143e9d 197 j = context->count[0];
nixnax 128:e5958d143e9d 198 if ((context->count[0] += len << 3) < j)
nixnax 128:e5958d143e9d 199 context->count[1]++;
nixnax 128:e5958d143e9d 200 context->count[1] += (len >> 29);
nixnax 128:e5958d143e9d 201 j = (j >> 3) & 63;
nixnax 128:e5958d143e9d 202 if ((j + len) > 63)
nixnax 128:e5958d143e9d 203 {
nixnax 128:e5958d143e9d 204 memcpy(&context->buffer[j], data, (i = 64 - j));
nixnax 128:e5958d143e9d 205 SHA1Transform(context->state, context->buffer);
nixnax 128:e5958d143e9d 206 for (; i + 63 < len; i += 64)
nixnax 128:e5958d143e9d 207 {
nixnax 128:e5958d143e9d 208 SHA1Transform(context->state, &data[i]);
nixnax 128:e5958d143e9d 209 }
nixnax 128:e5958d143e9d 210 j = 0;
nixnax 128:e5958d143e9d 211 }
nixnax 128:e5958d143e9d 212 else
nixnax 128:e5958d143e9d 213 i = 0;
nixnax 128:e5958d143e9d 214 memcpy(&context->buffer[j], &data[i], len - i);
nixnax 128:e5958d143e9d 215 }
nixnax 128:e5958d143e9d 216
nixnax 128:e5958d143e9d 217
nixnax 128:e5958d143e9d 218 /* Add padding and return the message digest. */
nixnax 128:e5958d143e9d 219
nixnax 128:e5958d143e9d 220 void SHA1Final(
nixnax 128:e5958d143e9d 221 unsigned char digest[20],
nixnax 128:e5958d143e9d 222 SHA1_CTX * context
nixnax 128:e5958d143e9d 223 )
nixnax 128:e5958d143e9d 224 {
nixnax 128:e5958d143e9d 225 unsigned i;
nixnax 128:e5958d143e9d 226
nixnax 128:e5958d143e9d 227 unsigned char finalcount[8];
nixnax 128:e5958d143e9d 228
nixnax 128:e5958d143e9d 229 unsigned char c;
nixnax 128:e5958d143e9d 230
nixnax 128:e5958d143e9d 231 #if 0 /* untested "improvement" by DHR */
nixnax 128:e5958d143e9d 232 /* Convert context->count to a sequence of bytes
nixnax 128:e5958d143e9d 233 * in finalcount. Second element first, but
nixnax 128:e5958d143e9d 234 * big-endian order within element.
nixnax 128:e5958d143e9d 235 * But we do it all backwards.
nixnax 128:e5958d143e9d 236 */
nixnax 128:e5958d143e9d 237 unsigned char *fcp = &finalcount[8];
nixnax 128:e5958d143e9d 238
nixnax 128:e5958d143e9d 239 for (i = 0; i < 2; i++)
nixnax 128:e5958d143e9d 240 {
nixnax 128:e5958d143e9d 241 uint32_t t = context->count[i];
nixnax 128:e5958d143e9d 242
nixnax 128:e5958d143e9d 243 int j;
nixnax 128:e5958d143e9d 244
nixnax 128:e5958d143e9d 245 for (j = 0; j < 4; t >>= 8, j++)
nixnax 128:e5958d143e9d 246 *--fcp = (unsigned char) t}
nixnax 128:e5958d143e9d 247 #else
nixnax 128:e5958d143e9d 248 for (i = 0; i < 8; i++)
nixnax 128:e5958d143e9d 249 {
nixnax 128:e5958d143e9d 250 finalcount[i] = (unsigned char) ((context->count[(i >= 4 ? 0 : 1)] >> ((3 - (i & 3)) * 8)) & 255); /* Endian independent */
nixnax 128:e5958d143e9d 251 }
nixnax 128:e5958d143e9d 252 #endif
nixnax 128:e5958d143e9d 253 c = 0200;
nixnax 128:e5958d143e9d 254 SHA1Update(context, &c, 1);
nixnax 128:e5958d143e9d 255 while ((context->count[0] & 504) != 448)
nixnax 128:e5958d143e9d 256 {
nixnax 128:e5958d143e9d 257 c = 0000;
nixnax 128:e5958d143e9d 258 SHA1Update(context, &c, 1);
nixnax 128:e5958d143e9d 259 }
nixnax 128:e5958d143e9d 260 SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */
nixnax 128:e5958d143e9d 261 for (i = 0; i < 20; i++)
nixnax 128:e5958d143e9d 262 {
nixnax 128:e5958d143e9d 263 digest[i] = (unsigned char)
nixnax 128:e5958d143e9d 264 ((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
nixnax 128:e5958d143e9d 265 }
nixnax 128:e5958d143e9d 266 /* Wipe variables */
nixnax 128:e5958d143e9d 267 memset(context, '\0', sizeof(*context));
nixnax 128:e5958d143e9d 268 memset(&finalcount, '\0', sizeof(finalcount));
nixnax 128:e5958d143e9d 269 }
nixnax 128:e5958d143e9d 270
nixnax 128:e5958d143e9d 271 void sha1(
nixnax 128:e5958d143e9d 272 char *hash_out,
nixnax 128:e5958d143e9d 273 const char *str,
nixnax 128:e5958d143e9d 274 int len)
nixnax 128:e5958d143e9d 275 {
nixnax 128:e5958d143e9d 276 SHA1_CTX ctx;
nixnax 128:e5958d143e9d 277 unsigned int ii;
nixnax 128:e5958d143e9d 278
nixnax 128:e5958d143e9d 279 SHA1Init(&ctx);
nixnax 128:e5958d143e9d 280 for (ii=0; ii<len; ii+=1)
nixnax 128:e5958d143e9d 281 SHA1Update(&ctx, (const unsigned char*)str + ii, 1);
nixnax 128:e5958d143e9d 282 SHA1Final((unsigned char *)hash_out, &ctx);
nixnax 128:e5958d143e9d 283 // hash_out[20] = '\0';
nixnax 128:e5958d143e9d 284 }
nixnax 128:e5958d143e9d 285