The Tor Browser / file comparison
comparison: gfx/skia/trunk/src/utils/SkSHA1.cpp
gfx/skia/trunk/src/utils/SkSHA1.cpp
- branch
- TOR_BUG_3246
- changeset 7
- 129ffea94266
equal
deleted
inserted
replaced
| -1:000000000000 | 0:278254641140 |
|---|---|
| 1 /* | |
| 2 * Copyright 2013 Google Inc. | |
| 3 * | |
| 4 * Use of this source code is governed by a BSD-style license that can be | |
| 5 * found in the LICENSE file. | |
| 6 * | |
| 7 * The following code is based on the description in RFC 3174. | |
| 8 * http://www.ietf.org/rfc/rfc3174.txt | |
| 9 */ | |
| 10 | |
| 11 #include "SkTypes.h" | |
| 12 #include "SkSHA1.h" | |
| 13 #include <string.h> | |
| 14 | |
| 15 /** SHA1 basic transformation. Transforms state based on block. */ | |
| 16 static void transform(uint32_t state[5], const uint8_t block[64]); | |
| 17 | |
| 18 /** Encodes input into output (5 big endian 32 bit values). */ | |
| 19 static void encode(uint8_t output[20], const uint32_t input[5]); | |
| 20 | |
| 21 /** Encodes input into output (big endian 64 bit value). */ | |
| 22 static void encode(uint8_t output[8], const uint64_t input); | |
| 23 | |
| 24 SkSHA1::SkSHA1() : byteCount(0) { | |
| 25 // These are magic numbers from the specification. The first four are the same as MD5. | |
| 26 this->state[0] = 0x67452301; | |
| 27 this->state[1] = 0xefcdab89; | |
| 28 this->state[2] = 0x98badcfe; | |
| 29 this->state[3] = 0x10325476; | |
| 30 this->state[4] = 0xc3d2e1f0; | |
| 31 } | |
| 32 | |
| 33 void SkSHA1::update(const uint8_t* input, size_t inputLength) { | |
| 34 unsigned int bufferIndex = (unsigned int)(this->byteCount & 0x3F); | |
| 35 unsigned int bufferAvailable = 64 - bufferIndex; | |
| 36 | |
| 37 unsigned int inputIndex; | |
| 38 if (inputLength >= bufferAvailable) { | |
| 39 if (bufferIndex) { | |
| 40 memcpy(&this->buffer[bufferIndex], input, bufferAvailable); | |
| 41 transform(this->state, this->buffer); | |
| 42 inputIndex = bufferAvailable; | |
| 43 } else { | |
| 44 inputIndex = 0; | |
| 45 } | |
| 46 | |
| 47 for (; inputIndex + 63 < inputLength; inputIndex += 64) { | |
| 48 transform(this->state, &input[inputIndex]); | |
| 49 } | |
| 50 | |
| 51 bufferIndex = 0; | |
| 52 } else { | |
| 53 inputIndex = 0; | |
| 54 } | |
| 55 | |
| 56 memcpy(&this->buffer[bufferIndex], &input[inputIndex], inputLength - inputIndex); | |
| 57 | |
| 58 this->byteCount += inputLength; | |
| 59 } | |
| 60 | |
| 61 void SkSHA1::finish(Digest& digest) { | |
| 62 // Get the number of bits before padding. | |
| 63 uint8_t bits[8]; | |
| 64 encode(bits, this->byteCount << 3); | |
| 65 | |
| 66 // Pad out to 56 mod 64. | |
| 67 unsigned int bufferIndex = (unsigned int)(this->byteCount & 0x3F); | |
| 68 unsigned int paddingLength = (bufferIndex < 56) ? (56 - bufferIndex) : (120 - bufferIndex); | |
| 69 static uint8_t PADDING[64] = { | |
| 70 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
| 71 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
| 72 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
| 73 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
| 74 }; | |
| 75 this->update(PADDING, paddingLength); | |
| 76 | |
| 77 // Append length (length before padding, will cause final update). | |
| 78 this->update(bits, 8); | |
| 79 | |
| 80 // Write out digest. | |
| 81 encode(digest.data, this->state); | |
| 82 | |
| 83 #if defined(SK_SHA1_CLEAR_DATA) | |
| 84 // Clear state. | |
| 85 memset(this, 0, sizeof(*this)); | |
| 86 #endif | |
| 87 } | |
| 88 | |
| 89 struct F1 { uint32_t operator()(uint32_t B, uint32_t C, uint32_t D) { | |
| 90 return (B & C) | ((~B) & D); | |
| 91 //return D ^ (B & (C ^ D)); | |
| 92 //return (B & C) ^ ((~B) & D); | |
| 93 //return (B & C) + ((~B) & D); | |
| 94 //return _mm_or_ps(_mm_andnot_ps(B, D), _mm_and_ps(B, C)); //SSE2 | |
| 95 //return vec_sel(D, C, B); //PPC | |
| 96 }}; | |
| 97 | |
| 98 struct F2 { uint32_t operator()(uint32_t B, uint32_t C, uint32_t D) { | |
| 99 return B ^ C ^ D; | |
| 100 }}; | |
| 101 | |
| 102 struct F3 { uint32_t operator()(uint32_t B, uint32_t C, uint32_t D) { | |
| 103 return (B & C) | (B & D) | (C & D); | |
| 104 //return (B & C) | (D & (B | C)); | |
| 105 //return (B & C) | (D & (B ^ C)); | |
| 106 //return (B & C) + (D & (B ^ C)); | |
| 107 //return (B & C) ^ (B & D) ^ (C & D); | |
| 108 }}; | |
| 109 | |
| 110 /** Rotates x left n bits. */ | |
| 111 static inline uint32_t rotate_left(uint32_t x, uint8_t n) { | |
| 112 return (x << n) | (x >> (32 - n)); | |
| 113 } | |
| 114 | |
| 115 template <typename T> | |
| 116 static inline void operation(T operation, | |
| 117 uint32_t A, uint32_t& B, uint32_t C, uint32_t D, uint32_t& E, | |
| 118 uint32_t w, uint32_t k) { | |
| 119 E += rotate_left(A, 5) + operation(B, C, D) + w + k; | |
| 120 B = rotate_left(B, 30); | |
| 121 } | |
| 122 | |
| 123 static void transform(uint32_t state[5], const uint8_t block[64]) { | |
| 124 uint32_t A = state[0], B = state[1], C = state[2], D = state[3], E = state[4]; | |
| 125 | |
| 126 // Round constants defined in SHA-1. | |
| 127 static const uint32_t K[] = { | |
| 128 0x5A827999, //sqrt(2) * 2^30 | |
| 129 0x6ED9EBA1, //sqrt(3) * 2^30 | |
| 130 0x8F1BBCDC, //sqrt(5) * 2^30 | |
| 131 0xCA62C1D6, //sqrt(10) * 2^30 | |
| 132 }; | |
| 133 | |
| 134 uint32_t W[80]; | |
| 135 | |
| 136 // Initialize the array W. | |
| 137 size_t i = 0; | |
| 138 for (size_t j = 0; i < 16; ++i, j += 4) { | |
| 139 W[i] = (((uint32_t)block[j ]) << 24) | | |
| 140 (((uint32_t)block[j+1]) << 16) | | |
| 141 (((uint32_t)block[j+2]) << 8) | | |
| 142 (((uint32_t)block[j+3]) ); | |
| 143 } | |
| 144 for (; i < 80; ++i) { | |
| 145 W[i] = rotate_left(W[i-3] ^ W[i-8] ^ W[i-14] ^ W[i-16], 1); | |
| 146 //The following is equivelent and speeds up SSE implementations, but slows non-SSE. | |
| 147 //W[i] = rotate_left(W[i-6] ^ W[i-16] ^ W[i-28] ^ W[i-32], 2); | |
| 148 } | |
| 149 | |
| 150 // Round 1 | |
| 151 operation(F1(), A, B, C, D, E, W[ 0], K[0]); | |
| 152 operation(F1(), E, A, B, C, D, W[ 1], K[0]); | |
| 153 operation(F1(), D, E, A, B, C, W[ 2], K[0]); | |
| 154 operation(F1(), C, D, E, A, B, W[ 3], K[0]); | |
| 155 operation(F1(), B, C, D, E, A, W[ 4], K[0]); | |
| 156 operation(F1(), A, B, C, D, E, W[ 5], K[0]); | |
| 157 operation(F1(), E, A, B, C, D, W[ 6], K[0]); | |
| 158 operation(F1(), D, E, A, B, C, W[ 7], K[0]); | |
| 159 operation(F1(), C, D, E, A, B, W[ 8], K[0]); | |
| 160 operation(F1(), B, C, D, E, A, W[ 9], K[0]); | |
| 161 operation(F1(), A, B, C, D, E, W[10], K[0]); | |
| 162 operation(F1(), E, A, B, C, D, W[11], K[0]); | |
| 163 operation(F1(), D, E, A, B, C, W[12], K[0]); | |
| 164 operation(F1(), C, D, E, A, B, W[13], K[0]); | |
| 165 operation(F1(), B, C, D, E, A, W[14], K[0]); | |
| 166 operation(F1(), A, B, C, D, E, W[15], K[0]); | |
| 167 operation(F1(), E, A, B, C, D, W[16], K[0]); | |
| 168 operation(F1(), D, E, A, B, C, W[17], K[0]); | |
| 169 operation(F1(), C, D, E, A, B, W[18], K[0]); | |
| 170 operation(F1(), B, C, D, E, A, W[19], K[0]); | |
| 171 | |
| 172 // Round 2 | |
| 173 operation(F2(), A, B, C, D, E, W[20], K[1]); | |
| 174 operation(F2(), E, A, B, C, D, W[21], K[1]); | |
| 175 operation(F2(), D, E, A, B, C, W[22], K[1]); | |
| 176 operation(F2(), C, D, E, A, B, W[23], K[1]); | |
| 177 operation(F2(), B, C, D, E, A, W[24], K[1]); | |
| 178 operation(F2(), A, B, C, D, E, W[25], K[1]); | |
| 179 operation(F2(), E, A, B, C, D, W[26], K[1]); | |
| 180 operation(F2(), D, E, A, B, C, W[27], K[1]); | |
| 181 operation(F2(), C, D, E, A, B, W[28], K[1]); | |
| 182 operation(F2(), B, C, D, E, A, W[29], K[1]); | |
| 183 operation(F2(), A, B, C, D, E, W[30], K[1]); | |
| 184 operation(F2(), E, A, B, C, D, W[31], K[1]); | |
| 185 operation(F2(), D, E, A, B, C, W[32], K[1]); | |
| 186 operation(F2(), C, D, E, A, B, W[33], K[1]); | |
| 187 operation(F2(), B, C, D, E, A, W[34], K[1]); | |
| 188 operation(F2(), A, B, C, D, E, W[35], K[1]); | |
| 189 operation(F2(), E, A, B, C, D, W[36], K[1]); | |
| 190 operation(F2(), D, E, A, B, C, W[37], K[1]); | |
| 191 operation(F2(), C, D, E, A, B, W[38], K[1]); | |
| 192 operation(F2(), B, C, D, E, A, W[39], K[1]); | |
| 193 | |
| 194 // Round 3 | |
| 195 operation(F3(), A, B, C, D, E, W[40], K[2]); | |
| 196 operation(F3(), E, A, B, C, D, W[41], K[2]); | |
| 197 operation(F3(), D, E, A, B, C, W[42], K[2]); | |
| 198 operation(F3(), C, D, E, A, B, W[43], K[2]); | |
| 199 operation(F3(), B, C, D, E, A, W[44], K[2]); | |
| 200 operation(F3(), A, B, C, D, E, W[45], K[2]); | |
| 201 operation(F3(), E, A, B, C, D, W[46], K[2]); | |
| 202 operation(F3(), D, E, A, B, C, W[47], K[2]); | |
| 203 operation(F3(), C, D, E, A, B, W[48], K[2]); | |
| 204 operation(F3(), B, C, D, E, A, W[49], K[2]); | |
| 205 operation(F3(), A, B, C, D, E, W[50], K[2]); | |
| 206 operation(F3(), E, A, B, C, D, W[51], K[2]); | |
| 207 operation(F3(), D, E, A, B, C, W[52], K[2]); | |
| 208 operation(F3(), C, D, E, A, B, W[53], K[2]); | |
| 209 operation(F3(), B, C, D, E, A, W[54], K[2]); | |
| 210 operation(F3(), A, B, C, D, E, W[55], K[2]); | |
| 211 operation(F3(), E, A, B, C, D, W[56], K[2]); | |
| 212 operation(F3(), D, E, A, B, C, W[57], K[2]); | |
| 213 operation(F3(), C, D, E, A, B, W[58], K[2]); | |
| 214 operation(F3(), B, C, D, E, A, W[59], K[2]); | |
| 215 | |
| 216 // Round 4 | |
| 217 operation(F2(), A, B, C, D, E, W[60], K[3]); | |
| 218 operation(F2(), E, A, B, C, D, W[61], K[3]); | |
| 219 operation(F2(), D, E, A, B, C, W[62], K[3]); | |
| 220 operation(F2(), C, D, E, A, B, W[63], K[3]); | |
| 221 operation(F2(), B, C, D, E, A, W[64], K[3]); | |
| 222 operation(F2(), A, B, C, D, E, W[65], K[3]); | |
| 223 operation(F2(), E, A, B, C, D, W[66], K[3]); | |
| 224 operation(F2(), D, E, A, B, C, W[67], K[3]); | |
| 225 operation(F2(), C, D, E, A, B, W[68], K[3]); | |
| 226 operation(F2(), B, C, D, E, A, W[69], K[3]); | |
| 227 operation(F2(), A, B, C, D, E, W[70], K[3]); | |
| 228 operation(F2(), E, A, B, C, D, W[71], K[3]); | |
| 229 operation(F2(), D, E, A, B, C, W[72], K[3]); | |
| 230 operation(F2(), C, D, E, A, B, W[73], K[3]); | |
| 231 operation(F2(), B, C, D, E, A, W[74], K[3]); | |
| 232 operation(F2(), A, B, C, D, E, W[75], K[3]); | |
| 233 operation(F2(), E, A, B, C, D, W[76], K[3]); | |
| 234 operation(F2(), D, E, A, B, C, W[77], K[3]); | |
| 235 operation(F2(), C, D, E, A, B, W[78], K[3]); | |
| 236 operation(F2(), B, C, D, E, A, W[79], K[3]); | |
| 237 | |
| 238 state[0] += A; | |
| 239 state[1] += B; | |
| 240 state[2] += C; | |
| 241 state[3] += D; | |
| 242 state[4] += E; | |
| 243 | |
| 244 #if defined(SK_SHA1_CLEAR_DATA) | |
| 245 // Clear sensitive information. | |
| 246 memset(W, 0, sizeof(W)); | |
| 247 #endif | |
| 248 } | |
| 249 | |
| 250 static void encode(uint8_t output[20], const uint32_t input[5]) { | |
| 251 for (size_t i = 0, j = 0; i < 5; i++, j += 4) { | |
| 252 output[j ] = (uint8_t)((input[i] >> 24) & 0xff); | |
| 253 output[j+1] = (uint8_t)((input[i] >> 16) & 0xff); | |
| 254 output[j+2] = (uint8_t)((input[i] >> 8) & 0xff); | |
| 255 output[j+3] = (uint8_t)((input[i] ) & 0xff); | |
| 256 } | |
| 257 } | |
| 258 | |
| 259 static void encode(uint8_t output[8], const uint64_t input) { | |
| 260 output[0] = (uint8_t)((input >> 56) & 0xff); | |
| 261 output[1] = (uint8_t)((input >> 48) & 0xff); | |
| 262 output[2] = (uint8_t)((input >> 40) & 0xff); | |
| 263 output[3] = (uint8_t)((input >> 32) & 0xff); | |
| 264 output[4] = (uint8_t)((input >> 24) & 0xff); | |
| 265 output[5] = (uint8_t)((input >> 16) & 0xff); | |
| 266 output[6] = (uint8_t)((input >> 8) & 0xff); | |
| 267 output[7] = (uint8_t)((input ) & 0xff); | |
| 268 } |
