packages: xorg-xserver-server/xorg-xserver-server-builtin-SHA1.patch (NEW) ...
baggins
baggins at pld-linux.org
Thu Apr 29 12:32:08 CEST 2010
Author: baggins Date: Thu Apr 29 10:32:08 2010 GMT
Module: packages Tag: HEAD
---- Log message:
- Render: Use built-in SHA1 library
---- Files affected:
packages/xorg-xserver-server:
xorg-xserver-server-builtin-SHA1.patch (NONE -> 1.1) (NEW)
---- Diffs:
================================================================
Index: packages/xorg-xserver-server/xorg-xserver-server-builtin-SHA1.patch
diff -u /dev/null packages/xorg-xserver-server/xorg-xserver-server-builtin-SHA1.patch:1.1
--- /dev/null Thu Apr 29 12:32:08 2010
+++ packages/xorg-xserver-server/xorg-xserver-server-builtin-SHA1.patch Thu Apr 29 12:32:03 2010
@@ -0,0 +1,679 @@
+From 3fbec7d4db59bbd24a9a768182000a1d004c5bc5 Mon Sep 17 00:00:00 2001
+From: Tiago Vignatti <tiago.vignatti at nokia.com>
+Date: Wed, 24 Mar 2010 17:27:43 +0200
+Subject: [PATCH] Revert "Revert "Render: Use built-in SHA1 library""
+
+This reverts commit a39377cbcbd3091095efbeab25bec18ae520147e.
+
+Conflicts:
+
+ configure.ac
+ include/dix-config.h.in
+ render/glyph.c
+
+
+Ok ok ok, it's the revert of a revert! Buhhh...
+
+Once upon a time, back in 2007, Carl Worth was trying to boost render
+(4c6abe1c). He prefered to use a "strong hash" to compare glyphs (19b3b1fd)
+and used openssl library for this. Further, for the same purpose, people
+started to set other SHA1 implementations in autoconf. And a lot of
+alternatives appeared - six, to be precise. In the mean time, John Tapsell
+commit a builtin implementation of SHA1. In the same day, Keith Packard
+reverted, stating "X.org should not be providing a custom SHA1
+implementation." (a39377cb). Now, users ended up with Xorg setting the default
+as the openssl's one (libcrypto), which takes 88 kB of xserver's private RSS.
+Besides that, we have a ridiculous "configure dot fucking ac stanza to work
+out which lib to use is almost as long as sha1.c was", to quote daniels.
+
+My simple argument against Keith's decision is simple: we can save 316 kB of
+RSS in a standalone Xorg call. Therefore, I'm in favor to keep our own very
+simple and shiny SHA1 implementation.
+
+---
+I'm not comfortable yet to send this patch around without see if there's any
+regressions on render or eventually get some ack from Carl.
+
+
+ configure.ac | 89 +------------------------
+ include/dix-config.h.in | 15 ----
+ os/Makefile.am | 1 -
+ os/xsha1.c | 168 ---------------------------------------------
+ render/Makefile.am | 3 +
+ render/glyph.c | 25 ++-----
+ render/sha1.c | 173 +++++++++++++++++++++++++++++++++++++++++++++++
+ render/sha1.h | 63 +++++++++++++++++
+ 8 files changed, 248 insertions(+), 289 deletions(-)
+ delete mode 100644 os/xsha1.c
+ create mode 100644 render/sha1.c
+ create mode 100644 render/sha1.h
+
+diff --git a/configure.ac b/configure.ac
+index 3e8ea10..ef21aa0 100644
+--- a/configure.ac
++++ b/configure.ac
+@@ -1305,7 +1305,7 @@ AC_DEFINE(BIGREQS, 1, [Support BigRequests extension])
+
+ if test "x$SPECIAL_DTRACE_OBJECTS" = "xyes" ; then
+ DIX_LIB='$(top_builddir)/dix/dix.O'
+- OS_LIB='$(top_builddir)/os/os.O $(SHA1_LIBS)'
++ OS_LIB='$(top_builddir)/os/os.O'
+ else
+ DIX_LIB='$(top_builddir)/dix/libdix.la'
+ OS_LIB='$(top_builddir)/os/libos.la'
+@@ -1325,93 +1325,6 @@ MIEXT_SHADOW_INC='-I$(top_srcdir)/miext/shadow'
+ MIEXT_SHADOW_LIB='$(top_builddir)/miext/shadow/libshadow.la'
+ CORE_INCS='-I$(top_srcdir)/include -I$(top_builddir)/include'
+
+-# SHA1 hashing
+-AC_ARG_WITH([sha1],
+- [AS_HELP_STRING([--with-sha1=libc|libmd|libgcrypt|libcrypto|libsha1|CommonCrypto],
+- [choose SHA1 implementation])])
+-AC_CHECK_FUNC([SHA1Init], [HAVE_SHA1_IN_LIBC=yes])
+-if test "x$with_sha1" = x && test "x$HAVE_SHA1_IN_LIBC" = xyes; then
+- with_sha1=libc
+-fi
+-if test "x$with_sha1" = xlibc && test "x$HAVE_SHA1_IN_LIBC" != xyes; then
+- AC_MSG_ERROR([libc requested but not found])
+-fi
+-if test "x$with_sha1" = xlibc; then
+- AC_DEFINE([HAVE_SHA1_IN_LIBC], [1],
+- [Use libc SHA1 functions])
+- SHA1_LIBS=""
+-fi
+-AC_CHECK_FUNC([CC_SHA1_Init], [HAVE_SHA1_IN_COMMONCRYPTO=yes])
+-if test "x$with_sha1" = x && test "x$HAVE_SHA1_IN_COMMONCRYPTO" = xyes; then
+- with_sha1=CommonCrypto
+-fi
+-if test "x$with_sha1" = xCommonCrypto && test "x$HAVE_SHA1_IN_COMMONCRYPTO" != xyes; then
+- AC_MSG_ERROR([CommonCrypto requested but not found])
+-fi
+-if test "x$with_sha1" = xCommonCrypto; then
+- AC_DEFINE([HAVE_SHA1_IN_COMMONCRYPTO], [1],
+- [Use CommonCrypto SHA1 functions])
+- SHA1_LIBS=""
+-fi
+-AC_CHECK_LIB([md], [SHA1Init], [HAVE_LIBMD=yes])
+-if test "x$with_sha1" = x && test "x$HAVE_LIBMD" = xyes; then
+- with_sha1=libmd
+-fi
+-if test "x$with_sha1" = xlibmd && test "x$HAVE_LIBMD" != xyes; then
+- AC_MSG_ERROR([libmd requested but not found])
+-fi
+-if test "x$with_sha1" = xlibmd; then
+- AC_DEFINE([HAVE_SHA1_IN_LIBMD], [1],
+- [Use libmd SHA1 functions])
+- SHA1_LIBS=-lmd
+-fi
+-AC_CHECK_LIB([gcrypt], [gcry_md_open], [HAVE_LIBGCRYPT=yes])
+-if test "x$with_sha1" = x && test "x$HAVE_LIBGCRYPT" = xyes; then
+- with_sha1=libgcrypt
+-fi
+-if test "x$with_sha1" = xlibgcrypt; then
+- AC_DEFINE([HAVE_SHA1_IN_LIBGCRYPT], [1],
+- [Use libgcrypt SHA1 functions])
+- SHA1_LIBS=-lgcrypt
+-fi
+-AC_CHECK_LIB([sha1], [sha1_begin], [HAVE_LIBSHA1=yes])
+-if test "x$with_sha1" = x && test "x$HAVE_LIBSHA1" = xyes; then
+- with_sha1=libsha1
+-fi
+-if test "x$with_sha1" = xlibsha1; then
+- AC_DEFINE([HAVE_SHA1_IN_LIBSHA1], [1],
+- [Use libsha1 for SHA1])
+- SHA1_LIBS=-lsha1
+-fi
+-# We don't need all of the OpenSSL libraries, just libcrypto
+-AC_CHECK_LIB([crypto], [SHA1_Init], [HAVE_LIBCRYPTO=yes])
+-PKG_CHECK_MODULES([OPENSSL], [openssl], [HAVE_OPENSSL_PKC=yes],
+- [HAVE_OPENSSL_PKC=no])
+-if test "x$HAVE_LIBCRYPTO" = xyes || test "x$HAVE_OPENSSL_PKC" = xyes; then
+- if test "x$with_sha1" = x; then
+- with_sha1=libcrypto
+- fi
+-else
+- if test "x$with_sha1" = xlibcrypto; then
+- AC_MSG_ERROR([OpenSSL libcrypto requested but not found])
+- fi
+-fi
+-if test "x$with_sha1" = xlibcrypto; then
+- if test "x$HAVE_LIBCRYPTO" = xyes; then
+- SHA1_LIBS=-lcrypto
+- else
+- SHA1_LIBS="$OPENSSL_LIBS"
+- SHA1_CFLAGS="$OPENSSL_CFLAGS"
+- fi
+-fi
+-AC_MSG_CHECKING([for SHA1 implementation])
+-if test "x$with_sha1" = x; then
+- AC_MSG_ERROR([No suitable SHA1 implementation found])
+-fi
+-AC_MSG_RESULT([$with_sha1])
+-AC_SUBST(SHA1_LIBS)
+-AC_SUBST(SHA1_CFLAGS)
+-
+ PKG_CHECK_MODULES([XSERVERCFLAGS], [$REQUIRED_MODULES $REQUIRED_LIBS])
+ PKG_CHECK_MODULES([XSERVERLIBS], [$REQUIRED_LIBS])
+
+diff --git a/include/dix-config.h.in b/include/dix-config.h.in
+index 058c8fd..d6e99a5 100644
+--- a/include/dix-config.h.in
++++ b/include/dix-config.h.in
+@@ -160,21 +160,6 @@
+ /* Define to 1 if you have the <rpcsvc/dbm.h> header file. */
+ #undef HAVE_RPCSVC_DBM_H
+
+-/* Define to use libc SHA1 functions */
+-#undef HAVE_SHA1_IN_LIBC
+-
+-/* Define to use CommonCrypto SHA1 functions */
+-#undef HAVE_SHA1_IN_COMMONCRYPTO
+-
+-/* Define to use libmd SHA1 functions */
+-#undef HAVE_SHA1_IN_LIBMD
+-
+-/* Define to use libgcrypt SHA1 functions */
+-#undef HAVE_SHA1_IN_LIBGCRYPT
+-
+-/* Define to use libsha1 for SHA1 */
+-#undef HAVE_SHA1_IN_LIBSHA1
+-
+ /* Define to 1 if you have the `shmctl64' function. */
+ #undef HAVE_SHMCTL64
+
+diff --git a/os/Makefile.am b/os/Makefile.am
+index 66a4a0f..b8c1636 100644
+--- a/os/Makefile.am
++++ b/os/Makefile.am
+@@ -22,7 +22,6 @@ libos_la_SOURCES = \
+ strcasecmp.c \
+ strcasestr.c \
+ xdmauth.c \
+- xsha1.c \
+ xstrans.c \
+ xprintf.c \
+ $(XORG_SRCS)
+diff --git a/os/xsha1.c b/os/xsha1.c
+deleted file mode 100644
+index 355862f..0000000
+--- a/os/xsha1.c
++++ /dev/null
+@@ -1,168 +0,0 @@
+-#ifdef HAVE_DIX_CONFIG_H
+-#include <dix-config.h>
+-#endif
+-
+-#include "os.h"
+-#include "xsha1.h"
+-
+-#if defined(HAVE_SHA1_IN_LIBMD) /* Use libmd for SHA1 */ \
+- || defined(HAVE_SHA1_IN_LIBC) /* Use libc for SHA1 */
+-
+-# include <sha1.h>
+-
+-void *x_sha1_init(void)
+-{
+- SHA1_CTX *ctx = xalloc(sizeof(*ctx));
+- if (!ctx)
+- return NULL;
+- SHA1Init(ctx);
+- return ctx;
+-}
+-
+-int x_sha1_update(void *ctx, void *data, int size)
+-{
+- SHA1_CTX *sha1_ctx = ctx;
+- SHA1Update(sha1_ctx, data, size);
+- return 1;
+-}
+-
+-int x_sha1_final(void *ctx, unsigned char result[20])
+-{
+- SHA1_CTX *sha1_ctx = ctx;
+- SHA1Final(result, sha1_ctx);
+- xfree(sha1_ctx);
+- return 1;
+-}
+-
+-#elif defined(HAVE_SHA1_IN_COMMONCRYPTO) /* Use CommonCrypto for SHA1 */
+-
+-#include <CommonCrypto/CommonDigest.h>
+-
+-void *x_sha1_init(void)
+-{
+- CC_SHA1_CTX *ctx = xalloc(sizeof(*ctx));
+- if (!ctx)
+- return NULL;
+- CC_SHA1_Init(ctx);
+- return ctx;
+-}
+-
+-int x_sha1_update(void *ctx, void *data, int size)
+-{
+- CC_SHA1_CTX *sha1_ctx = ctx;
+- CC_SHA1_Update(sha1_ctx, data, size);
+- return 1;
+-}
+-
+-int x_sha1_final(void *ctx, unsigned char result[20])
+-{
+- CC_SHA1_CTX *sha1_ctx = ctx;
+- CC_SHA1_Final(result, sha1_ctx);
+- xfree(sha1_ctx);
+- return 1;
+-}
+-
+-#elif defined(HAVE_SHA1_IN_LIBGCRYPT) /* Use libgcrypt for SHA1 */
+-
+-# include <gcrypt.h>
+-
+-void *x_sha1_init(void)
+-{
+- static int init;
+- gcry_md_hd_t h;
+- gcry_error_t err;
+-
+- if (!init) {
+- if (!gcry_check_version(NULL))
+- return NULL;
+- gcry_control(GCRYCTL_DISABLE_SECMEM, 0);
+- gcry_control(GCRYCTL_INITIALIZATION_FINISHED, 0);
+- init = 1;
+- }
+-
+- err = gcry_md_open(&h, GCRY_MD_SHA1, 0);
+- if (err)
+- return NULL;
+- return h;
+-}
+-
+-int x_sha1_update(void *ctx, void *data, int size)
+-{
+- gcry_md_hd_t h = ctx;
+- gcry_md_write(h, data, size);
+- return 1;
+-}
+-
+-int x_sha1_final(void *ctx, unsigned char result[20])
+-{
+- gcry_md_hd_t h = ctx;
+- memcpy(result, gcry_md_read(h, GCRY_MD_SHA1), 20);
+- gcry_md_close(h);
+- return 1;
+-}
+-
+-#elif defined(HAVE_SHA1_IN_LIBSHA1) /* Use libsha1 */
+-
+-# include <libsha1.h>
+-
+-void *x_sha1_init(void)
+-{
+- sha1_ctx *ctx = xalloc(sizeof(*ctx));
+- if(!ctx)
+- return NULL;
+- sha1_begin(ctx);
+- return ctx;
+-}
+-
+-int x_sha1_update(void *ctx, void *data, int size)
+-{
+- sha1_hash(data, size, ctx);
+- return 1;
+-}
+-
+-int x_sha1_final(void *ctx, unsigned char result[20])
+-{
+- sha1_end(result, ctx);
+- xfree(ctx);
+- return 1;
+-}
+-
+-#else /* Use OpenSSL's libcrypto */
+-
+-# include <stddef.h> /* buggy openssl/sha.h wants size_t */
+-# include <openssl/sha.h>
+-
+-void *x_sha1_init(void)
+-{
+- int ret;
+- SHA_CTX *ctx = xalloc(sizeof(*ctx));
+- if (!ctx)
+- return NULL;
+- ret = SHA1_Init(ctx);
+- if (!ret) {
+- xfree(ctx);
+- return NULL;
+- }
+- return ctx;
+-}
+-
+-int x_sha1_update(void *ctx, void *data, int size)
+-{
+- int ret;
+- SHA_CTX *sha_ctx = ctx;
+- ret = SHA1_Update(sha_ctx, data, size);
+- if (!ret)
+- xfree(sha_ctx);
+- return ret;
+-}
+-
+-int x_sha1_final(void *ctx, unsigned char result[20])
+-{
+- int ret;
+- SHA_CTX *sha_ctx = ctx;
+- ret = SHA1_Final(result, sha_ctx);
+- xfree(sha_ctx);
+- return ret;
+-}
+-
+-#endif
+diff --git a/render/Makefile.am b/render/Makefile.am
+index 216c613..bb46702 100644
+--- a/render/Makefile.am
++++ b/render/Makefile.am
+@@ -14,8 +14,11 @@ librender_la_SOURCES = \
+ mitri.c \
+ picture.c \
+ render.c \
++ sha1.c \
+ renderedge.c
+
+ if XORG
+ sdk_HEADERS = picture.h mipict.h glyphstr.h picturestr.h renderedge.h
+ endif
++
++EXTRA_DIST = sha1.h
+diff --git a/render/glyph.c b/render/glyph.c
+index 0b864ad..e14530a 100644
+--- a/render/glyph.c
++++ b/render/glyph.c
+@@ -26,8 +26,7 @@
+ #include <dix-config.h>
+ #endif
+
+-#include "xsha1.h"
+-
++#include "sha1.h"
+ #include "misc.h"
+ #include "scrnintstr.h"
+ #include "os.h"
+@@ -193,21 +192,13 @@ HashGlyph (xGlyphInfo *gi,
+ unsigned long size,
+ unsigned char sha1[20])
+ {
+- void *ctx = x_sha1_init();
+- int success;
+-
+- if (!ctx)
+- return BadAlloc;
+-
+- success = x_sha1_update(ctx, gi, sizeof(xGlyphInfo));
+- if (!success)
+- return BadAlloc;
+- success = x_sha1_update(ctx, bits, size);
+- if (!success)
+- return BadAlloc;
+- success = x_sha1_final(ctx, sha1);
+- if (!success)
+- return BadAlloc;
++ SHA1_CTX ctx;
++
++ SHA1Init (&ctx);
++ SHA1Update (&ctx, gi, sizeof (xGlyphInfo));
++ SHA1Update (&ctx, bits, size);
++ SHA1Final (sha1, &ctx);
++
+ return Success;
+ }
+
+diff --git a/render/sha1.c b/render/sha1.c
+new file mode 100644
+index 0000000..820eb2a
+--- /dev/null
++++ b/render/sha1.c
+@@ -0,0 +1,173 @@
++/*
++ * SHA-1 in C
++ * By Steve Reid <steve at edmweb.com>
++ * 100% Public Domain
++ *
++ * Test Vectors (from FIPS PUB 180-1)
++ * "abc"
++ * A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
++ * "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
++ * 84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
++ * A million repetitions of "a"
++ * 34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
++ */
++
++#include <sys/param.h>
++#include <string.h>
++#include <sha1.h>
++
++#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
++
++/*
++ * blk0() and blk() perform the initial expand.
++ * I got the idea of expanding during the round function from SSLeay
++ */
++#if BYTE_ORDER == LITTLE_ENDIAN
++# define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
++ |(rol(block->l[i],8)&0x00FF00FF))
++#else
++# define blk0(i) block->l[i]
++#endif
++#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
++ ^block->l[(i+2)&15]^block->l[i&15],1))
++
++/*
++ * (R0+R1), R2, R3, R4 are the different operations (rounds) 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.
++ */
++void
++SHA1Transform(uint32_t state[5], const uint8_t buffer[SHA1_BLOCK_LENGTH])
++{
++ uint32_t a, b, c, d, e;
++ uint8_t workspace[SHA1_BLOCK_LENGTH];
++ typedef union {
++ uint8_t c[64];
++ uint32_t l[16];
++ } CHAR64LONG16;
++ CHAR64LONG16 *block = (CHAR64LONG16 *)workspace;
++
++ (void)memcpy(block, buffer, SHA1_BLOCK_LENGTH);
++
++ /* 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;
++}
++
++
++/*
++ * SHA1Init - Initialize new context
++ */
++void
++SHA1Init(SHA1_CTX *context)
++{
++
++ /* SHA1 initialization constants */
++ context->count = 0;
++ context->state[0] = 0x67452301;
++ context->state[1] = 0xEFCDAB89;
++ context->state[2] = 0x98BADCFE;
++ context->state[3] = 0x10325476;
++ context->state[4] = 0xC3D2E1F0;
++}
++
++
++/*
++ * Run your data through this.
++ */
++void
++SHA1Update(SHA1_CTX *context, const uint8_t *data, size_t len)
++{
++ size_t i, j;
++
++ j = (size_t)((context->count >> 3) & 63);
++ context->count += (len << 3);
++ if ((j + len) > 63) {
++ (void)memcpy(&context->buffer[j], data, (i = 64-j));
++ SHA1Transform(context->state, context->buffer);
++ for ( ; i + 63 < len; i += 64)
++ SHA1Transform(context->state, (uint8_t *)&data[i]);
++ j = 0;
++ } else {
++ i = 0;
++ }
++ (void)memcpy(&context->buffer[j], &data[i], len - i);
++}
++
++
++/*
++ * Add padding and return the message digest.
++ */
++void
++SHA1Pad(SHA1_CTX *context)
++{
++ uint8_t finalcount[8];
++ uint i;
++
++ for (i = 0; i < 8; i++) {
++ finalcount[i] = (uint8_t)((context->count >>
++ ((7 - (i & 7)) * 8)) & 255); /* Endian independent */
++ }
++ SHA1Update(context, (uint8_t *)"\200", 1);
++ while ((context->count & 504) != 448)
++ SHA1Update(context, (uint8_t *)"\0", 1);
++ SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */
++}
<<Diff was trimmed, longer than 597 lines>>
More information about the pld-cvs-commit
mailing list