kris
/
pqc
1
1
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Browse Source

common: use fixed size integers

master
Kris Kwiatkowski 5 years ago
parent
69401eb697
commit
312616113a
4 changed files with 147 additions and 172 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +75
    -90
      common/fips202.c
  2. +11
    -16
      common/fips202.h
  3. +59
    -62
      common/sha2.c
  4. +2
    -4
      common/sha2.h

+ 75
- 90
common/fips202.c View File

@@ -5,10 +5,11 @@
* from https://twitter.com/tweetfips202
* by Gilles Van Assche, Daniel J. Bernstein, and Peter Schwabe */

#include "fips202.h"
#include <stddef.h>
#include <stdint.h>

#include "fips202.h"

#define NROUNDS 24
#define ROL(a, offset) (((a) << (offset)) ^ ((a) >> (64 - (offset))))

@@ -17,15 +18,13 @@
*
* Description: Load 8 bytes into uint64_t in little-endian order
*
* Arguments: - const unsigned char *x: pointer to input byte array
* Arguments: - const uint8_t *x: pointer to input byte array
*
* Returns the loaded 64-bit unsigned integer
**************************************************/
static uint64_t load64(const unsigned char *x) {
unsigned int i;
static uint64_t load64(const uint8_t *x) {
uint64_t r = 0;

for (i = 0; i < 8; ++i) {
for (size_t i = 0; i < 8; ++i) {
r |= (uint64_t)x[i] << 8 * i;
}

@@ -41,27 +40,25 @@ static uint64_t load64(const unsigned char *x) {
* - uint64_t u: input 64-bit unsigned integer
**************************************************/
static void store64(uint8_t *x, uint64_t u) {
unsigned int i;

for (i = 0; i < 8; ++i) {
for (size_t i = 0; i < 8; ++i) {
x[i] = u >> 8 * i;
}
}

/* Keccak round constants */
static const uint64_t KeccakF_RoundConstants[NROUNDS] = {
(uint64_t)0x0000000000000001ULL, (uint64_t)0x0000000000008082ULL,
(uint64_t)0x800000000000808aULL, (uint64_t)0x8000000080008000ULL,
(uint64_t)0x000000000000808bULL, (uint64_t)0x0000000080000001ULL,
(uint64_t)0x8000000080008081ULL, (uint64_t)0x8000000000008009ULL,
(uint64_t)0x000000000000008aULL, (uint64_t)0x0000000000000088ULL,
(uint64_t)0x0000000080008009ULL, (uint64_t)0x000000008000000aULL,
(uint64_t)0x000000008000808bULL, (uint64_t)0x800000000000008bULL,
(uint64_t)0x8000000000008089ULL, (uint64_t)0x8000000000008003ULL,
(uint64_t)0x8000000000008002ULL, (uint64_t)0x8000000000000080ULL,
(uint64_t)0x000000000000800aULL, (uint64_t)0x800000008000000aULL,
(uint64_t)0x8000000080008081ULL, (uint64_t)0x8000000000008080ULL,
(uint64_t)0x0000000080000001ULL, (uint64_t)0x8000000080008008ULL
0x0000000000000001ULL, 0x0000000000008082ULL,
0x800000000000808aULL, 0x8000000080008000ULL,
0x000000000000808bULL, 0x0000000080000001ULL,
0x8000000080008081ULL, 0x8000000000008009ULL,
0x000000000000008aULL, 0x0000000000000088ULL,
0x0000000080008009ULL, 0x000000008000000aULL,
0x000000008000808bULL, 0x800000000000008bULL,
0x8000000000008089ULL, 0x8000000000008003ULL,
0x8000000000008002ULL, 0x8000000000000080ULL,
0x000000000000800aULL, 0x800000008000000aULL,
0x8000000080008081ULL, 0x8000000000008080ULL,
0x0000000080000001ULL, 0x8000000080008008ULL
};

/*************************************************
@@ -341,16 +338,16 @@ static void KeccakF1600_StatePermute(uint64_t *state) {
* non-incremental, starts by zeroeing the state.
*
* Arguments: - uint64_t *s: pointer to (uninitialized) output Keccak state
* - unsigned int r: rate in bytes (e.g., 168 for SHAKE128)
* - const unsigned char *m: pointer to input to be absorbed into s
* - unsigned long long mlen: length of input in bytes
* - unsigned char p: domain-separation byte for different
* - uint32_t r: rate in bytes (e.g., 168 for SHAKE128)
* - const uint8_t *m: pointer to input to be absorbed into s
* - size_t mlen: length of input in bytes
* - uint8_t p: domain-separation byte for different
* Keccak-derived functions
**************************************************/
static void keccak_absorb(uint64_t *s, unsigned int r, const unsigned char *m,
unsigned long long mlen, unsigned char p) {
unsigned int i;
unsigned char t[200];
static void keccak_absorb(uint64_t *s, uint32_t r, const uint8_t *m,
size_t mlen, uint8_t p) {
size_t i;
uint8_t t[200];

/* Zero state */
for (i = 0; i < 25; ++i) {
@@ -387,19 +384,17 @@ static void keccak_absorb(uint64_t *s, unsigned int r, const unsigned char *m,
* Modifies the state. Can be called multiple times to keep
* squeezing, i.e., is incremental.
*
* Arguments: - unsigned char *h: pointer to output blocks
* - unsigned long long int nblocks: number of blocks to be
* Arguments: - uint8_t *h: pointer to output blocks
* - size_t nblocks: number of blocks to be
* squeezed (written to h)
* - uint64_t *s: pointer to input/output Keccak state
* - unsigned int r: rate in bytes (e.g., 168 for SHAKE128)
* - uint32_t r: rate in bytes (e.g., 168 for SHAKE128)
**************************************************/
static void keccak_squeezeblocks(unsigned char *h, unsigned long nblocks,
uint64_t *s, unsigned int r) {
unsigned int i;

static void keccak_squeezeblocks(uint8_t *h, size_t nblocks,
uint64_t *s, uint32_t r) {
while (nblocks > 0) {
KeccakF1600_StatePermute(s);
for (i = 0; i < (r >> 3); i++) {
for (size_t i = 0; i < (r >> 3); i++) {
store64(h + 8 * i, s[i]);
}
h += r;
@@ -414,12 +409,11 @@ static void keccak_squeezeblocks(unsigned char *h, unsigned long nblocks,
* non-incremental, starts by zeroeing the state.
*
* Arguments: - uint64_t *s: pointer to (uninitialized) output Keccak state
* - const unsigned char *input: pointer to input to be absorbed
* - const uint8_t *input: pointer to input to be absorbed
* into s
* - unsigned long long inlen: length of input in bytes
* - size_t inlen: length of input in bytes
**************************************************/
void shake128_absorb(uint64_t *s, const unsigned char *input,
unsigned long long inlen) {
void shake128_absorb(uint64_t *s, const uint8_t *input, size_t inlen) {
keccak_absorb(s, SHAKE128_RATE, input, inlen, 0x1F);
}

@@ -430,13 +424,12 @@ void shake128_absorb(uint64_t *s, const unsigned char *input,
* SHAKE128_RATE bytes each. Modifies the state. Can be called
* multiple times to keep squeezing, i.e., is incremental.
*
* Arguments: - unsigned char *output: pointer to output blocks
* - unsigned long long nblocks: number of blocks to be squeezed
* Arguments: - uint8_t *output: pointer to output blocks
* - size_t nblocks: number of blocks to be squeezed
* (written to output)
* - uint64_t *s: pointer to input/output Keccak state
**************************************************/
void shake128_squeezeblocks(unsigned char *output, unsigned long nblocks,
uint64_t *s) {
void shake128_squeezeblocks(uint8_t *output, size_t nblocks, uint64_t *s) {
keccak_squeezeblocks(output, nblocks, s, SHAKE128_RATE);
}

@@ -447,12 +440,11 @@ void shake128_squeezeblocks(unsigned char *output, unsigned long nblocks,
* non-incremental, starts by zeroeing the state.
*
* Arguments: - uint64_t *s: pointer to (uninitialized) output Keccak state
* - const unsigned char *input: pointer to input to be absorbed
* - const uint8_t *input: pointer to input to be absorbed
* into s
* - unsigned long long inlen: length of input in bytes
* - size_t inlen: length of input in bytes
**************************************************/
void shake256_absorb(uint64_t *s, const unsigned char *input,
unsigned long long inlen) {
void shake256_absorb(uint64_t *s, const uint8_t *input, size_t inlen) {
keccak_absorb(s, SHAKE256_RATE, input, inlen, 0x1F);
}

@@ -463,13 +455,12 @@ void shake256_absorb(uint64_t *s, const unsigned char *input,
* SHAKE256_RATE bytes each. Modifies the state. Can be called
* multiple times to keep squeezing, i.e., is incremental.
*
* Arguments: - unsigned char *output: pointer to output blocks
* - unsigned long long nblocks: number of blocks to be squeezed
* (written to output)
* Arguments: - uint8_t *output: pointer to output blocks
* - size_t nblocks: number of blocks to be squeezed
* (written to output)
* - uint64_t *s: pointer to input/output Keccak state
**************************************************/
void shake256_squeezeblocks(unsigned char *output, unsigned long nblocks,
uint64_t *s) {
void shake256_squeezeblocks(uint8_t *output, size_t nblocks, uint64_t *s) {
keccak_squeezeblocks(output, nblocks, s, SHAKE256_RATE);
}

@@ -478,16 +469,15 @@ void shake256_squeezeblocks(unsigned char *output, unsigned long nblocks,
*
* Description: SHAKE128 XOF with non-incremental API
*
* Arguments: - unsigned char *output: pointer to output
* - unsigned long long outlen: requested output length in bytes
* - const unsigned char *input: pointer to input
* - unsigned long long inlen: length of input in bytes
* Arguments: - uint8_t *output: pointer to output
* - size_t outlen: requested output length in bytes
* - const uint8_t *input: pointer to input
* - size_t inlen: length of input in bytes
**************************************************/
void shake128(unsigned char *output, unsigned long long outlen,
const unsigned char *input, unsigned long long inlen) {
unsigned int i;
unsigned long nblocks = outlen / SHAKE128_RATE;
unsigned char t[SHAKE128_RATE];
void shake128(uint8_t *output, size_t outlen,
const uint8_t *input, size_t inlen) {
size_t nblocks = outlen / SHAKE128_RATE;
uint8_t t[SHAKE128_RATE];
uint64_t s[25];

shake128_absorb(s, input, inlen);
@@ -498,7 +488,7 @@ void shake128(unsigned char *output, unsigned long long outlen,

if (outlen) {
shake128_squeezeblocks(t, 1, s);
for (i = 0; i < outlen; ++i) {
for (size_t i = 0; i < outlen; ++i) {
output[i] = t[i];
}
}
@@ -509,16 +499,15 @@ void shake128(unsigned char *output, unsigned long long outlen,
*
* Description: SHAKE256 XOF with non-incremental API
*
* Arguments: - unsigned char *output: pointer to output
* - unsigned long long outlen: requested output length in bytes
* - const unsigned char *input: pointer to input
* - unsigned long long inlen: length of input in bytes
* Arguments: - uint8_t *output: pointer to output
* - size_t outlen: requested output length in bytes
* - const uint8_t *input: pointer to input
* - size_t inlen: length of input in bytes
**************************************************/
void shake256(unsigned char *output, unsigned long long outlen,
const unsigned char *input, unsigned long long inlen) {
unsigned int i;
unsigned long nblocks = outlen / SHAKE256_RATE;
unsigned char t[SHAKE256_RATE];
void shake256(uint8_t *output, size_t outlen,
const uint8_t *input, size_t inlen) {
size_t nblocks = outlen / SHAKE256_RATE;
uint8_t t[SHAKE256_RATE];
uint64_t s[25];

shake256_absorb(s, input, inlen);
@@ -529,7 +518,7 @@ void shake256(unsigned char *output, unsigned long long outlen,

if (outlen) {
shake256_squeezeblocks(t, 1, s);
for (i = 0; i < outlen; ++i) {
for (size_t i = 0; i < outlen; ++i) {
output[i] = t[i];
}
}
@@ -540,15 +529,13 @@ void shake256(unsigned char *output, unsigned long long outlen,
*
* Description: SHA3-256 with non-incremental API
*
* Arguments: - unsigned char *output: pointer to output
* - const unsigned char *input: pointer to input
* - unsigned long long inlen: length of input in bytes
* Arguments: - uint8_t *output: pointer to output
* - const uint8_t *input: pointer to input
* - size_t inlen: length of input in bytes
**************************************************/
void sha3_256(unsigned char *output, const unsigned char *input,
unsigned long long inlen) {
void sha3_256(uint8_t *output, const uint8_t *input, size_t inlen) {
uint64_t s[25];
unsigned char t[SHA3_256_RATE];
size_t i;
uint8_t t[SHA3_256_RATE];

/* Absorb input */
keccak_absorb(s, SHA3_256_RATE, input, inlen, 0x06);
@@ -556,7 +543,7 @@ void sha3_256(unsigned char *output, const unsigned char *input,
/* Squeeze output */
keccak_squeezeblocks(t, 1, s, SHA3_256_RATE);

for (i = 0; i < 32; i++) {
for (size_t i = 0; i < 32; i++) {
output[i] = t[i];
}
}
@@ -566,15 +553,13 @@ void sha3_256(unsigned char *output, const unsigned char *input,
*
* Description: SHA3-512 with non-incremental API
*
* Arguments: - unsigned char *output: pointer to output
* - const unsigned char *input: pointer to input
* - unsigned long long inlen: length of input in bytes
* Arguments: - uint8_t *output: pointer to output
* - const uint8_t *input: pointer to input
* - size_t inlen: length of input in bytes
**************************************************/
void sha3_512(unsigned char *output, const unsigned char *input,
unsigned long long inlen) {
void sha3_512(uint8_t *output, const uint8_t *input, size_t inlen) {
uint64_t s[25];
unsigned char t[SHA3_512_RATE];
size_t i;
uint8_t t[SHA3_512_RATE];

/* Absorb input */
keccak_absorb(s, SHA3_512_RATE, input, inlen, 0x06);
@@ -582,7 +567,7 @@ void sha3_512(unsigned char *output, const unsigned char *input,
/* Squeeze output */
keccak_squeezeblocks(t, 1, s, SHA3_512_RATE);

for (i = 0; i < 64; i++) {
for (size_t i = 0; i < 64; i++) {
output[i] = t[i];
}
}

+ 11
- 16
common/fips202.h View File

@@ -1,6 +1,7 @@
#ifndef FIPS202_H
#define FIPS202_H

#include <stddef.h>
#include <stdint.h>

#define SHAKE128_RATE 168
@@ -8,27 +9,21 @@
#define SHA3_256_RATE 136
#define SHA3_512_RATE 72

void shake128_absorb(uint64_t *s, const unsigned char *input,
unsigned long long inlen);
void shake128_absorb(uint64_t *s, const uint8_t *input, size_t inlen);

void shake128_squeezeblocks(unsigned char *output, unsigned long nblocks,
uint64_t *s);
void shake128_squeezeblocks(uint8_t *output, size_t nblocks, uint64_t *s);

void shake256_absorb(uint64_t *s, const unsigned char *input,
unsigned long long inlen);
void shake256_absorb(uint64_t *s, const uint8_t *input, size_t inlen);

void shake256_squeezeblocks(unsigned char *output, unsigned long nblocks,
uint64_t *s);
void shake256_squeezeblocks(uint8_t *output, size_t nblocks, uint64_t *s);

void shake128(unsigned char *output, unsigned long long outlen,
const unsigned char *input, unsigned long long inlen);
void shake128(uint8_t *output, size_t outlen,
const uint8_t *input, size_t inlen);

void shake256(unsigned char *output, unsigned long long outlen,
const unsigned char *input, unsigned long long inlen);
void shake256(uint8_t *output, size_t outlen,
const uint8_t *input, size_t inlen);

void sha3_256(unsigned char *output, const unsigned char *input,
unsigned long long inlen);
void sha3_512(unsigned char *output, const unsigned char *input,
unsigned long long inlen);
void sha3_256(uint8_t *output, const uint8_t *input, size_t inlen);
void sha3_512(uint8_t *output, const uint8_t *input, size_t inlen);

#endif

+ 59
- 62
common/sha2.c View File

@@ -2,18 +2,19 @@
* crypto_hash/sha512/ref/ from http://bench.cr.yp.to/supercop.html
* by D. J. Bernstein */

#include "sha2.h"
#include <stddef.h>
#include <stdint.h>

typedef unsigned long long uint64;
#include "sha2.h"

static uint64 load_bigendian(const unsigned char *x) {
return (uint64)(x[7]) | (((uint64)(x[6])) << 8) | (((uint64)(x[5])) << 16) |
(((uint64)(x[4])) << 24) | (((uint64)(x[3])) << 32) |
(((uint64)(x[2])) << 40) | (((uint64)(x[1])) << 48) |
(((uint64)(x[0])) << 56);
static uint64_t load_bigendian(const unsigned char *x) {
return (uint64_t)(x[7]) | (((uint64_t)(x[6])) << 8) | (((uint64_t)(x[5])) << 16) |
(((uint64_t)(x[4])) << 24) | (((uint64_t)(x[3])) << 32) |
(((uint64_t)(x[2])) << 40) | (((uint64_t)(x[1])) << 48) |
(((uint64_t)(x[0])) << 56);
}

static void store_bigendian(unsigned char *x, uint64 u) {
static void store_bigendian(uint8_t *x, uint64_t u) {
x[7] = u;
u >>= 8;
x[6] = u;
@@ -73,20 +74,20 @@ static void store_bigendian(unsigned char *x, uint64 u) {
b = a; \
a = T1 + T2;

static int crypto_hashblocks_sha512(unsigned char *statebytes,
const unsigned char *in,
unsigned long long inlen) {
uint64 state[8];
uint64 a;
uint64 b;
uint64 c;
uint64 d;
uint64 e;
uint64 f;
uint64 g;
uint64 h;
uint64 T1;
uint64 T2;
static int crypto_hashblocks_sha512(uint8_t *statebytes,
const uint8_t *in,
size_t inlen) {
uint64_t state[8];
uint64_t a;
uint64_t b;
uint64_t c;
uint64_t d;
uint64_t e;
uint64_t f;
uint64_t g;
uint64_t h;
uint64_t T1;
uint64_t T2;

a = load_bigendian(statebytes + 0);
state[0] = a;
@@ -106,22 +107,22 @@ static int crypto_hashblocks_sha512(unsigned char *statebytes,
state[7] = h;

while (inlen >= 128) {
uint64 w0 = load_bigendian(in + 0);
uint64 w1 = load_bigendian(in + 8);
uint64 w2 = load_bigendian(in + 16);
uint64 w3 = load_bigendian(in + 24);
uint64 w4 = load_bigendian(in + 32);
uint64 w5 = load_bigendian(in + 40);
uint64 w6 = load_bigendian(in + 48);
uint64 w7 = load_bigendian(in + 56);
uint64 w8 = load_bigendian(in + 64);
uint64 w9 = load_bigendian(in + 72);
uint64 w10 = load_bigendian(in + 80);
uint64 w11 = load_bigendian(in + 88);
uint64 w12 = load_bigendian(in + 96);
uint64 w13 = load_bigendian(in + 104);
uint64 w14 = load_bigendian(in + 112);
uint64 w15 = load_bigendian(in + 120);
uint64_t w0 = load_bigendian(in + 0);
uint64_t w1 = load_bigendian(in + 8);
uint64_t w2 = load_bigendian(in + 16);
uint64_t w3 = load_bigendian(in + 24);
uint64_t w4 = load_bigendian(in + 32);
uint64_t w5 = load_bigendian(in + 40);
uint64_t w6 = load_bigendian(in + 48);
uint64_t w7 = load_bigendian(in + 56);
uint64_t w8 = load_bigendian(in + 64);
uint64_t w9 = load_bigendian(in + 72);
uint64_t w10 = load_bigendian(in + 80);
uint64_t w11 = load_bigendian(in + 88);
uint64_t w12 = load_bigendian(in + 96);
uint64_t w13 = load_bigendian(in + 104);
uint64_t w14 = load_bigendian(in + 112);
uint64_t w15 = load_bigendian(in + 120);

F(w0, 0x428a2f98d728ae22ULL)
F(w1, 0x7137449123ef65cdULL)
@@ -252,7 +253,7 @@ static int crypto_hashblocks_sha512(unsigned char *statebytes,

#define blocks crypto_hashblocks_sha512

static const unsigned char iv_384[64] = {
static const uint8_t iv_384[64] = {
0xcb, 0xbb, 0x9d, 0x5d, 0xc1, 0x05, 0x9e, 0xd8, 0x62, 0x9a, 0x29,
0x2a, 0x36, 0x7c, 0xd5, 0x07, 0x91, 0x59, 0x01, 0x5a, 0x30, 0x70,
0xdd, 0x17, 0x15, 0x2f, 0xec, 0xd8, 0xf7, 0x0e, 0x59, 0x39, 0x67,
@@ -261,7 +262,7 @@ static const unsigned char iv_384[64] = {
0xa7, 0x47, 0xb5, 0x48, 0x1d, 0xbe, 0xfa, 0x4f, 0xa4
};

static const unsigned char iv_512[64] = {
static const uint8_t iv_512[64] = {
0x6a, 0x09, 0xe6, 0x67, 0xf3, 0xbc, 0xc9, 0x08, 0xbb, 0x67, 0xae,
0x85, 0x84, 0xca, 0xa7, 0x3b, 0x3c, 0x6e, 0xf3, 0x72, 0xfe, 0x94,
0xf8, 0x2b, 0xa5, 0x4f, 0xf5, 0x3a, 0x5f, 0x1d, 0x36, 0xf1, 0x51,
@@ -270,14 +271,12 @@ static const unsigned char iv_512[64] = {
0x6b, 0x5b, 0xe0, 0xcd, 0x19, 0x13, 0x7e, 0x21, 0x79
};

int sha384(unsigned char *out, const unsigned char *in,
unsigned long long inlen) {
unsigned char h[64];
unsigned char padded[256];
unsigned int i;
unsigned long long bytes = inlen;
int sha384(uint8_t *out, const uint8_t *in, size_t inlen) {
uint8_t h[64];
uint8_t padded[256];
uint64_t bytes = inlen;

for (i = 0; i < 64; ++i) {
for (size_t i = 0; i < 64; ++i) {
h[i] = iv_384[i];
}

@@ -286,13 +285,13 @@ int sha384(unsigned char *out, const unsigned char *in,
inlen &= 127;
in -= inlen;

for (i = 0; i < inlen; ++i) {
for (size_t i = 0; i < inlen; ++i) {
padded[i] = in[i];
}
padded[inlen] = 0x80;

if (inlen < 112) {
for (i = inlen + 1; i < 119; ++i) {
for (size_t i = inlen + 1; i < 119; ++i) {
padded[i] = 0;
}
padded[119] = bytes >> 61;
@@ -306,7 +305,7 @@ int sha384(unsigned char *out, const unsigned char *in,
padded[127] = bytes << 3;
blocks(h, padded, 128);
} else {
for (i = inlen + 1; i < 247; ++i) {
for (size_t i = inlen + 1; i < 247; ++i) {
padded[i] = 0;
}
padded[247] = bytes >> 61;
@@ -321,21 +320,19 @@ int sha384(unsigned char *out, const unsigned char *in,
blocks(h, padded, 256);
}

for (i = 0; i < 48; ++i) {
for (size_t i = 0; i < 48; ++i) {
out[i] = h[i];
}

return 0;
}

int sha512(unsigned char *out, const unsigned char *in,
unsigned long long inlen) {
unsigned char h[64];
unsigned char padded[256];
unsigned int i;
unsigned long long bytes = inlen;
int sha512(uint8_t *out, const uint8_t *in, size_t inlen) {
uint8_t h[64];
uint8_t padded[256];
uint64_t bytes = inlen;

for (i = 0; i < 64; ++i) {
for (size_t i = 0; i < 64; ++i) {
h[i] = iv_512[i];
}

@@ -344,13 +341,13 @@ int sha512(unsigned char *out, const unsigned char *in,
inlen &= 127;
in -= inlen;

for (i = 0; i < inlen; ++i) {
for (size_t i = 0; i < inlen; ++i) {
padded[i] = in[i];
}
padded[inlen] = 0x80;

if (inlen < 112) {
for (i = inlen + 1; i < 119; ++i) {
for (size_t i = inlen + 1; i < 119; ++i) {
padded[i] = 0;
}
padded[119] = bytes >> 61;
@@ -364,7 +361,7 @@ int sha512(unsigned char *out, const unsigned char *in,
padded[127] = bytes << 3;
blocks(h, padded, 128);
} else {
for (i = inlen + 1; i < 247; ++i) {
for (size_t i = inlen + 1; i < 247; ++i) {
padded[i] = 0;
}
padded[247] = bytes >> 61;
@@ -379,7 +376,7 @@ int sha512(unsigned char *out, const unsigned char *in,
blocks(h, padded, 256);
}

for (i = 0; i < 64; ++i) {
for (size_t i = 0; i < 64; ++i) {
out[i] = h[i];
}



+ 2
- 4
common/sha2.h View File

@@ -1,9 +1,7 @@
#ifndef SHA2_H
#define SHA2_H

int sha384(unsigned char *out, const unsigned char *in,
unsigned long long inlen);
int sha512(unsigned char *out, const unsigned char *in,
unsigned long long inlen);
int sha384(uint8_t *out, const uint8_t *in, size_t inlen);
int sha512(uint8_t *out, const uint8_t *in, size_t inlen);

#endif

Write Preview
Loading…
Cancel
Save