From df13e5523df231124858003c93bdaa3b7a361f07 Mon Sep 17 00:00:00 2001 From: Enrico Scholz Date: Thu, 21 Feb 2008 23:22:23 +0000 Subject: [PATCH] added support for using libnss instead of beecrypt for vhashify's hash calculation. libnss has bad SHA1 performance on i386, but is a) maintained and b) gives better performance with all other hashes and on x86_64. I am just waiting for somebody to write the OpenSSL layer so that I can try the padlock hardware crypto device on my C7 ;) git-svn-id: http://svn.linux-vserver.org/svn/util-vserver/trunk@2685 94cd875c-1c1d-0410-91d2-eb244daf1a30 --- NEWS | 9 ++ configure.ac | 103 +++++++++++-- lib_internal/Makefile-files | 3 + lib_internal/crypto-wrapper-beecrypt.h | 130 ++++++++++++++++ lib_internal/crypto-wrapper-nss.h | 176 ++++++++++++++++++++++ lib_internal/crypto-wrapper.h | 31 ++++ lib_internal/testsuite/Makefile-files | 26 ++++ lib_internal/testsuite/SPEED-RESULTS.txt | 246 +++++++++++++++++++++++++++++++ lib_internal/testsuite/crypto-speed.c | 112 ++++++++++++++ lib_internal/testsuite/crypto.c | 164 +++++++++++++++++++++ src/Makefile-files | 15 +- src/testsuite/Makefile-files | 21 +-- src/testsuite/hashcalc-plain.c | 33 +++-- src/testsuite/hashcalc.c | 11 +- src/testsuite/hashcalc.sh | 23 ++- src/vhashify-init.hc | 13 +- src/vhashify.c | 33 +++-- 17 files changed, 1068 insertions(+), 81 deletions(-) create mode 100644 lib_internal/crypto-wrapper-beecrypt.h create mode 100644 lib_internal/crypto-wrapper-nss.h create mode 100644 lib_internal/crypto-wrapper.h create mode 100644 lib_internal/testsuite/SPEED-RESULTS.txt create mode 100644 lib_internal/testsuite/crypto-speed.c create mode 100644 lib_internal/testsuite/crypto.c diff --git a/NEWS b/NEWS index 84caa2e..cc17f49 100644 --- a/NEWS +++ b/NEWS @@ -1,3 +1,12 @@ +version 0.30.??? +================ + + - added support for using libnss instead of beecrypt for + vhashify's hash calculation. libnss has bad SHA1 performance on + i386, but is a) maintained and b) gives better performance with + all other hashes and on x86_64. + + version 0.30.214 ================ - patches for yum-3.2. diff --git a/configure.ac b/configure.ac index 3c47610..36b6685 100644 --- a/configure.ac +++ b/configure.ac @@ -42,6 +42,7 @@ AC_PROG_CC AC_PROG_INSTALL AC_PROG_LN_S AM_PROG_CC_C_O +PKG_PROG_PKG_CONFIG ENSC_CXXCOMPILER ENSC_C99COMPILER @@ -311,8 +312,28 @@ fi dnl ######################## dnl +dnl {crypto stuff +dnl +AC_MSG_CHECKING([for used crypto API]) +AC_ARG_WITH(crypto-api, + AC_HELP_STRING([--with-crypto-api=API], + [select crypto api to be used; possible values are `none', `nss', `beecrypt', `auto' (default:auto)]), + [case $withval in + (none|nss|beecrypt|auto) ensc_crypto_api=$withval;; + (*) AC_MSG_ERROR([invalid initscripts value, only gentoo and sysv are supported]);; + esac],[ensc_crypto_api=auto]) +AC_MSG_RESULT($ensc_crypto_api) + + +dnl Now, check for matching crypto api. When selected 'auto', the +dnl first matching one wins + +dnl ######################## +dnl dnl {check for beecrypt dnl +case $ensc_crypto_api in +(auto|beecrypt) if test x"$ensc_cv_c99_c99compiler" = xyes; then ensc_have_beecrypt=yes @@ -325,17 +346,20 @@ if test x"$ensc_cv_c99_c99compiler" = xyes; then AC_CHECK_LIB(beecrypt, hashFunctionContextInit, [ : ], [ ensc_have_beecrypt=no ]) fi - - if test x"$ensc_have_beecrypt" != xyes; then - AC_MSG_WARN([ -**** -**** 'beecrypt' could not be found; -**** this will disable the build of 'vhashify' -****]) - fi else ensc_have_beecrypt=no -fi +fi;; +esac + +case $ensc_crypto_api in +(auto) if test x"$ensc_have_beecrypt" = xyes; then + AC_MSG_NOTICE([using beecrypt as crypto api]) + ensc_crypto_api=beecrypt + fi;; +(beecrypt) if test x"$ensc_have_beecrypt" != xyes; then + AC_MSG_ERROR([beecrypt crypto api not found]) + fi;; +esac AM_CONDITIONAL(ENSC_HAVE_BEECRYPT, test x"$ensc_have_beecrypt" = xyes) AM_CONDITIONAL(ENSC_CAN_BEECRYPT_WITH_DIETLIBC, false) @@ -345,6 +369,66 @@ dnl dnl ######################## +dnl ######################## +dnl +dnl {check for nss +dnl + +case $ensc_crypto_api in +(nss) PKG_CHECK_MODULES(NSS, nss);; +(auto) PKG_CHECK_MODULES(NSS, nss, [ + AC_MSG_NOTICE([using NSS as crypto api]) + ensc_crypto_api=nss], + AC_MSG_RESULT(no));; +esac + +dnl +dnl nss stuff ends here} +dnl +dnl ######################## + +case $ensc_crypto_api in +(beecrypt) + ENSC_HAVE_CRYPTO=true + ENSC_CRYPTO_API=ENSC_CRYPTO_API_BEECRYPT + ENSC_CRYPTO_CFLAGS= + ENSC_CRYPTO_LIB=-lbeecrypt + ENSC_CAN_CRYPTO_WITH_DIETLIBC=false + ;; + +(nss) + ENSC_HAVE_CRYPTO=true + ENSC_CRYPTO_API=ENSC_CRYPTO_API_NSS + ENSC_CRYPTO_CFLAGS=$NSS_CFLAGS + ENSC_CRYPTO_LIB=$NSS_LIBS + ENSC_CAN_CRYPTO_WITH_DIETLIBC=false + ;; + +(none) + ENSC_HAVE_CRYPTO=false + ENSC_CRYPTO_API=ENSC_CRYPTO_API_NONE + ENSC_CRYPTO_CFLAGS= + ENSC_CRYPTO_LIB= + ENSC_CAN_CRYPTO_WITH_DIETLIBC=false + + AC_MSG_WARN([No crypto api found/select. This will disable the build of `vhashify']) + ;; + +(*) AC_MSG_ERROR([internal error]) +esac + +AM_CONDITIONAL(ENSC_HAVE_CRYPTO, $ENSC_HAVE_CRYPTO) +AM_CONDITIONAL(ENSC_CAN_CRYPTO_WITH_DIETLIBC, $ENSC_CAN_CRYPTO_WITH_DIETLIBC) +AC_SUBST(ENSC_CRYPTO_CFLAGS, $ENSC_CRYPTO_CFLAGS) +AC_SUBST(ENSC_CRYPTO_LIB, $ENSC_CRYPTO_LIB) +AC_DEFINE_UNQUOTED(ENSC_CRYPTO_API, $ENSC_CRYPTO_API, [Used crypto API]) + +dnl +dnl crypto stuff ends here} +dnl +dnl ######################## + + dnl Check what distro this is, use Gentoo initscripts if appropriate AC_MSG_CHECKING([for host initscripts]) AC_ARG_WITH(initscripts, AC_HELP_STRING([--with-initscripts=TYPE], [force host initscripts; valid values are 'gentoo' and 'sysv' (default: guess)]), [ @@ -407,6 +491,7 @@ Features: ext2fs Source: $ensc_cv_test_ext2fs_header syscall(2) invocation: $with_syscall vserver(2) syscall#: $ensc_cv_value_syscall_vserver + crypto api: $ensc_crypto_api Paths: prefix: $prefix diff --git a/lib_internal/Makefile-files b/lib_internal/Makefile-files index 85f807b..1feb631 100644 --- a/lib_internal/Makefile-files +++ b/lib_internal/Makefile-files @@ -52,6 +52,9 @@ endif noinst_HEADERS += \ lib_internal/coreassert.h \ + lib_internal/crypto-wrapper.h \ + lib_internal/crypto-wrapper-nss.h \ + lib_internal/crypto-wrapper-beecrypt.h \ lib_internal/errinfo.h \ lib_internal/jail.h \ lib_internal/matchlist.h \ diff --git a/lib_internal/crypto-wrapper-beecrypt.h b/lib_internal/crypto-wrapper-beecrypt.h new file mode 100644 index 0000000..bfd455a --- /dev/null +++ b/lib_internal/crypto-wrapper-beecrypt.h @@ -0,0 +1,130 @@ +/* --*- c -*-- + * Copyright (C) 2008 Enrico Scholz + * + * 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; version 2 and/or 3 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef H_UTIL_VSERVER_LIB_INTERNAL_CRYPTO_WRAPPER_BEECRYPT_H +#define H_UTIL_VSERVER_LIB_INTERNAL_CRYPTO_WRAPPER_BEECRYPT_H + +#include +#include + +typedef hashFunction ensc_hash_method; +typedef hashFunctionContext ensc_hash_context; + +inline static void +ensc_crypto_init(void) +{ +} + +inline static ensc_hash_method const * +ensc_crypto_hash_get_default(void) +{ + return hashFunctionDefault(); +} + +inline static ensc_hash_method const * +ensc_crypto_hash_find(char const *id_c) +{ + char *id = strdupa(id_c); + char *ptr = id; + char const *name; + + while (*ptr) { + *ptr = tolower(*ptr); + ++ptr; + } + + ptr = id; + while ((ptr=strchr(ptr, '-'))!=NULL) + memmove(ptr, ptr+1, strlen(ptr)); + + if (strcmp(id, "md2")==0) + name = "MD2"; + else if (strcmp(id, "md5")==0) + name = "MD5"; + else if (strcmp(id, "sha1")==0) + name = "SHA-1"; + else if (strcasecmp(id, "sha256")==0) + name = "SHA-256"; +#if 0 + /* sha-384 in beecrypt seems to be broken; digestsize is reported as + * 64 there although 48 is the correct value */ + else if (strcasecmp(id, "sha384")==0) + name = "SHA-384"; +#endif + else if (strcasecmp(id, "sha512")==0) + name = "SHA-512"; + else + name = NULL; + + return hashFunctionFind(name); +} + +inline static char const * +ensc_crypto_hash_get_name(ensc_hash_method const *m) +{ + return m->name; +} + +inline static size_t +ensc_crypto_hash_get_digestsize(ensc_hash_method const *m) +{ + return m->digestsize; +} + + + +inline static size_t +ensc_crypto_hashctx_get_digestsize(ensc_hash_context const *ctx) +{ + return ensc_crypto_hash_get_digestsize(ctx->algo); +} + +inline static int +ensc_crypto_hashctx_get_digest(ensc_hash_context *ctx, void *result, + size_t *res_len, size_t UNUSED max_res_len) +{ + int rc = hashFunctionContextDigest(ctx, result); + if (res_len) + *res_len = ctx->algo->digestsize; + + return rc; +} + +inline static int +ensc_crypto_hashctx_update(ensc_hash_context *ctx, void const *src, size_t len) +{ + return hashFunctionContextUpdate(ctx, src, len); +} + +inline static int +ensc_crypto_hashctx_init(ensc_hash_context *ctx, ensc_hash_method const *m) +{ + return hashFunctionContextInit(ctx, m); +} + +inline static int +ensc_crypto_hashctx_reset(ensc_hash_context *ctx) +{ + return hashFunctionContextReset(ctx); +} + +inline static void +ensc_crypto_hashctx_free(ensc_hash_context *ctx) +{ + hashFunctionContextFree(ctx); +} + +#endif /* H_UTIL_VSERVER_LIB_INTERNAL_CRYPTO_WRAPPER_BEECRYPT_H */ diff --git a/lib_internal/crypto-wrapper-nss.h b/lib_internal/crypto-wrapper-nss.h new file mode 100644 index 0000000..ae0128d --- /dev/null +++ b/lib_internal/crypto-wrapper-nss.h @@ -0,0 +1,176 @@ +/* --*- c -*-- + * Copyright (C) 2008 Enrico Scholz + * + * 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; version 3 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef H_UTIL_VSERVER_LIB_INTERNAL_CRYPTO_WRAPPER_NSS_H +#define H_UTIL_VSERVER_LIB_INTERNAL_CRYPTO_WRAPPER_NSS_H + +#include +#include +#include + +#include "util-cast.h" + +typedef struct SECHashObjectStr ensc_hash_method; +typedef struct HASHContextStr *ensc_hash_context; + +inline static int +ensc_crypto_init(void) +{ + NSS_NoDB_Init(NULL); + return 0; +} + +inline static ensc_hash_method const * +ensc_crypto_hash_get_default(void) +{ + return HASH_GetHashObject(SEC_OID_SHA1); +} + +inline static ensc_hash_method const * +ensc_crypto_hash_find(char const *id_c) +{ + SECOidTag oid; + +#if 1 + char *id = strdupa(id_c); + char *ptr = id; + + while (*ptr) { + *ptr = tolower(*ptr); + ++ptr; + } + + ptr = id; + while ((ptr=strchr(ptr, '-'))!=NULL) + memmove(ptr, ptr+1, strlen(ptr)); + + if (strcmp(id, "md2")==0) + oid = SEC_OID_MD2; + else if (strcmp(id, "md5")==0) + oid = SEC_OID_MD5; + else if (strcmp(id, "sha1")==0) + oid = SEC_OID_SHA1; + else if (strcasecmp(id, "sha256")==0) + oid = SEC_OID_SHA256; + else if (strcasecmp(id, "sha384")==0) + oid = SEC_OID_SHA384; + else if (strcasecmp(id, "sha512")==0) + oid = SEC_OID_SHA512; + else + oid = SEC_OID_UNKNOWN; + +#else + struct SECItemStr const item = { + .type = ???, + .data = const_cast(unsigned char *)(static_cast(unsigned char const *)(id)), + .len = strlen(id) + }; + SECOidTag oid; + + oid = SECOID_FindOIDTag(&item); +#endif + + return HASH_GetHashObjectByOidTag(oid); +} + +inline static char const * +ensc_crypto_hash_get_name(ensc_hash_method const *m) +{ + char const * const NAMES[] = { + [HASH_AlgNULL] = "null", + [HASH_AlgMD2] = "md2", + [HASH_AlgMD5] = "md5", + [HASH_AlgSHA1] = "sha1", + [HASH_AlgSHA256] = "sha256", + [HASH_AlgSHA384] = "sha384", + [HASH_AlgSHA512] = "sha512", + }; + size_t idx = static_cast(size_t)(m->type); + + if (idx >= sizeof(NAMES)/sizeof(NAMES[0])) + return NULL; + + return NAMES[idx]; + /* TODO: use SECOID_FindOIDTagDescription()? */ +} + +inline static size_t +ensc_crypto_hash_get_digestsize(ensc_hash_method const *m) +{ + size_t const SIZES[] = { + [HASH_AlgMD2] = MD2_LENGTH, + [HASH_AlgMD5] = MD5_LENGTH, + [HASH_AlgSHA1] = SHA1_LENGTH, + [HASH_AlgSHA256] = SHA256_LENGTH, + [HASH_AlgSHA384] = SHA384_LENGTH, + [HASH_AlgSHA512] = SHA512_LENGTH, + }; + size_t idx = static_cast(size_t)(m->type); + + if (idx >= sizeof(SIZES)/sizeof(SIZES[0])) + return 0; + + return SIZES[idx]; +} + +inline static size_t +ensc_crypto_hashctx_get_digestsize(ensc_hash_context const *ctx) +{ + return ensc_crypto_hash_get_digestsize((*ctx)->hashobj); +} + +inline static int +ensc_crypto_hashctx_get_digest(ensc_hash_context *ctx, void *result, + size_t UNUSED *res_len_a, size_t UNUSED max_res_len) +{ + unsigned int res_len; + + HASH_End(*ctx, result, &res_len, max_res_len); + if (res_len_a) + *res_len_a = res_len; + + return 0; +} + +inline static int +ensc_crypto_hashctx_init(ensc_hash_context *ctx, ensc_hash_method const *m) +{ + *ctx = HASH_Create(m->type); + return *ctx==NULL ? -1 : 0; +} + +inline static int +ensc_crypto_hashctx_update(ensc_hash_context *ctx, void const *src, size_t len) +{ + HASH_Update(*ctx, src, len); + return 0; +} + +inline static int +ensc_crypto_hashctx_reset(ensc_hash_context *ctx) +{ + HASH_Begin(*ctx); + return 0; +} + +inline static void +ensc_crypto_hashctx_free(ensc_hash_context *ctx) +{ + HASH_Destroy(*ctx); + *ctx = NULL; +} + +#endif /* H_UTIL_VSERVER_LIB_INTERNAL_CRYPTO_WRAPPER_NSS_H */ diff --git a/lib_internal/crypto-wrapper.h b/lib_internal/crypto-wrapper.h new file mode 100644 index 0000000..2201bf2 --- /dev/null +++ b/lib_internal/crypto-wrapper.h @@ -0,0 +1,31 @@ +/* --*- c -*-- + * Copyright (C) 2008 Enrico Scholz + * + * 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; version 2 and/or 3 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef H_UTIL_VSERVER_LIB_INTERNAL_CRYPTO_WRAPPER_H +#define H_UTIL_VSERVER_LIB_INTERNAL_CRYPTO_WRAPPER_H + +#define ENSC_CRYPTO_API_NSS 1 +#define ENSC_CRYPTO_API_BEECRYPT 2 + +#if ENSC_CRYPTO_API == ENSC_CRYPTO_API_BEECRYPT +#include "crypto-wrapper-beecrypt.h" +#elif ENSC_CRYPTO_API == ENSC_CRYPTO_API_NSS +#include "crypto-wrapper-nss.h" +#else +#error undefined crypto API +#endif + +#endif /* H_UTIL_VSERVER_LIB_INTERNAL_CRYPTO_WRAPPER_H */ diff --git a/lib_internal/testsuite/Makefile-files b/lib_internal/testsuite/Makefile-files index 314e512..e745359 100644 --- a/lib_internal/testsuite/Makefile-files +++ b/lib_internal/testsuite/Makefile-files @@ -36,10 +36,21 @@ TESTS += lib_internal/testsuite/filecfg-ml \ lib_internal/testsuite/matchlist-gnu endif +if ENSC_HAVE_CRYPTO +check_PROGRAMS += lib_internal/testsuite/crypto \ + lib_internal/testsuite/crypto-speed +TESTS += lib_internal/testsuite/crypto +endif + DIETPROGS += lib_internal/testsuite/isnumber \ lib_internal/testsuite/sigbus \ lib_internal/testsuite/matchlist +if ENSC_CAN_CRYPTO_WITH_DIETLIBC +DIETPROGS += lib_internal/testsuite/crypto \ + lib_internal/testsuite/crypto-speed +endif + EXTRA_DIST += lib_internal/testsuite/copy-check TESTS_ENVIRONMENT += libinternaltestsuitedir=$(top_builddir)/lib_internal/testsuite @@ -79,3 +90,18 @@ lib_internal_testsuite_matchlist_CPPFLAGS = $(AM_CPPFLAGS) # see note above lib_internal_testsuite_matchlist_gnu_SOURCES = lib_internal/testsuite/matchlist.c lib_internal_testsuite_matchlist_gnu_LDADD = $(LIBINTERNAL_GLIBC) lib_internal_testsuite_matchlist_gnu_CPPFLAGS = $(AM_CPPFLAGS) # see note above + +if ENSC_HAVE_CRYPTO +lib_internal_testsuite_crypto_speed_SOURCES = lib_internal/testsuite/crypto-speed.c +lib_internal_testsuite_crypto_speed_CFLAGS = $(AM_CFLAGS) $(ENSC_CRYPTO_CFLAGS) +lib_internal_testsuite_crypto_speed_LDADD = $(ENSC_CRYPTO_LIB) -lrt + +lib_internal_testsuite_crypto_SOURCES = lib_internal/testsuite/crypto.c +lib_internal_testsuite_crypto_CFLAGS = $(AM_CFLAGS) $(ENSC_CRYPTO_CFLAGS) +lib_internal_testsuite_crypto_LDADD = $(ENSC_CRYPTO_LIB) + +if !ENSC_CAN_CRYPTO_WITH_DIETLIBC +lib_internal_testsuite_crypto_speed_LDFLAGS = -Wl,--as-needed +lib_internal_testsuite_crypto_LDFLAGS = -Wl,--as-needed +endif +endif diff --git a/lib_internal/testsuite/SPEED-RESULTS.txt b/lib_internal/testsuite/SPEED-RESULTS.txt new file mode 100644 index 0000000..96b33f1 --- /dev/null +++ b/lib_internal/testsuite/SPEED-RESULTS.txt @@ -0,0 +1,246 @@ +System: +T61, Core2Duo 2.2Ghz, 4GiB RAM, Fedora 8, 64 bit + + +64 bit +======== --with-crypto-api=nss ============ + md5: 1 x 0 -> 0.000010612s, 0 bytes/s + md5: 1048576 x 0 -> 0.240403614s, 0 bytes/s + md5: 1 x 16 -> 0.000001792s, 8.928.571 bytes/s + md5: 1048576 x 16 -> 0.290466264s, 57.759.602 bytes/s + md5: 16 x 1024 -> 0.000071528s, 229.057.152 bytes/s + md5: 16384 x 1024 -> 0.050839303s, 330.004.838 bytes/s + md5: 16 x 1048576 -> 0.047048043s, 356.597.531 bytes/s + md5: 100 x 1048576 -> 0.293919980s, 356.755.604 bytes/s + md5: 1000 x 1048576 -> 2.947685749s, 355.728.557 bytes/s + sha1: 1 x 0 -> 0.000004680s, 0 bytes/s + sha1: 1048576 x 0 -> 0.234542043s, 0 bytes/s + sha1: 1 x 16 -> 0.000002353s, 6.799.830 bytes/s + sha1: 1048576 x 16 -> 0.346382108s, 48.435.573 bytes/s + sha1: 16 x 1024 -> 0.000083828s, 195.447.821 bytes/s + sha1: 16384 x 1024 -> 0.080529647s, 208.335.893 bytes/s + sha1: 16 x 1048576 -> 0.077226951s, 217.245.608 bytes/s + sha1: 100 x 1048576 -> 0.482363856s, 217.382.788 bytes/s + sha1: 1000 x 1048576 -> 4.860877286s, 215.717.439 bytes/s +sha256: 1 x 0 -> 0.000005987s, 0 bytes/s +sha256: 1048576 x 0 -> 0.234423065s, 0 bytes/s +sha256: 1 x 16 -> 0.000002859s, 5.596.362 bytes/s +sha256: 1048576 x 16 -> 0.388906658s, 43.139.441 bytes/s +sha256: 16 x 1024 -> 0.000158419s, 103.421.938 bytes/s +sha256: 16384 x 1024 -> 0.150738207s, 111.300.355 bytes/s +sha256: 16 x 1048576 -> 0.147762674s, 113.541.637 bytes/s +sha256: 100 x 1048576 -> 0.920904318s, 113.863.729 bytes/s +sha256: 1000 x 1048576 -> 9.222825976s, 113.693.568 bytes/s +sha512: 1 x 0 -> 0.000012629s, 0 bytes/s +sha512: 1048576 x 0 -> 0.232183717s, 0 bytes/s +sha512: 1 x 16 -> 0.000003574s, 4.476.776 bytes/s +sha512: 1048576 x 16 -> 0.340624988s, 49.254.213 bytes/s +sha512: 16 x 1024 -> 0.000106430s, 153.941.557 bytes/s +sha512: 16384 x 1024 -> 0.101951761s, 164.560.335 bytes/s +sha512: 16 x 1048576 -> 0.098160536s, 170.916.100 bytes/s +sha512: 100 x 1048576 -> 0.611599635s, 171.448.107 bytes/s +sha512: 1000 x 1048576 -> 6.109529732s, 171.629.576 bytes/s + + +======== --with-crypto-api=beecrypt ====== + md5: 1 x 0 -> 0.000019913s, 0 bytes/s + md5: 1048576 x 0 -> 0.043844247s, 0 bytes/s + md5: 1 x 16 -> 0.000003545s, 4.513.399 bytes/s + md5: 1048576 x 16 -> 0.088413571s, 189.758.379 bytes/s + md5: 16 x 1024 -> 0.000047876s, 342.217.394 bytes/s + md5: 16384 x 1024 -> 0.044752750s, 374.886.817 bytes/s + md5: 16 x 1048576 -> 0.044899921s, 373.658.029 bytes/s + md5: 100 x 1048576 -> 0.280756545s, 373.482.299 bytes/s + md5: 1000 x 1048576 -> 2.802876816s, 374.107.058 bytes/s + sha1: 1 x 0 -> 0.000005236s, 0 bytes/s + sha1: 1048576 x 0 -> 0.036770880s, 0 bytes/s + sha1: 1 x 16 -> 0.000001467s, 10.906.612 bytes/s + sha1: 1048576 x 16 -> 0.127525089s, 131.560.119 bytes/s + sha1: 16 x 1024 -> 0.000088543s, 185.040.037 bytes/s + sha1: 16384 x 1024 -> 0.084912873s, 197.581.537 bytes/s + sha1: 16 x 1048576 -> 0.084310211s, 198.993.879 bytes/s + sha1: 100 x 1048576 -> 0.528023625s, 198.585.053 bytes/s + sha1: 1000 x 1048576 -> 5.284808204s, 198.413.255 bytes/s +sha256: 1 x 0 -> 0.000005436s, 0 bytes/s +sha256: 1048576 x 0 -> 0.036945402s, 0 bytes/s +sha256: 1 x 16 -> 0.000002002s, 7.992.007 bytes/s +sha256: 1048576 x 16 -> 0.195753663s, 85.705.757 bytes/s +sha256: 16 x 1024 -> 0.000158651s, 103.270.701 bytes/s +sha256: 16384 x 1024 -> 0.152873039s, 109.746.074 bytes/s +sha256: 16 x 1048576 -> 0.151477419s, 110.757.207 bytes/s +sha256: 100 x 1048576 -> 0.947547671s, 110.662.084 bytes/s +sha256: 1000 x 1048576 -> 9.478980465s, 110.621.179 bytes/s +sha512: 1 x 0 -> 0.000013080s, 0 bytes/s +sha512: 1048576 x 0 -> 0.046340109s, 0 bytes/s +sha512: 1 x 16 -> 0.000002583s, 6.194.347 bytes/s +sha512: 1048576 x 16 -> 0.154927531s, 108.290.733 bytes/s +sha512: 16 x 1024 -> 0.000114033s, 143.677.707 bytes/s +sha512: 16384 x 1024 -> 0.102781822s, 163.231.354 bytes/s +sha512: 16 x 1048576 -> 0.102118303s, 164.291.958 bytes/s +sha512: 100 x 1048576 -> 0.639161103s, 164.055.039 bytes/s +sha512: 1000 x 1048576 -> 6.402716295s, 163.770.492 bytes/s + + + + + +32 bit +======== --with-crypto-api=nss ============ + md5: 1 x 0 -> 0.000012284s, 0 bytes/s + md5: 1048576 x 0 -> 0.351524846s, 0 bytes/s + md5: 1 x 16 -> 0.000002187s, 7.315.957 bytes/s + md5: 1048576 x 16 -> 0.427717323s, 39.225.009 bytes/s + md5: 16 x 1024 -> 0.000070463s, 232.519.194 bytes/s + md5: 16384 x 1024 -> 0.067484999s, 248.606.597 bytes/s + md5: 16 x 1048576 -> 0.062185788s, 269.791.805 bytes/s + md5: 100 x 1048576 -> 0.388526572s, 269.885.273 bytes/s + md5: 1000 x 1048576 -> 3.899700600s, 268.886.283 bytes/s + sha1: 1 x 0 -> 0.000005877s, 0 bytes/s + sha1: 1048576 x 0 -> 0.340648155s, 0 bytes/s + sha1: 1 x 16 -> 0.000008329s, 1.920.998 bytes/s + sha1: 1048576 x 16 -> 0.509808543s, 32.908.856 bytes/s + sha1: 16 x 1024 -> 0.000159847s, 102.498.013 bytes/s + sha1: 16384 x 1024 -> 0.165871684s, 101.145.750 bytes/s + sha1: 16 x 1048576 -> 0.146010257s, 114.904.365 bytes/s + sha1: 100 x 1048576 -> 0.911497730s, 115.038.794 bytes/s + sha1: 1000 x 1048576 -> 9.126493727s, 114.893.630 bytes/s +sha256: 1 x 0 -> 0.000010657s, 0 bytes/s +sha256: 1048576 x 0 -> 0.340843492s, 0 bytes/s +sha256: 1 x 16 -> 0.000004360s, 3.669.724 bytes/s +sha256: 1048576 x 16 -> 0.613874241s, 27.330.053 bytes/s +sha256: 16 x 1024 -> 0.000259229s, 63.202.805 bytes/s +sha256: 16384 x 1024 -> 0.250969198s, 66.849.701 bytes/s +sha256: 16 x 1048576 -> 0.247802951s, 67.703.858 bytes/s +sha256: 100 x 1048576 -> 1.553324694s, 67.505.268 bytes/s +sha256: 1000 x 1048576 -> 15.557616964s, 67.399.525 bytes/s +sha512: 1 x 0 -> 0.000012079s, 0 bytes/s +sha512: 1048576 x 0 -> 0.345451653s, 0 bytes/s +sha512: 1 x 16 -> 0.000007218s, 2.216.680 bytes/s +sha512: 1048576 x 16 -> 0.975005743s, 17.207.299 bytes/s +sha512: 16 x 1024 -> 0.000661291s, 24.775.779 bytes/s +sha512: 16384 x 1024 -> 0.612676930s, 27.383.462 bytes/s +sha512: 16 x 1048576 -> 0.606441419s, 27.665.023 bytes/s +sha512: 100 x 1048576 -> 3.789441963s, 27.670.987 bytes/s +sha512: 1000 x 1048576 -> 37.944704131s, 27.634.317 bytes/s + + +======= --with-crypto-api=beecrypt ========= + md5: 1 x 0 -> 0.000023938s, 0 bytes/s + md5: 1048576 x 0 -> 0.058107490s, 0 bytes/s + md5: 1 x 16 -> 0.000003805s, 4.204.993 bytes/s + md5: 1048576 x 16 -> 0.123594359s, 135.744.188 bytes/s + md5: 16 x 1024 -> 0.000053382s, 306.919.935 bytes/s + md5: 16384 x 1024 -> 0.050902371s, 329.595.963 bytes/s + md5: 16 x 1048576 -> 0.049934429s, 335.984.937 bytes/s + md5: 100 x 1048576 -> 0.322439450s, 325.200.902 bytes/s + md5: 1000 x 1048576 -> 3.119201490s, 336.168.087 bytes/s + sha1: 1 x 0 -> 0.000004520s, 0 bytes/s + sha1: 1048576 x 0 -> 0.054753513s, 0 bytes/s + sha1: 1 x 16 -> 0.000001847s, 8.662.696 bytes/s + sha1: 1048576 x 16 -> 0.179519878s, 93.456.034 bytes/s + sha1: 16 x 1024 -> 0.000110003s, 148.941.392 bytes/s + sha1: 16384 x 1024 -> 0.115976962s, 144.659.902 bytes/s + sha1: 16 x 1048576 -> 0.105239505s, 159.419.373 bytes/s + sha1: 100 x 1048576 -> 0.656445997s, 159.735.302 bytes/s + sha1: 1000 x 1048576 -> 6.719054793s, 156.060.045 bytes/s +sha256: 1 x 0 -> 0.000011564s, 0 bytes/s +sha256: 1048576 x 0 -> 0.068358959s, 0 bytes/s +sha256: 1 x 16 -> 0.000003228s, 4.956.629 bytes/s +sha256: 1048576 x 16 -> 0.354763055s, 47.291.328 bytes/s +sha256: 16 x 1024 -> 0.000263999s, 62.060.841 bytes/s +sha256: 16384 x 1024 -> 0.259517650s, 64.647.687 bytes/s +sha256: 16 x 1048576 -> 0.257160705s, 65.240.200 bytes/s +sha256: 100 x 1048576 -> 1.604815811s, 65.339.336 bytes/s +sha256: 1000 x 1048576 -> 16.418434570s, 63.865.772 bytes/s +sha512: 1 x 0 -> 0.000040958s, 0 bytes/s +sha512: 1048576 x 0 -> 0.080563994s, 0 bytes/s +sha512: 1 x 16 -> 0.000007829s, 2.043.683 bytes/s +sha512: 1048576 x 16 -> 0.875192486s, 19.169.744 bytes/s +sha512: 16 x 1024 -> 0.000784418s, 20.886.823 bytes/s +sha512: 16384 x 1024 -> 0.774741496s, 21.655.243 bytes/s +sha512: 16 x 1048576 -> 0.772724538s, 21.711.768 bytes/s +sha512: 100 x 1048576 -> 4.879952557s, 21.487.422 bytes/s +sha512: 1000 x 1048576 -> 48.663248611s, 21.547.595 bytes/s + + + +============================ + +VIA C7, 1.2GHz, 1GiB RAM, Fedora 8 i386 + +======== --with-crypto-api=nss ============ + md5: 1 x 0 -> 0.000000001s, 0 bytes/s + md5: 1048576 x 0 -> 1.300000000s, 0 bytes/s + md5: 1 x 16 -> 0.000000001s, 16.000.000.000 bytes/s + md5: 1048576 x 16 -> 1.480000000s, 11.335.956 bytes/s + md5: 16 x 1024 -> 0.000000001s, 16.384.000.000.000 bytes/s + md5: 16384 x 1024 -> 0.260000000s, 64.527.753 bytes/s + md5: 16 x 1048576 -> 0.260000000s, 64.527.753 bytes/s + md5: 100 x 1048576 -> 1.600000000s, 65.536.000 bytes/s + md5: 1000 x 1048576 -> 15.980000000s, 65.618.022 bytes/s + sha1: 1 x 0 -> 0.000000001s, 0 bytes/s + sha1: 1048576 x 0 -> 1.120000000s, 0 bytes/s + sha1: 1 x 16 -> 0.000000001s, 16.000.000.000 bytes/s + sha1: 1048576 x 16 -> 1.820000000s, 9.218.250 bytes/s + sha1: 16 x 1024 -> 0.000000001s, 16.384.000.000.000 bytes/s + sha1: 16384 x 1024 -> 0.600000000s, 27.962.026 bytes/s + sha1: 16 x 1048576 -> 0.610000000s, 27.503.632 bytes/s + sha1: 100 x 1048576 -> 3.780000000s, 27.740.105 bytes/s + sha1: 1000 x 1048576 -> 37.760000000s, 27.769.491 bytes/s +sha256: 1 x 0 -> 0.000000001s, 0 bytes/s +sha256: 1048576 x 0 -> 1.120000000s, 0 bytes/s +sha256: 1 x 16 -> 0.000000001s, 16.000.000.000 bytes/s +sha256: 1048576 x 16 -> 2.220000000s, 7.557.304 bytes/s +sha256: 16 x 1024 -> 0.010000000s, 1.638.400 bytes/s +sha256: 16384 x 1024 -> 1.000000000s, 16.777.216 bytes/s +sha256: 16 x 1048576 -> 1.000000000s, 16.777.216 bytes/s +sha256: 100 x 1048576 -> 6.280000000s, 16.697.070 bytes/s +sha256: 1000 x 1048576 -> 62.890000000s, 16.673.175 bytes/s +sha512: 1 x 0 -> 0.000000001s, 0 bytes/s +sha512: 1048576 x 0 -> 1.120000000s, 0 bytes/s +sha512: 1 x 16 -> 0.000000001s, 16.000.000.000 bytes/s +sha512: 1048576 x 16 -> 3.550000000s, 4.725.976 bytes/s +sha512: 16 x 1024 -> 0.010000000s, 1.638.400 bytes/s +sha512: 16384 x 1024 -> 2.350000000s, 7.139.240 bytes/s +sha512: 16 x 1048576 -> 2.380000000s, 7.049.250 bytes/s +sha512: 100 x 1048576 -> 14.770000000s, 7.099.363 bytes/s +sha512: 1000 x 1048576 -> 147.610000000s, 7.103.692 bytes/s + + +======== --with-crypto-api=beecrypt ====== + md5: 1 x 0 -> 0.000000001s, 0 bytes/s + md5: 1048576 x 0 -> 0.390000000s, 0 bytes/s + md5: 1 x 16 -> 0.000000001s, 3.115.098.112 bytes/s + md5: 1048576 x 16 -> 0.510000000s, 32.896.501 bytes/s + md5: 16 x 1024 -> 0.000000001s, 2.994.733.056 bytes/s + md5: 16384 x 1024 -> 0.230000000s, 72.944.417 bytes/s + md5: 16 x 1048576 -> 0.240000000s, 69.905.066 bytes/s + md5: 100 x 1048576 -> 1.520000000s, 68.985.263 bytes/s + md5: 1000 x 1048576 -> 15.220000000s, 68.894.612 bytes/s + sha1: 1 x 0 -> 0.000000001s, 0 bytes/s + sha1: 1048576 x 0 -> 0.190000000s, 0 bytes/s + sha1: 1 x 16 -> 0.000000001s, 3.115.098.112 bytes/s + sha1: 1048576 x 16 -> 0.700000000s, 23.967.451 bytes/s + sha1: 16 x 1024 -> 0.000000001s, 2.994.733.056 bytes/s + sha1: 16384 x 1024 -> 0.430000000s, 39.016.781 bytes/s + sha1: 16 x 1048576 -> 0.440000000s, 38.130.036 bytes/s + sha1: 100 x 1048576 -> 2.730000000s, 38.409.377 bytes/s + sha1: 1000 x 1048576 -> 27.230000000s, 38.508.116 bytes/s +sha256: 1 x 0 -> 0.000000001s, 0 bytes/s +sha256: 1048576 x 0 -> 0.200000000s, 0 bytes/s +sha256: 1 x 16 -> 0.000000001s, 3.115.098.112 bytes/s +sha256: 1048576 x 16 -> 1.360000000s, 12.336.188 bytes/s +sha256: 16 x 1024 -> 0.000000001s, 2.994.733.056 bytes/s +sha256: 16384 x 1024 -> 1.100000000s, 15.252.014 bytes/s +sha256: 16 x 1048576 -> 1.110000000s, 15.114.609 bytes/s +sha256: 100 x 1048576 -> 6.920000000s, 15.152.832 bytes/s +sha256: 1000 x 1048576 -> 69.290000000s, 15.133.150 bytes/s +sha512: 1 x 0 -> 0.000000001s, 0 bytes/s +sha512: 1048576 x 0 -> 0.260000000s, 0 bytes/s +sha512: 1 x 16 -> 0.000000001s, 3.115.098.112 bytes/s +sha512: 1048576 x 16 -> 2.950000000s, 5.687.191 bytes/s +sha512: 16 x 1024 -> 0.000000001s, 2.994.733.056 bytes/s +sha512: 16384 x 1024 -> 2.600000000s, 6.452.775 bytes/s +sha512: 16 x 1048576 -> 2.630000000s, 6.379.169 bytes/s +sha512: 100 x 1048576 -> 16.400000000s, 6.393.756 bytes/s +sha512: 1000 x 1048576 -> 164.250000000s, 6.384.024 bytes/s diff --git a/lib_internal/testsuite/crypto-speed.c b/lib_internal/testsuite/crypto-speed.c new file mode 100644 index 0000000..0672a27 --- /dev/null +++ b/lib_internal/testsuite/crypto-speed.c @@ -0,0 +1,112 @@ +/* --*- c -*-- + * Copyright (C) 2008 Enrico Scholz + * + * 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; version 2 and/or 3 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#define ENSC_TESTSUITE + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include +#include +#include + + +static void +do_benchmark(char const *meth_name) +{ + struct { + size_t block_size; + size_t blocks; + } const DATA_SIZES[] = { + { 0, 1 }, + { 0, 1024*1024 }, + { 16, 1 }, + { 16, 1024*1024 }, + { 1024, 16 }, + { 1024, 16*1024 }, + { 1024*1024, 16 }, + { 1024*1024, 100 }, + { 1024*1024, 1000 } + }; + + ensc_hash_method const *m = ensc_crypto_hash_find(meth_name); + ensc_hash_context ctx; + size_t d_len = m ? ensc_crypto_hash_get_digestsize(m) : 0; + char digest[d_len]; + char * buf; + size_t i; + + assert(m); + assert(ensc_crypto_hashctx_init(&ctx, m)==0); + + for (i=0; i %2lu.%09lus, %'15llu bytes/s\n", + meth_name, DATA_SIZES[i].blocks, bs, + delta.tv_sec, delta.tv_nsec, (unsigned long long)(bps)); + } + + ensc_crypto_hashctx_free(&ctx); +} + +int main() +{ + char const * const METHS[] = { + "md5", "sha1", "sha256", "sha512", NULL + }; + char const * const * meth; + + ensc_crypto_init(); + setlocale(LC_NUMERIC, ""); /* needed for the thousands grouping */ + + for (meth=METHS+0; *meth; ++meth) + do_benchmark(*meth); +} diff --git a/lib_internal/testsuite/crypto.c b/lib_internal/testsuite/crypto.c new file mode 100644 index 0000000..5b11f97 --- /dev/null +++ b/lib_internal/testsuite/crypto.c @@ -0,0 +1,164 @@ +/* --*- c -*-- + * Copyright (C) 2008 Enrico Scholz + * + * 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; version 2 and/or 3 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#define ENSC_TESTSUITE + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include + +static unsigned int +hex2digit(char c) +{ + if (c>='0' && c<='9') + return c-'0'; + c &= ~0x20; + if (c>='A' && c<='F') + return c-'A' + 10; + + assert(0); + return 0; +} + +static void +convert_digest_ascii2bin(void *dst_v, char const *digest, size_t d_len) +{ + unsigned char *dst = dst_v; + + while (d_len>0) { + *dst = hex2digit(*digest++)<<4; + *dst |= hex2digit(*digest++); + + ++dst; + --d_len; + } +} + +static void +test_digest(char const *name, size_t d_len, + void const *buf, size_t buf_len, + char const *digest) +{ + ensc_hash_method const *m = ensc_crypto_hash_find(name); + ensc_hash_context ctx; + unsigned char *exp_digest[d_len/8]; + unsigned char *bin_digest[d_len/8]; + size_t bin_digest_len; + size_t i; + + d_len /= 8; + convert_digest_ascii2bin(exp_digest, digest, d_len); + + assert(m); + assert(ensc_crypto_hash_get_digestsize(m)==d_len); + + { + char const *tmp_name = ensc_crypto_hash_get_name(m); + ensc_hash_method const *tmp_meth = tmp_name ? ensc_crypto_hash_find(tmp_name) : NULL; + + assert(tmp_name!=NULL); + assert(tmp_meth!=NULL); + assert(ensc_crypto_hash_get_digestsize(tmp_meth)==d_len); + } + + ensc_crypto_hashctx_init(&ctx, m); + assert(ensc_crypto_hashctx_get_digestsize(&ctx)==d_len); + + /* run it multiple times to test for correct reset/init behavior */ + for (i=0; i<3; ++i) { + assert(ensc_crypto_hashctx_reset(&ctx)==0); + assert(ensc_crypto_hashctx_update(&ctx, buf, buf_len)==0); + + switch (i) { + case 0: + case 2: + break; + + case 1: + assert(ensc_crypto_hashctx_update(&ctx, "gremlin", 7)==0); + break; + } + + assert(ensc_crypto_hashctx_get_digest(&ctx, bin_digest, &bin_digest_len, d_len)==0); + assert(bin_digest_len==d_len); + + + switch (i) { + case 0: + case 2: + assert(memcmp(exp_digest, bin_digest, d_len)==0); + break; + + case 1: + assert(memcmp(exp_digest, bin_digest, d_len)!=0); + break; + } + } + + ensc_crypto_hashctx_free(&ctx); +} + +int main() +{ + ensc_crypto_init(); + assert(ensc_crypto_hash_get_default()!=NULL); + + /* MD-5 */ + + test_digest("md5", 128, "", 0, "d41d8cd98f00b204e9800998ecf8427e"); + test_digest("md-5", 128, "", 0, "d41d8cd98f00b204e9800998ecf8427e"); + test_digest("MD5", 128, "", 0, "d41d8cd98f00b204e9800998ecf8427e"); + test_digest("MD-5", 128, "", 0, "d41d8cd98f00b204e9800998ecf8427e"); + + test_digest("md5", 128, "foo", 3, "acbd18db4cc2f85cedef654fccc4a4d8"); + + /* SHA-1 */ + test_digest("sha1", 160, "", 0, "da39a3ee5e6b4b0d3255bfef95601890afd80709"); + test_digest("sha-1", 160, "", 0, "da39a3ee5e6b4b0d3255bfef95601890afd80709"); + test_digest("SHA1", 160, "", 0, "da39a3ee5e6b4b0d3255bfef95601890afd80709"); + test_digest("SHA-1", 160, "", 0, "da39a3ee5e6b4b0d3255bfef95601890afd80709"); + + test_digest("sha1", 160, "foo", 3, "0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33"); + + /* SHA-256 */ + test_digest("sha256", 256, "", 0, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"); + test_digest("sha-256", 256, "", 0, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"); + test_digest("SHA256", 256, "", 0, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"); + test_digest("SHA-256", 256, "", 0, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"); + + test_digest("sha256", 256, "foo", 3, "2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae"); + +#if ENSC_CRYPTO_API != ENSC_CRYPTO_API_BEECRYPT /* see comments in crypto-wrapper-beecrypt.h */ + /* SHA-384 */ + test_digest("sha384", 384, "", 0, "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b"); + test_digest("sha-384", 384, "", 0, "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b"); + test_digest("SHA384", 384, "", 0, "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b"); + test_digest("SHA-384", 384, "", 0, "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b"); + + test_digest("sha384", 384, "foo", 3, "98c11ffdfdd540676b1a137cb1a22b2a70350c9a44171d6b1180c6be5cbb2ee3f79d532c8a1dd9ef2e8e08e752a3babb"); +#endif + + /* SHA-512 */ + test_digest("sha512", 512, "", 0, "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e"); + test_digest("sha-512", 512, "", 0, "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e"); + test_digest("SHA512", 512, "", 0, "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e"); + test_digest("SHA-512", 512, "", 0, "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e"); + + test_digest("sha512", 512, "foo", 3, "f7fbba6e0636f890e56fbbf3283e524c6fa3204ae298382d624741d0dc6638326e282c41be5e4254d8820772c5518a2c5a8c0c7f7eda19594a7eb539453e1ed7"); +} diff --git a/src/Makefile-files b/src/Makefile-files index 34a5be1..33e17cb 100644 --- a/src/Makefile-files +++ b/src/Makefile-files @@ -86,7 +86,7 @@ DIETPROGS += src/chcontext-compat \ src/vspace \ src/vmemctrl -if ENSC_CAN_BEECRYPT_WITH_DIETLIBC +if ENSC_CAN_CRYPTO_WITH_DIETLIBC DIETPROGS += src/vhashify endif @@ -127,9 +127,9 @@ pkglib_PROGRAMS += src/capchroot \ $(src_pkglib_CXX_X_PROGS) if ENSC_HAVE_C99_COMPILER -if ENSC_HAVE_BEECRYPT +if ENSC_HAVE_CRYPTO pkglib_PROGRAMS += src/vhashify -endif ENSC_HAVE_BEECRYPT +endif ENSC_HAVE_CRYPTO endif ENSC_HAVE_C99_COMPILER legacy_PROGRAMS += src/ifspec \ @@ -295,12 +295,13 @@ src_vunify_LDADD = $(LIBINTERNAL) $(VSERVER_LDADDS) src_vunify_LDFLAGS = $(VSERVER_LDFLGS) src_vhashify_SOURCES = src/vhashify.c -if ENSC_CAN_BEECRYPT_WITH_DIETLIBC -src_vhashify_LDADD = $(LIBINTERNAL) $(LIBENSCVECTOR) -lbeecrypt $(VSERVER_LDADDS) +src_vhashify_CFLAGS = $(AM_CFLAGS) $(ENSC_CRYPTO_CFLAGS) +if ENSC_CAN_CRYPTO_WITH_DIETLIBC +src_vhashify_LDADD = $(LIBINTERNAL) $(LIBENSCVECTOR) $(ENSC_CRYPTO_LIB) $(VSERVER_LDADDS) src_vhashify_LDFLAGS = $(VSERVER_LDFLGS) else -src_vhashify_LDADD = $(LIBINTERNAL_GLIBC) $(LIBENSCVECTOR_GLIBC) $(LIBVSERVER_GLIBC) -lbeecrypt -src_vhashify_LDFLAGS = +src_vhashify_LDADD = $(LIBINTERNAL_GLIBC) $(LIBENSCVECTOR_GLIBC) $(LIBVSERVER_GLIBC) $(ENSC_CRYPTO_LIB) +src_vhashify_LDFLAGS = -Wl,--as-needed endif src_vuname_SOURCES = src/vuname.c diff --git a/src/testsuite/Makefile-files b/src/testsuite/Makefile-files index 3e9b2a1..0bfe6c0 100644 --- a/src/testsuite/Makefile-files +++ b/src/testsuite/Makefile-files @@ -22,7 +22,7 @@ src_testsuite_check_active_PRGS = src/testsuite/vunify-functest \ src_testsuite_check_passive_PRGS = src/testsuite/rpm-fake-test if ENSC_HAVE_C99_COMPILER -if ENSC_HAVE_BEECRYPT +if ENSC_HAVE_CRYPTO src_testsuite_check_passive_PRGS += src/testsuite/hashcalc \ src/testsuite/hashcalc-plain endif @@ -33,7 +33,7 @@ check_PROGRAMS += $(src_testsuite_check_passive_PRGS) \ if ENSC_HAVE_C99_COMPILER src_testsuite_check_src_C99_SCRPTS = src/testsuite/vunify-test.sh -if ENSC_HAVE_BEECRYPT +if ENSC_HAVE_CRYPTO src_testsuite_check_src_C99_SCRPTS += src/testsuite/hashcalc-plain.sh \ src/testsuite/hashcalc.sh endif @@ -73,18 +73,21 @@ src_testsuite_chbind_test_LDADD = lib/libvserver.la src_testsuite_hashcalc_SOURCES = src/testsuite/hashcalc.c src_testsuite_hashcalc_plain_SOURCES = src/testsuite/hashcalc-plain.c -if ENSC_CAN_BEECRYPT_WITH_DIETLIBC -src_testsuite_hashcalc_LDADD = $(LIBINTERNAL) $(LIBENSCVECTOR) -lbeecrypt $(VSERVER_LDADDS) +src_testsuite_hashcalc_CFLAGS = $(AM_CFLAGS) $(ENSC_CRYPTO_CFLAGS) +src_testsuite_hashcalc_plain_CFLAGS = $(AM_CFLAGS) $(ENSC_CRYPTO_CFLAGS) + +if ENSC_CAN_CRYPTO_WITH_DIETLIBC +src_testsuite_hashcalc_LDADD = $(LIBINTERNAL) $(LIBENSCVECTOR) $(ENSC_CRYPTO_LIB) $(VSERVER_LDADDS) src_testsuite_hashcalc_LDFLAGS = $(VSERVER_LDFLGS) -src_testsuite_hashcalc_plain_LDADD = $(LIBINTERNAL) $(LIBENSCVECTOR) -lbeecrypt $(VSERVER_LDADDS) +src_testsuite_hashcalc_plain_LDADD = $(LIBINTERNAL) $(LIBENSCVECTOR) $(ENSC_CRYPTO_LIB) $(VSERVER_LDADDS) src_testsuite_hashcalc_plain_LDFLAGS = $(VSERVER_LDFLGS) else -src_testsuite_hashcalc_LDADD = $(LIBINTERNAL_GLIBC) $(LIBENSCVECTOR_GLIBC) $(LIBVSERVER_GLIBC) -lbeecrypt -src_testsuite_hashcalc_LDFLAGS = +src_testsuite_hashcalc_LDADD = $(LIBINTERNAL_GLIBC) $(LIBENSCVECTOR_GLIBC) $(LIBVSERVER_GLIBC) $(ENSC_CRYPTO_LIB) +src_testsuite_hashcalc_LDFLAGS = -Wl,--as-needed -src_testsuite_hashcalc_plain_LDADD = $(LIBINTERNAL_GLIBC) $(LIBENSCVECTOR_GLIBC) $(LIBVSERVER_GLIBC) -lbeecrypt -src_testsuite_hashcalc_plain_LDFLAGS = +src_testsuite_hashcalc_plain_LDADD = $(LIBINTERNAL_GLIBC) $(LIBENSCVECTOR_GLIBC) $(LIBVSERVER_GLIBC) $(ENSC_CRYPTO_LIB) +src_testsuite_hashcalc_plain_LDFLAGS = -Wl,--as-needed endif src_testsuite_CPPFLAGS = -I $(top_srcdir)/src -D ENSC_TESTSUITE diff --git a/src/testsuite/hashcalc-plain.c b/src/testsuite/hashcalc-plain.c index 7e2421b..16ce2c8 100644 --- a/src/testsuite/hashcalc-plain.c +++ b/src/testsuite/hashcalc-plain.c @@ -20,7 +20,7 @@ # include #endif -#include +#include #include #include #include @@ -32,15 +32,15 @@ #define HASH_BLOCKSIZE 0x10000000u static bool -convertDigest(char res[], hashFunctionContext * h_ctx) +convertDigest(char res[], ensc_hash_context * h_ctx) { static char const HEX_DIGIT[] = "0123456789abcdef"; - size_t d_size = h_ctx->algo->digestsize; + size_t d_size = ensc_crypto_hashctx_get_digestsize(h_ctx); unsigned char digest[d_size]; size_t out = 0; - if (hashFunctionContextDigest(h_ctx, digest)==-1) + if (ensc_crypto_hashctx_get_digest(h_ctx, digest, NULL, d_size)==-1) return false; for (size_t in=0; in/dev/null for i in $tmpdir/rand-*; do - sha1_0=$($hashcalc "$i" SHA-1 | tr -d / ) - sha1_1=$(sha1sum "$i" | awk '{ print $1}' ) + for m in md5 sha1 sha256 sha512; do + sum_0=$($hashcalc "$i" "$m" | tr -d / ) + sum_1=$(${m}sum "$i" | awk '{ print $1}' ) - test x"$sha1_0" = x"$sha1_1" || { - echo "SHA-1 mismatch at $(basename $i)" - exit 1 - } - - md5_0=$($hashcalc "$i" MD5 | tr -d / ) - md5_1=$(md5sum "$i" | awk '{ print $1}' ) - - test x"$md5_0" = x"$md5_1" || { - echo "MD5 mismatch at $(basename $i)" - exit 1 - } + # compare only the first 80 chars as vhashify will cut digest to MAXPATHLEN + test x"${sum_0::80}" = x"${sum_1::80}" || { + echo "$m mismatch at $(basename $i): '$sum_0' vs. '$sum_1'" + exit 1 + } + done done true diff --git a/src/vhashify-init.hc b/src/vhashify-init.hc index 49aa7b1..9ddc85b 100644 --- a/src/vhashify-init.hc +++ b/src/vhashify-init.hc @@ -96,15 +96,18 @@ initHashMethod(struct HashDirConfiguration *conf, char const *filename) { int fd = open(filename, O_RDONLY); if (fd==-1 && conf->method==0) - conf->method = hashFunctionDefault(); + conf->method = ensc_crypto_hash_get_default(); if (fd==-1) { + char const *hash_name; assert(conf->method!=0); if (conf->method==0) return false; if (global_args->dry_run) return true; // do not create the file - + fd = Eopen(filename, O_WRONLY|O_CREAT|O_EXCL|O_NOFOLLOW, 0644); - TEMP_FAILURE_RETRY(write(fd, conf->method->name, strlen(conf->method->name))); + + hash_name = ensc_crypto_hash_get_name(conf->method); + TEMP_FAILURE_RETRY(write(fd, hash_name, strlen(hash_name))); TEMP_FAILURE_RETRY(write(fd, "\n", 1)); } else { @@ -119,7 +122,7 @@ initHashMethod(struct HashDirConfiguration *conf, char const *filename) --s; buf[s] = '\0'; - conf->method = hashFunctionFind(buf); + conf->method = ensc_crypto_hash_find(buf); if (conf->method==0) { WRITE_MSG(2, "Can not find hash-function '"); WRITE_STR(2, buf); @@ -130,7 +133,7 @@ initHashMethod(struct HashDirConfiguration *conf, char const *filename) WRITE_MSG(2, "Can not read configuration file for hash-method\n"); } - if (conf->method!=0 && conf->method->digestsize*8>HASH_MAXBITS) { + if (conf->method!=0 && ensc_crypto_hash_get_digestsize(conf->method)*8>HASH_MAXBITS) { WRITE_MSG(2, "Wow... what an huge hash-function. I can not handle so much bits; giving up...\n"); conf->method=0; } diff --git a/src/vhashify.c b/src/vhashify.c index b4edf3d..ed13eba 100644 --- a/src/vhashify.c +++ b/src/vhashify.c @@ -30,7 +30,7 @@ #include "lib_internal/unify.h" #include "ensc_vector/vector.h" -#include +#include "lib_internal/crypto-wrapper.h" #include #include @@ -95,7 +95,7 @@ typedef char HashPath[HASH_MAXBITS/4 + (HASH_MAXBITS/4/2) + struct HashDirConfiguration { - hashFunction const *method; + ensc_hash_method const *method; enum { hshALL=0, hshSTART = 1, hshMIDDLE=2, hshEND = 4, hshINVALID = -1 } blocks; size_t blocksize; @@ -109,7 +109,7 @@ struct WalkdownInfo HashDirCollection hash_dirs; size_t hash_dirs_max_size; - hashFunctionContext hash_context; + ensc_hash_context hash_context; }; int wrapper_exit_code = 1; @@ -251,13 +251,13 @@ static bool convertDigest(HashPath d_path) { static char const HEX_DIGIT[] = "0123456789abcdef"; - hashFunctionContext * const h_ctx = &global_info.hash_context; - size_t d_size = h_ctx->algo->digestsize; - + ensc_hash_context * const h_ctx = &global_info.hash_context; + size_t d_size = ensc_crypto_hashctx_get_digestsize(h_ctx); + unsigned char digest[d_size]; size_t out = 0; - if (hashFunctionContextDigest(h_ctx, digest)==-1) + if (ensc_crypto_hashctx_get_digest(h_ctx, digest, NULL, d_size)==-1) return false; for (size_t in=0; @@ -275,7 +275,7 @@ convertDigest(HashPath d_path) #ifndef ENSC_TESTSUITE static bool -addStatHash(hashFunctionContext *h_ctx, struct stat const * const st) +addStatHash(ensc_hash_context *h_ctx, struct stat const * const st) { #define DECL_ATTR(X) __typeof__(st->st_##X) X #define SET_ATTR(X) .X = st->st_##X @@ -300,11 +300,11 @@ addStatHash(hashFunctionContext *h_ctx, struct stat const * const st) #undef DECL_ATTR - return hashFunctionContextUpdate(h_ctx, (void *)&tmp, sizeof tmp)!=-1; + return ensc_crypto_hashctx_update(h_ctx, (void *)&tmp, sizeof tmp)!=-1; } #else static bool -addStatHash(hashFunctionContext UNUSED *h_ctx, struct stat const UNUSED * const st) +addStatHash(ensc_hash_context UNUSED *h_ctx, struct stat const UNUSED * const st) { return true; } @@ -313,13 +313,13 @@ addStatHash(hashFunctionContext UNUSED *h_ctx, struct stat const UNUSED * const static bool calculateHashFromFD(int fd, HashPath d_path, struct stat const * const st) { - hashFunctionContext * const h_ctx = &global_info.hash_context; + ensc_hash_context * const h_ctx = &global_info.hash_context; void const * volatile buf = 0; loff_t volatile buf_size = 0; bool volatile res = false; - if (hashFunctionContextReset(h_ctx)==-1 || + if (ensc_crypto_hashctx_reset(h_ctx)==-1 || !addStatHash(h_ctx, st)) return false; @@ -340,7 +340,7 @@ calculateHashFromFD(int fd, HashPath d_path, struct stat const * const st) offset += buf_size; madvise(const_cast(void *)(buf), buf_size, MADV_SEQUENTIAL); // ignore error... - if (hashFunctionContextUpdate(h_ctx, buf, buf_size)==-1) goto out; + if (ensc_crypto_hashctx_update(h_ctx, buf, buf_size)==-1) goto out; munmap(const_cast(void *)(buf), buf_size); buf = 0; @@ -668,14 +668,15 @@ int main(int argc, char *argv[]) return EXIT_FAILURE; } + ensc_crypto_init(); switch (args.mode) { case mdMANUALLY : initModeManually(&args, argc-optind, argv+optind); break; case mdVSERVER : initModeVserver (&args, argc-optind, argv+optind); break; default : assert(false); return EXIT_FAILURE; }; - if (hashFunctionContextInit(&global_info.hash_context, - global_info.hash_conf.method)==-1) { + if (ensc_crypto_hashctx_init(&global_info.hash_context, + global_info.hash_conf.method)==-1) { WRITE_MSG(2, "Failed to initialize hash-context\n"); return EXIT_FAILURE; } @@ -691,7 +692,7 @@ int main(int argc, char *argv[]) #ifndef NDEBUG MatchList_destroy(&global_info.dst_list); freeHashList(&global_info.hash_dirs); - hashFunctionContextFree(&global_info.hash_context); + ensc_crypto_hashctx_free(&global_info.hash_context); #endif return EXIT_SUCCESS; -- 1.8.1.5