tls_sha256.c 6.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307
  1. /* SHA-256 + HMAC-SHA256 + HKDF: see tls_sha256.h. */
  2. #include "tls_sha256.h"
  3. static const unsigned int K[64] = {
  4. 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
  5. 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
  6. 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
  7. 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
  8. 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
  9. 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
  10. 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
  11. 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
  12. 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
  13. 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
  14. 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
  15. 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
  16. 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
  17. 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
  18. 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
  19. 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
  20. };
  21. static unsigned int rotr(unsigned int x, unsigned int n)
  22. {
  23. return (x >> n) | (x << (32 - n));
  24. }
  25. static void sha256_block(struct sha256_ctx *c, const unsigned char *p)
  26. {
  27. unsigned int w[64], a, b, d, e, f, g, h, t1, t2;
  28. unsigned int cc;
  29. int i;
  30. for (i = 0; i < 16; i++) {
  31. w[i] = ((unsigned int)p[i * 4] << 24) |
  32. ((unsigned int)p[i * 4 + 1] << 16) |
  33. ((unsigned int)p[i * 4 + 2] << 8) |
  34. (unsigned int)p[i * 4 + 3];
  35. }
  36. for (; i < 64; i++) {
  37. unsigned int s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^
  38. (w[i - 15] >> 3);
  39. unsigned int s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^
  40. (w[i - 2] >> 10);
  41. w[i] = w[i - 16] + s0 + w[i - 7] + s1;
  42. }
  43. a = c->h[0];
  44. b = c->h[1];
  45. cc = c->h[2];
  46. d = c->h[3];
  47. e = c->h[4];
  48. f = c->h[5];
  49. g = c->h[6];
  50. h = c->h[7];
  51. for (i = 0; i < 64; i++) {
  52. unsigned int s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
  53. unsigned int ch = (e & f) ^ (~e & g);
  54. unsigned int s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
  55. unsigned int maj = (a & b) ^ (a & cc) ^ (b & cc);
  56. t1 = h + s1 + ch + K[i] + w[i];
  57. t2 = s0 + maj;
  58. h = g;
  59. g = f;
  60. f = e;
  61. e = d + t1;
  62. d = cc;
  63. cc = b;
  64. b = a;
  65. a = t1 + t2;
  66. }
  67. c->h[0] += a;
  68. c->h[1] += b;
  69. c->h[2] += cc;
  70. c->h[3] += d;
  71. c->h[4] += e;
  72. c->h[5] += f;
  73. c->h[6] += g;
  74. c->h[7] += h;
  75. }
  76. void sha256_init(struct sha256_ctx *c)
  77. {
  78. c->h[0] = 0x6a09e667;
  79. c->h[1] = 0xbb67ae85;
  80. c->h[2] = 0x3c6ef372;
  81. c->h[3] = 0xa54ff53a;
  82. c->h[4] = 0x510e527f;
  83. c->h[5] = 0x9b05688c;
  84. c->h[6] = 0x1f83d9ab;
  85. c->h[7] = 0x5be0cd19;
  86. c->bits = 0;
  87. c->buflen = 0;
  88. }
  89. void sha256_update(struct sha256_ctx *c, const void *data, unsigned int len)
  90. {
  91. const unsigned char *p = (const unsigned char *)data;
  92. unsigned int i;
  93. c->bits += (unsigned long long)len * 8;
  94. if (c->buflen) {
  95. unsigned int want = 64 - c->buflen;
  96. if (want > len)
  97. want = len;
  98. for (i = 0; i < want; i++)
  99. c->buf[c->buflen + i] = p[i];
  100. c->buflen += want;
  101. p += want;
  102. len -= want;
  103. if (c->buflen < 64)
  104. return;
  105. sha256_block(c, c->buf);
  106. c->buflen = 0;
  107. }
  108. while (len >= 64) {
  109. sha256_block(c, p);
  110. p += 64;
  111. len -= 64;
  112. }
  113. for (i = 0; i < len; i++)
  114. c->buf[i] = p[i];
  115. c->buflen = len;
  116. }
  117. void sha256_final(struct sha256_ctx *c, unsigned char out[32])
  118. {
  119. unsigned long long bits = c->bits;
  120. unsigned int i;
  121. c->buf[c->buflen++] = 0x80;
  122. if (c->buflen > 56) {
  123. while (c->buflen < 64)
  124. c->buf[c->buflen++] = 0;
  125. sha256_block(c, c->buf);
  126. c->buflen = 0;
  127. }
  128. while (c->buflen < 56)
  129. c->buf[c->buflen++] = 0;
  130. for (i = 0; i < 8; i++)
  131. c->buf[56 + i] = (unsigned char)(bits >> (56 - i * 8));
  132. sha256_block(c, c->buf);
  133. for (i = 0; i < 8; i++) {
  134. out[i * 4] = (unsigned char)(c->h[i] >> 24);
  135. out[i * 4 + 1] = (unsigned char)(c->h[i] >> 16);
  136. out[i * 4 + 2] = (unsigned char)(c->h[i] >> 8);
  137. out[i * 4 + 3] = (unsigned char)c->h[i];
  138. }
  139. }
  140. void sha256_copy(struct sha256_ctx *dst, const struct sha256_ctx *src)
  141. {
  142. unsigned int i;
  143. for (i = 0; i < 8; i++)
  144. dst->h[i] = src->h[i];
  145. dst->bits = src->bits;
  146. dst->buflen = src->buflen;
  147. for (i = 0; i < 64; i++)
  148. dst->buf[i] = src->buf[i];
  149. }
  150. void sha256(const void *data, unsigned int len, unsigned char out[32])
  151. {
  152. struct sha256_ctx c;
  153. sha256_init(&c);
  154. sha256_update(&c, data, len);
  155. sha256_final(&c, out);
  156. }
  157. /* ---- HMAC ---- */
  158. void hmac_sha256_init(struct hmac_sha256_ctx *c, const unsigned char *key,
  159. unsigned int key_len)
  160. {
  161. unsigned char k[64], kh[32], pad[64];
  162. unsigned int i;
  163. for (i = 0; i < 64; i++)
  164. k[i] = 0;
  165. if (key_len > 64) {
  166. sha256(key, key_len, kh);
  167. for (i = 0; i < 32; i++)
  168. k[i] = kh[i];
  169. } else {
  170. for (i = 0; i < key_len; i++)
  171. k[i] = key[i];
  172. }
  173. for (i = 0; i < 64; i++)
  174. pad[i] = k[i] ^ 0x36;
  175. sha256_init(&c->inner);
  176. sha256_update(&c->inner, pad, 64);
  177. for (i = 0; i < 64; i++)
  178. c->okey[i] = k[i] ^ 0x5c;
  179. }
  180. void hmac_sha256_update(struct hmac_sha256_ctx *c, const void *data,
  181. unsigned int len)
  182. {
  183. sha256_update(&c->inner, data, len);
  184. }
  185. void hmac_sha256_final(struct hmac_sha256_ctx *c, unsigned char out[32])
  186. {
  187. struct sha256_ctx outer;
  188. unsigned char ih[32];
  189. sha256_final(&c->inner, ih);
  190. sha256_init(&outer);
  191. sha256_update(&outer, c->okey, 64);
  192. sha256_update(&outer, ih, 32);
  193. sha256_final(&outer, out);
  194. }
  195. /* ---- HKDF ---- */
  196. void hmac_sha256(const unsigned char *key, unsigned int key_len,
  197. const void *data, unsigned int len, unsigned char out[32])
  198. {
  199. struct hmac_sha256_ctx h;
  200. hmac_sha256_init(&h, key, key_len);
  201. hmac_sha256_update(&h, data, len);
  202. hmac_sha256_final(&h, out);
  203. }
  204. void hkdf_extract(const unsigned char *salt, unsigned int salt_len,
  205. const void *ikm, unsigned int ikm_len, unsigned char out[32])
  206. {
  207. unsigned char zero[32];
  208. unsigned int i;
  209. if (!salt) {
  210. for (i = 0; i < 32; i++)
  211. zero[i] = 0;
  212. salt = zero;
  213. salt_len = 32;
  214. }
  215. hmac_sha256(salt, salt_len, ikm, ikm_len, out);
  216. }
  217. void hkdf_expand(const unsigned char prk[32], const void *info,
  218. unsigned int info_len, unsigned char *out,
  219. unsigned int out_len)
  220. {
  221. unsigned char t[32];
  222. unsigned int tlen = 0, pos = 0;
  223. unsigned char ctr = 1;
  224. if (out_len == 0)
  225. return;
  226. while (pos < out_len) {
  227. struct hmac_sha256_ctx h;
  228. unsigned int avail, k;
  229. hmac_sha256_init(&h, prk, 32);
  230. if (tlen)
  231. hmac_sha256_update(&h, t, tlen);
  232. if (info_len)
  233. hmac_sha256_update(&h, info, info_len);
  234. hmac_sha256_update(&h, &ctr, 1);
  235. hmac_sha256_final(&h, t);
  236. tlen = 32;
  237. ctr++;
  238. avail = out_len - pos;
  239. if (avail > 32)
  240. avail = 32;
  241. for (k = 0; k < avail; k++)
  242. out[pos + k] = t[k];
  243. pos += avail;
  244. }
  245. }
  246. void hkdf_expand_label(const unsigned char secret[32], const char *label,
  247. const unsigned char *ctx, unsigned int ctx_len,
  248. unsigned char *out, unsigned int out_len)
  249. {
  250. static const char prefix[] = "tls13 ";
  251. unsigned char info[96];
  252. unsigned int o = 0, n = 0, i;
  253. while (label[n])
  254. n++;
  255. info[o++] = (unsigned char)(out_len >> 8);
  256. info[o++] = (unsigned char)out_len;
  257. info[o++] = (unsigned char)(6 + n);
  258. for (i = 0; i < 6; i++)
  259. info[o++] = (unsigned char)prefix[i];
  260. for (i = 0; i < n; i++)
  261. info[o++] = (unsigned char)label[i];
  262. info[o++] = (unsigned char)ctx_len;
  263. for (i = 0; i < ctx_len; i++)
  264. info[o++] = ctx[i];
  265. hkdf_expand(secret, info, o, out, out_len);
  266. }