@@ -1,3 +1,9 @@

+Wed Feb 18 17:24:48 EET 2009 (edwin)

+------------------------------------

+ * freshclam/, libclamav/, shared/, sigtool/, unit_tests/: use sha256

+ instead of md5 in phishcheck.  move sha256 to libclamav.  add more

+ tests.

+

 Wed Feb 18 12:41:17 CET 2009 (tk)

 ---------------------------------

  * etc/clamav-milter.conf: fix PidFile example (bb#1408)

@@ -28,7 +28,6 @@ freshclam_SOURCES = \

     $(top_srcdir)/shared/getopt.h \

     $(top_srcdir)/shared/misc.c \

     $(top_srcdir)/shared/misc.h \

-    $(top_srcdir)/shared/sha256.c \

     $(top_srcdir)/shared/cdiff.c \

     $(top_srcdir)/shared/cdiff.h \

     $(top_srcdir)/shared/tar.c \

@@ -73,10 +73,10 @@ am__installdirs = "$(DESTDIR)$(bindir)"

 binPROGRAMS_INSTALL = $(INSTALL_PROGRAM)

 PROGRAMS = $(bin_PROGRAMS)

 am_freshclam_OBJECTS = output.$(OBJEXT) optparser.$(OBJEXT) \

-	getopt.$(OBJEXT) misc.$(OBJEXT) sha256.$(OBJEXT) \

-	cdiff.$(OBJEXT) tar.$(OBJEXT) freshclam.$(OBJEXT) \

-	manager.$(OBJEXT) notify.$(OBJEXT) dns.$(OBJEXT) \

-	execute.$(OBJEXT) nonblock.$(OBJEXT) mirman.$(OBJEXT)

+	getopt.$(OBJEXT) misc.$(OBJEXT) cdiff.$(OBJEXT) tar.$(OBJEXT) \

+	freshclam.$(OBJEXT) manager.$(OBJEXT) notify.$(OBJEXT) \

+	dns.$(OBJEXT) execute.$(OBJEXT) nonblock.$(OBJEXT) \

+	mirman.$(OBJEXT)

 freshclam_OBJECTS = $(am_freshclam_OBJECTS)

 freshclam_LDADD = $(LDADD)

 DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)

@@ -257,7 +257,6 @@ freshclam_SOURCES = \

     $(top_srcdir)/shared/getopt.h \

     $(top_srcdir)/shared/misc.c \

     $(top_srcdir)/shared/misc.h \

-    $(top_srcdir)/shared/sha256.c \

     $(top_srcdir)/shared/cdiff.c \

     $(top_srcdir)/shared/cdiff.h \

     $(top_srcdir)/shared/tar.c \

@@ -378,7 +377,6 @@ distclean-compile:

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/notify.Po@am__quote@

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/optparser.Po@am__quote@

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/output.Po@am__quote@

-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sha256.Po@am__quote@

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tar.Po@am__quote@

 .c.o:

@@ -458,20 +456,6 @@ misc.obj: $(top_srcdir)/shared/misc.c

 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@

 @am__fastdepCC_FALSE@	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o misc.obj `if test -f '$(top_srcdir)/shared/misc.c'; then $(CYGPATH_W) '$(top_srcdir)/shared/misc.c'; else $(CYGPATH_W) '$(srcdir)/$(top_srcdir)/shared/misc.c'; fi`

-sha256.o: $(top_srcdir)/shared/sha256.c

-@am__fastdepCC_TRUE@	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT sha256.o -MD -MP -MF $(DEPDIR)/sha256.Tpo -c -o sha256.o `test -f '$(top_srcdir)/shared/sha256.c' || echo '$(srcdir)/'`$(top_srcdir)/shared/sha256.c

-@am__fastdepCC_TRUE@	mv -f $(DEPDIR)/sha256.Tpo $(DEPDIR)/sha256.Po

-@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$(top_srcdir)/shared/sha256.c' object='sha256.o' libtool=no @AMDEPBACKSLASH@

-@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@

-@am__fastdepCC_FALSE@	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o sha256.o `test -f '$(top_srcdir)/shared/sha256.c' || echo '$(srcdir)/'`$(top_srcdir)/shared/sha256.c

-

-sha256.obj: $(top_srcdir)/shared/sha256.c

