tls_test.c 7.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245
  1. /* Host-side test vectors for the ring-3 TLS crypto (tls_sha256.c,
  2. * tls_chacha20.c, tls_x25519.c). Independent references: NIST/RFC 4231
  3. * for SHA-256/HMAC, RFC 5869 for HKDF, an independently generated TLS 1.3
  4. * expand-label chain, RFC 8439 for ChaCha20-Poly1305 and RFC 7748 for
  5. * X25519. Build and run: make test-crypto */
  6. #include <stdio.h>
  7. #include <string.h>
  8. #include "tls_sha256.h"
  9. #include "tls_chacha20.h"
  10. #include "tls_x25519.h"
  11. static int failures;
  12. static int checks;
  13. static void unhex(const char *s, unsigned char *out, unsigned int n)
  14. {
  15. unsigned int i;
  16. for (i = 0; i < n; i++) {
  17. unsigned int hi = (unsigned int)(s[i * 2]);
  18. unsigned int lo = (unsigned int)(s[i * 2 + 1]);
  19. hi = (hi <= '9') ? hi - '0' : ((hi | 0x20) - 'a' + 10);
  20. lo = (lo <= '9') ? lo - '0' : ((lo | 0x20) - 'a' + 10);
  21. out[i] = (unsigned char)((hi << 4) | lo);
  22. }
  23. }
  24. static void check(const char *name, const unsigned char *got, const char *exp_hex,
  25. unsigned int n)
  26. {
  27. unsigned char exp[128];
  28. unsigned int i;
  29. checks++;
  30. unhex(exp_hex, exp, n);
  31. if (memcmp(got, exp, n) == 0)
  32. return;
  33. failures++;
  34. printf("FAIL %s\n got ", name);
  35. for (i = 0; i < n; i++)
  36. printf("%02x", got[i]);
  37. printf("\n exp %s\n", exp_hex);
  38. }
  39. static void test_sha256(void)
  40. {
  41. unsigned char out[32];
  42. static const unsigned char longmsg[] =
  43. "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
  44. sha256("", 0, out);
  45. check("sha256(empty)", out,
  46. "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
  47. 32);
  48. sha256("abc", 3, out);
  49. check("sha256(abc)", out,
  50. "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
  51. 32);
  52. sha256(longmsg, sizeof(longmsg) - 1, out);
  53. check("sha256(448-bit)", out,
  54. "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1",
  55. 32);
  56. }
  57. static void test_hmac(void)
  58. {
  59. unsigned char key[20], out[32];
  60. memset(key, 0x0b, sizeof(key));
  61. hmac_sha256(key, sizeof(key), "Hi There", 8, out);
  62. check("hmac rfc4231-1", out,
  63. "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7",
  64. 32);
  65. hmac_sha256((const unsigned char *)"Jefe", 4,
  66. "what do ya want for nothing?", 28, out);
  67. check("hmac rfc4231-2", out,
  68. "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843",
  69. 32);
  70. }
  71. static void test_hkdf(void)
  72. {
  73. unsigned char ikm[22], salt[13], info[10], prk[32], okm[42];
  74. unsigned char early[32], derived[32], hs[32], shared[32];
  75. unsigned char chs[32], key[32], iv[12], fin[32];
  76. unsigned char empty_hash[32], zero[32];
  77. static const char *chain[] = {
  78. "33ad0a1c607ec03b09e6cd9893680ce210adf300aa1f2660e1b22e10f170f92a",
  79. "6f2615a108c702c5678f54fc9dbab69716c076189c48250cebeac3576c3611ba",
  80. "ddbe37614d014a8c19db0a47955ee6930b3ee727c408386ba274344962b0e015",
  81. "88af332c76d7e0dcb50151a802d39cd678dd53eb4a1b094024b5cb47128303f0",
  82. "b6b698fd98207b1c0edb367ab1d18cca98358cbe0989fc7de93a2dcf684c7fcd",
  83. "66adf518b563ca9d053f9cd2",
  84. "74c1f9cd877263ae11cadc6d24d7947c1eb7cc1e864828613f938250f9553684",
  85. };
  86. unsigned int i;
  87. memset(ikm, 0x0b, sizeof(ikm));
  88. unhex("000102030405060708090a0b0c", salt, sizeof(salt));
  89. unhex("f0f1f2f3f4f5f6f7f8f9", info, sizeof(info));
  90. hkdf_extract(salt, sizeof(salt), ikm, sizeof(ikm), prk);
  91. check("hkdf rfc5869 prk", prk,
  92. "077709362c2e32df0ddc3f0dc47bba6390b6c73bb50f9c3122ec844ad7c2b3e5",
  93. 32);
  94. hkdf_expand(prk, info, sizeof(info), okm, sizeof(okm));
  95. check("hkdf rfc5869 okm", okm,
  96. "3cb25f25faacd57a90434f64d0362f2a2d2d0a90cf1a5a4c5db02d56ecc4c5bf"
  97. "34007208d5b887185865", 42);
  98. /* TLS 1.3 key schedule, cross-checked against an independent
  99. * implementation (the early/derived pair matches RFC 8448). */
  100. memset(zero, 0, sizeof(zero));
  101. sha256("", 0, empty_hash);
  102. hkdf_extract(0, 0, zero, 32, early);
  103. check("early secret", early, chain[0], 32);
  104. hkdf_expand_label(early, "derived", empty_hash, 32, derived, 32);
  105. check("derive derived", derived, chain[1], 32);
  106. for (i = 0; i < 32; i++)
  107. shared[i] = (unsigned char)i;
  108. hkdf_extract(derived, 32, shared, 32, hs);
  109. check("handshake secret", hs, chain[2], 32);
  110. {
  111. unsigned char ctx[32];
  112. memset(ctx, 'X', sizeof(ctx));
  113. hkdf_expand_label(hs, "c hs traffic", ctx, 32, chs, 32);
  114. }
  115. check("c hs traffic", chs, chain[3], 32);
  116. hkdf_expand_label(chs, "key", 0, 0, key, 32);
  117. check("hs key", key, chain[4], 32);
  118. hkdf_expand_label(chs, "iv", 0, 0, iv, 12);
  119. check("hs iv", iv, chain[5], 12);
  120. hkdf_expand_label(chs, "finished", 0, 0, fin, 32);
  121. check("finished key", fin, chain[6], 32);
  122. }
  123. static void test_chacha(void)
  124. {
  125. unsigned char key[32], nonce[12], ks[64], zero[64];
  126. unsigned char aad[12], pt[114], ct[114], tag[16], dec[114];
  127. static const char *aead_pt =
  128. "Ladies and Gentlemen of the class of '99: If I could offer you "
  129. "only one tip for the future, sunscreen would be it.";
  130. unsigned int i;
  131. for (i = 0; i < 32; i++)
  132. key[i] = (unsigned char)i;
  133. unhex("000000090000004a00000000", nonce, sizeof(nonce));
  134. memset(zero, 0, sizeof(zero));
  135. {
  136. struct chacha20_ctx c;
  137. chacha20_init(&c, key, nonce, 1);
  138. chacha20_xor(&c, ks, zero, sizeof(ks));
  139. }
  140. check("chacha20 block rfc8439", ks,
  141. "10f1e7e4d13b5915500fdd1fa32071c4c7d1f4c733c068030422aa9ac3d46c4e"
  142. "d2826446079faa0914c2d705d98b02a2b5129cd1de164eb9cbd083e8a2503c4e",
  143. 64);
  144. unhex("808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f",
  145. key, 32);
  146. unhex("070000004041424344454647", nonce, sizeof(nonce));
  147. unhex("50515253c0c1c2c3c4c5c6c7", aad, sizeof(aad));
  148. memcpy(pt, aead_pt, sizeof(pt));
  149. aead_seal(key, nonce, aad, sizeof(aad), pt, sizeof(pt), ct, tag);
  150. check("aead ct rfc8439", ct,
  151. "d31a8d34648e60db7b86afbc53ef7ec2a4aded51296e08fea9e2b5a736ee62d6"
  152. "3dbea45e8ca9671282fafb69da92728b1a71de0a9e060b2905d6a5b67ecd3b36"
  153. "92ddbd7f2d778b8c9803aee328091b58fab324e4fad675945585808b4831d7bc"
  154. "3ff4def08e4b7a9de576d26586cec64b6116", 114);
  155. check("aead tag rfc8439", tag,
  156. "1ae10b594f09e26a7e902ecbd0600691", 16);
  157. memset(dec, 0, sizeof(dec));
  158. {
  159. struct aead_open_ctx a;
  160. unsigned char expect[16];
  161. unsigned int off = 0;
  162. aead_open_init(&a, key, nonce, aad, sizeof(aad));
  163. /* Odd chunk sizes exercise the incremental path. */
  164. while (off < sizeof(pt)) {
  165. unsigned int n = 7;
  166. if (n > sizeof(pt) - off)
  167. n = sizeof(pt) - off;
  168. aead_open_update(&a, dec + off, ct + off, n);
  169. off += n;
  170. }
  171. aead_open_tag(&a, expect);
  172. check("aead open tag", expect,
  173. "1ae10b594f09e26a7e902ecbd0600691", 16);
  174. }
  175. check("aead open pt", dec,
  176. "4c616469657320616e642047656e746c656d656e206f662074686520636c6173"
  177. "73206f66202739393a204966204920636f756c64206f6666657220796f75206f"
  178. "6e6c79206f6e652074697020666f7220746865206675747572652c2073756e73"
  179. "637265656e20776f756c642062652069742e", 114);
  180. }
  181. static void test_x25519(void)
  182. {
  183. unsigned char a_priv[32], a_pub[32], b_priv[32], b_pub[32];
  184. unsigned char shared[32];
  185. static const char *a_priv_hex =
  186. "77076d0a7318a57d3c16c17251b26645df4c2f87ebc0992ab177fba51db92c2a";
  187. static const char *b_priv_hex =
  188. "5dab087e624a8a4b79e17f8b83800ee66f3bb1292618b6fd1c2f8b27ff88e0eb";
  189. static const char *shared_hex =
  190. "4a5d9d5ba4ce2de1728e3bf480350f25e07e21c947d19e3376f09b3c1e161742";
  191. unhex(a_priv_hex, a_priv, 32);
  192. unhex(b_priv_hex, b_priv, 32);
  193. x25519(a_pub, a_priv, x25519_base_point);
  194. check("x25519 alice pub", a_pub,
  195. "8520f0098930a754748b7ddcb43ef75a0dbf3a0d26381af4eba4a98eaa9b4e6a",
  196. 32);
  197. x25519(b_pub, b_priv, x25519_base_point);
  198. check("x25519 bob pub", b_pub,
  199. "de9edb7d7b7dc1b4d35b61c2ece435373f8343c85b78674dadfc7e146f882b4f",
  200. 32);
  201. x25519(shared, a_priv, b_pub);
  202. check("x25519 shared a", shared, shared_hex, 32);
  203. x25519(shared, b_priv, a_pub);
  204. check("x25519 shared b", shared, shared_hex, 32);
  205. }
  206. int main(void)
  207. {
  208. test_sha256();
  209. test_hmac();
  210. test_hkdf();
  211. test_chacha();
  212. test_x25519();
  213. printf("%s: %d checks, %d failure(s)\n",
  214. failures ? "FAIL" : "ok", checks, failures);
  215. return failures ? 1 : 0;
  216. }