*/
#include <ccan/crypto/sha256/sha256.h>
#include <ccan/endian/endian.h>
+ #include <ccan/compiler/compiler.h>
#include <stdbool.h>
#include <assert.h>
#include <string.h>
#ifdef CCAN_CRYPTO_SHA256_USE_OPENSSL
ctx->c.md_len = 0;
#else
- ctx->bytes = -1ULL;
+ ctx->bytes = (size_t)-1;
#endif
}
- static void check_sha256(struct sha256_ctx *ctx)
+ static void check_sha256(struct sha256_ctx *ctx UNUSED)
{
#ifdef CCAN_CRYPTO_SHA256_USE_OPENSSL
assert(ctx->c.md_len != 0);
#else
- assert(ctx->bytes != -1ULL);
+ assert(ctx->bytes != (size_t)-1);
#endif
}
s[7] += h;
}
- static bool alignment_ok(const void *p, size_t n)
+ static bool alignment_ok(const void *p UNUSED, size_t n UNUSED)
{
#if HAVE_UNALIGNED_ACCESS
return true;
size_t bufsize = ctx->bytes % 64;
if (bufsize + len >= 64) {
- // Fill the buffer, and process it.
+ /* Fill the buffer, and process it. */
memcpy(ctx->buf.u8 + bufsize, data, 64 - bufsize);
ctx->bytes += 64 - bufsize;
data += 64 - bufsize;
}
while (len >= 64) {
- // Process full chunks directly from the source.
+ /* Process full chunks directly from the source. */
if (alignment_ok(data, sizeof(uint32_t)))
Transform(ctx->s, (const uint32_t *)data);
else {
}
if (len) {
- // Fill the buffer with what remains.
+ /* Fill the buffer with what remains. */
memcpy(ctx->buf.u8 + bufsize, data, len);
ctx->bytes += len;
}
uint64_t sizedesc;
size_t i;
- sizedesc = cpu_to_be64(ctx->bytes << 3);
+ sizedesc = cpu_to_be64((uint64_t)ctx->bytes << 3);
/* Add '1' bit to terminate, then all 0 bits, up to next block - 8. */
- add(ctx, pad, 1 + ((119 - (ctx->bytes % 64)) % 64));
+ add(ctx, pad, 1 + ((128 - 8 - (ctx->bytes % 64) - 1) % 64));
/* Add number of bits of data (big endian) */
add(ctx, &sizedesc, 8);
for (i = 0; i < sizeof(ctx->s) / sizeof(ctx->s[0]); i++)
#include <stdlib.h>
/* Uncomment this to use openssl's SHA256 routines (and link with -lcrypto) */
-//#define CCAN_CRYPTO_SHA256_USE_OPENSSL 1
+/*#define CCAN_CRYPTO_SHA256_USE_OPENSSL 1*/
#ifdef CCAN_CRYPTO_SHA256_USE_OPENSSL
#include <openssl/sha.h>
*/
struct sha256 {
union {
- /* Array of chars */
- unsigned char u8[32];
- /* Array of uint32_t */
uint32_t u32[8];
+ unsigned char u8[32];
} u;
};
SHA256_CTX c;
#else
uint32_t s[8];
- uint64_t bytes;
union {
- uint32_t u32[8];
+ uint32_t u32[16];
unsigned char u8[64];
} buf;
+ size_t bytes;
#endif
};
/**
* SHA256_INIT - initializer for an SHA256 context.
*
- * This can be used to staticly initialize an SHA256 context (instead
+ * This can be used to statically initialize an SHA256 context (instead
* of sha256_init()).
*
* Example:
#else
#define SHA256_INIT \
{ { 0x6a09e667ul, 0xbb67ae85ul, 0x3c6ef372ul, 0xa54ff53aul, \
- 0x510e527ful, 0x9b05688cul, 0x1f83d9abul, 0x5be0cd19ul }, 0 }
+ 0x510e527ful, 0x9b05688cul, 0x1f83d9abul, 0x5be0cd19ul }, \
+ { { 0 } }, 0 }
#endif
/**