From: Rusty Russell Date: Wed, 8 Jul 2015 06:34:50 +0000 (+0930) Subject: crypto/ripemd160: new module. X-Git-Url: http://git.ozlabs.org/?a=commitdiff_plain;h=0a76c98f726514245389587c1d361d9281198280;p=ccan crypto/ripemd160: new module. Signed-off-by: Rusty Russell --- diff --git a/Makefile-ccan b/Makefile-ccan index 5cc06d97..48b56919 100644 --- a/Makefile-ccan +++ b/Makefile-ccan @@ -48,6 +48,7 @@ MODS_WITH_SRC := antithread \ crc \ crcsync \ cpuid \ + crypto/ripemd160 \ crypto/sha256 \ crypto/shachain \ daemonize \ diff --git a/ccan/crypto/ripemd160/LICENSE b/ccan/crypto/ripemd160/LICENSE new file mode 120000 index 00000000..2b1feca5 --- /dev/null +++ b/ccan/crypto/ripemd160/LICENSE @@ -0,0 +1 @@ +../../../licenses/BSD-MIT \ No newline at end of file diff --git a/ccan/crypto/ripemd160/_info b/ccan/crypto/ripemd160/_info new file mode 100644 index 00000000..4df7d4d2 --- /dev/null +++ b/ccan/crypto/ripemd160/_info @@ -0,0 +1,55 @@ +#include "config.h" +#include +#include + +/** + * crypto/ripemd160 - implementation of RIPEMD 160 bit digest algorithm. + * + * This code is either a wrapper for openssl (if CCAN_CRYPTO_RIPEMD160_USE_OPENSSL + * is defined) or an open-coded implementation based on Bitcoin's. + * + * License: BSD-MIT + * Maintainer: Rusty Russell + * + * Example: + * #include + * #include + * #include + * #include + * + * // Simple demonstration: idential strings will have the same hash, but + * // two different strings will not. + * int main(int argc, char *argv[]) + * { + * struct ripemd160 hash1, hash2; + * + * if (argc != 3) + * errx(1, "Usage: %s ", argv[0]); + * + * ripemd160(&hash1, argv[1], strlen(argv[1])); + * ripemd160(&hash2, argv[2], strlen(argv[2])); + * printf("Hash is %s\n", memcmp(&hash1, &hash2, sizeof(hash1)) + * ? "different" : "same"); + * return 0; + * } + */ +int main(int argc, char *argv[]) +{ + /* Expect exactly one argument */ + if (argc != 2) + return 1; + + if (strcmp(argv[1], "depends") == 0) { + printf("ccan/endian\n"); + return 0; + } + + if (strcmp(argv[1], "libs") == 0) { +#ifdef CCAN_CRYPTO_RIPEMD160_USE_OPENSSL + printf("crypto\n"); +#endif + return 0; + } + + return 1; +} diff --git a/ccan/crypto/ripemd160/ripemd160.c b/ccan/crypto/ripemd160/ripemd160.c new file mode 100644 index 00000000..46a6c950 --- /dev/null +++ b/ccan/crypto/ripemd160/ripemd160.c @@ -0,0 +1,408 @@ +/* MIT (BSD) license - see LICENSE file for details */ +/* RIPEMD core code translated from the Bitcoin project's C++: + * + * src/crypto/ripemd160.cpp commit f914f1a746d7f91951c1da262a4a749dd3ebfa71 + * Copyright (c) 2014 The Bitcoin Core developers + * Distributed under the MIT software license, see the accompanying + * file COPYING or http://www.opensource.org/licenses/mit-license.php. + */ +#include +#include +#include +#include +#include + +static void invalidate_ripemd160(struct ripemd160_ctx *ctx) +{ +#ifdef CCAN_CRYPTO_RIPEMD160_USE_OPENSSL + ctx->c.num = -1U; +#else + ctx->bytes = -1ULL; +#endif +} + +static void check_ripemd160(struct ripemd160_ctx *ctx) +{ +#ifdef CCAN_CRYPTO_RIPEMD160_USE_OPENSSL + assert(ctx->c.num != -1U); +#else + assert(ctx->bytes != -1ULL); +#endif +} + +#ifdef CCAN_CRYPTO_RIPEMD160_USE_OPENSSL +void ripemd160_init(struct ripemd160_ctx *ctx) +{ + RIPEMD160_Init(&ctx->c); +} + +void ripemd160_update(struct ripemd160_ctx *ctx, const void *p, size_t size) +{ + check_ripemd160(ctx); + RIPEMD160_Update(&ctx->c, p, size); +} + +void ripemd160_done(struct ripemd160_ctx *ctx, struct ripemd160 *res) +{ + RIPEMD160_Final(res->u.u8, &ctx->c); + invalidate_ripemd160(ctx); +} +#else +static uint32_t inline f1(uint32_t x, uint32_t y, uint32_t z) { return x ^ y ^ z; } +static uint32_t inline f2(uint32_t x, uint32_t y, uint32_t z) { return (x & y) | (~x & z); } +static uint32_t inline f3(uint32_t x, uint32_t y, uint32_t z) { return (x | ~y) ^ z; } +static uint32_t inline f4(uint32_t x, uint32_t y, uint32_t z) { return (x & z) | (y & ~z); } +static uint32_t inline f5(uint32_t x, uint32_t y, uint32_t z) { return x ^ (y | ~z); } + +/** Initialize RIPEMD-160 state. */ +static void inline Initialize(uint32_t* s) +{ + s[0] = 0x67452301ul; + s[1] = 0xEFCDAB89ul; + s[2] = 0x98BADCFEul; + s[3] = 0x10325476ul; + s[4] = 0xC3D2E1F0ul; +} + +static uint32_t inline rol(uint32_t x, int i) { return (x << i) | (x >> (32 - i)); } + +static void inline Round(uint32_t *a, uint32_t b, uint32_t *c, uint32_t d, uint32_t e, uint32_t f, uint32_t x, uint32_t k, int r) +{ + *a = rol(*a + f + x + k, r) + e; + *c = rol(*c, 10); +} + +static void inline R11(uint32_t *a, uint32_t b, uint32_t *c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f1(b, *c, d), x, 0, r); } +static void inline R21(uint32_t *a, uint32_t b, uint32_t *c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f2(b, *c, d), x, 0x5A827999ul, r); } +static void inline R31(uint32_t *a, uint32_t b, uint32_t *c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f3(b, *c, d), x, 0x6ED9EBA1ul, r); } +static void inline R41(uint32_t *a, uint32_t b, uint32_t *c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f4(b, *c, d), x, 0x8F1BBCDCul, r); } +static void inline R51(uint32_t *a, uint32_t b, uint32_t *c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f5(b, *c, d), x, 0xA953FD4Eul, r); } + +static void inline R12(uint32_t *a, uint32_t b, uint32_t *c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f5(b, *c, d), x, 0x50A28BE6ul, r); } +static void inline R22(uint32_t *a, uint32_t b, uint32_t *c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f4(b, *c, d), x, 0x5C4DD124ul, r); } +static void inline R32(uint32_t *a, uint32_t b, uint32_t *c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f3(b, *c, d), x, 0x6D703EF3ul, r); } +static void inline R42(uint32_t *a, uint32_t b, uint32_t *c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f2(b, *c, d), x, 0x7A6D76E9ul, r); } +static void inline R52(uint32_t *a, uint32_t b, uint32_t *c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f1(b, *c, d), x, 0, r); } + +/** Perform a RIPEMD-160 transformation, processing a 64-byte chunk. */ +static void Transform(uint32_t *s, const uint32_t *chunk) +{ + uint32_t a1 = s[0], b1 = s[1], c1 = s[2], d1 = s[3], e1 = s[4]; + uint32_t a2 = a1, b2 = b1, c2 = c1, d2 = d1, e2 = e1; + uint32_t w0 = le32_to_cpu(chunk[0]), w1 = le32_to_cpu(chunk[1]), w2 = le32_to_cpu(chunk[2]), w3 = le32_to_cpu(chunk[3]); + uint32_t w4 = le32_to_cpu(chunk[4]), w5 = le32_to_cpu(chunk[5]), w6 = le32_to_cpu(chunk[6]), w7 = le32_to_cpu(chunk[7]); + uint32_t w8 = le32_to_cpu(chunk[8]), w9 = le32_to_cpu(chunk[9]), w10 = le32_to_cpu(chunk[10]), w11 = le32_to_cpu(chunk[11]); + uint32_t w12 = le32_to_cpu(chunk[12]), w13 = le32_to_cpu(chunk[13]), w14 = le32_to_cpu(chunk[14]), w15 = le32_to_cpu(chunk[15]); + + R11(&a1, b1, &c1, d1, e1, w0, 11); + R12(&a2, b2, &c2, d2, e2, w5, 8); + R11(&e1, a1, &b1, c1, d1, w1, 14); + R12(&e2, a2, &b2, c2, d2, w14, 9); + R11(&d1, e1, &a1, b1, c1, w2, 15); + R12(&d2, e2, &a2, b2, c2, w7, 9); + R11(&c1, d1, &e1, a1, b1, w3, 12); + R12(&c2, d2, &e2, a2, b2, w0, 11); + R11(&b1, c1, &d1, e1, a1, w4, 5); + R12(&b2, c2, &d2, e2, a2, w9, 13); + R11(&a1, b1, &c1, d1, e1, w5, 8); + R12(&a2, b2, &c2, d2, e2, w2, 15); + R11(&e1, a1, &b1, c1, d1, w6, 7); + R12(&e2, a2, &b2, c2, d2, w11, 15); + R11(&d1, e1, &a1, b1, c1, w7, 9); + R12(&d2, e2, &a2, b2, c2, w4, 5); + R11(&c1, d1, &e1, a1, b1, w8, 11); + R12(&c2, d2, &e2, a2, b2, w13, 7); + R11(&b1, c1, &d1, e1, a1, w9, 13); + R12(&b2, c2, &d2, e2, a2, w6, 7); + R11(&a1, b1, &c1, d1, e1, w10, 14); + R12(&a2, b2, &c2, d2, e2, w15, 8); + R11(&e1, a1, &b1, c1, d1, w11, 15); + R12(&e2, a2, &b2, c2, d2, w8, 11); + R11(&d1, e1, &a1, b1, c1, w12, 6); + R12(&d2, e2, &a2, b2, c2, w1, 14); + R11(&c1, d1, &e1, a1, b1, w13, 7); + R12(&c2, d2, &e2, a2, b2, w10, 14); + R11(&b1, c1, &d1, e1, a1, w14, 9); + R12(&b2, c2, &d2, e2, a2, w3, 12); + R11(&a1, b1, &c1, d1, e1, w15, 8); + R12(&a2, b2, &c2, d2, e2, w12, 6); + + R21(&e1, a1, &b1, c1, d1, w7, 7); + R22(&e2, a2, &b2, c2, d2, w6, 9); + R21(&d1, e1, &a1, b1, c1, w4, 6); + R22(&d2, e2, &a2, b2, c2, w11, 13); + R21(&c1, d1, &e1, a1, b1, w13, 8); + R22(&c2, d2, &e2, a2, b2, w3, 15); + R21(&b1, c1, &d1, e1, a1, w1, 13); + R22(&b2, c2, &d2, e2, a2, w7, 7); + R21(&a1, b1, &c1, d1, e1, w10, 11); + R22(&a2, b2, &c2, d2, e2, w0, 12); + R21(&e1, a1, &b1, c1, d1, w6, 9); + R22(&e2, a2, &b2, c2, d2, w13, 8); + R21(&d1, e1, &a1, b1, c1, w15, 7); + R22(&d2, e2, &a2, b2, c2, w5, 9); + R21(&c1, d1, &e1, a1, b1, w3, 15); + R22(&c2, d2, &e2, a2, b2, w10, 11); + R21(&b1, c1, &d1, e1, a1, w12, 7); + R22(&b2, c2, &d2, e2, a2, w14, 7); + R21(&a1, b1, &c1, d1, e1, w0, 12); + R22(&a2, b2, &c2, d2, e2, w15, 7); + R21(&e1, a1, &b1, c1, d1, w9, 15); + R22(&e2, a2, &b2, c2, d2, w8, 12); + R21(&d1, e1, &a1, b1, c1, w5, 9); + R22(&d2, e2, &a2, b2, c2, w12, 7); + R21(&c1, d1, &e1, a1, b1, w2, 11); + R22(&c2, d2, &e2, a2, b2, w4, 6); + R21(&b1, c1, &d1, e1, a1, w14, 7); + R22(&b2, c2, &d2, e2, a2, w9, 15); + R21(&a1, b1, &c1, d1, e1, w11, 13); + R22(&a2, b2, &c2, d2, e2, w1, 13); + R21(&e1, a1, &b1, c1, d1, w8, 12); + R22(&e2, a2, &b2, c2, d2, w2, 11); + + R31(&d1, e1, &a1, b1, c1, w3, 11); + R32(&d2, e2, &a2, b2, c2, w15, 9); + R31(&c1, d1, &e1, a1, b1, w10, 13); + R32(&c2, d2, &e2, a2, b2, w5, 7); + R31(&b1, c1, &d1, e1, a1, w14, 6); + R32(&b2, c2, &d2, e2, a2, w1, 15); + R31(&a1, b1, &c1, d1, e1, w4, 7); + R32(&a2, b2, &c2, d2, e2, w3, 11); + R31(&e1, a1, &b1, c1, d1, w9, 14); + R32(&e2, a2, &b2, c2, d2, w7, 8); + R31(&d1, e1, &a1, b1, c1, w15, 9); + R32(&d2, e2, &a2, b2, c2, w14, 6); + R31(&c1, d1, &e1, a1, b1, w8, 13); + R32(&c2, d2, &e2, a2, b2, w6, 6); + R31(&b1, c1, &d1, e1, a1, w1, 15); + R32(&b2, c2, &d2, e2, a2, w9, 14); + R31(&a1, b1, &c1, d1, e1, w2, 14); + R32(&a2, b2, &c2, d2, e2, w11, 12); + R31(&e1, a1, &b1, c1, d1, w7, 8); + R32(&e2, a2, &b2, c2, d2, w8, 13); + R31(&d1, e1, &a1, b1, c1, w0, 13); + R32(&d2, e2, &a2, b2, c2, w12, 5); + R31(&c1, d1, &e1, a1, b1, w6, 6); + R32(&c2, d2, &e2, a2, b2, w2, 14); + R31(&b1, c1, &d1, e1, a1, w13, 5); + R32(&b2, c2, &d2, e2, a2, w10, 13); + R31(&a1, b1, &c1, d1, e1, w11, 12); + R32(&a2, b2, &c2, d2, e2, w0, 13); + R31(&e1, a1, &b1, c1, d1, w5, 7); + R32(&e2, a2, &b2, c2, d2, w4, 7); + R31(&d1, e1, &a1, b1, c1, w12, 5); + R32(&d2, e2, &a2, b2, c2, w13, 5); + + R41(&c1, d1, &e1, a1, b1, w1, 11); + R42(&c2, d2, &e2, a2, b2, w8, 15); + R41(&b1, c1, &d1, e1, a1, w9, 12); + R42(&b2, c2, &d2, e2, a2, w6, 5); + R41(&a1, b1, &c1, d1, e1, w11, 14); + R42(&a2, b2, &c2, d2, e2, w4, 8); + R41(&e1, a1, &b1, c1, d1, w10, 15); + R42(&e2, a2, &b2, c2, d2, w1, 11); + R41(&d1, e1, &a1, b1, c1, w0, 14); + R42(&d2, e2, &a2, b2, c2, w3, 14); + R41(&c1, d1, &e1, a1, b1, w8, 15); + R42(&c2, d2, &e2, a2, b2, w11, 14); + R41(&b1, c1, &d1, e1, a1, w12, 9); + R42(&b2, c2, &d2, e2, a2, w15, 6); + R41(&a1, b1, &c1, d1, e1, w4, 8); + R42(&a2, b2, &c2, d2, e2, w0, 14); + R41(&e1, a1, &b1, c1, d1, w13, 9); + R42(&e2, a2, &b2, c2, d2, w5, 6); + R41(&d1, e1, &a1, b1, c1, w3, 14); + R42(&d2, e2, &a2, b2, c2, w12, 9); + R41(&c1, d1, &e1, a1, b1, w7, 5); + R42(&c2, d2, &e2, a2, b2, w2, 12); + R41(&b1, c1, &d1, e1, a1, w15, 6); + R42(&b2, c2, &d2, e2, a2, w13, 9); + R41(&a1, b1, &c1, d1, e1, w14, 8); + R42(&a2, b2, &c2, d2, e2, w9, 12); + R41(&e1, a1, &b1, c1, d1, w5, 6); + R42(&e2, a2, &b2, c2, d2, w7, 5); + R41(&d1, e1, &a1, b1, c1, w6, 5); + R42(&d2, e2, &a2, b2, c2, w10, 15); + R41(&c1, d1, &e1, a1, b1, w2, 12); + R42(&c2, d2, &e2, a2, b2, w14, 8); + + R51(&b1, c1, &d1, e1, a1, w4, 9); + R52(&b2, c2, &d2, e2, a2, w12, 8); + R51(&a1, b1, &c1, d1, e1, w0, 15); + R52(&a2, b2, &c2, d2, e2, w15, 5); + R51(&e1, a1, &b1, c1, d1, w5, 5); + R52(&e2, a2, &b2, c2, d2, w10, 12); + R51(&d1, e1, &a1, b1, c1, w9, 11); + R52(&d2, e2, &a2, b2, c2, w4, 9); + R51(&c1, d1, &e1, a1, b1, w7, 6); + R52(&c2, d2, &e2, a2, b2, w1, 12); + R51(&b1, c1, &d1, e1, a1, w12, 8); + R52(&b2, c2, &d2, e2, a2, w5, 5); + R51(&a1, b1, &c1, d1, e1, w2, 13); + R52(&a2, b2, &c2, d2, e2, w8, 14); + R51(&e1, a1, &b1, c1, d1, w10, 12); + R52(&e2, a2, &b2, c2, d2, w7, 6); + R51(&d1, e1, &a1, b1, c1, w14, 5); + R52(&d2, e2, &a2, b2, c2, w6, 8); + R51(&c1, d1, &e1, a1, b1, w1, 12); + R52(&c2, d2, &e2, a2, b2, w2, 13); + R51(&b1, c1, &d1, e1, a1, w3, 13); + R52(&b2, c2, &d2, e2, a2, w13, 6); + R51(&a1, b1, &c1, d1, e1, w8, 14); + R52(&a2, b2, &c2, d2, e2, w14, 5); + R51(&e1, a1, &b1, c1, d1, w11, 11); + R52(&e2, a2, &b2, c2, d2, w0, 15); + R51(&d1, e1, &a1, b1, c1, w6, 8); + R52(&d2, e2, &a2, b2, c2, w3, 13); + R51(&c1, d1, &e1, a1, b1, w15, 5); + R52(&c2, d2, &e2, a2, b2, w9, 11); + R51(&b1, c1, &d1, e1, a1, w13, 6); + R52(&b2, c2, &d2, e2, a2, w11, 11); + + uint32_t t = s[0]; + s[0] = s[1] + c1 + d2; + s[1] = s[2] + d1 + e2; + s[2] = s[3] + e1 + a2; + s[3] = s[4] + a1 + b2; + s[4] = t + b1 + c2; +} + +static bool alignment_ok(const void *p, size_t n) +{ +#if HAVE_UNALIGNED_ACCESS + return true; +#else + return ((size_t)p % n == 0); +#endif +} + +static void add(struct ripemd160_ctx *ctx, const void *p, size_t len) +{ + const unsigned char *data = p; + size_t bufsize = ctx->bytes % 64; + + if (bufsize + len >= 64) { + // Fill the buffer, and process it. + memcpy(ctx->buf.u8 + bufsize, data, 64 - bufsize); + ctx->bytes += 64 - bufsize; + data += 64 - bufsize; + len -= 64 - bufsize; + Transform(ctx->s, ctx->buf.u32); + bufsize = 0; + } + + while (len >= 64) { + // Process full chunks directly from the source. + if (alignment_ok(data, sizeof(uint32_t))) + Transform(ctx->s, (const uint32_t *)data); + else { + memcpy(ctx->buf.u8, data, sizeof(ctx->buf)); + Transform(ctx->s, ctx->buf.u32); + } + ctx->bytes += 64; + data += 64; + len -= 64; + } + + if (len) { + // Fill the buffer with what remains. + memcpy(ctx->buf.u8 + bufsize, data, len); + ctx->bytes += len; + } +} + +void ripemd160_init(struct ripemd160_ctx *ctx) +{ + struct ripemd160_ctx init = RIPEMD160_INIT; + *ctx = init; +} + +void ripemd160_update(struct ripemd160_ctx *ctx, const void *p, size_t size) +{ + check_ripemd160(ctx); + add(ctx, p, size); +} + +void ripemd160_done(struct ripemd160_ctx *ctx, struct ripemd160 *res) +{ + static const unsigned char pad[64] = {0x80}; + uint64_t sizedesc; + size_t i; + + sizedesc = cpu_to_le64(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 number of bits of data (big endian) */ + add(ctx, &sizedesc, 8); + for (i = 0; i < sizeof(ctx->s) / sizeof(ctx->s[0]); i++) + res->u.u32[i] = cpu_to_le32(ctx->s[i]); + invalidate_ripemd160(ctx); +} +#endif + +void ripemd160(struct ripemd160 *sha, const void *p, size_t size) +{ + struct ripemd160_ctx ctx; + + ripemd160_init(&ctx); + ripemd160_update(&ctx, p, size); + ripemd160_done(&ctx, sha); +} + +void ripemd160_u8(struct ripemd160_ctx *ctx, uint8_t v) +{ + ripemd160_update(ctx, &v, sizeof(v)); +} + +void ripemd160_u16(struct ripemd160_ctx *ctx, uint16_t v) +{ + ripemd160_update(ctx, &v, sizeof(v)); +} + +void ripemd160_u32(struct ripemd160_ctx *ctx, uint32_t v) +{ + ripemd160_update(ctx, &v, sizeof(v)); +} + +void ripemd160_u64(struct ripemd160_ctx *ctx, uint64_t v) +{ + ripemd160_update(ctx, &v, sizeof(v)); +} + +/* Add as little-endian */ +void ripemd160_le16(struct ripemd160_ctx *ctx, uint16_t v) +{ + leint16_t lev = cpu_to_le16(v); + ripemd160_update(ctx, &lev, sizeof(lev)); +} + +void ripemd160_le32(struct ripemd160_ctx *ctx, uint32_t v) +{ + leint32_t lev = cpu_to_le32(v); + ripemd160_update(ctx, &lev, sizeof(lev)); +} + +void ripemd160_le64(struct ripemd160_ctx *ctx, uint64_t v) +{ + leint64_t lev = cpu_to_le64(v); + ripemd160_update(ctx, &lev, sizeof(lev)); +} + +/* Add as big-endian */ +void ripemd160_be16(struct ripemd160_ctx *ctx, uint16_t v) +{ + beint16_t bev = cpu_to_be16(v); + ripemd160_update(ctx, &bev, sizeof(bev)); +} + +void ripemd160_be32(struct ripemd160_ctx *ctx, uint32_t v) +{ + beint32_t bev = cpu_to_be32(v); + ripemd160_update(ctx, &bev, sizeof(bev)); +} + +void ripemd160_be64(struct ripemd160_ctx *ctx, uint64_t v) +{ + beint64_t bev = cpu_to_be64(v); + ripemd160_update(ctx, &bev, sizeof(bev)); +} diff --git a/ccan/crypto/ripemd160/ripemd160.h b/ccan/crypto/ripemd160/ripemd160.h new file mode 100644 index 00000000..e29e42bb --- /dev/null +++ b/ccan/crypto/ripemd160/ripemd160.h @@ -0,0 +1,148 @@ +#ifndef CCAN_CRYPTO_RIPEMD160_H +#define CCAN_CRYPTO_RIPEMD160_H +/* BSD-MIT - see LICENSE file for details */ +#include "config.h" +#include +#include + +/* Uncomment this to use openssl's RIPEMD160 routines (and link with -lcrypto) */ +//#define CCAN_CRYPTO_RIPEMD160_USE_OPENSSL 1 + +#ifdef CCAN_CRYPTO_RIPEMD160_USE_OPENSSL +#include +#endif + +/** + * struct ripemd160 - structure representing a completed RIPEMD160. + * @u.u8: an unsigned char array. + * @u.u32: a 32-bit integer array. + * + * Other fields may be added to the union in future. + */ +struct ripemd160 { + union { + /* Array of chars */ + unsigned char u8[20]; + /* Array of uint32_t */ + uint32_t u32[5]; + } u; +}; + +/** + * ripemd160 - return ripemd160 of an object. + * @ripemd160: the ripemd160 to fill in + * @p: pointer to memory, + * @size: the number of bytes pointed to by @p + * + * The bytes pointed to by @p is RIPEMD160 hashed into @ripemd160. This is + * equivalent to ripemd160_init(), ripemd160_update() then ripemd160_done(). + */ +void ripemd160(struct ripemd160 *sha, const void *p, size_t size); + +/** + * struct ripemd160_ctx - structure to store running context for ripemd160 + */ +struct ripemd160_ctx { +#ifdef CCAN_CRYPTO_RIPEMD160_USE_OPENSSL + RIPEMD160_CTX c; +#else + uint32_t s[5]; + uint64_t bytes; + union { + uint32_t u32[8]; + unsigned char u8[64]; + } buf; +#endif +}; + +/** + * ripemd160_init - initialize an RIPEMD160 context. + * @ctx: the ripemd160_ctx to initialize + * + * This must be called before ripemd160_update or ripemd160_done, or + * alternately you can assign RIPEMD160_INIT. + * + * If it was already initialized, this forgets anything which was + * hashed before. + * + * Example: + * static void hash_all(const char **arr, struct ripemd160 *hash) + * { + * size_t i; + * struct ripemd160_ctx ctx; + * + * ripemd160_init(&ctx); + * for (i = 0; arr[i]; i++) + * ripemd160_update(&ctx, arr[i], strlen(arr[i])); + * ripemd160_done(&ctx, hash); + * } + */ +void ripemd160_init(struct ripemd160_ctx *ctx); + +/** + * RIPEMD160_INIT - initializer for an RIPEMD160 context. + * + * This can be used to staticly initialize an RIPEMD160 context (instead + * of ripemd160_init()). + * + * Example: + * static void hash_all(const char **arr, struct ripemd160 *hash) + * { + * size_t i; + * struct ripemd160_ctx ctx = RIPEMD160_INIT; + * + * for (i = 0; arr[i]; i++) + * ripemd160_update(&ctx, arr[i], strlen(arr[i])); + * ripemd160_done(&ctx, hash); + * } + */ +#ifdef CCAN_CRYPTO_RIPEMD160_USE_OPENSSL +#define RIPEMD160_INIT \ + { { 0x67452301ul, 0xEFCDAB89ul, 0x98BADCFEul, 0x10325476ul, \ + 0xC3D2E1F0ul, \ + 0x0, 0x0, \ + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, \ + 0 } } +#else +#define RIPEMD160_INIT \ + { { 0x67452301ul, 0xEFCDAB89ul, 0x98BADCFEul, 0x10325476ul, \ + 0xC3D2E1F0ul }, 0 } +#endif + +/** + * ripemd160_update - include some memory in the hash. + * @ctx: the ripemd160_ctx to use + * @p: pointer to memory, + * @size: the number of bytes pointed to by @p + * + * You can call this multiple times to hash more data, before calling + * ripemd160_done(). + */ +void ripemd160_update(struct ripemd160_ctx *ctx, const void *p, size_t size); + +/** + * ripemd160_done - finish RIPEMD160 and return the hash + * @ctx: the ripemd160_ctx to complete + * @res: the hash to return. + * + * Note that @ctx is *destroyed* by this, and must be reinitialized. + * To avoid that, pass a copy instead. + */ +void ripemd160_done(struct ripemd160_ctx *ripemd160, struct ripemd160 *res); + +/* Add various types to an RIPEMD160 hash */ +void ripemd160_u8(struct ripemd160_ctx *ctx, uint8_t v); +void ripemd160_u16(struct ripemd160_ctx *ctx, uint16_t v); +void ripemd160_u32(struct ripemd160_ctx *ctx, uint32_t v); +void ripemd160_u64(struct ripemd160_ctx *ctx, uint64_t v); + +/* Add as little-endian */ +void ripemd160_le16(struct ripemd160_ctx *ctx, uint16_t v); +void ripemd160_le32(struct ripemd160_ctx *ctx, uint32_t v); +void ripemd160_le64(struct ripemd160_ctx *ctx, uint64_t v); + +/* Add as big-endian */ +void ripemd160_be16(struct ripemd160_ctx *ctx, uint16_t v); +void ripemd160_be32(struct ripemd160_ctx *ctx, uint32_t v); +void ripemd160_be64(struct ripemd160_ctx *ctx, uint64_t v); +#endif /* CCAN_CRYPTO_RIPEMD160_H */ diff --git a/ccan/crypto/ripemd160/test/run-lotsa-data.c b/ccan/crypto/ripemd160/test/run-lotsa-data.c new file mode 100644 index 00000000..b35a96f0 --- /dev/null +++ b/ccan/crypto/ripemd160/test/run-lotsa-data.c @@ -0,0 +1,23 @@ +#include +/* Include the C files directly. */ +#include +#include + +int main(void) +{ + struct ripemd160 h, expected; + static const char zeroes[1000]; + size_t i; + + plan_tests(63); + + /* Test different alignments. */ + ripemd160(&expected, zeroes, sizeof(zeroes) - 64); + for (i = 1; i < 64; i++) { + ripemd160(&h, zeroes + i, sizeof(zeroes) - 64); + ok1(memcmp(&h, &expected, sizeof(h)) == 0); + } + + /* This exits depending on whether all tests passed */ + return exit_status(); +} diff --git a/ccan/crypto/ripemd160/test/run-test-vectors.c b/ccan/crypto/ripemd160/test/run-test-vectors.c new file mode 100644 index 00000000..70581c77 --- /dev/null +++ b/ccan/crypto/ripemd160/test/run-test-vectors.c @@ -0,0 +1,84 @@ +#include +/* Include the C files directly. */ +#include +#include + +/* Test vectors. */ +struct test { + const char *test; + size_t repetitions; + beint32_t result[5]; +}; + +/* Test vectors from: http://homes.esat.kuleuven.be/~bosselae/ripemd160.html */ +static struct test tests[] = { + { "", 1, + { CPU_TO_BE32(0x9c1185a5), CPU_TO_BE32(0xc5e9fc54), + CPU_TO_BE32(0x61280897), CPU_TO_BE32(0x7ee8f548), + CPU_TO_BE32(0xb2258d31) } }, + { "abc", 1, + { CPU_TO_BE32(0x8eb208f7), CPU_TO_BE32(0xe05d987a), + CPU_TO_BE32(0x9b044a8e), CPU_TO_BE32(0x98c6b087), + CPU_TO_BE32(0xf15a0bfc) } }, + { "message digest", 1, + { CPU_TO_BE32(0x5d0689ef), CPU_TO_BE32(0x49d2fae5), + CPU_TO_BE32(0x72b881b1), CPU_TO_BE32(0x23a85ffa), + CPU_TO_BE32(0x21595f36) } }, + { "abcdefghijklmnopqrstuvwxyz", 1, + { CPU_TO_BE32(0xf71c2710), CPU_TO_BE32(0x9c692c1b), + CPU_TO_BE32(0x56bbdceb), CPU_TO_BE32(0x5b9d2865), + CPU_TO_BE32(0xb3708dbc) } }, + { "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 1, + { CPU_TO_BE32(0x12a05338), CPU_TO_BE32(0x4a9c0c88), + CPU_TO_BE32(0xe405a06c), CPU_TO_BE32(0x27dcf49a), + CPU_TO_BE32(0xda62eb2b) } }, + { "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", 1, + { CPU_TO_BE32(0xb0e20b6e), CPU_TO_BE32(0x31166402), + CPU_TO_BE32(0x86ed3a87), CPU_TO_BE32(0xa5713079), + CPU_TO_BE32(0xb21f5189) } }, + { "1234567890", 8, + { CPU_TO_BE32(0x9b752e45), CPU_TO_BE32(0x573d4b39), + CPU_TO_BE32(0xf4dbd332), CPU_TO_BE32(0x3cab82bf), + CPU_TO_BE32(0x63326bfb) } }, + { "a", 1000000, + { CPU_TO_BE32(0x52783243), CPU_TO_BE32(0xc1697bdb), + CPU_TO_BE32(0xe16d37f9), CPU_TO_BE32(0x7f68f083), + CPU_TO_BE32(0x25dc1528) } } +}; + +static bool do_test(const struct test *t, bool single) +{ + struct ripemd160 h; + + if (single) { + if (t->repetitions != 1) + return true; + ripemd160(&h, t->test, strlen(t->test)); + } else { + struct ripemd160_ctx ctx = RIPEMD160_INIT; + size_t i; + + for (i = 0; i < t->repetitions; i++) + ripemd160_update(&ctx, t->test, strlen(t->test)); + ripemd160_done(&ctx, &h); + } + + return memcmp(&h.u, t->result, sizeof(t->result)) == 0; +} + +int main(void) +{ + size_t i; + + /* This is how many tests you plan to run */ + plan_tests(sizeof(tests) / sizeof(struct test) * 2); + + for (i = 0; i < sizeof(tests) / sizeof(struct test); i++) + ok1(do_test(&tests[i], false)); + + for (i = 0; i < sizeof(tests) / sizeof(struct test); i++) + ok1(do_test(&tests[i], true)); + + /* This exits depending on whether all tests passed */ + return exit_status(); +} diff --git a/ccan/crypto/ripemd160/test/run-types.c b/ccan/crypto/ripemd160/test/run-types.c new file mode 100644 index 00000000..50e1fcc3 --- /dev/null +++ b/ccan/crypto/ripemd160/test/run-types.c @@ -0,0 +1,63 @@ +#include +/* Include the C files directly. */ +#include +#include + +static unsigned char arr[] = { + 0x12, +#if HAVE_BIG_ENDIAN + /* u16 */ + 0x12, 0x34, + /* u32 */ + 0x12, 0x34, 0x56, 0x78, + /* u64 */ + 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, +#else + /* u16 */ + 0x34, 0x12, + /* u32 */ + 0x78, 0x56, 0x34, 0x12, + /* u64 */ + 0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12, +#endif + /* le16 */ + 0x34, 0x12, + /* le32 */ + 0x78, 0x56, 0x34, 0x12, + /* le64 */ + 0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12, + /* be16 */ + 0x12, 0x34, + /* be32 */ + 0x12, 0x34, 0x56, 0x78, + /* be64 */ + 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0 +}; + +int main(void) +{ + struct ripemd160 h, expected; + struct ripemd160_ctx ctx; + + /* This is how many tests you plan to run */ + plan_tests(1); + + ripemd160_init(&ctx); + ripemd160_u8(&ctx, 0x12); + ripemd160_u16(&ctx, 0x1234); + ripemd160_u32(&ctx, 0x12345678); + ripemd160_u64(&ctx, 0x123456789abcdef0ULL); + ripemd160_le16(&ctx, 0x1234); + ripemd160_le32(&ctx, 0x12345678); + ripemd160_le64(&ctx, 0x123456789abcdef0ULL); + ripemd160_be16(&ctx, 0x1234); + ripemd160_be32(&ctx, 0x12345678); + ripemd160_be64(&ctx, 0x123456789abcdef0ULL); + ripemd160_done(&ctx, &h); + + ripemd160(&expected, arr, sizeof(arr)); + ok1(memcmp(&h, &expected, sizeof(h)) == 0); + + /* This exits depending on whether all tests passed */ + return exit_status(); +}