-@am__fastdepCC_TRUE@	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT sha256.obj -MD -MP -MF $(DEPDIR)/sha256.Tpo -c -o sha256.obj `if test -f '$(top_srcdir)/shared/sha256.c'; then $(CYGPATH_W) '$(top_srcdir)/shared/sha256.c'; else $(CYGPATH_W) '$(srcdir)/$(top_srcdir)/shared/sha256.c'; fi`

-@am__fastdepCC_TRUE@	mv -f $(DEPDIR)/sha256.Tpo $(DEPDIR)/sha256.Po

-@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$(top_srcdir)/shared/sha256.c' object='sha256.obj' libtool=no @AMDEPBACKSLASH@

-@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@

-@am__fastdepCC_FALSE@	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o sha256.obj `if test -f '$(top_srcdir)/shared/sha256.c'; then $(CYGPATH_W) '$(top_srcdir)/shared/sha256.c'; else $(CYGPATH_W) '$(srcdir)/$(top_srcdir)/shared/sha256.c'; fi`

-

 cdiff.o: $(top_srcdir)/shared/cdiff.c

 @am__fastdepCC_TRUE@	$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT cdiff.o -MD -MP -MF $(DEPDIR)/cdiff.Tpo -c -o cdiff.o `test -f '$(top_srcdir)/shared/cdiff.c' || echo '$(srcdir)/'`$(top_srcdir)/shared/cdiff.c

 @am__fastdepCC_TRUE@	mv -f $(DEPDIR)/cdiff.Tpo $(DEPDIR)/cdiff.Po

@@ -264,7 +264,9 @@ libclamav_la_SOURCES = \

 	version.h\

 	mpool.c\

 	mpool.h \

-	default.h

+	default.h\

+	sha256.c\

+	sha256.h

 .PHONY: version.h.tmp

 version.lo: version.h

@@ -100,7 +100,8 @@ am_libclamav_la_OBJECTS = matcher-ac.lo matcher-bm.lo matcher.lo \

 	sis.lo uuencode.lo phishcheck.lo phish_domaincheck_db.lo \

 	phish_whitelist.lo regex_list.lo regex_suffix.lo mspack.lo \

 	cab.lo entconv.lo hashtab.lo dconf.lo lzma_iface.lo explode.lo \

-	textnorm.lo dlp.lo js-norm.lo uniq.lo version.lo mpool.lo

+	textnorm.lo dlp.lo js-norm.lo uniq.lo version.lo mpool.lo \

+	sha256.lo

 libclamav_la_OBJECTS = $(am_libclamav_la_OBJECTS)

 libclamav_la_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \

 	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \

@@ -560,7 +561,9 @@ libclamav_la_SOURCES = \

 	version.h\

 	mpool.c\

 	mpool.h \

-	default.h

+	default.h\

+	sha256.c\

+	sha256.h

 noinst_LTLIBRARIES = libclamav_internal_utils.la

 COMMON_CLEANFILES = version.h version.h.tmp *.gcda *.gcno lzma/*.gcda lzma/*.gcno

@@ -712,6 +715,7 @@ distclean-compile:

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/regex_suffix.Plo@am__quote@

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rtf.Plo@am__quote@

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/scanners.Plo@am__quote@

+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sha256.Plo@am__quote@

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sis.Plo@am__quote@

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/special.Plo@am__quote@

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/spin.Plo@am__quote@

@@ -128,6 +128,10 @@ CLAMAV_PRIVATE {

     cli_ftw;

     cli_unlink;

     cli_writen;

+    sha256_init;

+    sha256_update;

+    sha256_final;

+    cli_url_canon;

   local:

     *;

 };

@@ -45,7 +45,7 @@

 #include "iana_tld.h"

 #include "iana_cctld.h"

 #include "scanners.h"

-#include "md5.h"

+#include "sha256.h"

 #include <assert.h>

 #include "mpool.h"

@@ -482,6 +482,7 @@ static int isSSL(const char* URL)

 static void

 str_hex_to_char(char **begin, const char **end)

 {

+	char *firsthex, *sbegin_;

 	char *sbegin = *begin;

 	const char *str_end = *end;

@@ -497,16 +498,25 @@ str_hex_to_char(char **begin, const char **end)

 		sbegin += 2;

 	}

 	*begin = sbegin++;

-	while(sbegin+3 < str_end) {

-		while(sbegin+3<str_end && sbegin[0]=='%') {

-			const char* src = sbegin+3;

+	do {

+	    sbegin_ = sbegin;

+	    firsthex = NULL;

+	    while(sbegin+3 <= str_end) {

+		if (sbegin+3<=str_end && sbegin[0]=='%') {

+		    const char* src = sbegin+3;

+		    if (isxdigit(sbegin[1]) && isxdigit(sbegin[2])) {

 			*sbegin = hex2int((unsigned char*)sbegin+1);

+			if (*sbegin == '%' && !firsthex)

+			    firsthex = sbegin;

 			/* move string */

 			memmove(sbegin+1,src,str_end-src+1);

 			str_end -= 2;

