예제 #1
0
int
main (void)
{
  u64 i = u64init (42, 4711);
  u64 j, k, l;

  j = u64hilo (42, 4711);

  if (u64lt (i, j) || u64lt (j, i))
    return 1;

  i = u64hilo (0, 42);
  j = u64hilo (0, 43);

  if (!u64lt (i, j))
    return 1;

  k = u64plus (i, j);
  l = u64hilo (0, 42 + 43);

  if (u64lt (k, l) || u64lt (l, k))
    return 1;

  return 0;
}
예제 #2
0
/* Process the remaining bytes in the internal buffer and the usual
   prolog according to the standard and write the result to RESBUF.  */
static void
sha512_conclude_ctx (struct sha512_ctx *ctx)
{
    /* Take yet unprocessed bytes into account.  */
    size_t bytes = ctx->buflen;
    size_t size = (bytes < 112) ? 128 / 8 : 128 * 2 / 8;

    /* Now count remaining bytes.  */
    ctx->total[0] = u64plus (ctx->total[0], u64lo (bytes));
    if (u64lt (ctx->total[0], u64lo (bytes)))
        ctx->total[1] = u64plus (ctx->total[1], u64lo (1));

    /* Put the 128-bit file length in *bits* at the end of the buffer.
       Use set_uint64 rather than a simple assignment, to avoid risk of
       unaligned access.  */
    set_uint64 ((char *) &ctx->buffer[size - 2],
                SWAP (u64or (u64shl (ctx->total[1], 3),
                             u64shr (ctx->total[0], 61))));
    set_uint64 ((char *) &ctx->buffer[size - 1],
                SWAP (u64shl (ctx->total[0], 3)));

    memcpy (&((char *) ctx->buffer)[bytes], fillbuf, (size - 2) * 8 - bytes);

    /* Process last bytes.  */
    sha512_process_block (ctx->buffer, size * 8, ctx);
}
예제 #3
0
void
sha512_process_block (const void *buffer, size_t len, struct sha512_ctx *ctx)
{
    u64 const *words = (u64 const *)buffer;
    u64 const *endp = words + len / sizeof (u64);
    u64 x[16];
    u64 a = ctx->state[0];
    u64 b = ctx->state[1];
    u64 c = ctx->state[2];
    u64 d = ctx->state[3];
    u64 e = ctx->state[4];
    u64 f = ctx->state[5];
    u64 g = ctx->state[6];
    u64 h = ctx->state[7];
    u64 lolen = u64size (len);

    /* First increment the byte count.  FIPS PUB 180-2 specifies the possible
       length of the file up to 2^128 bits.  Here we only compute the
       number of bytes.  Do a double word increment.  */
    ctx->total[0] = u64plus (ctx->total[0], lolen);
    ctx->total[1] = u64plus (ctx->total[1],
                             u64plus (u64size (len >> 31 >> 31 >> 2),
                                      u64lo (u64lt (ctx->total[0], lolen))));

#define S0(x) u64xor (u64rol(x, 63), u64xor (u64rol (x, 56), u64shr (x, 7)))
#define S1(x) u64xor (u64rol (x, 45), u64xor (u64rol (x, 3), u64shr (x, 6)))
#define SS0(x) u64xor (u64rol (x, 36), u64xor (u64rol (x, 30), u64rol (x, 25)))
#define SS1(x) u64xor (u64rol(x, 50), u64xor (u64rol (x, 46), u64rol (x, 23)))

#define M(I) (x[(I) & 15]                                                 \
              = u64plus (x[(I) & 15],                                     \
                         u64plus (S1 (x[((I) - 2) & 15]),                 \
                                  u64plus (x[((I) - 7) & 15],             \
                                           S0 (x[((I) - 15) & 15])))))

