cvs commit: ALFS/nALFS/src/lib Makefile.in digest.c digest.h md5.c md5.h

neven at linuxfromscratch.org neven at linuxfromscratch.org
Fri Sep 19 03:49:01 PDT 2003


neven       03/09/19 04:49:01

  Modified:    nALFS    Rules.mak.in configure.in
               nALFS/src Makefile.in
               nALFS/src/handlers Makefile.in new-unpack.c
  Added:       nALFS/src/lib Makefile.in digest.c digest.h md5.c md5.h
  Log:
  MD5 computation code from Christophe Devine added and --without-ssl
  made default.  src/lib directory created and digest/md5 common code
  moved into it from unpack handler.  Done by Kevin P. Fleming.
  
  Revision  Changes    Path
  1.3       +5 -2      ALFS/nALFS/Rules.mak.in
  
  Index: Rules.mak.in
  ===================================================================
  RCS file: /home/cvsroot/ALFS/nALFS/Rules.mak.in,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- Rules.mak.in	17 Sep 2003 21:51:16 -0000	1.2
  +++ Rules.mak.in	19 Sep 2003 10:49:01 -0000	1.3
  @@ -38,20 +38,23 @@
   INSTALL     := @INSTALL@
   
   CC          := @CC@
  +LD          := @LD@
  +AR          := @AR@
  +RANLIB      := @RANLIB@
   
   CPPFLAGS    := @CPPFLAGS@
   CFLAGS      := @CFLAGS@
   LDFLAGS     := @LDFLAGS@
   LDLIBS      := @LIBS@
   
  +NALFS_LIB   := $(top_builddir)/src/lib/lib.a
   
   handlers_directory := $(libdir)/nALFS/
   
   CPPFLAGS += -DHANDLERS_DIRECTORY=\"$(handlers_directory)\"
  -CPPFLAGS += -I$(abs_top_srcdir)/src/
  +CPPFLAGS += -I$(abs_top_srcdir)/src/ -I$(abs_top_srcdir)/src/lib/
   
   CFLAGS   += -W -Wall -Wshadow -Winline
  -
   
   C_FILES  := $(wildcard $(srcdir)/*.c)
   H_FILES  := $(wildcard $(srcdir)/*.h)
  
  
  
  1.3       +8 -4      ALFS/nALFS/configure.in
  
  Index: configure.in
  ===================================================================
  RCS file: /home/cvsroot/ALFS/nALFS/configure.in,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- configure.in	17 Sep 2003 21:51:16 -0000	1.2
  +++ configure.in	19 Sep 2003 10:49:01 -0000	1.3
  @@ -28,6 +28,9 @@
   AC_PROG_CC
   AC_PROG_INSTALL
   
  +AC_CHECK_TOOL(AR, ar)
  +AC_CHECK_TOOL(LD, ld)
  +AC_CHECK_TOOL(RANLIB, ranlib, :)
   
   AC_CHECK_LIB(ncurses, initscr)
   AC_CHECK_LIB(form, form_driver)
  @@ -66,22 +69,22 @@
   
   AC_ARG_WITH(ssl,
   [  --with-ssl=PREFIX       specify prefix for ssl files (ssl will be used
  -                          for checking MD5 digest in <unpack>)],
  +                          for checking non-MD5 digests in <unpack> elements)],
   [
   	case "$withval" in
   		n|no)
  -			disable_ssl=yes
   			;;
   		y|ye|yes)
  +			enable_ssl=yes
   			;;
  -
   		*)
   			LIBS="$LIBS -L$withval/lib"
  +			enable_ssl=yes
   			;;
   	esac
   ])
   
  -if test "$disable_ssl" != "yes" ; then
  +if test "$enable_ssl" == "yes" ; then
   	AC_CHECK_LIB(ssl, OpenSSL_add_all_digests, [
   		CPPFLAGS="$CPPFLAGS -DHAVE_LIBSSL"
   		LIBS="$LIBS -lcrypto -lssl"])
  @@ -130,5 +133,6 @@
   Rules.mak
   Makefile
   src/Makefile
  +src/lib/Makefile
   src/handlers/Makefile
   ])
  
  
  
  1.3       +8 -3      ALFS/nALFS/src/Makefile.in
  
  Index: Makefile.in
  ===================================================================
  RCS file: /home/cvsroot/ALFS/nALFS/src/Makefile.in,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- Makefile.in	17 Sep 2003 21:51:17 -0000	1.2
  +++ Makefile.in	19 Sep 2003 10:49:01 -0000	1.3
  @@ -29,14 +29,17 @@
   LDFLAGS += -Wl,-export-dynamic
   
   
  -.PHONY: all handlers
  +.PHONY: all $(NALFS_LIB) handlers
   
  -all: handlers nALFS
  +all: $(NALFS_LIB) handlers nALFS
  +
  +$(NALFS_LIB):
  +	@make -C lib
   
   handlers:
   	@make -C handlers
   
  -nALFS: $(O_FILES)
  +nALFS: $(O_FILES) $(NALFS_LIB)
   	$(CC) $(LDFLAGS) $^ $(LDLIBS) -o $@
   
   $(O_FILES): %.o: $(srcdir)/%.c
  @@ -46,9 +49,11 @@
   .PHONY: clean distclean
   
   clean:
  +	@make -C lib clean
   	@make -C handlers clean
   	$(RM) $(O_FILES) nALFS
   
   distclean:
  +	@make -C lib distclean
   	@make -C handlers distclean
   	$(RM) Makefile
  
  
  
  1.3       +4 -6      ALFS/nALFS/src/handlers/Makefile.in
  
  Index: Makefile.in
  ===================================================================
  RCS file: /home/cvsroot/ALFS/nALFS/src/handlers/Makefile.in,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- Makefile.in	17 Sep 2003 21:51:17 -0000	1.2
  +++ Makefile.in	19 Sep 2003 10:49:01 -0000	1.3
  @@ -28,16 +28,14 @@
   
   CFLAGS += -fPIC -shared
   
  -SO_FILES = $(patsubst $(srcdir)/%.c,%.so, $(C_FILES))
  -
  +SO_FILES := $(patsubst $(srcdir)/%.c,%.so, $(C_FILES))
   
   .PHONY: all
   
  -all: $(SO_FILES)
  -
  -$(SO_FILES): %.so: $(srcdir)/%.c
  -	$(CC) $(CFLAGS) $(CPPFLAGS) $< -o $@
  +all: $(NALFS_LIB) $(SO_FILES)
   
  +$(SO_FILES): %.so: $(srcdir)/%.c $(NALFS_LIB)
  +	$(CC) $(CFLAGS) $(CPPFLAGS) $^ -o $@
   
   .PHONY: clean distclean
   
  
  
  
  1.2       +2 -71     ALFS/nALFS/src/handlers/new-unpack.c
  
  Index: new-unpack.c
  ===================================================================
  RCS file: /home/cvsroot/ALFS/nALFS/src/handlers/new-unpack.c,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- new-unpack.c	17 Sep 2003 15:38:13 -0000	1.1
  +++ new-unpack.c	19 Sep 2003 10:49:01 -0000	1.2
  @@ -36,80 +36,19 @@
   #include "nalfs.h"
   #include "backend.h"
   #include "config.h"
  +#include "digest.h"
   
   
   #define El_unpack_reference(el) alloc_trimmed_param_value("reference", el)
   #define El_unpack_archive(el) alloc_trimmed_param_value("archive", el)
   #define El_unpack_destination(el) alloc_trimmed_param_value("destination", el)
  +#define El_unpack_digest(el) alloc_trimmed_param_value("digest", el)
   
   
   typedef enum extension_e {
   	GZ, TAR_GZ, TGZ, BZ2, TAR_BZ2, TAR, ZIP, TAR_Z, Z, UNKNOWN
   } extension_e;
   
  -
  -#ifdef HAVE_LIBSSL
  -
  -#define El_unpack_digest(el) alloc_trimmed_param_value("digest", el)
  -
  -#include <openssl/evp.h>
  -
  -int verify_digest(char* type, char* digest, char* file)
  -{
  -        EVP_MD_CTX ctx;
  -	const EVP_MD *md;
  -	char buffer[4094];
  -	FILE *istream;
  -	unsigned char md_value[EVP_MAX_MD_SIZE];
  -	char md_value_hex[2*EVP_MAX_MD_SIZE + 1 ];
  -	unsigned int md_len;
  -	int i;
  -	char *s;
  -
  -
  -	OpenSSL_add_all_digests();
  -
  -	md = EVP_get_digestbyname(type);
  -
  -	EVP_DigestInit(&ctx, md);
  -
  -	istream = fopen(file, "r");
  -	if (istream) {
  -		size_t nbbytes;
  -
  -		while ((nbbytes = fread(&buffer[0], 1, sizeof(buffer), istream)) != 0) {
  -		        EVP_DigestUpdate(&ctx, &buffer[0], nbbytes);
  -		}
  -
  -		fclose(istream);
  -
  -		EVP_DigestFinal(&ctx, &md_value[0], &md_len);
  -
  -
  -		for(i = 0, s = &md_value_hex[0]; i < (int)md_len; s += 2, ++i) {
  -		        sprintf(s, "%02x", md_value[i]);
  -                }
  -		*s = 0;
  -
  -		if (! strcmp(digest, &md_value_hex[0])) {
  -			Nprint("Digest ok.");
  -		        return 0;
  -		}
  -
  -		Nprint_err("Expected digest : %s", digest);
  -		Nprint_err("Found digest    : %s", &md_value_hex[0]);
  -
  -	} else {
  -		Nprint_err(
  -		"Unable to open the archive when checking digest: %s", file);
  -	}
  -
  -	return -1;
  -}
  -
  -#endif
  -
  -
   #ifdef HAVE_LIBCURL
   
   typedef struct output_file_s {
  @@ -262,11 +201,7 @@
   char *handler_syntax_versions[] = { "3.0", "3.1", NULL };
   // char *handler_attributes[] = { NULL };
   char *handler_parameters[] =
  -#ifdef HAVE_LIBSSL
   	{ "digest", "reference", "archive", "destination", NULL };
  -#else
  -	{ "reference", "archive", "destination", NULL };
  -#endif
   int handler_action = 1;
   
   
  @@ -276,9 +211,7 @@
   	char *base_name;
   	char *archive;
   	char *destination;
  -#ifdef HAVE_LIBSSL
   	char *digest;
  -#endif
   	struct stat file_stat;
   	extension_e extension = UNKNOWN;
   
  @@ -326,7 +259,6 @@
   		}
   	}
   
  -#ifdef HAVE_LIBSSL
   	if ((digest = El_unpack_digest(el)) != NULL) {
   		element_s *el2 = first_param("digest", el);
   		char *type = attr_value("type", el2);
  @@ -351,7 +283,6 @@
   			return -1;
   		}
   	}
  -#endif
   
   	/* Watch for the order! */
   	if (! (strncmp(archive + strlen(archive) - 7, ".tar.gz", 7)))
  
  
  
  1.1                  ALFS/nALFS/src/lib/Makefile.in
  
  Index: Makefile.in
  ===================================================================
  #
  #   Makefile - Makefile for common code library.
  #
  #   Copyright (C) 2001-2003
  #
  #   Neven Has <haski at sezampro.yu> and
  #   Kevin P. Fleming <kpfleming at backtobasicsmgmt.com>
  #
  #   This program is free software; you can redistribute it and/or modify
  #   it under the terms of the GNU General Public License as published by
  #   the Free Software Foundation; either version 2 of the License, or
  #   (at your option) any later version.
  #
  #   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, write to the Free Software
  #   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  #
  
  srcdir       := @top_srcdir@/src/lib
  top_builddir := @top_builddir@
  include $(top_builddir)/Rules.mak
  
  .PHONY: all
  
  all: $(NALFS_LIB)
  
  $(NALFS_LIB): $(O_FILES)
  	$(AR) cr $@ $^
  	$(RANLIB) $@
  
  $(O_FILES): %.o: $(srcdir)/%.c
  	$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@
  
  .PHONY: clean distclean
  
  clean:
  	$(RM) $(O_FILES) $(NALFS_LIB)
  
  distclean:
  	$(RM) Makefile
  
  
  
  1.1                  ALFS/nALFS/src/lib/digest.c
  
  Index: digest.c
  ===================================================================
  /*
   *  digest.c - Verify a file's contents have not been changed.
   * 
   *  Copyright (C) 2001-2003
   *  
   *  Neven Has <haski at sezampro.yu> and
   *  Kevin P. Fleming <kpfleming at backtobasicsmgmt.com>
   *
   *  This program is free software; you can redistribute it and/or modify
   *  it under the terms of the GNU General Public License as published by
   *  the Free Software Foundation; either version 2 of the License, or
   *  (at your option) any later version.
   *
   *  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, write to the Free Software
   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
  
  #include <stdlib.h>
  #include <string.h>
  #include <unistd.h>
  #include <errno.h>
  #include <ctype.h>
  #include <sys/types.h>
  
  #ifdef HAVE_LIBSSL
  
  #include <openssl/evp.h>
  #define MAX_MD_SIZE EVP_MAX_MD_SIZE
  
  #else /* !HAVE_LIBSSL */
  
  #define MAX_MD_SIZE 16
  
  #endif /* HAVE_LIBSSL */
  
  #include "win.h"
  #include "md5.h"
  
  int verify_digest(const char* type, char* digest, const char* file)
  {
  	char buffer[4094];
  	FILE *istream;
  	unsigned int i;
  	unsigned int md_len = 0;
  	unsigned char md_value[MAX_MD_SIZE];
  	char md_value_hex[2*MAX_MD_SIZE + 1 ];
  	int use_ssl;
  
          struct md5_context md5_ctx;
  
  #ifdef HAVE_LIBSSL
          EVP_MD_CTX ssl_ctx;
  	const EVP_MD *ssl_md;
  #endif /* HAVE_LIBSSL */
  
  	use_ssl = strncmp(type, "md5", 3);
  
  	if (!use_ssl) {
  		md5_starts(&md5_ctx);
  	} else {
  #ifdef HAVE_LIBSSL
  		OpenSSL_add_all_digests();
  		ssl_md = EVP_get_digestbyname(type);
  		if (ssl_md)
  			EVP_DigestInit(&ssl_ctx, ssl_md);
  		else {
  			Nprint_err("SSL does not support %s digest", type);
  			return -1;
  		}
  #else /* !HAVE_LIBSSL */
  		Nprint_err("Only MD5 digest supported without SSL");
  		return -1;
  #endif /* HAVE_LIBSSL */
  	}
  
  	istream = fopen(file, "r");
  	if (istream) {
  		size_t nbbytes;
  
  		while ((nbbytes = fread(&buffer[0], 1, sizeof(buffer), istream)) != 0) {
  			if (!use_ssl)
  				md5_update(&md5_ctx, &buffer[0], nbbytes);
  #ifdef HAVE_LIBSSL
  			else
  			        EVP_DigestUpdate(&ssl_ctx, &buffer[0], nbbytes);
  #endif /* HAVE_LIBSSL */
  		}
  
  		if (!use_ssl) {
  			md5_finish(&md5_ctx, &md_value[0]);
  			md_len = 16;
  		}
  #ifdef HAVE_LIBSSL
  		else
  			EVP_DigestFinal(&ssl_ctx, &md_value[0], &md_len);
  #endif /* HAVE_LIBSSL */
  
  		fclose(istream);
  
  		for(i = 0; i < md_len; i++)
  	                sprintf(&md_value_hex[0] + i * 2, "%02x", md_value[i]);
  
  		if (! strcmp(digest, &md_value_hex[0])) {
  			Nprint("Digest ok.");
  		        return 0;
  		}
  
  		Nprint_err("Expected digest : %s", digest);
  		Nprint_err("Found digest    : %s", &md_value_hex[0]);
  
  	} else {
  		Nprint_err(
  		"Unable to open the archive when checking digest: %s", file);
  	}
  
  	return -1;
  }
  
  
  
  1.1                  ALFS/nALFS/src/lib/digest.h
  
  Index: digest.h
  ===================================================================
  /*
   *  digest.h - Verify a file's contents have not been changed.
   * 
   *  Copyright (C) 2003-2003
   *  
   *  Neven Has <haski at sezampro.yu> and
   *  Kevin P. Fleming <kpfleming at backtobasicsmgmt.com>
   *
   *  This program is free software; you can redistribute it and/or modify
   *  it under the terms of the GNU General Public License as published by
   *  the Free Software Foundation; either version 2 of the License, or
   *  (at your option) any later version.
   *
   *  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, write to the Free Software
   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
  #ifndef _DIGEST_H
  #define _DIGEST_H
  
  extern int verify_digest(const char *type, char *digest, const char *file);
  
  #endif /* _DIGEST_H */
  
  
  
  1.1                  ALFS/nALFS/src/lib/md5.c
  
  Index: md5.c
  ===================================================================
  /*
   *  md5.c - MD5 (RFC 1321) sum computation.
   * 
   *  Copyright (C) 2001-2003
   *  
   *  Christophe Devine <devine at cr0.net>
   *
   *  This program is free software; you can redistribute it and/or modify
   *  it under the terms of the GNU General Public License as published by
   *  the Free Software Foundation; either version 2 of the License, or
   *  (at your option) any later version.
   *
   *  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, write to the Free Software
   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
  #include <string.h>
  #include "md5.h"
  
  #define GET_UINT32(n,b,i)                       \
  {                                               \
      (n) = ( (uint32) (b)[(i) + 3] << 24 )       \
          | ( (uint32) (b)[(i) + 2] << 16 )       \
          | ( (uint32) (b)[(i) + 1] <<  8 )       \
          | ( (uint32) (b)[(i)    ]       );      \
  }
  
  #define PUT_UINT32(n,b,i)                       \
  {                                               \
      (b)[(i)    ] = (uint8) ( (n)       );       \
      (b)[(i) + 1] = (uint8) ( (n) >>  8 );       \
      (b)[(i) + 2] = (uint8) ( (n) >> 16 );       \
      (b)[(i) + 3] = (uint8) ( (n) >> 24 );       \
  }
  
  void md5_starts( struct md5_context *ctx )
  {
      ctx->total[0] = 0;
      ctx->total[1] = 0;
      ctx->state[0] = 0x67452301;
      ctx->state[1] = 0xEFCDAB89;
      ctx->state[2] = 0x98BADCFE;
      ctx->state[3] = 0x10325476;
  }
  
  void md5_process( struct md5_context *ctx, uint8 data[64] )
  {
      uint32 A, B, C, D, X[16];
  
      GET_UINT32( X[0],  data,  0 );
      GET_UINT32( X[1],  data,  4 );
      GET_UINT32( X[2],  data,  8 );
      GET_UINT32( X[3],  data, 12 );
      GET_UINT32( X[4],  data, 16 );
      GET_UINT32( X[5],  data, 20 );
      GET_UINT32( X[6],  data, 24 );
      GET_UINT32( X[7],  data, 28 );
      GET_UINT32( X[8],  data, 32 );
      GET_UINT32( X[9],  data, 36 );
      GET_UINT32( X[10], data, 40 );
      GET_UINT32( X[11], data, 44 );
      GET_UINT32( X[12], data, 48 );
      GET_UINT32( X[13], data, 52 );
      GET_UINT32( X[14], data, 56 );
      GET_UINT32( X[15], data, 60 );
  
  #define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))
  
  #define P(a,b,c,d,k,s,t)                                \
  {                                                       \
      a += F(b,c,d) + X[k] + t; a = S(a,s) + b;           \
  }
  
      A = ctx->state[0];
      B = ctx->state[1];
      C = ctx->state[2];
      D = ctx->state[3];
  
  #define F(x,y,z) (z ^ (x & (y ^ z)))
  
      P( A, B, C, D,  0,  7, 0xD76AA478 );
      P( D, A, B, C,  1, 12, 0xE8C7B756 );
      P( C, D, A, B,  2, 17, 0x242070DB );
      P( B, C, D, A,  3, 22, 0xC1BDCEEE );
      P( A, B, C, D,  4,  7, 0xF57C0FAF );
      P( D, A, B, C,  5, 12, 0x4787C62A );
      P( C, D, A, B,  6, 17, 0xA8304613 );
      P( B, C, D, A,  7, 22, 0xFD469501 );
      P( A, B, C, D,  8,  7, 0x698098D8 );
      P( D, A, B, C,  9, 12, 0x8B44F7AF );
      P( C, D, A, B, 10, 17, 0xFFFF5BB1 );
      P( B, C, D, A, 11, 22, 0x895CD7BE );
      P( A, B, C, D, 12,  7, 0x6B901122 );
      P( D, A, B, C, 13, 12, 0xFD987193 );
      P( C, D, A, B, 14, 17, 0xA679438E );
      P( B, C, D, A, 15, 22, 0x49B40821 );
  
  #undef F
  
  #define F(x,y,z) (y ^ (z & (x ^ y)))
  
      P( A, B, C, D,  1,  5, 0xF61E2562 );
      P( D, A, B, C,  6,  9, 0xC040B340 );
      P( C, D, A, B, 11, 14, 0x265E5A51 );
      P( B, C, D, A,  0, 20, 0xE9B6C7AA );
      P( A, B, C, D,  5,  5, 0xD62F105D );
      P( D, A, B, C, 10,  9, 0x02441453 );
      P( C, D, A, B, 15, 14, 0xD8A1E681 );
      P( B, C, D, A,  4, 20, 0xE7D3FBC8 );
      P( A, B, C, D,  9,  5, 0x21E1CDE6 );
      P( D, A, B, C, 14,  9, 0xC33707D6 );
      P( C, D, A, B,  3, 14, 0xF4D50D87 );
      P( B, C, D, A,  8, 20, 0x455A14ED );
      P( A, B, C, D, 13,  5, 0xA9E3E905 );
      P( D, A, B, C,  2,  9, 0xFCEFA3F8 );
      P( C, D, A, B,  7, 14, 0x676F02D9 );
      P( B, C, D, A, 12, 20, 0x8D2A4C8A );
  
  #undef F
      
  #define F(x,y,z) (x ^ y ^ z)
  
      P( A, B, C, D,  5,  4, 0xFFFA3942 );
      P( D, A, B, C,  8, 11, 0x8771F681 );
      P( C, D, A, B, 11, 16, 0x6D9D6122 );
      P( B, C, D, A, 14, 23, 0xFDE5380C );
      P( A, B, C, D,  1,  4, 0xA4BEEA44 );
      P( D, A, B, C,  4, 11, 0x4BDECFA9 );
      P( C, D, A, B,  7, 16, 0xF6BB4B60 );
      P( B, C, D, A, 10, 23, 0xBEBFBC70 );
      P( A, B, C, D, 13,  4, 0x289B7EC6 );
      P( D, A, B, C,  0, 11, 0xEAA127FA );
      P( C, D, A, B,  3, 16, 0xD4EF3085 );
      P( B, C, D, A,  6, 23, 0x04881D05 );
      P( A, B, C, D,  9,  4, 0xD9D4D039 );
      P( D, A, B, C, 12, 11, 0xE6DB99E5 );
      P( C, D, A, B, 15, 16, 0x1FA27CF8 );
      P( B, C, D, A,  2, 23, 0xC4AC5665 );
  
  #undef F
  
  #define F(x,y,z) (y ^ (x | ~z))
  
      P( A, B, C, D,  0,  6, 0xF4292244 );
      P( D, A, B, C,  7, 10, 0x432AFF97 );
      P( C, D, A, B, 14, 15, 0xAB9423A7 );
      P( B, C, D, A,  5, 21, 0xFC93A039 );
      P( A, B, C, D, 12,  6, 0x655B59C3 );
      P( D, A, B, C,  3, 10, 0x8F0CCC92 );
      P( C, D, A, B, 10, 15, 0xFFEFF47D );
      P( B, C, D, A,  1, 21, 0x85845DD1 );
      P( A, B, C, D,  8,  6, 0x6FA87E4F );
      P( D, A, B, C, 15, 10, 0xFE2CE6E0 );
      P( C, D, A, B,  6, 15, 0xA3014314 );
      P( B, C, D, A, 13, 21, 0x4E0811A1 );
      P( A, B, C, D,  4,  6, 0xF7537E82 );
      P( D, A, B, C, 11, 10, 0xBD3AF235 );
      P( C, D, A, B,  2, 15, 0x2AD7D2BB );
      P( B, C, D, A,  9, 21, 0xEB86D391 );
  
  #undef F
  
      ctx->state[0] += A;
      ctx->state[1] += B;
      ctx->state[2] += C;
      ctx->state[3] += D;
  }
  
  void md5_update( struct md5_context *ctx, uint8 *input, uint32 length )
  {
      uint32 left, fill;
  
      if( ! length ) return;
  
      left = ( ctx->total[0] >> 3 ) & 0x3F;
      fill = 64 - left;
  
      ctx->total[0] += length <<  3;
      ctx->total[1] += length >> 29;
  
      ctx->total[0] &= 0xFFFFFFFF;
      ctx->total[1] += ctx->total[0] < ( length << 3 );
  
      if( left && length >= fill )
      {
          memcpy( (void *) (ctx->buffer + left), (void *) input, fill );
          md5_process( ctx, ctx->buffer );
          length -= fill;
          input  += fill;
          left = 0;
      }
  
      while( length >= 64 )
      {
          md5_process( ctx, input );
          length -= 64;
          input  += 64;
      }
  
      if( length )
      {
          memcpy( (void *) (ctx->buffer + left), (void *) input, length );
      }
  }
  
  static uint8 md5_padding[64] =
  {
   0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  };
  
  void md5_finish( struct md5_context *ctx, uint8 digest[16] )
  {
      uint32 last, padn;
      uint8 msglen[8];
  
      PUT_UINT32( ctx->total[0], msglen, 0 );
      PUT_UINT32( ctx->total[1], msglen, 4 );
  
      last = ( ctx->total[0] >> 3 ) & 0x3F;
      padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
  
      md5_update( ctx, md5_padding, padn );
      md5_update( ctx, msglen, 8 );
  
      PUT_UINT32( ctx->state[0], digest,  0 );
      PUT_UINT32( ctx->state[1], digest,  4 );
      PUT_UINT32( ctx->state[2], digest,  8 );
      PUT_UINT32( ctx->state[3], digest, 12 );
  }
  
  
  
  1.1                  ALFS/nALFS/src/lib/md5.h
  
  Index: md5.h
  ===================================================================
  /*
   *  md5.h - MD5 (RFC 1321) sum computation.
   * 
   *  Copyright (C) 2001-2003
   *  
   *  Christophe Devine <devine at cr0.net>
   *
   *  This program is free software; you can redistribute it and/or modify
   *  it under the terms of the GNU General Public License as published by
   *  the Free Software Foundation; either version 2 of the License, or
   *  (at your option) any later version.
   *
   *  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, write to the Free Software
   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
  #ifndef _MD5_H
  #define _MD5_H
  
  #define uint8  unsigned char
  #define uint32 unsigned long int
  
  struct md5_context
  {
      uint32 total[2];
      uint32 state[4];
      uint8 buffer[64];
  };
  
  extern void md5_starts( struct md5_context *ctx );
  extern void md5_update( struct md5_context *ctx, uint8 *input, uint32 length );
  extern void md5_finish( struct md5_context *ctx, uint8 digest[16] );
  
  #endif /* _MD5_H */
  
  
  



More information about the alfs-log mailing list