+		    }

 		}

 		sbegin++;

-	}

+	    }

+	    sbegin = sbegin_;

+	} while (firsthex);

 	*end = str_end;

 }

@@ -1158,66 +1168,96 @@ static int hash_match(const struct regex_matcher *rlist, const char *host, size_

 	s[hlen+plen] = '\0';

 	cli_dbgmsg("hash lookup for: %s\n",s);

 #endif

-	if(rlist->md5_hashes.bm_patterns) {

-		unsigned char md5_dig[16];

-		cli_md5_ctx md5;

-

-		cli_md5_init(&md5);

-		cli_md5_update(&md5, host, hlen);

-		cli_md5_update(&md5, path, plen);

-		cli_md5_final(md5_dig, &md5);

-		if(SO_search(&rlist->md5_filter, md5_dig, 16) != -1 &&

-				cli_bm_scanbuff(md5_dig, 16, &virname, &rlist->md5_hashes,0,0,-1) == CL_VIRUS) {

-			switch(*virname) {

-				case '1':

-					return CL_PHISH_HASH1;

-				case '2':

-					return CL_PHISH_HASH2;

-				default:

-					return CL_PHISH_HASH0;

-			}

+	if(rlist->sha256_hashes.bm_patterns) {

+	    unsigned char sha256_dig[32];

+	    SHA256_CTX sha256;

+

+	    sha256_init(&sha256);

+	    sha256_update(&sha256, host, hlen);

+	    sha256_update(&sha256, path, plen);

+	    sha256_final(&sha256, sha256_dig);

+	    if(SO_search(&rlist->sha256_filter, sha256_dig, 32) != -1 &&

+	       cli_bm_scanbuff(sha256_dig, 32, &virname, &rlist->sha256_hashes,0,0,-1) == CL_VIRUS) {

+		switch(*virname) {

+		    case '1':

+			return CL_PHISH_HASH1;

+		    case '2':

+			return CL_PHISH_HASH2;

+		    default:

+			return CL_PHISH_HASH0;

 		}

+	    }

 	}

 	return CL_SUCCESS;

 }

 #define URL_MAX_LEN 1024

 #define COMPONENTS 4

-static int url_hash_match(const struct regex_matcher *rlist, const char *inurl, size_t len)

+int cli_url_canon(const char *inurl, size_t len, char *urlbuff, size_t dest_len, char **host, size_t *hostlen, char **path, size_t *pathlen)

 {

-	char urlbuff[URL_MAX_LEN+3];/* htmlnorm truncates at 1024 bytes + terminating null + slash + host end null */

-	char *url, *p;

+	char *url, *p, *last;

+	char *host_begin, *path_begin;

 	const char *urlend = urlbuff + len;

-	char *host_begin;

 	size_t host_len, path_len;

-	char *path_begin;

-	const char *component;

-	const char *lp[COMPONENTS+1];

-	size_t pp[COMPONENTS+2];

-	size_t j, k, ji, ki;

-	int rc;

-	if(!rlist || !rlist->md5_hashes.bm_patterns) {

-		return CL_SUCCESS;

-	}

-	if(!inurl)

-		return CL_EMEM;

-	strncpy(urlbuff, inurl, URL_MAX_LEN);

-	urlbuff[URL_MAX_LEN] = urlbuff[URL_MAX_LEN+1] = urlbuff[URL_MAX_LEN+2] = '\0';

+	dest_len -= 3;

+	strncpy(urlbuff, inurl, dest_len);

+	urlbuff[dest_len] = urlbuff[dest_len+1] = urlbuff[dest_len+2] = '\0';

 	url = urlbuff;

-	str_hex_to_char(&url, &urlend);

-	len = urlend - url;

-	host_begin = strchr(url,':');

-	if(!host_begin) {

+

+	host_begin = strchr(url, ':');

+	if(!host_begin)

 		return CL_PHISH_CLEAN;

-	}

 	++host_begin;

+

+	p = strchr(host_begin, '@');

+	if (p)

+	    host_begin = p+1;

+	url = host_begin;

+	str_hex_to_char(&url, &urlend);

+	host_begin = url;

+	len = urlend - url;

 	while((host_begin < urlend) && *host_begin == '/') ++host_begin;

 	while(*host_begin == '.' && host_begin < urlend) ++host_begin;

-	p = strchr(host_begin, '@');

-	if(p)

-		host_begin = p+1;

+	last = strchr(host_begin, '/');

+	p = host_begin;

+	while (p < urlend) {

+	    if (p+2 < urlend && *p == '/' && p[1] == '.' ) {

+		if (p[2] == '/') {

+		    if (p + 3 < urlend)

+			memmove(p+1, p+3, urlend - p - 3);

+		    urlend -= 2;

+		}

+		else if (p[2] == '.' && (p[3] == '/' || p[3] == '\0') && last) {

+		    if (p+4 < urlend)

+			memmove(last+1, p+4, urlend - p - 4);

+		    urlend -= 3 + (p - last);

+		}

+	    }

+	    if (*p == '/')

+		last = p;

+	    p++;

+	}

+	p = &url[urlend - url];

+	*p = '\0';

+

+	p = host_begin;

+	while (p < urlend && p+2 < url + dest_len) {

+	    unsigned char c = *p;

+	    if (c <= 32 || c >= 127 || c == '%' || c == '#') {

+		char hexchars[] = "0123456789ABCDEF";

+		memmove(p+3, p+1, urlend - p - 1);

+		*p++ = '%';

+		*p++ = hexchars[c>>4];

+		*p = hexchars[c&0xf];

+		urlend += 2;

+	    }

+	    p++;

+	}

+	*p = '\0';

+	urlend = p;

+	len = urlend - url;

 	host_len = strcspn(host_begin, ":/?");

 	path_begin = host_begin + host_len;

 	if(host_len < len) {

@@ -1227,10 +1267,45 @@ static int url_hash_match(const struct regex_matcher *rlist, const char *inurl,

 	} else path_begin = url+len;

 	if(url + len >= path_begin) {

 		path_len = url + len - path_begin + 1;

-	} else

+		p = strchr(path_begin, '#');

+		if (p) {

+		    *p = '\0';

+		    path_len = p - path_begin;

+		}

+	} else {

 		path_len = 0;

+		path_begin = "";

+	}

 	str_make_lowercase(host_begin, host_len);

+	*host = host_begin;

+	*path = path_begin;

+	*hostlen = host_len;

+	*pathlen = path_len;

+	return CL_PHISH_NODECISION;

+}

+

+static int url_hash_match(const struct regex_matcher *rlist, const char *inurl, size_t len)

+{

+	size_t j, k, ji, ki;

+	char *host_begin, *path_begin;

+	const char *component;

+	size_t path_len;

+	size_t host_len;

+	char *p;

+	int rc;

+	const char *lp[COMPONENTS+1];

+	size_t pp[COMPONENTS+2];

+	char urlbuff[URL_MAX_LEN+3];/* htmlnorm truncates at 1024 bytes + terminating null + slash + host end null */

+

+	if(!rlist || !rlist->sha256_hashes.bm_patterns) {

+		return CL_SUCCESS;

+	}

+	if(!inurl)

+		return CL_EMEM;

+	rc = cli_url_canon(inurl, len, urlbuff, sizeof(urlbuff), &host_begin, &host_len, &path_begin, &path_len);

+	if (rc == CL_PHISH_CLEAN)

+	    return rc;

 	j=COMPONENTS;

 	component = strrchr(host_begin, '.');

 	while(component && j > 0) {

@@ -72,6 +72,7 @@ void phish_disable(struct cl_engine* engine,const char* reason);

 /* Global, non-thread-safe functions, call only once! */

 int phishing_init(struct cl_engine* engine);

 void phishing_done(struct cl_engine* engine);

+int cli_url_canon(const char *inurl, size_t len, char *urlbuff, size_t dest_len, char **host, size_t *hostlen, char **path, size_t *pathlen);

 /* end of non-thread-safe functions */

@@ -363,13 +363,13 @@ int init_regex_list(struct regex_matcher* matcher)

 		return rc;

 	}

 #ifdef USE_MPOOL

-	matcher->md5_hashes.mempool = mp;

+	matcher->sha256_hashes.mempool = mp;

 #endif

-	if((rc = cli_bm_init(&matcher->md5_hashes))) {

+	if((rc = cli_bm_init(&matcher->sha256_hashes))) {

 		return rc;

 	}

 	SO_init(&matcher->filter);

-	SO_init(&matcher->md5_filter);

+	SO_init(&matcher->sha256_filter);

 	return CL_SUCCESS;

 }

@@ -425,15 +425,15 @@ static int add_hash(struct regex_matcher *matcher, char* pattern, const char fl)

 	pat->pattern = (unsigned char*)cli_mpool_hex2str(matcher->mempool, pattern);

 	if(!pat->pattern)

 		return CL_EMALFDB;

-	pat->length = 16;

+	pat->length = 32;

 	pat->virname = mpool_malloc(matcher->mempool, 1);

 	if(!pat->virname) {

 		free(pat);

 		return CL_EMEM;

 	}

 	*pat->virname = fl;

-	SO_preprocess_add(&matcher->md5_filter, pat->pattern, pat->length);

-	if((rc = cli_bm_addpatt(&matcher->md5_hashes, pat))) {

+	SO_preprocess_add(&matcher->sha256_filter, pat->pattern, pat->length);

+	if((rc = cli_bm_addpatt(&matcher->sha256_hashes, pat))) {

 		cli_errmsg("add_hash: failed to add BM pattern\n");

 		free(pat->pattern);

 		free(pat->virname);

@@ -596,7 +596,7 @@ void regex_list_done(struct regex_matcher* matcher)

 			mpool_free(matcher->mempool, matcher->all_pregs);

 		}

 		hashtab_free(&matcher->suffix_hash);

-		cli_bm_free(&matcher->md5_hashes);

+		cli_bm_free(&matcher->sha256_hashes);

 	}

 }

@@ -50,8 +50,8 @@ struct regex_matcher {

 	size_t regex_cnt;

 	regex_t **all_pregs;

 	struct cli_matcher suffixes;

-	struct cli_matcher md5_hashes;

-	struct filter md5_filter;

+	struct cli_matcher sha256_hashes;

+	struct filter sha256_filter;

 	struct filter filter;

 #ifdef USE_MPOOL

 	mpool_t *mempool;

new file mode 100644

@@ -0,0 +1,481 @@

+/*-

+ * Copyright (c) 2001-2003 Allan Saddi <allan@saddi.com>

+ * All rights reserved.

+ *

+ * Redistribution and use in source and binary forms, with or without

+ * modification, are permitted provided that the following conditions

+ * are met:

+ * 1. Redistributions of source code must retain the above copyright

+ *    notice, this list of conditions and the following disclaimer.

+ * 2. Redistributions in binary form must reproduce the above copyright

+ *    notice, this list of conditions and the following disclaimer in the

+ *    documentation and/or other materials provided with the distribution.

+ *

+ * THIS SOFTWARE IS PROVIDED BY ALLAN SADDI AND HIS CONTRIBUTORS ``AS IS''

+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

+ * ARE DISCLAIMED.  IN NO EVENT SHALL ALLAN SADDI OR HIS CONTRIBUTORS BE

+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

+ * POSSIBILITY OF SUCH DAMAGE.

+ *

+ * $Id: sha256.c 680 2003-07-25 21:57:49Z asaddi $

+ */

+

+/*

+ * Define WORDS_BIGENDIAN if compiling on a big-endian architecture.

+ *

+ * Define SHA256_TEST to test the implementation using the NIST's

+ * sample messages. The output should be:

+ *

+ *   ba7816bf 8f01cfea 414140de 5dae2223 b00361a3 96177a9c b410ff61 f20015ad

+ *   248d6a61 d20638b8 e5c02693 0c3e6039 a33ce459 64ff2167 f6ecedd4 19db06c1

+ *   cdc76e5c 9914fb92 81a1c7e2 84d73e67 f1809a48 a497200e 046d39cc c7112cd0

+ */

+

+#ifdef HAVE_CONFIG_H

+#include "clamav-config.h"

+#endif /* HAVE_CONFIG_H */

+

+#if HAVE_INTTYPES_H

+# include <inttypes.h>

+#else

+# if HAVE_STDINT_H

+#  include <stdint.h>

+# endif

+#endif

+

+#include <string.h>

+

+#include "sha256.h"

+

+#ifndef lint

+static const char rcsid[] =

+	"$Id: sha256.c 680 2003-07-25 21:57:49Z asaddi $";

+#endif /* !lint */

+

+#define ROTL(x, n) (((x) << (n)) | ((x) >> (32 - (n))))

+#define ROTR(x, n) (((x) >> (n)) | ((x) << (32 - (n))))

+

+#define Ch(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))

+#define Maj(x, y, z) (((x) & ((y) | (z))) | ((y) & (z)))

+#define SIGMA0(x) (ROTR((x), 2) ^ ROTR((x), 13) ^ ROTR((x), 22))

+#define SIGMA1(x) (ROTR((x), 6) ^ ROTR((x), 11) ^ ROTR((x), 25))

+#define sigma0(x) (ROTR((x), 7) ^ ROTR((x), 18) ^ ((x) >> 3))

+#define sigma1(x) (ROTR((x), 17) ^ ROTR((x), 19) ^ ((x) >> 10))

+

+#define DO_ROUND() { \

+  t1 = h + SIGMA1(e) + Ch(e, f, g) + *(Kp++) + *(W++); \

+  t2 = SIGMA0(a) + Maj(a, b, c); \

+  h = g; \

+  g = f; \

+  f = e; \

+  e = d + t1; \

+  d = c; \

+  c = b; \

+  b = a; \

+  a = t1 + t2; \

+}

+

+static const uint32_t K[64] = {

+  0x428a2f98L, 0x71374491L, 0xb5c0fbcfL, 0xe9b5dba5L,

+  0x3956c25bL, 0x59f111f1L, 0x923f82a4L, 0xab1c5ed5L,

+  0xd807aa98L, 0x12835b01L, 0x243185beL, 0x550c7dc3L,

+  0x72be5d74L, 0x80deb1feL, 0x9bdc06a7L, 0xc19bf174L,

+  0xe49b69c1L, 0xefbe4786L, 0x0fc19dc6L, 0x240ca1ccL,

+  0x2de92c6fL, 0x4a7484aaL, 0x5cb0a9dcL, 0x76f988daL,

+  0x983e5152L, 0xa831c66dL, 0xb00327c8L, 0xbf597fc7L,

+  0xc6e00bf3L, 0xd5a79147L, 0x06ca6351L, 0x14292967L,

+  0x27b70a85L, 0x2e1b2138L, 0x4d2c6dfcL, 0x53380d13L,

+  0x650a7354L, 0x766a0abbL, 0x81c2c92eL, 0x92722c85L,

+  0xa2bfe8a1L, 0xa81a664bL, 0xc24b8b70L, 0xc76c51a3L,

+  0xd192e819L, 0xd6990624L, 0xf40e3585L, 0x106aa070L,

+  0x19a4c116L, 0x1e376c08L, 0x2748774cL, 0x34b0bcb5L,

+  0x391c0cb3L, 0x4ed8aa4aL, 0x5b9cca4fL, 0x682e6ff3L,

+  0x748f82eeL, 0x78a5636fL, 0x84c87814L, 0x8cc70208L,

+  0x90befffaL, 0xa4506cebL, 0xbef9a3f7L, 0xc67178f2L

+};

+

+#ifndef RUNTIME_ENDIAN

+

+#if WORDS_BIGENDIAN == 1 

+

+#define BYTESWAP(x) (x)

+#define BYTESWAP64(x) (x)

+

+#else /* WORDS_BIGENDIAN */

+

+#define BYTESWAP(x) ((ROTR((x), 8) & 0xff00ff00L) | \

+		     (ROTL((x), 8) & 0x00ff00ffL))

+#define BYTESWAP64(x) _byteswap64(x)

+

+static inline uint64_t _byteswap64(uint64_t x)

+{

+  uint32_t a = x >> 32;

+  uint32_t b = (uint32_t) x;

+  return ((uint64_t) BYTESWAP(b) << 32) | (uint64_t) BYTESWAP(a);

+}

+

+#endif /* WORDS_BIGENDIAN */

+

+#else /* !RUNTIME_ENDIAN */

+

+#define BYTESWAP(x) _byteswap(sc->littleEndian, x)

+#define BYTESWAP64(x) _byteswap64(sc->littleEndian, x)

+

+#define _BYTESWAP(x) ((ROTR((x), 8) & 0xff00ff00L) | \

+		      (ROTL((x), 8) & 0x00ff00ffL))

