OLD | NEW |
(Empty) | |
| 1 /* This Source Code Form is subject to the terms of the Mozilla Public |
| 2 * License, v. 2.0. If a copy of the MPL was not distributed with this |
| 3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ |
| 4 |
| 5 /* Adopted from the public domain code in NaCl by djb. */ |
| 6 |
| 7 #include <prtypes.h> |
| 8 #include <string.h> |
| 9 |
| 10 #include <stdio.h> |
| 11 |
| 12 #define ROTL32(v, n) (((v) << (n)) | ((v) >> (32 - (n)))) |
| 13 #define ROTATE(v, c) (ROTL32(v, c)) |
| 14 #define XOR(v, w) ((v) ^ (w)) |
| 15 #define PLUS(x, y) ((x) + (y)) |
| 16 #define PLUSONE(v) (PLUS((v), 1)) |
| 17 |
| 18 #define U32TO8_LITTLE(p, v) \ |
| 19 { (p)[0] = (v >> 0) & 0xff; (p)[1] = (v >> 8) & 0xff; \ |
| 20 (p)[2] = (v >> 16) & 0xff; (p)[3] = (v >> 24) & 0xff; } |
| 21 #define U8TO32_LITTLE(p) \ |
| 22 (((PRUint32)((p)[0]) ) | ((PRUint32)((p)[1]) << 8) | \ |
| 23 ((PRUint32)((p)[2]) << 16) | ((PRUint32)((p)[3]) << 24) ) |
| 24 |
| 25 #define QUARTERROUND(a,b,c,d) \ |
| 26 x[a] = PLUS(x[a],x[b]); x[d] = ROTATE(XOR(x[d],x[a]),16); \ |
| 27 x[c] = PLUS(x[c],x[d]); x[b] = ROTATE(XOR(x[b],x[c]),12); \ |
| 28 x[a] = PLUS(x[a],x[b]); x[d] = ROTATE(XOR(x[d],x[a]), 8); \ |
| 29 x[c] = PLUS(x[c],x[d]); x[b] = ROTATE(XOR(x[b],x[c]), 7); |
| 30 |
| 31 static void ChaChaCore(unsigned char output[64], const PRUint32 input[16], |
| 32 int num_rounds) { |
| 33 PRUint32 x[16]; |
| 34 int i; |
| 35 |
| 36 memcpy(x, input, sizeof(PRUint32) * 16); |
| 37 for (i = 20; i > 0; i -= 2) { |
| 38 QUARTERROUND( 0, 4, 8,12) |
| 39 QUARTERROUND( 1, 5, 9,13) |
| 40 QUARTERROUND( 2, 6,10,14) |
| 41 QUARTERROUND( 3, 7,11,15) |
| 42 QUARTERROUND( 0, 5,10,15) |
| 43 QUARTERROUND( 1, 6,11,12) |
| 44 QUARTERROUND( 2, 7, 8,13) |
| 45 QUARTERROUND( 3, 4, 9,14) |
| 46 } |
| 47 |
| 48 for (i = 0; i < 16; ++i) { |
| 49 x[i] = PLUS(x[i], input[i]); |
| 50 } |
| 51 for (i = 0; i < 16; ++i) { |
| 52 U32TO8_LITTLE(output + 4 * i, x[i]); |
| 53 } |
| 54 } |
| 55 |
| 56 static const unsigned char sigma[16] = "expand 32-byte k"; |
| 57 |
| 58 void ChaCha20XOR(unsigned char *out, const unsigned char *in, size_t inLen, |
| 59 const unsigned char key[32], const unsigned char nonce[8], |
| 60 size_t counter) { |
| 61 unsigned char block[64]; |
| 62 PRUint32 input[16]; |
| 63 PRUint64 counter64 = counter; |
| 64 unsigned int u; |
| 65 size_t i; |
| 66 |
| 67 input[4] = U8TO32_LITTLE(key + 0); |
| 68 input[5] = U8TO32_LITTLE(key + 4); |
| 69 input[6] = U8TO32_LITTLE(key + 8); |
| 70 input[7] = U8TO32_LITTLE(key + 12); |
| 71 |
| 72 input[8] = U8TO32_LITTLE(key + 16); |
| 73 input[9] = U8TO32_LITTLE(key + 20); |
| 74 input[10] = U8TO32_LITTLE(key + 24); |
| 75 input[11] = U8TO32_LITTLE(key + 28); |
| 76 |
| 77 input[0] = U8TO32_LITTLE(sigma + 0); |
| 78 input[1] = U8TO32_LITTLE(sigma + 4); |
| 79 input[2] = U8TO32_LITTLE(sigma + 8); |
| 80 input[3] = U8TO32_LITTLE(sigma + 12); |
| 81 |
| 82 input[12] = counter64; |
| 83 input[13] = counter64 >> 32; |
| 84 input[14] = U8TO32_LITTLE(nonce); |
| 85 input[15] = U8TO32_LITTLE(nonce + 4); |
| 86 |
| 87 while (inLen >= 64) { |
| 88 ChaChaCore(block, input, 20); |
| 89 for (i = 0; i < 64; i++) { |
| 90 out[i] = in[i] ^ block[i]; |
| 91 } |
| 92 |
| 93 input[12]++; |
| 94 if (input[12] == 0) { |
| 95 input[13]++; |
| 96 } |
| 97 |
| 98 inLen -= 64; |
| 99 in += 64; |
| 100 out += 64; |
| 101 } |
| 102 |
| 103 if (inLen > 0) { |
| 104 ChaChaCore(block, input, 20); |
| 105 for (i = 0; i < inLen; i++) { |
| 106 out[i] = in[i] ^ block[i]; |
| 107 } |
| 108 } |
| 109 } |
OLD | NEW |