Rusty Russell
10 years ago
7 changed files with 782 additions and 0 deletions
@ -0,0 +1 @@ |
|||
../../../licenses/BSD-MIT |
@ -0,0 +1,55 @@ |
|||
#include "config.h" |
|||
#include <stdio.h> |
|||
#include <string.h> |
|||
|
|||
/** |
|||
* 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 <rusty@rustcorp.com.au> |
|||
* |
|||
* Example: |
|||
* #include <ccan/crypto/ripemd160/ripemd160.h> |
|||
* #include <err.h> |
|||
* #include <stdio.h> |
|||
* #include <string.h> |
|||
* |
|||
* // 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 <string1> <string2>", 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; |
|||
} |
@ -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 <ccan/crypto/ripemd160/ripemd160.h> |
|||
#include <ccan/endian/endian.h> |
|||
#include <stdbool.h> |
|||
#include <assert.h> |
|||
#include <string.h> |
|||
|
|||
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)); |
|||
} |
@ -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 <stdint.h> |
|||
#include <stdlib.h> |
|||
|
|||
/* 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 <openssl/ripemd.h> |
|||
#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 */ |
@ -0,0 +1,23 @@ |
|||
#include <ccan/crypto/ripemd160/ripemd160.h> |
|||
/* Include the C files directly. */ |
|||
#include <ccan/crypto/ripemd160/ripemd160.c> |
|||
#include <ccan/tap/tap.h> |
|||
|
|||
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(); |
|||
} |
@ -0,0 +1,84 @@ |
|||
#include <ccan/crypto/ripemd160/ripemd160.h> |
|||
/* Include the C files directly. */ |
|||
#include <ccan/crypto/ripemd160/ripemd160.c> |
|||
#include <ccan/tap/tap.h> |
|||
|
|||
/* 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(); |
|||
} |
@ -0,0 +1,63 @@ |
|||
#include <ccan/crypto/ripemd160/ripemd160.h> |
|||
/* Include the C files directly. */ |
|||
#include <ccan/crypto/ripemd160/ripemd160.c> |
|||
#include <ccan/tap/tap.h> |
|||
|
|||
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(); |
|||
} |
Loading…
Reference in new issue