+#define _BYTESWAP64(x) __byteswap64(x)

+

+static inline uint64_t __byteswap64(uint64_t x)

+{

+  uint32_t a = x >> 32;

+  uint32_t b = (uint32_t) x;

+  return ((uint64_t) _BYTESWAP(b) << 32) | (uint64_t) _BYTESWAP(a);

+}

+

+static inline uint32_t _byteswap(int littleEndian, uint32_t x)

+{

+  if (!littleEndian)

+    return x;

+  else

+    return _BYTESWAP(x);

+}

+

+static inline uint64_t _byteswap64(int littleEndian, uint64_t x)

+{

+  if (!littleEndian)

+    return x;

+  else

+    return _BYTESWAP64(x);

+}

+

+static inline void setEndian(int *littleEndianp)

+{

+  union {

+    uint32_t w;

+    uint8_t b[4];

+  } endian;

+

+  endian.w = 1L;

+  *littleEndianp = endian.b[0] != 0;

+}

+

+#endif /* !RUNTIME_ENDIAN */

+

+static const uint8_t padding[64] = {

+  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00

+};

+

+void

+sha256_init (SHA256_CTX *sc)

+{

+#ifdef RUNTIME_ENDIAN

+  setEndian (&sc->littleEndian);

+#endif /* RUNTIME_ENDIAN */

+

+  sc->totalLength = 0LL;

+  sc->hash[0] = 0x6a09e667L;

+  sc->hash[1] = 0xbb67ae85L;

+  sc->hash[2] = 0x3c6ef372L;

+  sc->hash[3] = 0xa54ff53aL;

+  sc->hash[4] = 0x510e527fL;

+  sc->hash[5] = 0x9b05688cL;

+  sc->hash[6] = 0x1f83d9abL;

+  sc->hash[7] = 0x5be0cd19L;

+  sc->bufferLength = 0L;

+}

