[sheepdog] [PATCH] use GPL sha1 code instead of openssl
Liu Yuan
namei.unix at gmail.com
Tue Jul 10 10:23:20 CEST 2012
On 07/10/2012 04:17 PM, MORITA Kazutaka wrote:
> This uses GPL sha1 code (taken from open-iscsi) instead of OpenSSL to
> avoid OpenSSL and GPL license incompatibility issue.
>
> Signed-off-by: MORITA Kazutaka <morita.kazutaka at lab.ntt.co.jp>
> ---
> configure.ac | 4 -
> include/sha1.h | 27 ++++++++
> lib/Makefile.am | 2 +-
> lib/sha1.c | 168 ++++++++++++++++++++++++++++++++++++++++++++++++
> sheep/farm/farm.h | 2 +-
> sheep/farm/sha1_file.c | 16 ++--
> 6 files changed, 205 insertions(+), 14 deletions(-)
> create mode 100644 include/sha1.h
> create mode 100644 lib/sha1.c
>
> diff --git a/configure.ac b/configure.ac
> index 7a3e3ab..cef63ea 100644
> --- a/configure.ac
> +++ b/configure.ac
> @@ -280,10 +280,6 @@ if test "x${enable_accord}" = xyes; then
> fi
>
> if test "x${enable_farm}" = xyes; then
> - AC_CHECK_LIB([crypto], [SHA1_Init],,
> - AC_MSG_ERROR(libcrypto not found))
> - AC_CHECK_HEADERS([openssl/sha.h],,
> - AC_MSG_ERROR(sha.h header missing))
> AC_DEFINE_UNQUOTED([HAVE_FARM], 1, [have farm])
> PACKAGE_FEATURES="$PACKAGE_FEATURES farm"
> fi
> diff --git a/include/sha1.h b/include/sha1.h
> new file mode 100644
> index 0000000..cc60dc1
> --- /dev/null
> +++ b/include/sha1.h
> @@ -0,0 +1,27 @@
> +/*
> + * sha1.h - SHA1 Secure Hash Algorithm used for CHAP authentication.
> + * copied from the Linux kernel's Cryptographic API and slightly adjusted to
> + * fit IET's needs
> + *
> + * This file is (c) 2004 Xiranet Communications GmbH <arne.redlich at xiranet.com>
> + * and licensed under the GPL.
> + */
> +
> +#ifndef SHA1_H
> +#define SHA1_H
> +
> +#include <sys/types.h>
> +#include <string.h>
> +#include <inttypes.h>
> +
> +struct sha1_ctx {
> + uint64_t count;
> + uint32_t state[5];
> + uint8_t buffer[64];
> +};
> +
> +void sha1_init(void *ctx);
> +void sha1_update(void *ctx, const uint8_t *data, unsigned int len);
> +void sha1_final(void* ctx, uint8_t *out);
> +
> +#endif
> diff --git a/lib/Makefile.am b/lib/Makefile.am
> index f6ac984..0e11ec8 100644
> --- a/lib/Makefile.am
> +++ b/lib/Makefile.am
> @@ -5,4 +5,4 @@ INCLUDES = -I$(top_builddir)/include -I$(top_srcdir)/include
> noinst_LIBRARIES = libsheepdog.a
>
> libsheepdog_a_SOURCES = event.c logger.c net.c util.c rbtree.c ring_buffer.c \
> - strbuf.c
> + strbuf.c sha1.c
> diff --git a/lib/sha1.c b/lib/sha1.c
> new file mode 100644
> index 0000000..5cf444a
> --- /dev/null
> +++ b/lib/sha1.c
> @@ -0,0 +1,168 @@
> +/*
> + * Cryptographic API.
> + *
> + * SHA1 Secure Hash Algorithm.
> + *
> + * Derived from cryptoapi implementation, adapted for in-place
> + * scatterlist interface. Originally based on the public domain
> + * implementation written by Steve Reid.
> + *
> + * Copyright (c) Alan Smithee.
> + * Copyright (c) Andrew McDonald <andrew at mcdonald.org.uk>
> + * Copyright (c) Jean-Francois Dive <jef at linuxbe.org>
> + *
> + * This program is free software; you can redistribute it and/or modify it
> + * under the terms of the GNU General Public License as published by the Free
> + * Software Foundation; either version 2 of the License, or (at your option)
> + * any later version.
> + *
> + */
> +#include <arpa/inet.h>
> +#include "sha1.h"
> +
> +#define SHA1_DIGEST_SIZE 20
> +#define SHA1_HMAC_BLOCK_SIZE 64
> +
> +static inline uint32_t rol(uint32_t value, uint32_t bits)
> +{
> + return (((value) << (bits)) | ((value) >> (32 - (bits))));
> +}
> +
> +/* blk0() and blk() perform the initial expand. */
> +/* I got the idea of expanding during the round function from SSLeay */
> +# define blk0(i) block32[i]
> +
> +#define blk(i) (block32[i&15] = rol(block32[(i+13)&15]^block32[(i+8)&15] \
> + ^block32[(i+2)&15]^block32[i&15],1))
> +
> +/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
> +#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5); \
> + w=rol(w,30);
> +#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5); \
> + w=rol(w,30);
> +#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
> +#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5); \
> + w=rol(w,30);
> +#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
> +
> +/* Hash a single 512-bit block. This is the core of the algorithm. */
> +static void sha1_transform(uint32_t *state, const uint8_t *in)
> +{
> + uint32_t a, b, c, d, e;
> + uint32_t block32[16];
> +
> + /* convert/copy data to workspace */
> + for (a = 0; a < sizeof(block32)/sizeof(uint32_t); a++)
> + block32[a] = ntohl (((const uint32_t *)in)[a]);
> +
> + /* Copy context->state[] to working vars */
> + a = state[0];
> + b = state[1];
> + c = state[2];
> + d = state[3];
> + e = state[4];
> +
> + /* 4 rounds of 20 operations each. Loop unrolled. */
> + R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
> + R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
> + R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
> + R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
> + R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
> + R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
> + R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
> + R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
> + R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
> + R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
> + R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
> + R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
> + R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
> + R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
> + R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
> + R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
> + R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
> + R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
> + R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
> + R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
> + /* Add the working vars back into context.state[] */
> + state[0] += a;
> + state[1] += b;
> + state[2] += c;
> + state[3] += d;
> + state[4] += e;
> + /* Wipe variables */
> + a = b = c = d = e = 0;
> + memset (block32, 0x00, sizeof block32);
> +}
> +
> +void sha1_init(void *ctx)
> +{
> + struct sha1_ctx *sctx = ctx;
> + static const struct sha1_ctx initstate = {
> + 0,
> + { 0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0 },
> + { 0, }
> + };
> +
> + *sctx = initstate;
> +}
> +
> +void sha1_update(void *ctx, const uint8_t *data, unsigned int len)
> +{
> + struct sha1_ctx *sctx = ctx;
> + unsigned int i, j;
> +
> + j = (sctx->count >> 3) & 0x3f;
> + sctx->count += len << 3;
> +
> + if ((j + len) > 63) {
> + memcpy(&sctx->buffer[j], data, (i = 64-j));
> + sha1_transform(sctx->state, sctx->buffer);
> + for ( ; i + 63 < len; i += 64) {
> + sha1_transform(sctx->state, &data[i]);
> + }
> + j = 0;
> + }
> + else i = 0;
> + memcpy(&sctx->buffer[j], &data[i], len - i);
> +}
> +
> +
> +/* Add padding and return the message digest. */
> +void sha1_final(void* ctx, uint8_t *out)
> +{
> + struct sha1_ctx *sctx = ctx;
> + uint32_t i, j, idx, padlen;
> + uint64_t t;
> + uint8_t bits[8] = { 0, };
> + static const uint8_t padding[64] = { 0x80, };
> +
> + t = sctx->count;
> + bits[7] = 0xff & t; t>>=8;
> + bits[6] = 0xff & t; t>>=8;
> + bits[5] = 0xff & t; t>>=8;
> + bits[4] = 0xff & t; t>>=8;
> + bits[3] = 0xff & t; t>>=8;
> + bits[2] = 0xff & t; t>>=8;
> + bits[1] = 0xff & t; t>>=8;
> + bits[0] = 0xff & t;
> +
> + /* Pad out to 56 mod 64 */
> + idx = (sctx->count >> 3) & 0x3f;
> + padlen = (idx < 56) ? (56 - idx) : ((64+56) - idx);
> + sha1_update(sctx, padding, padlen);
> +
> + /* Append length */
> + sha1_update(sctx, bits, sizeof bits);
> +
> + /* Store state in digest */
> + for (i = j = 0; i < 5; i++, j += 4) {
> + uint32_t t2 = sctx->state[i];
> + out[j+3] = t2 & 0xff; t2>>=8;
> + out[j+2] = t2 & 0xff; t2>>=8;
> + out[j+1] = t2 & 0xff; t2>>=8;
> + out[j ] = t2 & 0xff;
> + }
> +
> + /* Wipe context */
> + memset(sctx, 0, sizeof *sctx);
> +}
> diff --git a/sheep/farm/farm.h b/sheep/farm/farm.h
> index 72b8b5d..b5f5d61 100644
> --- a/sheep/farm/farm.h
> +++ b/sheep/farm/farm.h
> @@ -12,13 +12,13 @@
> #include <errno.h>
> #include <sys/mman.h>
> #include <linux/limits.h>
> -#include <openssl/sha.h>
> #include <zlib.h>
>
> #include "sheepdog_proto.h"
> #include "sheep.h"
> #include "logger.h"
> #include "strbuf.h"
> +#include "sha1.h"
>
> #define HEX_LEN 40
> #define NAME_LEN HEX_LEN
> diff --git a/sheep/farm/sha1_file.c b/sheep/farm/sha1_file.c
> index ead1a00..b0abc16 100644
> --- a/sheep/farm/sha1_file.c
> +++ b/sheep/farm/sha1_file.c
> @@ -138,11 +138,11 @@ err_open:
> int sha1_file_write(unsigned char *buf, unsigned len, unsigned char *outsha1)
> {
> unsigned char sha1[SHA1_LEN];
> - SHA_CTX c;
> + struct sha1_ctx c;
>
> - SHA1_Init(&c);
> - SHA1_Update(&c, buf, len);
> - SHA1_Final(sha1, &c);
> + sha1_init(&c);
> + sha1_update(&c, buf, len);
> + sha1_final(&c, sha1);
>
> if (sha1_buffer_write(sha1, buf, len) < 0)
> return -1;
> @@ -197,11 +197,11 @@ static void *unpack_sha1_file(void *map, unsigned long mapsize, struct sha1_file
> static int verify_sha1_file(const unsigned char *sha1, void *buf, unsigned long len)
> {
> unsigned char tmp[SHA1_LEN];
> - SHA_CTX c;
> + struct sha1_ctx c;
>
> - SHA1_Init(&c);
> - SHA1_Update(&c, buf, len);
> - SHA1_Final(tmp, &c);
> + sha1_init(&c);
> + sha1_update(&c, buf, len);
> + sha1_final(&c, tmp);
>
> if (memcmp((char *)tmp, (char *)sha1, SHA1_LEN) != 0) {
> dprintf("failed, %s != %s\n", sha1_to_hex(sha1),
>
Wow, very quick response, looks gorgeous to me.
Thanks,
Yuan
More information about the sheepdog
mailing list