gerrit.fd Code Review - trex.git/blob

   1
   2 /*-
   3  * Copyright 2005,2007,2009 Colin Percival
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  */
  28
  29 #include "api.h"
  30 #include "crypto_hash_sha512.h"
  31 #include "utils.h"
  32
  33 #include <sys/types.h>
  34
  35 #include <limits.h>
  36 #include <stdint.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39
  40 /* Avoid namespace collisions with BSD <sys/endian.h>. */
  41 #define be64dec _sha512_be64dec
  42 #define be64enc _sha512_be64enc
  43
  44 static inline uint64_t
  45 be64dec(const void *pp)
  46 {
  47     const uint8_t *p = (uint8_t const *)pp;
  48
  49     return ((uint64_t)(p[7]) + ((uint64_t)(p[6]) << 8) +
  50             ((uint64_t)(p[5]) << 16) + ((uint64_t)(p[4]) << 24) +
  51             ((uint64_t)(p[3]) << 32) + ((uint64_t)(p[2]) << 40) +
  52             ((uint64_t)(p[1]) << 48) + ((uint64_t)(p[0]) << 56));
  53 }
  54
  55 static inline void
  56 be64enc(void *pp, uint64_t x)
  57 {
  58     uint8_t *p = (uint8_t *)pp;
  59
  60     p[7] = x & 0xff;
  61     p[6] = (x >> 8) & 0xff;
  62     p[5] = (x >> 16) & 0xff;
  63     p[4] = (x >> 24) & 0xff;
  64     p[3] = (x >> 32) & 0xff;
  65     p[2] = (x >> 40) & 0xff;
  66     p[1] = (x >> 48) & 0xff;
  67     p[0] = (x >> 56) & 0xff;
  68 }
  69
  70 static void
  71 be64enc_vect(unsigned char *dst, const uint64_t *src, size_t len)
  72 {
  73     size_t i;
  74
  75     for (i = 0; i < len / 8; i++) {
  76         be64enc(dst + i * 8, src[i]);
  77     }
  78 }
  79
  80 static void
  81 be64dec_vect(uint64_t *dst, const unsigned char *src, size_t len)
  82 {
  83     size_t i;
  84
  85     for (i = 0; i < len / 8; i++) {
  86         dst[i] = be64dec(src + i * 8);
  87     }
  88 }
  89
  90 #define Ch(x, y, z)     ((x & (y ^ z)) ^ z)
  91 #define Maj(x, y, z)    ((x & (y | z)) | (y & z))
  92 #define SHR(x, n)       (x >> n)
  93 #define ROTR(x, n)      ((x >> n) | (x << (64 - n)))
  94 #define S0(x)           (ROTR(x, 28) ^ ROTR(x, 34) ^ ROTR(x, 39))
  95 #define S1(x)           (ROTR(x, 14) ^ ROTR(x, 18) ^ ROTR(x, 41))
  96 #define s0(x)           (ROTR(x, 1) ^ ROTR(x, 8) ^ SHR(x, 7))
  97 #define s1(x)           (ROTR(x, 19) ^ ROTR(x, 61) ^ SHR(x, 6))
  98
  99 #define RND(a, b, c, d, e, f, g, h, k)              \
 100     t0 = h + S1(e) + Ch(e, f, g) + k;               \
 101     t1 = S0(a) + Maj(a, b, c);                      \
 102     d += t0;                                        \
 103     h  = t0 + t1;
 104
 105 #define RNDr(S, W, i, k)                    \
 106     RND(S[(80 - i) % 8], S[(81 - i) % 8],   \
 107         S[(82 - i) % 8], S[(83 - i) % 8],   \
 108         S[(84 - i) % 8], S[(85 - i) % 8],   \
 109         S[(86 - i) % 8], S[(87 - i) % 8],   \
 110         W[i] + k)
 111
 112 static void
 113 SHA512_Transform(uint64_t *state, const unsigned char block[128])
 114 {
 115     uint64_t W[80];
 116     uint64_t S[8];
 117     uint64_t t0, t1;
 118     int i;
 119
 120     be64dec_vect(W, block, 128);
 121     for (i = 16; i < 80; i++) {
 122         W[i] = s1(W[i - 2]) + W[i - 7] + s0(W[i - 15]) + W[i - 16];
 123     }
 124
 125     memcpy(S, state, 64);
 126
 127     RNDr(S, W, 0, 0x428a2f98d728ae22ULL);
 128     RNDr(S, W, 1, 0x7137449123ef65cdULL);
 129     RNDr(S, W, 2, 0xb5c0fbcfec4d3b2fULL);
 130     RNDr(S, W, 3, 0xe9b5dba58189dbbcULL);
 131     RNDr(S, W, 4, 0x3956c25bf348b538ULL);
 132     RNDr(S, W, 5, 0x59f111f1b605d019ULL);
 133     RNDr(S, W, 6, 0x923f82a4af194f9bULL);
 134     RNDr(S, W, 7, 0xab1c5ed5da6d8118ULL);
 135     RNDr(S, W, 8, 0xd807aa98a3030242ULL);
 136     RNDr(S, W, 9, 0x12835b0145706fbeULL);
 137     RNDr(S, W, 10, 0x243185be4ee4b28cULL);
 138     RNDr(S, W, 11, 0x550c7dc3d5ffb4e2ULL);
 139     RNDr(S, W, 12, 0x72be5d74f27b896fULL);
 140     RNDr(S, W, 13, 0x80deb1fe3b1696b1ULL);
 141     RNDr(S, W, 14, 0x9bdc06a725c71235ULL);
 142     RNDr(S, W, 15, 0xc19bf174cf692694ULL);
 143     RNDr(S, W, 16, 0xe49b69c19ef14ad2ULL);
 144     RNDr(S, W, 17, 0xefbe4786384f25e3ULL);
 145     RNDr(S, W, 18, 0x0fc19dc68b8cd5b5ULL);
 146     RNDr(S, W, 19, 0x240ca1cc77ac9c65ULL);
 147     RNDr(S, W, 20, 0x2de92c6f592b0275ULL);
 148     RNDr(S, W, 21, 0x4a7484aa6ea6e483ULL);
 149     RNDr(S, W, 22, 0x5cb0a9dcbd41fbd4ULL);
 150     RNDr(S, W, 23, 0x76f988da831153b5ULL);
 151     RNDr(S, W, 24, 0x983e5152ee66dfabULL);
 152     RNDr(S, W, 25, 0xa831c66d2db43210ULL);
 153     RNDr(S, W, 26, 0xb00327c898fb213fULL);
 154     RNDr(S, W, 27, 0xbf597fc7beef0ee4ULL);
 155     RNDr(S, W, 28, 0xc6e00bf33da88fc2ULL);
 156     RNDr(S, W, 29, 0xd5a79147930aa725ULL);
 157     RNDr(S, W, 30, 0x06ca6351e003826fULL);
 158     RNDr(S, W, 31, 0x142929670a0e6e70ULL);
 159     RNDr(S, W, 32, 0x27b70a8546d22ffcULL);
 160     RNDr(S, W, 33, 0x2e1b21385c26c926ULL);
 161     RNDr(S, W, 34, 0x4d2c6dfc5ac42aedULL);
 162     RNDr(S, W, 35, 0x53380d139d95b3dfULL);
 163     RNDr(S, W, 36, 0x650a73548baf63deULL);
 164     RNDr(S, W, 37, 0x766a0abb3c77b2a8ULL);
 165     RNDr(S, W, 38, 0x81c2c92e47edaee6ULL);
 166     RNDr(S, W, 39, 0x92722c851482353bULL);
 167     RNDr(S, W, 40, 0xa2bfe8a14cf10364ULL);
 168     RNDr(S, W, 41, 0xa81a664bbc423001ULL);
 169     RNDr(S, W, 42, 0xc24b8b70d0f89791ULL);
 170     RNDr(S, W, 43, 0xc76c51a30654be30ULL);
 171     RNDr(S, W, 44, 0xd192e819d6ef5218ULL);
 172     RNDr(S, W, 45, 0xd69906245565a910ULL);
 173     RNDr(S, W, 46, 0xf40e35855771202aULL);
 174     RNDr(S, W, 47, 0x106aa07032bbd1b8ULL);
 175     RNDr(S, W, 48, 0x19a4c116b8d2d0c8ULL);
 176     RNDr(S, W, 49, 0x1e376c085141ab53ULL);
 177     RNDr(S, W, 50, 0x2748774cdf8eeb99ULL);
 178     RNDr(S, W, 51, 0x34b0bcb5e19b48a8ULL);
 179     RNDr(S, W, 52, 0x391c0cb3c5c95a63ULL);
 180     RNDr(S, W, 53, 0x4ed8aa4ae3418acbULL);
 181     RNDr(S, W, 54, 0x5b9cca4f7763e373ULL);
 182     RNDr(S, W, 55, 0x682e6ff3d6b2b8a3ULL);
 183     RNDr(S, W, 56, 0x748f82ee5defb2fcULL);
 184     RNDr(S, W, 57, 0x78a5636f43172f60ULL);
 185     RNDr(S, W, 58, 0x84c87814a1f0ab72ULL);
 186     RNDr(S, W, 59, 0x8cc702081a6439ecULL);
 187     RNDr(S, W, 60, 0x90befffa23631e28ULL);
 188     RNDr(S, W, 61, 0xa4506cebde82bde9ULL);
 189     RNDr(S, W, 62, 0xbef9a3f7b2c67915ULL);
 190     RNDr(S, W, 63, 0xc67178f2e372532bULL);
 191     RNDr(S, W, 64, 0xca273eceea26619cULL);
 192     RNDr(S, W, 65, 0xd186b8c721c0c207ULL);
 193     RNDr(S, W, 66, 0xeada7dd6cde0eb1eULL);
 194     RNDr(S, W, 67, 0xf57d4f7fee6ed178ULL);
 195     RNDr(S, W, 68, 0x06f067aa72176fbaULL);
 196     RNDr(S, W, 69, 0x0a637dc5a2c898a6ULL);
 197     RNDr(S, W, 70, 0x113f9804bef90daeULL);
 198     RNDr(S, W, 71, 0x1b710b35131c471bULL);
 199     RNDr(S, W, 72, 0x28db77f523047d84ULL);
 200     RNDr(S, W, 73, 0x32caab7b40c72493ULL);
 201     RNDr(S, W, 74, 0x3c9ebe0a15c9bebcULL);
 202     RNDr(S, W, 75, 0x431d67c49c100d4cULL);
 203     RNDr(S, W, 76, 0x4cc5d4becb3e42b6ULL);
 204     RNDr(S, W, 77, 0x597f299cfc657e2aULL);
 205     RNDr(S, W, 78, 0x5fcb6fab3ad6faecULL);
 206     RNDr(S, W, 79, 0x6c44198c4a475817ULL);
 207
 208     for (i = 0; i < 8; i++) {
 209         state[i] += S[i];
 210     }
 211
 212     sodium_memzero((void *) W, sizeof W);
 213     sodium_memzero((void *) S, sizeof S);
 214     sodium_memzero((void *) &t0, sizeof t0);
 215     sodium_memzero((void *) &t1, sizeof t1);
 216 }
 217
 218 static unsigned char PAD[128] = {
 219     0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 220     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 221     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 222     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 223     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 224     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 225     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 226     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 227 };
 228
 229 static void
 230 SHA512_Pad(crypto_hash_sha512_state *state)
 231 {
 232     unsigned char len[16];
 233     uint64_t r, plen;
 234
 235     be64enc_vect(len, state->count, 16);
 236
 237     r = (state->count[1] >> 3) & 0x7f;
 238     plen = (r < 112) ? (112 - r) : (240 - r);
 239     crypto_hash_sha512_update(state, PAD, (unsigned long long) plen);
 240
 241     crypto_hash_sha512_update(state, len, 16);
 242 }
 243
 244 int
 245 crypto_hash_sha512_init(crypto_hash_sha512_state *state)
 246 {
 247     state->count[0] = state->count[1] = 0;
 248
 249     state->state[0] = 0x6a09e667f3bcc908ULL;
 250     state->state[1] = 0xbb67ae8584caa73bULL;
 251     state->state[2] = 0x3c6ef372fe94f82bULL;
 252     state->state[3] = 0xa54ff53a5f1d36f1ULL;
 253     state->state[4] = 0x510e527fade682d1ULL;
 254     state->state[5] = 0x9b05688c2b3e6c1fULL;
 255     state->state[6] = 0x1f83d9abfb41bd6bULL;
 256     state->state[7] = 0x5be0cd19137e2179ULL;
 257
 258     return 0;
 259 }
 260
 261 int
 262 crypto_hash_sha512_update(crypto_hash_sha512_state *state,
 263                           const unsigned char *in,
 264                           unsigned long long inlen)
 265 {
 266     uint64_t bitlen[2];
 267     uint64_t r;
 268     const unsigned char *src = in;
 269
 270     r = (state->count[1] >> 3) & 0x7f;
 271
 272     bitlen[1] = ((uint64_t)inlen) << 3;
 273     bitlen[0] = ((uint64_t)inlen) >> 61;
 274
 275     /* LCOV_EXCL_START */
 276     if ((state->count[1] += bitlen[1]) < bitlen[1]) {
 277         state->count[0]++;
 278     }
 279     /* LCOV_EXCL_STOP */
 280     state->count[0] += bitlen[0];
 281
 282     if (inlen < 128 - r) {
 283         memcpy(&state->buf[r], src, inlen);
 284         return 0;
 285     }
 286     memcpy(&state->buf[r], src, 128 - r);
 287     SHA512_Transform(state->state, state->buf);
 288     src += 128 - r;
 289     inlen -= 128 - r;
 290
 291     while (inlen >= 128) {
 292         SHA512_Transform(state->state, src);
 293         src += 128;
 294         inlen -= 128;
 295     }
 296     memcpy(state->buf, src, inlen);
 297
 298     return 0;
 299 }
 300
 301 int
 302 crypto_hash_sha512_final(crypto_hash_sha512_state *state,
 303                          unsigned char *out)
 304 {
 305     SHA512_Pad(state);
 306     be64enc_vect(out, state->state, 64);
 307     sodium_memzero((void *) state, sizeof *state);
 308
 309     return 0;
 310 }
 311
 312 int
 313 crypto_hash(unsigned char *out, const unsigned char *in,
 314             unsigned long long inlen)
 315 {
 316     crypto_hash_sha512_state state;
 317
 318     crypto_hash_sha512_init(&state);
 319     crypto_hash_sha512_update(&state, in, inlen);
 320     crypto_hash_sha512_final(&state, out);
 321
 322     return 0;
 323 }