+

+static void

+burnStack (int size)

+{

+  char buf[128];

+

+  memset (buf, 0, sizeof (buf));

+  size -= sizeof (buf);

+  if (size > 0)

+    burnStack (size);

+}

+

+static void

+SHA256Guts (SHA256_CTX *sc, const uint32_t *cbuf)

+{

+  uint32_t buf[64];

+  uint32_t *W, *W2, *W7, *W15, *W16;

+  uint32_t a, b, c, d, e, f, g, h;

+  uint32_t t1, t2;

+  const uint32_t *Kp;

+  int i;

+

+  W = buf;

+

+  for (i = 15; i >= 0; i--) {

+    *(W++) = BYTESWAP(*cbuf);

+    cbuf++;

+  }

+

+  W16 = &buf[0];

+  W15 = &buf[1];

+  W7 = &buf[9];

+  W2 = &buf[14];

+

+  for (i = 47; i >= 0; i--) {

+    *(W++) = sigma1(*W2) + *(W7++) + sigma0(*W15) + *(W16++);

+    W2++;

+    W15++;

+  }

+

+  a = sc->hash[0];

+  b = sc->hash[1];

+  c = sc->hash[2];

+  d = sc->hash[3];

+  e = sc->hash[4];

+  f = sc->hash[5];

+  g = sc->hash[6];

+  h = sc->hash[7];

+

+  Kp = K;

+  W = buf;

+

+#ifndef SHA256_UNROLL

+#define SHA256_UNROLL 1

+#endif /* !SHA256_UNROLL */

+

+#if SHA256_UNROLL == 1

+  for (i = 63; i >= 0; i--)

+    DO_ROUND();

+#elif SHA256_UNROLL == 2

+  for (i = 31; i >= 0; i--) {

+    DO_ROUND(); DO_ROUND();

+  }

+#elif SHA256_UNROLL == 4

+  for (i = 15; i >= 0; i--) {

+    DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+  }

+#elif SHA256_UNROLL == 8

+  for (i = 7; i >= 0; i--) {

+    DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+    DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+  }

+#elif SHA256_UNROLL == 16

+  for (i = 3; i >= 0; i--) {

+    DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+    DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+    DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+    DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+  }

+#elif SHA256_UNROLL == 32

+  for (i = 1; i >= 0; i--) {

+    DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+    DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+    DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+    DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+    DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+    DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+    DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+    DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+  }

+#elif SHA256_UNROLL == 64

+  DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+  DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+  DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+  DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+  DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+  DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+  DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+  DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+  DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+  DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+  DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+  DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+  DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+  DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+  DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+  DO_ROUND(); DO_ROUND(); DO_ROUND(); DO_ROUND();

+#else

+#error "SHA256_UNROLL must be 1, 2, 4, 8, 16, 32, or 64!"

+#endif

+

+  sc->hash[0] += a;

+  sc->hash[1] += b;

+  sc->hash[2] += c;

+  sc->hash[3] += d;

+  sc->hash[4] += e;

+  sc->hash[5] += f;

+  sc->hash[6] += g;

+  sc->hash[7] += h;

+}