#define R(A, B, C, D, E, F, G, H, K, M)                                   \
  do                                                                      \
    {                                                                     \
      u64 t0 = u64plus (SS0 (A), F2 (A, B, C));                           \
      u64 t1 =                                                            \
        u64plus (H, u64plus (SS1 (E),                                     \
                             u64plus (F1 (E, F, G), u64plus (K, M))));    \
      D = u64plus (D, t1);                                                \
      H = u64plus (t0, t1);                                               \
    }                                                                     \
  while (0)

    while (words < endp)
    {
        int t;
        /* FIXME: see sha1.c for a better implementation.  */
        for (t = 0; t < 16; t++)
        {
            x[t] = SWAP (*words);
            words++;
        }

        R( a, b, c, d, e, f, g, h, K( 0), x[ 0] );
        R( h, a, b, c, d, e, f, g, K( 1), x[ 1] );
        R( g, h, a, b, c, d, e, f, K( 2), x[ 2] );
        R( f, g, h, a, b, c, d, e, K( 3), x[ 3] );
        R( e, f, g, h, a, b, c, d, K( 4), x[ 4] );
        R( d, e, f, g, h, a, b, c, K( 5), x[ 5] );
        R( c, d, e, f, g, h, a, b, K( 6), x[ 6] );
        R( b, c, d, e, f, g, h, a, K( 7), x[ 7] );
        R( a, b, c, d, e, f, g, h, K( 8), x[ 8] );
        R( h, a, b, c, d, e, f, g, K( 9), x[ 9] );
        R( g, h, a, b, c, d, e, f, K(10), x[10] );
        R( f, g, h, a, b, c, d, e, K(11), x[11] );
        R( e, f, g, h, a, b, c, d, K(12), x[12] );
        R( d, e, f, g, h, a, b, c, K(13), x[13] );
        R( c, d, e, f, g, h, a, b, K(14), x[14] );
        R( b, c, d, e, f, g, h, a, K(15), x[15] );
        R( a, b, c, d, e, f, g, h, K(16), M(16) );
        R( h, a, b, c, d, e, f, g, K(17), M(17) );
        R( g, h, a, b, c, d, e, f, K(18), M(18) );
        R( f, g, h, a, b, c, d, e, K(19), M(19) );
        R( e, f, g, h, a, b, c, d, K(20), M(20) );
        R( d, e, f, g, h, a, b, c, K(21), M(21) );
        R( c, d, e, f, g, h, a, b, K(22), M(22) );
        R( b, c, d, e, f, g, h, a, K(23), M(23) );
        R( a, b, c, d, e, f, g, h, K(24), M(24) );
        R( h, a, b, c, d, e, f, g, K(25), M(25) );
        R( g, h, a, b, c, d, e, f, K(26), M(26) );
        R( f, g, h, a, b, c, d, e, K(27), M(27) );
        R( e, f, g, h, a, b, c, d, K(28), M(28) );
        R( d, e, f, g, h, a, b, c, K(29), M(29) );
        R( c, d, e, f, g, h, a, b, K(30), M(30) );
        R( b, c, d, e, f, g, h, a, K(31), M(31) );
        R( a, b, c, d, e, f, g, h, K(32), M(32) );
        R( h, a, b, c, d, e, f, g, K(33), M(33) );
        R( g, h, a, b, c, d, e, f, K(34), M(34) );
        R( f, g, h, a, b, c, d, e, K(35), M(35) );
        R( e, f, g, h, a, b, c, d, K(36), M(36) );
        R( d, e, f, g, h, a, b, c, K(37), M(37) );
        R( c, d, e, f, g, h, a, b, K(38), M(38) );
        R( b, c, d, e, f, g, h, a, K(39), M(39) );
        R( a, b, c, d, e, f, g, h, K(40), M(40) );
        R( h, a, b, c, d, e, f, g, K(41), M(41) );
        R( g, h, a, b, c, d, e, f, K(42), M(42) );
        R( f, g, h, a, b, c, d, e, K(43), M(43) );
        R( e, f, g, h, a, b, c, d, K(44), M(44) );
        R( d, e, f, g, h, a, b, c, K(45), M(45) );
        R( c, d, e, f, g, h, a, b, K(46), M(46) );
        R( b, c, d, e, f, g, h, a, K(47), M(47) );
        R( a, b, c, d, e, f, g, h, K(48), M(48) );
        R( h, a, b, c, d, e, f, g, K(49), M(49) );
        R( g, h, a, b, c, d, e, f, K(50), M(50) );
        R( f, g, h, a, b, c, d, e, K(51), M(51) );
        R( e, f, g, h, a, b, c, d, K(52), M(52) );
        R( d, e, f, g, h, a, b, c, K(53), M(53) );
        R( c, d, e, f, g, h, a, b, K(54), M(54) );
        R( b, c, d, e, f, g, h, a, K(55), M(55) );
        R( a, b, c, d, e, f, g, h, K(56), M(56) );
        R( h, a, b, c, d, e, f, g, K(57), M(57) );
        R( g, h, a, b, c, d, e, f, K(58), M(58) );
        R( f, g, h, a, b, c, d, e, K(59), M(59) );
        R( e, f, g, h, a, b, c, d, K(60), M(60) );
        R( d, e, f, g, h, a, b, c, K(61), M(61) );
        R( c, d, e, f, g, h, a, b, K(62), M(62) );
        R( b, c, d, e, f, g, h, a, K(63), M(63) );
        R( a, b, c, d, e, f, g, h, K(64), M(64) );
        R( h, a, b, c, d, e, f, g, K(65), M(65) );
        R( g, h, a, b, c, d, e, f, K(66), M(66) );
        R( f, g, h, a, b, c, d, e, K(67), M(67) );
        R( e, f, g, h, a, b, c, d, K(68), M(68) );
        R( d, e, f, g, h, a, b, c, K(69), M(69) );
        R( c, d, e, f, g, h, a, b, K(70), M(70) );
        R( b, c, d, e, f, g, h, a, K(71), M(71) );
        R( a, b, c, d, e, f, g, h, K(72), M(72) );
        R( h, a, b, c, d, e, f, g, K(73), M(73) );
        R( g, h, a, b, c, d, e, f, K(74), M(74) );
        R( f, g, h, a, b, c, d, e, K(75), M(75) );
        R( e, f, g, h, a, b, c, d, K(76), M(76) );
        R( d, e, f, g, h, a, b, c, K(77), M(77) );
        R( c, d, e, f, g, h, a, b, K(78), M(78) );
        R( b, c, d, e, f, g, h, a, K(79), M(79) );

        a = ctx->state[0] = u64plus (ctx->state[0], a);
        b = ctx->state[1] = u64plus (ctx->state[1], b);
        c = ctx->state[2] = u64plus (ctx->state[2], c);
        d = ctx->state[3] = u64plus (ctx->state[3], d);
        e = ctx->state[4] = u64plus (ctx->state[4], e);
        f = ctx->state[5] = u64plus (ctx->state[5], f);
        g = ctx->state[6] = u64plus (ctx->state[6], g);
        h = ctx->state[7] = u64plus (ctx->state[7], h);
    }
}