+

+void

+sha256_update (SHA256_CTX *sc, const void *vdata, uint32_t len)

+{

+  const uint8_t *data = vdata;

+  uint32_t bufferBytesLeft;

+  uint32_t bytesToCopy;

+  int needBurn = 0;

+

+#ifdef SHA256_FAST_COPY

+  if (sc->bufferLength) {

+    bufferBytesLeft = 64L - sc->bufferLength;

+

+    bytesToCopy = bufferBytesLeft;

+    if (bytesToCopy > len)

+      bytesToCopy = len;

+

+    memcpy (&sc->buffer.bytes[sc->bufferLength], data, bytesToCopy);

+

+    sc->totalLength += bytesToCopy * 8L;

+

+    sc->bufferLength += bytesToCopy;

+    data += bytesToCopy;

+    len -= bytesToCopy;

+

+    if (sc->bufferLength == 64L) {

+      SHA256Guts (sc, sc->buffer.words);

+      needBurn = 1;

+      sc->bufferLength = 0L;

+    }

+  }

+

+  while (len > 63L) {

+    sc->totalLength += 512L;

+

+    SHA256Guts (sc, data);

+    needBurn = 1;

+

+    data += 64L;

+    len -= 64L;

+  }

+

+  if (len) {

+    memcpy (&sc->buffer.bytes[sc->bufferLength], data, len);

+

+    sc->totalLength += len * 8L;

+

+    sc->bufferLength += len;

+  }

+#else /* SHA256_FAST_COPY */

+  while (len) {

+    bufferBytesLeft = 64L - sc->bufferLength;

+

+    bytesToCopy = bufferBytesLeft;

+    if (bytesToCopy > len)

+      bytesToCopy = len;

+

+    memcpy (&sc->buffer.bytes[sc->bufferLength], data, bytesToCopy);

+

+    sc->totalLength += bytesToCopy * 8L;

+

+    sc->bufferLength += bytesToCopy;

+    data += bytesToCopy;

+    len -= bytesToCopy;

+

+    if (sc->bufferLength == 64L) {

+      SHA256Guts (sc, sc->buffer.words);

+      needBurn = 1;

+      sc->bufferLength = 0L;

+    }

+  }

+#endif /* SHA256_FAST_COPY */

+

+  if (needBurn)

+    burnStack (sizeof (uint32_t[74]) + sizeof (uint32_t *[6]) + sizeof (int));

+}

+

+void

+sha256_final (SHA256_CTX *sc, uint8_t hash[SHA256_HASH_SIZE])

+{

+  uint32_t bytesToPad;

+  uint64_t lengthPad;

+  int i;

+

+  bytesToPad = 120L - sc->bufferLength;

+  if (bytesToPad > 64L)

+    bytesToPad -= 64L;

+

+  lengthPad = BYTESWAP64(sc->totalLength);

+

+  sha256_update (sc, padding, bytesToPad);

+  sha256_update (sc, &lengthPad, 8L);

+

+  if (hash) {

+    for (i = 0; i < SHA256_HASH_WORDS; i++) {

+#ifdef SHA256_FAST_COPY

+      *((uint32_t *) hash) = BYTESWAP(sc->hash[i]);

+#else /* SHA256_FAST_COPY */

+      hash[0] = (uint8_t) (sc->hash[i] >> 24);

+      hash[1] = (uint8_t) (sc->hash[i] >> 16);

+      hash[2] = (uint8_t) (sc->hash[i] >> 8);

+      hash[3] = (uint8_t) sc->hash[i];

+#endif /* SHA256_FAST_COPY */

+      hash += 4;

+    }

+  }

+}

+

+#ifdef SHA256_TEST

+

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+

+int

+main (int argc, char *argv[])

+{

+  SHA256_CTX foo;

+  uint8_t hash[SHA256_HASH_SIZE];

+  char buf[1000];

+  int i;

+

+  sha256_init (&foo);

+  sha256_update (&foo, "abc", 3);

+  sha256_final (&foo, hash);

+

+  for (i = 0; i < SHA256_HASH_SIZE;) {

+    printf ("%02x", hash[i++]);

+    if (!(i % 4))