From de8f24ea083384bb66b32ec105dc4743c5663cdf Mon Sep 17 00:00:00 2001
From: beck <>
Date: Wed, 29 Sep 1999 04:37:45 +0000
Subject: OpenSSL 0.9.4 merge

---
 src/lib/libcrypto/md5/Makefile.ssl      |   58 +-
 src/lib/libcrypto/md5/Makefile.uni      |    3 +-
 src/lib/libcrypto/md5/asm/m5-win32.asm  |   55 +-
 src/lib/libcrypto/md5/asm/md5-586.pl    |   40 +-
 src/lib/libcrypto/md5/asm/md5-sparcv9.S | 1029 +++++++++++++++++++++++++++++++
 src/lib/libcrypto/md5/asm/mx86unix.cpp  |  730 ----------------------
 src/lib/libcrypto/md5/md5.c             |   18 +-
 src/lib/libcrypto/md5/md5.h             |   51 +-
 src/lib/libcrypto/md5/md5_dgst.c        |  395 ++++--------
 src/lib/libcrypto/md5/md5_locl.h        |  160 ++---
 src/lib/libcrypto/md5/md5_one.c         |   28 +-
 src/lib/libcrypto/md5/md5s.cpp          |    2 +-
 src/lib/libcrypto/md5/md5test.c         |   23 +-
 13 files changed, 1397 insertions(+), 1195 deletions(-)
 create mode 100644 src/lib/libcrypto/md5/asm/md5-sparcv9.S
 delete mode 100644 src/lib/libcrypto/md5/asm/mx86unix.cpp

(limited to 'src/lib/libcrypto/md5')

diff --git a/src/lib/libcrypto/md5/Makefile.ssl b/src/lib/libcrypto/md5/Makefile.ssl
index 47e1ce05ca..29ae1b7458 100644
--- a/src/lib/libcrypto/md5/Makefile.ssl
+++ b/src/lib/libcrypto/md5/Makefile.ssl
@@ -8,15 +8,18 @@ CC=     cc
 CPP=    $(CC) -E
 INCLUDES=
 CFLAG=-g
+INSTALL_PREFIX=
+OPENSSLDIR=     /usr/local/ssl
 INSTALLTOP=/usr/local/ssl
 MAKE=           make -f Makefile.ssl
-MAKEDEPEND=     makedepend -f Makefile.ssl
+MAKEDEPEND=	$(TOP)/util/domd $(TOP)
 MAKEFILE=       Makefile.ssl
 AR=             ar r
 
 MD5_ASM_OBJ=
 
 CFLAGS= $(INCLUDES) $(CFLAG)
+ASFLAGS=$(CFLAGS)
 
 GENERAL=Makefile
 TEST=md5test.c
@@ -40,7 +43,7 @@ all:    lib
 
 lib:    $(LIBOBJ)
 	$(AR) $(LIB) $(LIBOBJ)
-	sh $(TOP)/util/ranlib.sh $(LIB)
+	$(RANLIB) $(LIB)
 	@touch lib
 
 # elf
@@ -59,26 +62,43 @@ asm/mx86-out.o: asm/mx86unix.cpp
 
 # bsdi
 asm/mx86bsdi.o: asm/mx86unix.cpp
-	$(CPP) -DBSDI asm/mx86unix.cpp | as -o asm/mx86bsdi.o
+	$(CPP) -DBSDI asm/mx86unix.cpp | sed 's/ :/:/' | as -o asm/mx86bsdi.o
 
-asm/mx86unix.cpp:
-	(cd asm; perl md5-586.pl cpp >mx86unix.cpp)
+asm/mx86unix.cpp: asm/md5-586.pl
+	(cd asm; $(PERL) md5-586.pl cpp >mx86unix.cpp)
+
+asm/md5-sparcv8plus.o: asm/md5-sparcv9.S
+	$(CC) $(ASFLAGS) -DMD5_BLOCK_DATA_ORDER -c \
+		-o asm/md5-sparcv8plus.o asm/md5-sparcv9.S
+
+# Old GNU assembler doesn't understand V9 instructions, so we
+# hire /usr/ccs/bin/as to do the job. Note that option is called
+# *-gcc27, but even gcc 2>=8 users may experience similar problem
+# if they didn't bother to upgrade GNU assembler. Such users should
+# not choose this option, but be adviced to *remove* GNU assembler
+# or upgrade it.
+sm/md5-sparcv8plus-gcc27.o: asm/md5-sparcv9.S
+	$(CC) $(ASFLAGS) -DMD5_BLOCK_DATA_ORDER -E asm/md5-sparcv9.S | \
+		/usr/ccs/bin/as -xarch=v8plus - -o asm/md5-sparcv8plus-gcc27.o
+
+asm/md5-sparcv9.o: asm/md5-sparcv9.S
+	$(CC) $(ASFLAGS) -DMD5_BLOCK_DATA_ORDER -c \
+		-o asm/md5-sparcv9.o asm/md5-sparcv9.S
 
 files:
-	perl $(TOP)/util/files.pl Makefile.ssl >> $(TOP)/MINFO
+	$(PERL) $(TOP)/util/files.pl Makefile.ssl >> $(TOP)/MINFO
 
 links:
-	/bin/rm -f Makefile
-	$(TOP)/util/point.sh Makefile.ssl Makefile ;
-	$(TOP)/util/mklink.sh ../../include $(EXHEADER)
-	$(TOP)/util/mklink.sh ../../test $(TEST)
-	$(TOP)/util/mklink.sh ../../apps $(APPS)
+	@$(TOP)/util/point.sh Makefile.ssl Makefile
+	@$(PERL) $(TOP)/util/mklink.pl ../../include/openssl $(EXHEADER)
+	@$(PERL) $(TOP)/util/mklink.pl ../../test $(TEST)
+	@$(PERL) $(TOP)/util/mklink.pl ../../apps $(APPS)
 
 install:
 	@for i in $(EXHEADER) ; \
 	do  \
-	(cp $$i $(INSTALLTOP)/include/$$i; \
-	chmod 644 $(INSTALLTOP)/include/$$i ); \
+	(cp $$i $(INSTALL_PREFIX)$(INSTALLTOP)/include/openssl/$$i; \
+	chmod 644 $(INSTALL_PREFIX)$(INSTALLTOP)/include/openssl/$$i ); \
 	done;
 
 tags:
@@ -90,15 +110,17 @@ lint:
 	lint -DLINT $(INCLUDES) $(SRC)>fluff
 
 depend:
-	$(MAKEDEPEND) $(INCLUDES) $(PROGS) $(LIBSRC)
+	$(MAKEDEPEND) $(INCLUDES) $(DEPFLAG) $(PROGS) $(LIBSRC)
 
 dclean:
-	perl -pe 'if (/^# DO NOT DELETE THIS LINE/) {print; exit(0);}' $(MAKEFILE) >Makefile.new
+	$(PERL) -pe 'if (/^# DO NOT DELETE THIS LINE/) {print; exit(0);}' $(MAKEFILE) >Makefile.new
 	mv -f Makefile.new $(MAKEFILE)
 
 clean:
-	/bin/rm -f *.o asm/*.o *.obj lib tags core .pure .nfs* *.old *.bak fluff
-
-errors:
+	rm -f asm/mx86unix.cpp *.o asm/*.o *.obj lib tags core .pure .nfs* *.old *.bak fluff
 
 # DO NOT DELETE THIS LINE -- make depend depends on it.
+
+md5_dgst.o: ../../include/openssl/md5.h ../../include/openssl/opensslconf.h
+md5_dgst.o: ../../include/openssl/opensslv.h ../md32_common.h md5_locl.h
+md5_one.o: ../../include/openssl/md5.h
diff --git a/src/lib/libcrypto/md5/Makefile.uni b/src/lib/libcrypto/md5/Makefile.uni
index 54685712db..d21c72f3ea 100644
--- a/src/lib/libcrypto/md5/Makefile.uni
+++ b/src/lib/libcrypto/md5/Makefile.uni
@@ -19,6 +19,7 @@ MAKE=           make
 MAKEDEPEND=     makedepend
 MAKEFILE=       Makefile.uni
 AR=             ar r
+RANLIB=         ranlib
 
 MD5_ASM_OBJ=
 
@@ -43,7 +44,7 @@ all:    $(LIB) $(TEST) $(APPS)
 
 $(LIB):    $(LIBOBJ)
 	$(AR) $(LIB) $(LIBOBJ)
-	sh $(TOP)/ranlib.sh $(LIB)
+	$(RANLIB) $(LIB)
 
 # elf
 asm/mx86-elf.o: asm/mx86unix.cpp
diff --git a/src/lib/libcrypto/md5/asm/m5-win32.asm b/src/lib/libcrypto/md5/asm/m5-win32.asm
index c2081da746..51f5f17ca3 100644
--- a/src/lib/libcrypto/md5/asm/m5-win32.asm
+++ b/src/lib/libcrypto/md5/asm/m5-win32.asm
@@ -8,15 +8,16 @@
         .386
 .model FLAT
 _TEXT	SEGMENT
-PUBLIC	_md5_block_x86
+PUBLIC	_md5_block_asm_host_order
 
-_md5_block_x86 PROC NEAR
+_md5_block_asm_host_order PROC NEAR
 	push	esi
 	push	edi
 	mov	edi,		DWORD PTR 12[esp]
 	mov	esi,		DWORD PTR 16[esp]
 	mov	ecx,		DWORD PTR 20[esp]
 	push	ebp
+	shl	ecx,		6
 	push	ebx
 	add	ecx,		esi
 	sub	ecx,		64
@@ -34,161 +35,161 @@ L000start:
 	xor	edi,		edx
 	and	edi,		ebx
 	lea	eax,		DWORD PTR 3614090360[ebp*1+eax]
-	mov	ebp,		DWORD PTR 4[esi]
 	xor	edi,		edx
 	add	eax,		edi
 	mov	edi,		ebx
 	rol	eax,		7
+	mov	ebp,		DWORD PTR 4[esi]
 	add	eax,		ebx
 	; R0 1
 	xor	edi,		ecx
 	and	edi,		eax
 	lea	edx,		DWORD PTR 3905402710[ebp*1+edx]
-	mov	ebp,		DWORD PTR 8[esi]
 	xor	edi,		ecx
 	add	edx,		edi
 	mov	edi,		eax
 	rol	edx,		12
+	mov	ebp,		DWORD PTR 8[esi]
 	add	edx,		eax
 	; R0 2
 	xor	edi,		ebx
 	and	edi,		edx
 	lea	ecx,		DWORD PTR 606105819[ebp*1+ecx]
-	mov	ebp,		DWORD PTR 12[esi]
 	xor	edi,		ebx
 	add	ecx,		edi
 	mov	edi,		edx
 	rol	ecx,		17
+	mov	ebp,		DWORD PTR 12[esi]
 	add	ecx,		edx
 	; R0 3
 	xor	edi,		eax
 	and	edi,		ecx
 	lea	ebx,		DWORD PTR 3250441966[ebp*1+ebx]
-	mov	ebp,		DWORD PTR 16[esi]
 	xor	edi,		eax
 	add	ebx,		edi
 	mov	edi,		ecx
 	rol	ebx,		22
+	mov	ebp,		DWORD PTR 16[esi]
 	add	ebx,		ecx
 	; R0 4
 	xor	edi,		edx
 	and	edi,		ebx
 	lea	eax,		DWORD PTR 4118548399[ebp*1+eax]
-	mov	ebp,		DWORD PTR 20[esi]
 	xor	edi,		edx
 	add	eax,		edi
 	mov	edi,		ebx
 	rol	eax,		7
+	mov	ebp,		DWORD PTR 20[esi]
 	add	eax,		ebx
 	; R0 5
 	xor	edi,		ecx
 	and	edi,		eax
 	lea	edx,		DWORD PTR 1200080426[ebp*1+edx]
-	mov	ebp,		DWORD PTR 24[esi]
 	xor	edi,		ecx
 	add	edx,		edi
 	mov	edi,		eax
 	rol	edx,		12
+	mov	ebp,		DWORD PTR 24[esi]
 	add	edx,		eax
 	; R0 6
 	xor	edi,		ebx
 	and	edi,		edx
 	lea	ecx,		DWORD PTR 2821735955[ebp*1+ecx]
-	mov	ebp,		DWORD PTR 28[esi]
 	xor	edi,		ebx
 	add	ecx,		edi
 	mov	edi,		edx
 	rol	ecx,		17
+	mov	ebp,		DWORD PTR 28[esi]
 	add	ecx,		edx
 	; R0 7
 	xor	edi,		eax
 	and	edi,		ecx
 	lea	ebx,		DWORD PTR 4249261313[ebp*1+ebx]
-	mov	ebp,		DWORD PTR 32[esi]
 	xor	edi,		eax
 	add	ebx,		edi
 	mov	edi,		ecx
 	rol	ebx,		22
+	mov	ebp,		DWORD PTR 32[esi]
 	add	ebx,		ecx
 	; R0 8
 	xor	edi,		edx
 	and	edi,		ebx
 	lea	eax,		DWORD PTR 1770035416[ebp*1+eax]
-	mov	ebp,		DWORD PTR 36[esi]
 	xor	edi,		edx
 	add	eax,		edi
 	mov	edi,		ebx
 	rol	eax,		7
+	mov	ebp,		DWORD PTR 36[esi]
 	add	eax,		ebx
 	; R0 9
 	xor	edi,		ecx
 	and	edi,		eax
 	lea	edx,		DWORD PTR 2336552879[ebp*1+edx]
-	mov	ebp,		DWORD PTR 40[esi]
 	xor	edi,		ecx
 	add	edx,		edi
 	mov	edi,		eax
 	rol	edx,		12
+	mov	ebp,		DWORD PTR 40[esi]
 	add	edx,		eax
 	; R0 10
 	xor	edi,		ebx
 	and	edi,		edx
 	lea	ecx,		DWORD PTR 4294925233[ebp*1+ecx]
-	mov	ebp,		DWORD PTR 44[esi]
 	xor	edi,		ebx
 	add	ecx,		edi
 	mov	edi,		edx
 	rol	ecx,		17
+	mov	ebp,		DWORD PTR 44[esi]
 	add	ecx,		edx
 	; R0 11
 	xor	edi,		eax
 	and	edi,		ecx
 	lea	ebx,		DWORD PTR 2304563134[ebp*1+ebx]
-	mov	ebp,		DWORD PTR 48[esi]
 	xor	edi,		eax
 	add	ebx,		edi
 	mov	edi,		ecx
 	rol	ebx,		22
+	mov	ebp,		DWORD PTR 48[esi]
 	add	ebx,		ecx
 	; R0 12
 	xor	edi,		edx
 	and	edi,		ebx
 	lea	eax,		DWORD PTR 1804603682[ebp*1+eax]
-	mov	ebp,		DWORD PTR 52[esi]
 	xor	edi,		edx
 	add	eax,		edi
 	mov	edi,		ebx
 	rol	eax,		7
+	mov	ebp,		DWORD PTR 52[esi]
 	add	eax,		ebx
 	; R0 13
 	xor	edi,		ecx
 	and	edi,		eax
 	lea	edx,		DWORD PTR 4254626195[ebp*1+edx]
-	mov	ebp,		DWORD PTR 56[esi]
 	xor	edi,		ecx
 	add	edx,		edi
 	mov	edi,		eax
 	rol	edx,		12
+	mov	ebp,		DWORD PTR 56[esi]
 	add	edx,		eax
 	; R0 14
 	xor	edi,		ebx
 	and	edi,		edx
 	lea	ecx,		DWORD PTR 2792965006[ebp*1+ecx]
-	mov	ebp,		DWORD PTR 60[esi]
 	xor	edi,		ebx
 	add	ecx,		edi
 	mov	edi,		edx
 	rol	ecx,		17
+	mov	ebp,		DWORD PTR 60[esi]
 	add	ecx,		edx
 	; R0 15
 	xor	edi,		eax
 	and	edi,		ecx
 	lea	ebx,		DWORD PTR 1236535329[ebp*1+ebx]
-	mov	ebp,		DWORD PTR 4[esi]
 	xor	edi,		eax
 	add	ebx,		edi
 	mov	edi,		ecx
 	rol	ebx,		22
+	mov	ebp,		DWORD PTR 4[esi]
 	add	ebx,		ecx
 	; 
 	; R1 section
@@ -359,8 +360,8 @@ L000start:
 	xor	edi,		ebx
 	lea	eax,		DWORD PTR 4294588738[ebp*1+eax]
 	add	eax,		edi
-	mov	ebp,		DWORD PTR 32[esi]
 	rol	eax,		4
+	mov	ebp,		DWORD PTR 32[esi]
 	mov	edi,		ebx
 	; R2 33
 	lea	edx,		DWORD PTR 2272392833[ebp*1+edx]
@@ -377,8 +378,8 @@ L000start:
 	xor	edi,		edx
 	lea	ecx,		DWORD PTR 1839030562[ebp*1+ecx]
 	add	ecx,		edi
-	mov	ebp,		DWORD PTR 56[esi]
 	rol	ecx,		16
+	mov	ebp,		DWORD PTR 56[esi]
 	mov	edi,		edx
 	; R2 35
 	lea	ebx,		DWORD PTR 4259657740[ebp*1+ebx]
@@ -395,8 +396,8 @@ L000start:
 	xor	edi,		ebx
 	lea	eax,		DWORD PTR 2763975236[ebp*1+eax]
 	add	eax,		edi
-	mov	ebp,		DWORD PTR 16[esi]
 	rol	eax,		4
+	mov	ebp,		DWORD PTR 16[esi]
 	mov	edi,		ebx
 	; R2 37
 	lea	edx,		DWORD PTR 1272893353[ebp*1+edx]
@@ -413,8 +414,8 @@ L000start:
 	xor	edi,		edx
 	lea	ecx,		DWORD PTR 4139469664[ebp*1+ecx]
 	add	ecx,		edi
-	mov	ebp,		DWORD PTR 40[esi]
 	rol	ecx,		16
+	mov	ebp,		DWORD PTR 40[esi]
 	mov	edi,		edx
 	; R2 39
 	lea	ebx,		DWORD PTR 3200236656[ebp*1+ebx]
@@ -431,8 +432,8 @@ L000start:
 	xor	edi,		ebx
 	lea	eax,		DWORD PTR 681279174[ebp*1+eax]
 	add	eax,		edi
-	mov	ebp,		DWORD PTR [esi]
 	rol	eax,		4
+	mov	ebp,		DWORD PTR [esi]
 	mov	edi,		ebx
 	; R2 41
 	lea	edx,		DWORD PTR 3936430074[ebp*1+edx]
@@ -449,8 +450,8 @@ L000start:
 	xor	edi,		edx
 	lea	ecx,		DWORD PTR 3572445317[ebp*1+ecx]
 	add	ecx,		edi
-	mov	ebp,		DWORD PTR 24[esi]
 	rol	ecx,		16
+	mov	ebp,		DWORD PTR 24[esi]
 	mov	edi,		edx
 	; R2 43
 	lea	ebx,		DWORD PTR 76029189[ebp*1+ebx]
@@ -467,8 +468,8 @@ L000start:
 	xor	edi,		ebx
 	lea	eax,		DWORD PTR 3654602809[ebp*1+eax]
 	add	eax,		edi
-	mov	ebp,		DWORD PTR 48[esi]
 	rol	eax,		4
+	mov	ebp,		DWORD PTR 48[esi]
 	mov	edi,		ebx
 	; R2 45
 	lea	edx,		DWORD PTR 3873151461[ebp*1+edx]
@@ -485,8 +486,8 @@ L000start:
 	xor	edi,		edx
 	lea	ecx,		DWORD PTR 530742520[ebp*1+ecx]
 	add	ecx,		edi
-	mov	ebp,		DWORD PTR 8[esi]
 	rol	ecx,		16
+	mov	ebp,		DWORD PTR 8[esi]
 	mov	edi,		edx
 	; R2 47
 	lea	ebx,		DWORD PTR 3299628645[ebp*1+ebx]
@@ -681,6 +682,6 @@ L000start:
 	pop	edi
 	pop	esi
 	ret
-_md5_block_x86 ENDP
+_md5_block_asm_host_order ENDP
 _TEXT	ENDS
 END
diff --git a/src/lib/libcrypto/md5/asm/md5-586.pl b/src/lib/libcrypto/md5/asm/md5-586.pl
index 2c7fb7dd98..5fc6a205ce 100644
--- a/src/lib/libcrypto/md5/asm/md5-586.pl
+++ b/src/lib/libcrypto/md5/asm/md5-586.pl
@@ -1,4 +1,4 @@
-#!/usr/bin/perl
+#!/usr/local/bin/perl
 
 # Normal is the
 # md5_block_x86(MD5_CTX *c, ULONG *X);
@@ -29,7 +29,7 @@ $X="esi";
  0, 7, 14, 5, 12, 3, 10, 1, 8, 15, 6, 13, 4, 11, 2, 9,	# R3
  );
 
-&md5_block("md5_block_x86");
+&md5_block("md5_block_asm_host_order");
 &asm_finish();
 
 sub Np
@@ -44,7 +44,7 @@ sub R0
 	local($pos,$a,$b,$c,$d,$K,$ki,$s,$t)=@_;
 
 	&mov($tmp1,$C)  if $pos < 0;
-	 &mov($tmp2,&DWP($xo[$ki]*4,$K,"",0)) if $pos < 0; # very first one 
+	&mov($tmp2,&DWP($xo[$ki]*4,$K,"",0)) if $pos < 0; # very first one 
 
 	# body proper
 
@@ -54,7 +54,6 @@ sub R0
 	&and($tmp1,$b); # F function - part 3
 	&lea($a,&DWP($t,$a,$tmp2,1));
 
-	&mov($tmp2,&DWP($xo[$ki+1]*4,$K,"",0)) if ($pos != 2);
 	&xor($tmp1,$d); # F function - part 4
 
 	&add($a,$tmp1);
@@ -62,8 +61,10 @@ sub R0
 	&mov($tmp1,&Np($c)) if $pos == 1;	# next tmp1 for R1
 
 	&rotl($a,$s);
-	&add($a,$b);
 
+	&mov($tmp2,&DWP($xo[$ki+1]*4,$K,"",0)) if ($pos != 2);
+
+	&add($a,$b);
 	}
 
 sub R1
@@ -100,16 +101,16 @@ if (($n & 1) == 0)
 	# make sure to do 'D' first, not 'B', else we clash with
 	# the last add from the previous round.
 
-	 &xor($tmp1,$d); # H function - part 2
+	&xor($tmp1,$d); # H function - part 2
 
 	&xor($tmp1,$b); # H function - part 3
-	 &lea($a,&DWP($t,$a,$tmp2,1));
+	&lea($a,&DWP($t,$a,$tmp2,1));
 
 	&add($a,$tmp1);
-	 &mov($tmp2,&DWP($xo[$ki+1]*4,$K,"",0));
 
 	&rotl($a,$s);
 
+	&mov($tmp2,&DWP($xo[$ki+1]*4,$K,"",0));
 	&mov($tmp1,&Np($c));
 	}
 else
@@ -118,17 +119,17 @@ else
 	# make sure to do 'D' first, not 'B', else we clash with
 	# the last add from the previous round.
 
-	 &lea($a,&DWP($t,$a,$tmp2,1));
+	&lea($a,&DWP($t,$a,$tmp2,1));
 
 	&add($b,$c);			# MOVED FORWARD
-	 &xor($tmp1,$d); # H function - part 2
+	&xor($tmp1,$d); # H function - part 2
 
 	&xor($tmp1,$b); # H function - part 3
-	 &mov($tmp2,&DWP($xo[$ki+1]*4,$K,"",0)) if ($pos != 2);
+	&mov($tmp2,&DWP($xo[$ki+1]*4,$K,"",0)) if ($pos != 2);
 
 	&add($a,$tmp1);
-	 &mov($tmp1,&Np($c)) if $pos < 1;	# H function - part 1
-	 &mov($tmp1,-1) if $pos == 1;		# I function - part 1
+	&mov($tmp1,&Np($c)) if $pos < 1;	# H function - part 1
+	&mov($tmp1,-1) if $pos == 1;		# I function - part 1
 
 	&rotl($a,$s);
 
@@ -146,21 +147,21 @@ sub R3
 	&xor($tmp1,$d) if $pos < 0; 	# I function - part 2
 
 	&or($tmp1,$b);				# I function - part 3
-	 &lea($a,&DWP($t,$a,$tmp2,1));
+	&lea($a,&DWP($t,$a,$tmp2,1));
 
 	&xor($tmp1,$c); 			# I function - part 4
-	 &mov($tmp2,&DWP($xo[$ki+1]*4,$K,"",0))	if $pos != 2; # load X/k value
-	 &mov($tmp2,&wparam(0)) if $pos == 2;
+	&mov($tmp2,&DWP($xo[$ki+1]*4,$K,"",0))	if $pos != 2; # load X/k value
+	&mov($tmp2,&wparam(0)) if $pos == 2;
 
 	&add($a,$tmp1);
-	 &mov($tmp1,-1) if $pos < 1;	# H function - part 1
-	 &add($K,64) if $pos >=1 && !$normal;
+	&mov($tmp1,-1) if $pos < 1;	# H function - part 1
+	&add($K,64) if $pos >=1 && !$normal;
 
 	&rotl($a,$s);
 
 	&xor($tmp1,&Np($d)) if $pos <= 0; 	# I function - part = first time
 	&mov($tmp1,&DWP( 0,$tmp2,"",0)) if $pos > 0;
-	 &add($a,$b);
+	&add($a,$b);
 	}
 
 
@@ -182,6 +183,7 @@ sub md5_block
 	 &mov($X,	&wparam(1)); # esi
 	&mov($C,	&wparam(2));
 	 &push("ebp");
+	&shl($C,	6);
 	&push("ebx");
 	 &add($C,	$X); # offset we end at
 	&sub($C,	64);
diff --git a/src/lib/libcrypto/md5/asm/md5-sparcv9.S b/src/lib/libcrypto/md5/asm/md5-sparcv9.S
new file mode 100644
index 0000000000..ca4257f134
--- /dev/null
+++ b/src/lib/libcrypto/md5/asm/md5-sparcv9.S
@@ -0,0 +1,1029 @@
+.ident	"md5-sparcv9.S, Version 1.0"
+.ident	"SPARC V9 ISA artwork by Andy Polyakov <appro@fy.chalmers.se>"
+.file	"md5-sparcv9.S"
+
+/*
+ * ====================================================================
+ * Copyright (c) 1999 Andy Polyakov <appro@fy.chalmers.se>.
+ *
+ * Rights for redistribution and usage in source and binary forms are
+ * granted as long as above copyright notices are retained. Warranty
+ * of any kind is (of course:-) disclaimed.
+ * ====================================================================
+ */
+
+/*
+ * This is my modest contribution to OpenSSL project (see
+ * http://www.openssl.org/ for more information about it) and is an
+ * assembler implementation of MD5 block hash function. I've hand-coded
+ * this for the sole reason to reach UltraSPARC-specific "load in
+ * little-endian byte order" instruction. This gives up to 15%
+ * performance improvement for cases when input message is aligned at
+ * 32 bits boundary. The module was tested under both 32 *and* 64 bit
+ * kernels. For updates see http://fy.chalmers.se/~appro/hpe/.
+ *
+ * To compile with SC4.x/SC5.x:
+ *
+ *	cc -xarch=v[9|8plus] -DULTRASPARC -DMD5_BLOCK_DATA_ORDER \
+ *		-c md5-sparcv9.S
+ *
+ * and with gcc:
+ *
+ *	gcc -mcpu=ultrasparc -DULTRASPARC -DMD5_BLOCK_DATA_ORDER \
+ *		-c md5-sparcv9.S
+ *
+ * or if above fails (it does if you have gas):
+ *
+ *	gcc -E -DULTRASPARC -DMD5_BLOCK_DATA_ORDER md5_block.sparc.S | \
+ *		as -xarch=v8plus /dev/fd/0 -o md5-sparcv9.o
+ */
+
+#define	A	%o0
+#define B	%o1
+#define	C	%o2
+#define	D	%o3
+#define	T1	%o4
+#define	T2	%o5
+
+#define	R0	%l0
+#define	R1	%l1
+#define	R2	%l2
+#define	R3	%l3
+#define	R4	%l4
+#define	R5	%l5
+#define	R6	%l6
+#define	R7	%l7
+#define	R8	%i3
+#define	R9	%i4
+#define	R10	%i5
+#define	R11	%g1
+#define R12	%g2
+#define	R13	%g3
+#define RX	%g4
+
+#define Aptr	%i0+0
+#define Bptr	%i0+4
+#define Cptr	%i0+8
+#define Dptr	%i0+12
+
+#define Aval	R5	/* those not used at the end of the last round */
+#define Bval	R6
+#define Cval	R7
+#define Dval	R8
+
+#if defined(MD5_BLOCK_DATA_ORDER)
+# if defined(ULTRASPARC)
+#  define	LOAD			lda
+#  define	X(i)			[%i1+i*4]%asi
+#  define	md5_block		md5_block_asm_data_order_aligned
+#  define	ASI_PRIMARY_LITTLE	0x88
+# else
+#  error "MD5_BLOCK_DATA_ORDER is supported only on UltraSPARC!"
+# endif
+#else
+# define	LOAD			ld
+# define	X(i)			[%i1+i*4]
+# define	md5_block		md5_block_asm_host_order
+#endif
+
+.section        ".text",#alloc,#execinstr
+
+#if defined(__SUNPRO_C) && defined(__sparcv9)
+  /* They've said -xarch=v9 at command line */
+  .register	%g2,#scratch
+  .register	%g3,#scratch
+# define	FRAME	-192
+#elif defined(__GNUC__) && defined(__arch64__)
+  /* They've said -m64 at command line */
+  .register     %g2,#scratch
+  .register     %g3,#scratch
+# define        FRAME   -192
+#else
+# define	FRAME	-96
+#endif
+
+.align  32
+
+.global md5_block
+md5_block:
+	save	%sp,FRAME,%sp
+
+	ld	[Dptr],D
+	ld	[Cptr],C
+	ld	[Bptr],B
+	ld	[Aptr],A
+#ifdef ASI_PRIMARY_LITTLE
+	rd	%asi,%o7	! How dare I? Well, I just do:-)
+	wr	%g0,ASI_PRIMARY_LITTLE,%asi
+#endif
+	LOAD	X(0),R0
+
+.Lmd5_block_loop:
+
+!!!!!!!!Round 0
+
+	xor	C,D,T1
+	sethi	%hi(0xd76aa478),T2
+	and	T1,B,T1
+	or	T2,%lo(0xd76aa478),T2	!=
+	xor	T1,D,T1
+	add	T1,R0,T1
+	LOAD	X(1),R1
+	add	T1,T2,T1		!=
+	add	A,T1,A
+	sll	A,7,T2
+	srl	A,32-7,A
+	or	A,T2,A			!=
+	 xor	 B,C,T1
+	add	A,B,A
+
+	sethi	%hi(0xe8c7b756),T2
+	and	T1,A,T1			!=
+	or	T2,%lo(0xe8c7b756),T2
+	xor	T1,C,T1
+	LOAD	X(2),R2
+	add	T1,R1,T1		!=
+	add	T1,T2,T1
+	add	D,T1,D
+	sll	D,12,T2
+	srl	D,32-12,D		!=
+	or	D,T2,D
+	 xor	 A,B,T1
+	add	D,A,D
+
+	sethi	%hi(0x242070db),T2	!=
+	and	T1,D,T1
+	or	T2,%lo(0x242070db),T2
+	xor	T1,B,T1
+	add	T1,R2,T1		!=
+	LOAD	X(3),R3
+	add	T1,T2,T1
+	add	C,T1,C
+	sll	C,17,T2			!=
+	srl	C,32-17,C
+	or	C,T2,C
+	 xor	 D,A,T1
+	add	C,D,C			!=
+
+	sethi	%hi(0xc1bdceee),T2
+	and	T1,C,T1
+	or	T2,%lo(0xc1bdceee),T2
+	xor	T1,A,T1			!=
+	add	T1,R3,T1
+	LOAD	X(4),R4
+	add	T1,T2,T1
+	add	B,T1,B			!=
+	sll	B,22,T2
+	srl	B,32-22,B
+	or	B,T2,B
+	 xor	 C,D,T1			!=
+	add	B,C,B
+
+	sethi	%hi(0xf57c0faf),T2
+	and	T1,B,T1
+	or	T2,%lo(0xf57c0faf),T2	!=
+	xor	T1,D,T1
+	add	T1,R4,T1
+	LOAD	X(5),R5
+	add	T1,T2,T1		!=
+	add	A,T1,A
+	sll	A,7,T2
+	srl	A,32-7,A
+	or	A,T2,A			!=
+	 xor	 B,C,T1
+	add	A,B,A
+
+	sethi	%hi(0x4787c62a),T2
+	and	T1,A,T1			!=
+	or	T2,%lo(0x4787c62a),T2
+	xor	T1,C,T1
+	LOAD	X(6),R6
+	add	T1,R5,T1		!=
+	add	T1,T2,T1
+	add	D,T1,D
+	sll	D,12,T2
+	srl	D,32-12,D		!=
+	or	D,T2,D
+	 xor	 A,B,T1
+	add	D,A,D
+
+	sethi	%hi(0xa8304613),T2	!=
+	and	T1,D,T1
+	or	T2,%lo(0xa8304613),T2
+	xor	T1,B,T1
+	add	T1,R6,T1		!=
+	LOAD	X(7),R7
+	add	T1,T2,T1
+	add	C,T1,C
+	sll	C,17,T2			!=
+	srl	C,32-17,C
+	or	C,T2,C
+	 xor	 D,A,T1
+	add	C,D,C			!=
+
+	sethi	%hi(0xfd469501),T2
+	and	T1,C,T1
+	or	T2,%lo(0xfd469501),T2
+	xor	T1,A,T1			!=
+	add	T1,R7,T1
+	LOAD	X(8),R8
+	add	T1,T2,T1
+	add	B,T1,B			!=
+	sll	B,22,T2
+	srl	B,32-22,B
+	or	B,T2,B
+	 xor	 C,D,T1			!=
+	add	B,C,B
+
+	sethi	%hi(0x698098d8),T2
+	and	T1,B,T1
+	or	T2,%lo(0x698098d8),T2	!=
+	xor	T1,D,T1
+	add	T1,R8,T1
+	LOAD	X(9),R9
+	add	T1,T2,T1		!=
+	add	A,T1,A
+	sll	A,7,T2
+	srl	A,32-7,A
+	or	A,T2,A			!=
+	 xor	 B,C,T1
+	add	A,B,A
+
+	sethi	%hi(0x8b44f7af),T2
+	and	T1,A,T1			!=
+	or	T2,%lo(0x8b44f7af),T2
+	xor	T1,C,T1
+	LOAD	X(10),R10
+	add	T1,R9,T1		!=
+	add	T1,T2,T1
+	add	D,T1,D
+	sll	D,12,T2
+	srl	D,32-12,D		!=
+	or	D,T2,D
+	 xor	 A,B,T1
+	add	D,A,D
+
+	sethi	%hi(0xffff5bb1),T2	!=
+	and	T1,D,T1
+	or	T2,%lo(0xffff5bb1),T2
+	xor	T1,B,T1
+	add	T1,R10,T1		!=
+	LOAD	X(11),R11
+	add	T1,T2,T1
+	add	C,T1,C
+	sll	C,17,T2			!=
+	srl	C,32-17,C
+	or	C,T2,C
+	 xor	 D,A,T1
+	add	C,D,C			!=
+
+	sethi	%hi(0x895cd7be),T2
+	and	T1,C,T1
+	or	T2,%lo(0x895cd7be),T2
+	xor	T1,A,T1			!=
+	add	T1,R11,T1
+	LOAD	X(12),R12
+	add	T1,T2,T1
+	add	B,T1,B			!=
+	sll	B,22,T2
+	srl	B,32-22,B
+	or	B,T2,B
+	 xor	 C,D,T1			!=
+	add	B,C,B
+
+	sethi	%hi(0x6b901122),T2
+	and	T1,B,T1
+	or	T2,%lo(0x6b901122),T2	!=
+	xor	T1,D,T1
+	add	T1,R12,T1
+	LOAD	X(13),R13
+	add	T1,T2,T1		!=
+	add	A,T1,A
+	sll	A,7,T2
+	srl	A,32-7,A
+	or	A,T2,A			!=
+	 xor	 B,C,T1
+	add	A,B,A
+
+	sethi	%hi(0xfd987193),T2
+	and	T1,A,T1			!=
+	or	T2,%lo(0xfd987193),T2
+	xor	T1,C,T1
+	LOAD	X(14),RX
+	add	T1,R13,T1		!=
+	add	T1,T2,T1
+	add	D,T1,D
+	sll	D,12,T2
+	srl	D,32-12,D		!=
+	or	D,T2,D
+	 xor	 A,B,T1
+	add	D,A,D
+
+	sethi	%hi(0xa679438e),T2	!=
+	and	T1,D,T1
+	or	T2,%lo(0xa679438e),T2
+	xor	T1,B,T1
+	add	T1,RX,T1		!=
+	LOAD	X(15),RX
+	add	T1,T2,T1
+	add	C,T1,C
+	sll	C,17,T2			!=
+	srl	C,32-17,C
+	or	C,T2,C
+	 xor	 D,A,T1
+	add	C,D,C			!=
+
+	sethi	%hi(0x49b40821),T2
+	and	T1,C,T1
+	or	T2,%lo(0x49b40821),T2
+	xor	T1,A,T1			!=
+	add	T1,RX,T1
+	!pre-LOADed	X(1),R1
+	add	T1,T2,T1
+	add	B,T1,B
+	sll	B,22,T2			!=
+	srl	B,32-22,B
+	or	B,T2,B
+	add	B,C,B
+
+!!!!!!!!Round 1
+
+	xor	B,C,T1			!=
+	sethi	%hi(0xf61e2562),T2
+	and	T1,D,T1
+	or	T2,%lo(0xf61e2562),T2
+	xor	T1,C,T1			!=
+	add	T1,R1,T1
+	!pre-LOADed	X(6),R6
+	add	T1,T2,T1
+	add	A,T1,A
+	sll	A,5,T2			!=
+	srl	A,32-5,A
+	or	A,T2,A
+	add	A,B,A
+
+	xor	A,B,T1			!=
+	sethi	%hi(0xc040b340),T2
+	and	T1,C,T1
+	or	T2,%lo(0xc040b340),T2
+	xor	T1,B,T1			!=
+	add	T1,R6,T1
+	!pre-LOADed	X(11),R11
+	add	T1,T2,T1
+	add	D,T1,D
+	sll	D,9,T2			!=
+	srl	D,32-9,D
+	or	D,T2,D
+	add	D,A,D
+
+	xor	D,A,T1			!=
+	sethi	%hi(0x265e5a51),T2
+	and	T1,B,T1
+	or	T2,%lo(0x265e5a51),T2
+	xor	T1,A,T1			!=
+	add	T1,R11,T1
+	!pre-LOADed	X(0),R0
+	add	T1,T2,T1
+	add	C,T1,C
+	sll	C,14,T2			!=
+	srl	C,32-14,C
+	or	C,T2,C
+	add	C,D,C
+
+	xor	C,D,T1			!=
+	sethi	%hi(0xe9b6c7aa),T2
+	and	T1,A,T1
+	or	T2,%lo(0xe9b6c7aa),T2
+	xor	T1,D,T1			!=
+	add	T1,R0,T1
+	!pre-LOADed	X(5),R5
+	add	T1,T2,T1
+	add	B,T1,B
+	sll	B,20,T2			!=
+	srl	B,32-20,B
+	or	B,T2,B
+	add	B,C,B
+
+	xor	B,C,T1			!=
+	sethi	%hi(0xd62f105d),T2
+	and	T1,D,T1
+	or	T2,%lo(0xd62f105d),T2
+	xor	T1,C,T1			!=
+	add	T1,R5,T1
+	!pre-LOADed	X(10),R10
+	add	T1,T2,T1
+	add	A,T1,A
+	sll	A,5,T2			!=
+	srl	A,32-5,A
+	or	A,T2,A
+	add	A,B,A
+
+	xor	A,B,T1			!=
+	sethi	%hi(0x02441453),T2
+	and	T1,C,T1
+	or	T2,%lo(0x02441453),T2
+	xor	T1,B,T1			!=
+	add	T1,R10,T1
+	LOAD	X(15),RX
+	add	T1,T2,T1
+	add	D,T1,D			!=
+	sll	D,9,T2
+	srl	D,32-9,D
+	or	D,T2,D
+	add	D,A,D			!=
+
+	xor	D,A,T1
+	sethi	%hi(0xd8a1e681),T2
+	and	T1,B,T1
+	or	T2,%lo(0xd8a1e681),T2	!=
+	xor	T1,A,T1
+	add	T1,RX,T1
+	!pre-LOADed	X(4),R4
+	add	T1,T2,T1
+	add	C,T1,C			!=
+	sll	C,14,T2
+	srl	C,32-14,C
+	or	C,T2,C
+	add	C,D,C			!=
+
+	xor	C,D,T1
+	sethi	%hi(0xe7d3fbc8),T2
+	and	T1,A,T1
+	or	T2,%lo(0xe7d3fbc8),T2	!=
+	xor	T1,D,T1
+	add	T1,R4,T1
+	!pre-LOADed	X(9),R9
+	add	T1,T2,T1
+	add	B,T1,B			!=
+	sll	B,20,T2
+	srl	B,32-20,B
+	or	B,T2,B
+	add	B,C,B			!=
+
+	xor	B,C,T1
+	sethi	%hi(0x21e1cde6),T2
+	and	T1,D,T1
+	or	T2,%lo(0x21e1cde6),T2	!=
+	xor	T1,C,T1
+	add	T1,R9,T1
+	LOAD	X(14),RX
+	add	T1,T2,T1		!=
+	add	A,T1,A
+	sll	A,5,T2
+	srl	A,32-5,A
+	or	A,T2,A			!=
+	add	A,B,A
+
+	xor	A,B,T1
+	sethi	%hi(0xc33707d6),T2
+	and	T1,C,T1			!=
+	or	T2,%lo(0xc33707d6),T2
+	xor	T1,B,T1
+	add	T1,RX,T1
+	!pre-LOADed	X(3),R3
+	add	T1,T2,T1		!=
+	add	D,T1,D
+	sll	D,9,T2
+	srl	D,32-9,D
+	or	D,T2,D			!=
+	add	D,A,D
+
+	xor	D,A,T1
+	sethi	%hi(0xf4d50d87),T2
+	and	T1,B,T1			!=
+	or	T2,%lo(0xf4d50d87),T2
+	xor	T1,A,T1
+	add	T1,R3,T1
+	!pre-LOADed	X(8),R8
+	add	T1,T2,T1		!=
+	add	C,T1,C
+	sll	C,14,T2
+	srl	C,32-14,C
+	or	C,T2,C			!=
+	add	C,D,C
+
+	xor	C,D,T1
+	sethi	%hi(0x455a14ed),T2
+	and	T1,A,T1			!=
+	or	T2,%lo(0x455a14ed),T2
+	xor	T1,D,T1
+	add	T1,R8,T1
+	!pre-LOADed	X(13),R13
+	add	T1,T2,T1		!=
+	add	B,T1,B
+	sll	B,20,T2
+	srl	B,32-20,B
+	or	B,T2,B			!=
+	add	B,C,B
+
+	xor	B,C,T1
+	sethi	%hi(0xa9e3e905),T2
+	and	T1,D,T1			!=
+	or	T2,%lo(0xa9e3e905),T2
+	xor	T1,C,T1
+	add	T1,R13,T1
+	!pre-LOADed	X(2),R2
+	add	T1,T2,T1		!=
+	add	A,T1,A
+	sll	A,5,T2
+	srl	A,32-5,A
+	or	A,T2,A			!=
+	add	A,B,A
+
+	xor	A,B,T1
+	sethi	%hi(0xfcefa3f8),T2
+	and	T1,C,T1			!=
+	or	T2,%lo(0xfcefa3f8),T2
+	xor	T1,B,T1
+	add	T1,R2,T1
+	!pre-LOADed	X(7),R7
+	add	T1,T2,T1		!=
+	add	D,T1,D
+	sll	D,9,T2
+	srl	D,32-9,D
+	or	D,T2,D			!=
+	add	D,A,D
+
+	xor	D,A,T1
+	sethi	%hi(0x676f02d9),T2
+	and	T1,B,T1			!=
+	or	T2,%lo(0x676f02d9),T2
+	xor	T1,A,T1
+	add	T1,R7,T1
+	!pre-LOADed	X(12),R12
+	add	T1,T2,T1		!=
+	add	C,T1,C
+	sll	C,14,T2
+	srl	C,32-14,C
+	or	C,T2,C			!=
+	add	C,D,C
+
+	xor	C,D,T1
+	sethi	%hi(0x8d2a4c8a),T2
+	and	T1,A,T1			!=
+	or	T2,%lo(0x8d2a4c8a),T2
+	xor	T1,D,T1
+	add	T1,R12,T1
+	!pre-LOADed	X(5),R5
+	add	T1,T2,T1		!=
+	add	B,T1,B
+	sll	B,20,T2
+	srl	B,32-20,B
+	or	B,T2,B			!=
+	add	B,C,B
+
+!!!!!!!!Round 2
+
+	xor	B,C,T1
+	sethi	%hi(0xfffa3942),T2
+	xor	T1,D,T1			!=
+	or	T2,%lo(0xfffa3942),T2
+	add	T1,R5,T1
+	!pre-LOADed	X(8),R8
+	add	T1,T2,T1
+	add	A,T1,A			!=
+	sll	A,4,T2
+	srl	A,32-4,A
+	or	A,T2,A
+	add	A,B,A			!=
+
+	xor	A,B,T1
+	sethi	%hi(0x8771f681),T2
+	xor	T1,C,T1
+	or	T2,%lo(0x8771f681),T2	!=
+	add	T1,R8,T1
+	!pre-LOADed	X(11),R11
+	add	T1,T2,T1
+	add	D,T1,D
+	sll	D,11,T2			!=
+	srl	D,32-11,D
+	or	D,T2,D
+	add	D,A,D
+
+	xor	D,A,T1			!=
+	sethi	%hi(0x6d9d6122),T2
+	xor	T1,B,T1
+	or	T2,%lo(0x6d9d6122),T2
+	add	T1,R11,T1		!=
+	LOAD	X(14),RX
+	add	T1,T2,T1
+	add	C,T1,C
+	sll	C,16,T2			!=
+	srl	C,32-16,C
+	or	C,T2,C
+	add	C,D,C
+
+	xor	C,D,T1			!=
+	sethi	%hi(0xfde5380c),T2
+	xor	T1,A,T1
+	or	T2,%lo(0xfde5380c),T2
+	add	T1,RX,T1		!=
+	!pre-LOADed	X(1),R1
+	add	T1,T2,T1
+	add	B,T1,B
+	sll	B,23,T2
+	srl	B,32-23,B		!=
+	or	B,T2,B
+	add	B,C,B
+
+	xor	B,C,T1
+	sethi	%hi(0xa4beea44),T2	!=
+	xor	T1,D,T1
+	or	T2,%lo(0xa4beea44),T2
+	add	T1,R1,T1
+	!pre-LOADed	X(4),R4
+	add	T1,T2,T1		!=
+	add	A,T1,A
+	sll	A,4,T2
+	srl	A,32-4,A
+	or	A,T2,A			!=
+	add	A,B,A
+
+	xor	A,B,T1
+	sethi	%hi(0x4bdecfa9),T2
+	xor	T1,C,T1			!=
+	or	T2,%lo(0x4bdecfa9),T2
+	add	T1,R4,T1
+	!pre-LOADed	X(7),R7
+	add	T1,T2,T1
+	add	D,T1,D			!=
+	sll	D,11,T2
+	srl	D,32-11,D
+	or	D,T2,D
+	add	D,A,D			!=
+
+	xor	D,A,T1
+	sethi	%hi(0xf6bb4b60),T2
+	xor	T1,B,T1
+	or	T2,%lo(0xf6bb4b60),T2	!=
+	add	T1,R7,T1
+	!pre-LOADed	X(10),R10
+	add	T1,T2,T1
+	add	C,T1,C
+	sll	C,16,T2			!=
+	srl	C,32-16,C
+	or	C,T2,C
+	add	C,D,C
+
+	xor	C,D,T1			!=
+	sethi	%hi(0xbebfbc70),T2
+	xor	T1,A,T1
+	or	T2,%lo(0xbebfbc70),T2
+	add	T1,R10,T1		!=
+	!pre-LOADed	X(13),R13
+	add	T1,T2,T1
+	add	B,T1,B
+	sll	B,23,T2
+	srl	B,32-23,B		!=
+	or	B,T2,B
+	add	B,C,B
+
+	xor	B,C,T1
+	sethi	%hi(0x289b7ec6),T2	!=
+	xor	T1,D,T1
+	or	T2,%lo(0x289b7ec6),T2
+	add	T1,R13,T1
+	!pre-LOADed	X(0),R0
+	add	T1,T2,T1		!=
+	add	A,T1,A
+	sll	A,4,T2
+	srl	A,32-4,A
+	or	A,T2,A			!=
+	add	A,B,A
+
+	xor	A,B,T1
+	sethi	%hi(0xeaa127fa),T2
+	xor	T1,C,T1			!=
+	or	T2,%lo(0xeaa127fa),T2
+	add	T1,R0,T1
+	!pre-LOADed	X(3),R3
+	add	T1,T2,T1
+	add	D,T1,D			!=
+	sll	D,11,T2
+	srl	D,32-11,D
+	or	D,T2,D
+	add	D,A,D			!=
+
+	xor	D,A,T1
+	sethi	%hi(0xd4ef3085),T2
+	xor	T1,B,T1
+	or	T2,%lo(0xd4ef3085),T2	!=
+	add	T1,R3,T1
+	!pre-LOADed	X(6),R6
+	add	T1,T2,T1
+	add	C,T1,C
+	sll	C,16,T2			!=
+	srl	C,32-16,C
+	or	C,T2,C
+	add	C,D,C
+
+	xor	C,D,T1			!=
+	sethi	%hi(0x04881d05),T2
+	xor	T1,A,T1
+	or	T2,%lo(0x04881d05),T2
+	add	T1,R6,T1		!=
+	!pre-LOADed	X(9),R9
+	add	T1,T2,T1
+	add	B,T1,B
+	sll	B,23,T2
+	srl	B,32-23,B		!=
+	or	B,T2,B
+	add	B,C,B
+
+	xor	B,C,T1
+	sethi	%hi(0xd9d4d039),T2	!=
+	xor	T1,D,T1
+	or	T2,%lo(0xd9d4d039),T2
+	add	T1,R9,T1
+	!pre-LOADed	X(12),R12
+	add	T1,T2,T1		!=
+	add	A,T1,A
+	sll	A,4,T2
+	srl	A,32-4,A
+	or	A,T2,A			!=
+	add	A,B,A
+
+	xor	A,B,T1
+	sethi	%hi(0xe6db99e5),T2
+	xor	T1,C,T1			!=
+	or	T2,%lo(0xe6db99e5),T2
+	add	T1,R12,T1
+	LOAD	X(15),RX
+	add	T1,T2,T1		!=
+	add	D,T1,D
+	sll	D,11,T2
+	srl	D,32-11,D
+	or	D,T2,D			!=
+	add	D,A,D
+
+	xor	D,A,T1
+	sethi	%hi(0x1fa27cf8),T2
+	xor	T1,B,T1			!=
+	or	T2,%lo(0x1fa27cf8),T2
+	add	T1,RX,T1
+	!pre-LOADed	X(2),R2
+	add	T1,T2,T1
+	add	C,T1,C			!=
+	sll	C,16,T2
+	srl	C,32-16,C
+	or	C,T2,C
+	add	C,D,C			!=
+
+	xor	C,D,T1
+	sethi	%hi(0xc4ac5665),T2
+	xor	T1,A,T1
+	or	T2,%lo(0xc4ac5665),T2	!=
+	add	T1,R2,T1
+	!pre-LOADed	X(0),R0
+	add	T1,T2,T1
+	add	B,T1,B
+	sll	B,23,T2			!=
+	srl	B,32-23,B
+	or	B,T2,B
+	add	B,C,B
+
+!!!!!!!!Round 3
+
+	orn	B,D,T1			!=
+	sethi	%hi(0xf4292244),T2
+	xor	T1,C,T1
+	or	T2,%lo(0xf4292244),T2
+	add	T1,R0,T1		!=
+	!pre-LOADed	X(7),R7
+	add	T1,T2,T1
+	add	A,T1,A
+	sll	A,6,T2
+	srl	A,32-6,A		!=
+	or	A,T2,A
+	add	A,B,A
+
+	orn	A,C,T1
+	sethi	%hi(0x432aff97),T2	!=
+	xor	T1,B,T1
+	or	T2,%lo(0x432aff97),T2
+	LOAD	X(14),RX
+	add	T1,R7,T1		!=
+	add	T1,T2,T1
+	add	D,T1,D
+	sll	D,10,T2
+	srl	D,32-10,D		!=
+	or	D,T2,D
+	add	D,A,D
+
+	orn	D,B,T1
+	sethi	%hi(0xab9423a7),T2	!=
+	xor	T1,A,T1
+	or	T2,%lo(0xab9423a7),T2
+	add	T1,RX,T1
+	!pre-LOADed	X(5),R5
+	add	T1,T2,T1		!=
+	add	C,T1,C
+	sll	C,15,T2
+	srl	C,32-15,C
+	or	C,T2,C			!=
+	add	C,D,C
+
+	orn	C,A,T1
+	sethi	%hi(0xfc93a039),T2
+	xor	T1,D,T1			!=
+	or	T2,%lo(0xfc93a039),T2
+	add	T1,R5,T1
+	!pre-LOADed	X(12),R12
+	add	T1,T2,T1
+	add	B,T1,B			!=
+	sll	B,21,T2
+	srl	B,32-21,B
+	or	B,T2,B
+	add	B,C,B			!=
+
+	orn	B,D,T1
+	sethi	%hi(0x655b59c3),T2
+	xor	T1,C,T1
+	or	T2,%lo(0x655b59c3),T2	!=
+	add	T1,R12,T1
+	!pre-LOADed	X(3),R3
+	add	T1,T2,T1
+	add	A,T1,A
+	sll	A,6,T2			!=
+	srl	A,32-6,A
+	or	A,T2,A
+	add	A,B,A
+
+	orn	A,C,T1			!=
+	sethi	%hi(0x8f0ccc92),T2
+	xor	T1,B,T1
+	or	T2,%lo(0x8f0ccc92),T2
+	add	T1,R3,T1		!=
+	!pre-LOADed	X(10),R10
+	add	T1,T2,T1
+	add	D,T1,D
+	sll	D,10,T2
+	srl	D,32-10,D		!=
+	or	D,T2,D
+	add	D,A,D
+
+	orn	D,B,T1
+	sethi	%hi(0xffeff47d),T2	!=
+	xor	T1,A,T1
+	or	T2,%lo(0xffeff47d),T2
+	add	T1,R10,T1
+	!pre-LOADed	X(1),R1
+	add	T1,T2,T1		!=
+	add	C,T1,C
+	sll	C,15,T2
+	srl	C,32-15,C
+	or	C,T2,C			!=
+	add	C,D,C
+
+	orn	C,A,T1
+	sethi	%hi(0x85845dd1),T2
+	xor	T1,D,T1			!=
+	or	T2,%lo(0x85845dd1),T2
+	add	T1,R1,T1
+	!pre-LOADed	X(8),R8
+	add	T1,T2,T1
+	add	B,T1,B			!=
+	sll	B,21,T2
+	srl	B,32-21,B
+	or	B,T2,B
+	add	B,C,B			!=
+
+	orn	B,D,T1
+	sethi	%hi(0x6fa87e4f),T2
+	xor	T1,C,T1
+	or	T2,%lo(0x6fa87e4f),T2	!=
+	add	T1,R8,T1
+	LOAD	X(15),RX
+	add	T1,T2,T1
+	add	A,T1,A			!=
+	sll	A,6,T2
+	srl	A,32-6,A
+	or	A,T2,A
+	add	A,B,A			!=
+
+	orn	A,C,T1
+	sethi	%hi(0xfe2ce6e0),T2
+	xor	T1,B,T1
+	or	T2,%lo(0xfe2ce6e0),T2	!=
+	add	T1,RX,T1
+	!pre-LOADed	X(6),R6
+	add	T1,T2,T1
+	add	D,T1,D
+	sll	D,10,T2			!=
+	srl	D,32-10,D
+	or	D,T2,D
+	add	D,A,D
+
+	orn	D,B,T1			!=
+	sethi	%hi(0xa3014314),T2
+	xor	T1,A,T1
+	or	T2,%lo(0xa3014314),T2
+	add	T1,R6,T1		!=
+	!pre-LOADed	X(13),R13
+	add	T1,T2,T1
+	add	C,T1,C
+	sll	C,15,T2
+	srl	C,32-15,C		!=
+	or	C,T2,C
+	add	C,D,C
+
+	orn	C,A,T1
+	sethi	%hi(0x4e0811a1),T2	!=
+	xor	T1,D,T1
+	or	T2,%lo(0x4e0811a1),T2
+	!pre-LOADed	X(4),R4
+	 ld	 [Aptr],Aval
+	add	T1,R13,T1		!=
+	add	T1,T2,T1
+	add	B,T1,B
+	sll	B,21,T2
+	srl	B,32-21,B		!=
+	or	B,T2,B
+	add	B,C,B
+
+	orn	B,D,T1
+	sethi	%hi(0xf7537e82),T2	!=
+	xor	T1,C,T1
+	or	T2,%lo(0xf7537e82),T2
+	!pre-LOADed	X(11),R11
+	 ld	 [Dptr],Dval
+	add	T1,R4,T1		!=
+	add	T1,T2,T1
+	add	A,T1,A
+	sll	A,6,T2
+	srl	A,32-6,A		!=
+	or	A,T2,A
+	add	A,B,A
+
+	orn	A,C,T1
+	sethi	%hi(0xbd3af235),T2	!=
+	xor	T1,B,T1
+	or	T2,%lo(0xbd3af235),T2
+	!pre-LOADed	X(2),R2
+	 ld	 [Cptr],Cval
+	add	T1,R11,T1		!=
+	add	T1,T2,T1
+	add	D,T1,D
+	sll	D,10,T2
+	srl	D,32-10,D		!=
+	or	D,T2,D
+	add	D,A,D
+
+	orn	D,B,T1
+	sethi	%hi(0x2ad7d2bb),T2	!=
+	xor	T1,A,T1
+	or	T2,%lo(0x2ad7d2bb),T2
+	!pre-LOADed	X(9),R9
+	 ld	 [Bptr],Bval
+	add	T1,R2,T1		!=
+	 add	 Aval,A,Aval
+	add	T1,T2,T1
+	 st	 Aval,[Aptr]
+	add	C,T1,C			!=
+	sll	C,15,T2
+	 add	 Dval,D,Dval
+	srl	C,32-15,C
+	or	C,T2,C			!=
+	 st	 Dval,[Dptr]
+	add	C,D,C
+
+	orn	C,A,T1
+	sethi	%hi(0xeb86d391),T2	!=
+	xor	T1,D,T1
+	or	T2,%lo(0xeb86d391),T2
+	add	T1,R9,T1
+	!pre-LOADed	X(0),R0
+	 mov	 Aval,A			!=
+	add	T1,T2,T1
+	 mov	 Dval,D
+	add	B,T1,B
+	sll	B,21,T2			!=
+	 add	 Cval,C,Cval
+	srl	B,32-21,B
+	 st	 Cval,[Cptr]
+	or	B,T2,B			!=
+	add	B,C,B
+
+	deccc	%i2
+	mov	Cval,C
+	add	B,Bval,B		!=
+	inc	64,%i1
+	nop
+	st	B,[Bptr]
+	nop				!=
+
+#ifdef	ULTRASPARC
+	bg,a,pt	%icc,.Lmd5_block_loop
+#else
+	bg,a	.Lmd5_block_loop
+#endif
+	LOAD	X(0),R0
+
+#ifdef ASI_PRIMARY_LITTLE
+	wr	%g0,%o7,%asi
+#endif
+	ret
+	restore	%g0,0,%o0
+
+.type	md5_block,#function
+.size	md5_block,(.-md5_block)
diff --git a/src/lib/libcrypto/md5/asm/mx86unix.cpp b/src/lib/libcrypto/md5/asm/mx86unix.cpp
deleted file mode 100644
index 5d399122b6..0000000000
--- a/src/lib/libcrypto/md5/asm/mx86unix.cpp
+++ /dev/null
@@ -1,730 +0,0 @@
-/* Run the C pre-processor over this file with one of the following defined
- * ELF - elf object files,
- * OUT - a.out object files,
- * BSDI - BSDI style a.out object files
- * SOL - Solaris style elf
- */
-
-#define TYPE(a,b)       .type   a,b
-#define SIZE(a,b)       .size   a,b
-
-#if defined(OUT) || defined(BSDI)
-#define md5_block_x86 _md5_block_x86
-
-#endif
-
-#ifdef OUT
-#define OK	1
-#define ALIGN	4
-#endif
-
-#ifdef BSDI
-#define OK              1
-#define ALIGN           4
-#undef SIZE
-#undef TYPE
-#define SIZE(a,b)
-#define TYPE(a,b)
-#endif
-
-#if defined(ELF) || defined(SOL)
-#define OK              1
-#define ALIGN           16
-#endif
-
-#ifndef OK
-You need to define one of
-ELF - elf systems - linux-elf, NetBSD and DG-UX
-OUT - a.out systems - linux-a.out and FreeBSD
-SOL - solaris systems, which are elf with strange comment lines
-BSDI - a.out with a very primative version of as.
-#endif
-
-/* Let the Assembler begin :-) */
-	/* Don't even think of reading this code */
-	/* It was automatically generated by md5-586.pl */
-	/* Which is a perl program used to generate the x86 assember for */
-	/* any of elf, a.out, BSDI,Win32, or Solaris */
-	/* eric <eay@cryptsoft.com> */
-
-	.file	"md5-586.s"
-	.version	"01.01"
-gcc2_compiled.:
-.text
-	.align ALIGN
-.globl md5_block_x86
-	TYPE(md5_block_x86,@function)
-md5_block_x86:
-	pushl	%esi
-	pushl	%edi
-	movl	12(%esp),	%edi
-	movl	16(%esp),	%esi
-	movl	20(%esp),	%ecx
-	pushl	%ebp
-	pushl	%ebx
-	addl	%esi,		%ecx
-	subl	$64,		%ecx
-	movl	(%edi),		%eax
-	pushl	%ecx
-	movl	4(%edi),	%ebx
-	movl	8(%edi),	%ecx
-	movl	12(%edi),	%edx
-.L000start:
-
-	/* R0 section */
-	movl	%ecx,		%edi
-	movl	(%esi),		%ebp
-	/* R0 0 */
-	xorl	%edx,		%edi
-	andl	%ebx,		%edi
-	leal	3614090360(%eax,%ebp,1),%eax
-	movl	4(%esi),	%ebp
-	xorl	%edx,		%edi
-	addl	%edi,		%eax
-	movl	%ebx,		%edi
-	roll	$7,		%eax
-	addl	%ebx,		%eax
-	/* R0 1 */
-	xorl	%ecx,		%edi
-	andl	%eax,		%edi
-	leal	3905402710(%edx,%ebp,1),%edx
-	movl	8(%esi),	%ebp
-	xorl	%ecx,		%edi
-	addl	%edi,		%edx
-	movl	%eax,		%edi
-	roll	$12,		%edx
-	addl	%eax,		%edx
-	/* R0 2 */
-	xorl	%ebx,		%edi
-	andl	%edx,		%edi
-	leal	606105819(%ecx,%ebp,1),%ecx
-	movl	12(%esi),	%ebp
-	xorl	%ebx,		%edi
-	addl	%edi,		%ecx
-	movl	%edx,		%edi
-	roll	$17,		%ecx
-	addl	%edx,		%ecx
-	/* R0 3 */
-	xorl	%eax,		%edi
-	andl	%ecx,		%edi
-	leal	3250441966(%ebx,%ebp,1),%ebx
-	movl	16(%esi),	%ebp
-	xorl	%eax,		%edi
-	addl	%edi,		%ebx
-	movl	%ecx,		%edi
-	roll	$22,		%ebx
-	addl	%ecx,		%ebx
-	/* R0 4 */
-	xorl	%edx,		%edi
-	andl	%ebx,		%edi
-	leal	4118548399(%eax,%ebp,1),%eax
-	movl	20(%esi),	%ebp
-	xorl	%edx,		%edi
-	addl	%edi,		%eax
-	movl	%ebx,		%edi
-	roll	$7,		%eax
-	addl	%ebx,		%eax
-	/* R0 5 */
-	xorl	%ecx,		%edi
-	andl	%eax,		%edi
-	leal	1200080426(%edx,%ebp,1),%edx
-	movl	24(%esi),	%ebp
-	xorl	%ecx,		%edi
-	addl	%edi,		%edx
-	movl	%eax,		%edi
-	roll	$12,		%edx
-	addl	%eax,		%edx
-	/* R0 6 */
-	xorl	%ebx,		%edi
-	andl	%edx,		%edi
-	leal	2821735955(%ecx,%ebp,1),%ecx
-	movl	28(%esi),	%ebp
-	xorl	%ebx,		%edi
-	addl	%edi,		%ecx
-	movl	%edx,		%edi
-	roll	$17,		%ecx
-	addl	%edx,		%ecx
-	/* R0 7 */
-	xorl	%eax,		%edi
-	andl	%ecx,		%edi
-	leal	4249261313(%ebx,%ebp,1),%ebx
-	movl	32(%esi),	%ebp
-	xorl	%eax,		%edi
-	addl	%edi,		%ebx
-	movl	%ecx,		%edi
-	roll	$22,		%ebx
-	addl	%ecx,		%ebx
-	/* R0 8 */
-	xorl	%edx,		%edi
-	andl	%ebx,		%edi
-	leal	1770035416(%eax,%ebp,1),%eax
-	movl	36(%esi),	%ebp
-	xorl	%edx,		%edi
-	addl	%edi,		%eax
-	movl	%ebx,		%edi
-	roll	$7,		%eax
-	addl	%ebx,		%eax
-	/* R0 9 */
-	xorl	%ecx,		%edi
-	andl	%eax,		%edi
-	leal	2336552879(%edx,%ebp,1),%edx
-	movl	40(%esi),	%ebp
-	xorl	%ecx,		%edi
-	addl	%edi,		%edx
-	movl	%eax,		%edi
-	roll	$12,		%edx
-	addl	%eax,		%edx
-	/* R0 10 */
-	xorl	%ebx,		%edi
-	andl	%edx,		%edi
-	leal	4294925233(%ecx,%ebp,1),%ecx
-	movl	44(%esi),	%ebp
-	xorl	%ebx,		%edi
-	addl	%edi,		%ecx
-	movl	%edx,		%edi
-	roll	$17,		%ecx
-	addl	%edx,		%ecx
-	/* R0 11 */
-	xorl	%eax,		%edi
-	andl	%ecx,		%edi
-	leal	2304563134(%ebx,%ebp,1),%ebx
-	movl	48(%esi),	%ebp
-	xorl	%eax,		%edi
-	addl	%edi,		%ebx
-	movl	%ecx,		%edi
-	roll	$22,		%ebx
-	addl	%ecx,		%ebx
-	/* R0 12 */
-	xorl	%edx,		%edi
-	andl	%ebx,		%edi
-	leal	1804603682(%eax,%ebp,1),%eax
-	movl	52(%esi),	%ebp
-	xorl	%edx,		%edi
-	addl	%edi,		%eax
-	movl	%ebx,		%edi
-	roll	$7,		%eax
-	addl	%ebx,		%eax
-	/* R0 13 */
-	xorl	%ecx,		%edi
-	andl	%eax,		%edi
-	leal	4254626195(%edx,%ebp,1),%edx
-	movl	56(%esi),	%ebp
-	xorl	%ecx,		%edi
-	addl	%edi,		%edx
-	movl	%eax,		%edi
-	roll	$12,		%edx
-	addl	%eax,		%edx
-	/* R0 14 */
-	xorl	%ebx,		%edi
-	andl	%edx,		%edi
-	leal	2792965006(%ecx,%ebp,1),%ecx
-	movl	60(%esi),	%ebp
-	xorl	%ebx,		%edi
-	addl	%edi,		%ecx
-	movl	%edx,		%edi
-	roll	$17,		%ecx
-	addl	%edx,		%ecx
-	/* R0 15 */
-	xorl	%eax,		%edi
-	andl	%ecx,		%edi
-	leal	1236535329(%ebx,%ebp,1),%ebx
-	movl	4(%esi),	%ebp
-	xorl	%eax,		%edi
-	addl	%edi,		%ebx
-	movl	%ecx,		%edi
-	roll	$22,		%ebx
-	addl	%ecx,		%ebx
-
-	/* R1 section */
-	/* R1 16 */
-	leal	4129170786(%eax,%ebp,1),%eax
-	xorl	%ebx,		%edi
-	andl	%edx,		%edi
-	movl	24(%esi),	%ebp
-	xorl	%ecx,		%edi
-	addl	%edi,		%eax
-	movl	%ebx,		%edi
-	roll	$5,		%eax
-	addl	%ebx,		%eax
-	/* R1 17 */
-	leal	3225465664(%edx,%ebp,1),%edx
-	xorl	%eax,		%edi
-	andl	%ecx,		%edi
-	movl	44(%esi),	%ebp
-	xorl	%ebx,		%edi
-	addl	%edi,		%edx
-	movl	%eax,		%edi
-	roll	$9,		%edx
-	addl	%eax,		%edx
-	/* R1 18 */
-	leal	643717713(%ecx,%ebp,1),%ecx
-	xorl	%edx,		%edi
-	andl	%ebx,		%edi
-	movl	(%esi),		%ebp
-	xorl	%eax,		%edi
-	addl	%edi,		%ecx
-	movl	%edx,		%edi
-	roll	$14,		%ecx
-	addl	%edx,		%ecx
-	/* R1 19 */
-	leal	3921069994(%ebx,%ebp,1),%ebx
-	xorl	%ecx,		%edi
-	andl	%eax,		%edi
-	movl	20(%esi),	%ebp
-	xorl	%edx,		%edi
-	addl	%edi,		%ebx
-	movl	%ecx,		%edi
-	roll	$20,		%ebx
-	addl	%ecx,		%ebx
-	/* R1 20 */
-	leal	3593408605(%eax,%ebp,1),%eax
-	xorl	%ebx,		%edi
-	andl	%edx,		%edi
-	movl	40(%esi),	%ebp
-	xorl	%ecx,		%edi
-	addl	%edi,		%eax
-	movl	%ebx,		%edi
-	roll	$5,		%eax
-	addl	%ebx,		%eax
-	/* R1 21 */
-	leal	38016083(%edx,%ebp,1),%edx
-	xorl	%eax,		%edi
-	andl	%ecx,		%edi
-	movl	60(%esi),	%ebp
-	xorl	%ebx,		%edi
-	addl	%edi,		%edx
-	movl	%eax,		%edi
-	roll	$9,		%edx
-	addl	%eax,		%edx
-	/* R1 22 */
-	leal	3634488961(%ecx,%ebp,1),%ecx
-	xorl	%edx,		%edi
-	andl	%ebx,		%edi
-	movl	16(%esi),	%ebp
-	xorl	%eax,		%edi
-	addl	%edi,		%ecx
-	movl	%edx,		%edi
-	roll	$14,		%ecx
-	addl	%edx,		%ecx
-	/* R1 23 */
-	leal	3889429448(%ebx,%ebp,1),%ebx
-	xorl	%ecx,		%edi
-	andl	%eax,		%edi
-	movl	36(%esi),	%ebp
-	xorl	%edx,		%edi
-	addl	%edi,		%ebx
-	movl	%ecx,		%edi
-	roll	$20,		%ebx
-	addl	%ecx,		%ebx
-	/* R1 24 */
-	leal	568446438(%eax,%ebp,1),%eax
-	xorl	%ebx,		%edi
-	andl	%edx,		%edi
-	movl	56(%esi),	%ebp
-	xorl	%ecx,		%edi
-	addl	%edi,		%eax
-	movl	%ebx,		%edi
-	roll	$5,		%eax
-	addl	%ebx,		%eax
-	/* R1 25 */
-	leal	3275163606(%edx,%ebp,1),%edx
-	xorl	%eax,		%edi
-	andl	%ecx,		%edi
-	movl	12(%esi),	%ebp
-	xorl	%ebx,		%edi
-	addl	%edi,		%edx
-	movl	%eax,		%edi
-	roll	$9,		%edx
-	addl	%eax,		%edx
-	/* R1 26 */
-	leal	4107603335(%ecx,%ebp,1),%ecx
-	xorl	%edx,		%edi
-	andl	%ebx,		%edi
-	movl	32(%esi),	%ebp
-	xorl	%eax,		%edi
-	addl	%edi,		%ecx
-	movl	%edx,		%edi
-	roll	$14,		%ecx
-	addl	%edx,		%ecx
-	/* R1 27 */
-	leal	1163531501(%ebx,%ebp,1),%ebx
-	xorl	%ecx,		%edi
-	andl	%eax,		%edi
-	movl	52(%esi),	%ebp
-	xorl	%edx,		%edi
-	addl	%edi,		%ebx
-	movl	%ecx,		%edi
-	roll	$20,		%ebx
-	addl	%ecx,		%ebx
-	/* R1 28 */
-	leal	2850285829(%eax,%ebp,1),%eax
-	xorl	%ebx,		%edi
-	andl	%edx,		%edi
-	movl	8(%esi),	%ebp
-	xorl	%ecx,		%edi
-	addl	%edi,		%eax
-	movl	%ebx,		%edi
-	roll	$5,		%eax
-	addl	%ebx,		%eax
-	/* R1 29 */
-	leal	4243563512(%edx,%ebp,1),%edx
-	xorl	%eax,		%edi
-	andl	%ecx,		%edi
-	movl	28(%esi),	%ebp
-	xorl	%ebx,		%edi
-	addl	%edi,		%edx
-	movl	%eax,		%edi
-	roll	$9,		%edx
-	addl	%eax,		%edx
-	/* R1 30 */
-	leal	1735328473(%ecx,%ebp,1),%ecx
-	xorl	%edx,		%edi
-	andl	%ebx,		%edi
-	movl	48(%esi),	%ebp
-	xorl	%eax,		%edi
-	addl	%edi,		%ecx
-	movl	%edx,		%edi
-	roll	$14,		%ecx
-	addl	%edx,		%ecx
-	/* R1 31 */
-	leal	2368359562(%ebx,%ebp,1),%ebx
-	xorl	%ecx,		%edi
-	andl	%eax,		%edi
-	movl	20(%esi),	%ebp
-	xorl	%edx,		%edi
-	addl	%edi,		%ebx
-	movl	%ecx,		%edi
-	roll	$20,		%ebx
-	addl	%ecx,		%ebx
-
-	/* R2 section */
-	/* R2 32 */
-	xorl	%edx,		%edi
-	xorl	%ebx,		%edi
-	leal	4294588738(%eax,%ebp,1),%eax
-	addl	%edi,		%eax
-	movl	32(%esi),	%ebp
-	roll	$4,		%eax
-	movl	%ebx,		%edi
-	/* R2 33 */
-	leal	2272392833(%edx,%ebp,1),%edx
-	addl	%ebx,		%eax
-	xorl	%ecx,		%edi
-	xorl	%eax,		%edi
-	movl	44(%esi),	%ebp
-	addl	%edi,		%edx
-	movl	%eax,		%edi
-	roll	$11,		%edx
-	addl	%eax,		%edx
-	/* R2 34 */
-	xorl	%ebx,		%edi
-	xorl	%edx,		%edi
-	leal	1839030562(%ecx,%ebp,1),%ecx
-	addl	%edi,		%ecx
-	movl	56(%esi),	%ebp
-	roll	$16,		%ecx
-	movl	%edx,		%edi
-	/* R2 35 */
-	leal	4259657740(%ebx,%ebp,1),%ebx
-	addl	%edx,		%ecx
-	xorl	%eax,		%edi
-	xorl	%ecx,		%edi
-	movl	4(%esi),	%ebp
-	addl	%edi,		%ebx
-	movl	%ecx,		%edi
-	roll	$23,		%ebx
-	addl	%ecx,		%ebx
-	/* R2 36 */
-	xorl	%edx,		%edi
-	xorl	%ebx,		%edi
-	leal	2763975236(%eax,%ebp,1),%eax
-	addl	%edi,		%eax
-	movl	16(%esi),	%ebp
-	roll	$4,		%eax
-	movl	%ebx,		%edi
-	/* R2 37 */
-	leal	1272893353(%edx,%ebp,1),%edx
-	addl	%ebx,		%eax
-	xorl	%ecx,		%edi
-	xorl	%eax,		%edi
-	movl	28(%esi),	%ebp
-	addl	%edi,		%edx
-	movl	%eax,		%edi
-	roll	$11,		%edx
-	addl	%eax,		%edx
-	/* R2 38 */
-	xorl	%ebx,		%edi
-	xorl	%edx,		%edi
-	leal	4139469664(%ecx,%ebp,1),%ecx
-	addl	%edi,		%ecx
-	movl	40(%esi),	%ebp
-	roll	$16,		%ecx
-	movl	%edx,		%edi
-	/* R2 39 */
-	leal	3200236656(%ebx,%ebp,1),%ebx
-	addl	%edx,		%ecx
-	xorl	%eax,		%edi
-	xorl	%ecx,		%edi
-	movl	52(%esi),	%ebp
-	addl	%edi,		%ebx
-	movl	%ecx,		%edi
-	roll	$23,		%ebx
-	addl	%ecx,		%ebx
-	/* R2 40 */
-	xorl	%edx,		%edi
-	xorl	%ebx,		%edi
-	leal	681279174(%eax,%ebp,1),%eax
-	addl	%edi,		%eax
-	movl	(%esi),		%ebp
-	roll	$4,		%eax
-	movl	%ebx,		%edi
-	/* R2 41 */
-	leal	3936430074(%edx,%ebp,1),%edx
-	addl	%ebx,		%eax
-	xorl	%ecx,		%edi
-	xorl	%eax,		%edi
-	movl	12(%esi),	%ebp
-	addl	%edi,		%edx
-	movl	%eax,		%edi
-	roll	$11,		%edx
-	addl	%eax,		%edx
-	/* R2 42 */
-	xorl	%ebx,		%edi
-	xorl	%edx,		%edi
-	leal	3572445317(%ecx,%ebp,1),%ecx
-	addl	%edi,		%ecx
-	movl	24(%esi),	%ebp
-	roll	$16,		%ecx
-	movl	%edx,		%edi
-	/* R2 43 */
-	leal	76029189(%ebx,%ebp,1),%ebx
-	addl	%edx,		%ecx
-	xorl	%eax,		%edi
-	xorl	%ecx,		%edi
-	movl	36(%esi),	%ebp
-	addl	%edi,		%ebx
-	movl	%ecx,		%edi
-	roll	$23,		%ebx
-	addl	%ecx,		%ebx
-	/* R2 44 */
-	xorl	%edx,		%edi
-	xorl	%ebx,		%edi
-	leal	3654602809(%eax,%ebp,1),%eax
-	addl	%edi,		%eax
-	movl	48(%esi),	%ebp
-	roll	$4,		%eax
-	movl	%ebx,		%edi
-	/* R2 45 */
-	leal	3873151461(%edx,%ebp,1),%edx
-	addl	%ebx,		%eax
-	xorl	%ecx,		%edi
-	xorl	%eax,		%edi
-	movl	60(%esi),	%ebp
-	addl	%edi,		%edx
-	movl	%eax,		%edi
-	roll	$11,		%edx
-	addl	%eax,		%edx
-	/* R2 46 */
-	xorl	%ebx,		%edi
-	xorl	%edx,		%edi
-	leal	530742520(%ecx,%ebp,1),%ecx
-	addl	%edi,		%ecx
-	movl	8(%esi),	%ebp
-	roll	$16,		%ecx
-	movl	%edx,		%edi
-	/* R2 47 */
-	leal	3299628645(%ebx,%ebp,1),%ebx
-	addl	%edx,		%ecx
-	xorl	%eax,		%edi
-	xorl	%ecx,		%edi
-	movl	(%esi),		%ebp
-	addl	%edi,		%ebx
-	movl	$-1,		%edi
-	roll	$23,		%ebx
-	addl	%ecx,		%ebx
-
-	/* R3 section */
-	/* R3 48 */
-	xorl	%edx,		%edi
-	orl	%ebx,		%edi
-	leal	4096336452(%eax,%ebp,1),%eax
-	xorl	%ecx,		%edi
-	movl	28(%esi),	%ebp
-	addl	%edi,		%eax
-	movl	$-1,		%edi
-	roll	$6,		%eax
-	xorl	%ecx,		%edi
-	addl	%ebx,		%eax
-	/* R3 49 */
-	orl	%eax,		%edi
-	leal	1126891415(%edx,%ebp,1),%edx
-	xorl	%ebx,		%edi
-	movl	56(%esi),	%ebp
-	addl	%edi,		%edx
-	movl	$-1,		%edi
-	roll	$10,		%edx
-	xorl	%ebx,		%edi
-	addl	%eax,		%edx
-	/* R3 50 */
-	orl	%edx,		%edi
-	leal	2878612391(%ecx,%ebp,1),%ecx
-	xorl	%eax,		%edi
-	movl	20(%esi),	%ebp
-	addl	%edi,		%ecx
-	movl	$-1,		%edi
-	roll	$15,		%ecx
-	xorl	%eax,		%edi
-	addl	%edx,		%ecx
-	/* R3 51 */
-	orl	%ecx,		%edi
-	leal	4237533241(%ebx,%ebp,1),%ebx
-	xorl	%edx,		%edi
-	movl	48(%esi),	%ebp
-	addl	%edi,		%ebx
-	movl	$-1,		%edi
-	roll	$21,		%ebx
-	xorl	%edx,		%edi
-	addl	%ecx,		%ebx
-	/* R3 52 */
-	orl	%ebx,		%edi
-	leal	1700485571(%eax,%ebp,1),%eax
-	xorl	%ecx,		%edi
-	movl	12(%esi),	%ebp
-	addl	%edi,		%eax
-	movl	$-1,		%edi
-	roll	$6,		%eax
-	xorl	%ecx,		%edi
-	addl	%ebx,		%eax
-	/* R3 53 */
-	orl	%eax,		%edi
-	leal	2399980690(%edx,%ebp,1),%edx
-	xorl	%ebx,		%edi
-	movl	40(%esi),	%ebp
-	addl	%edi,		%edx
-	movl	$-1,		%edi
-	roll	$10,		%edx
-	xorl	%ebx,		%edi
-	addl	%eax,		%edx
-	/* R3 54 */
-	orl	%edx,		%edi
-	leal	4293915773(%ecx,%ebp,1),%ecx
-	xorl	%eax,		%edi
-	movl	4(%esi),	%ebp
-	addl	%edi,		%ecx
-	movl	$-1,		%edi
-	roll	$15,		%ecx
-	xorl	%eax,		%edi
-	addl	%edx,		%ecx
-	/* R3 55 */
-	orl	%ecx,		%edi
-	leal	2240044497(%ebx,%ebp,1),%ebx
-	xorl	%edx,		%edi
-	movl	32(%esi),	%ebp
-	addl	%edi,		%ebx
-	movl	$-1,		%edi
-	roll	$21,		%ebx
-	xorl	%edx,		%edi
-	addl	%ecx,		%ebx
-	/* R3 56 */
-	orl	%ebx,		%edi
-	leal	1873313359(%eax,%ebp,1),%eax
-	xorl	%ecx,		%edi
-	movl	60(%esi),	%ebp
-	addl	%edi,		%eax
-	movl	$-1,		%edi
-	roll	$6,		%eax
-	xorl	%ecx,		%edi
-	addl	%ebx,		%eax
-	/* R3 57 */
-	orl	%eax,		%edi
-	leal	4264355552(%edx,%ebp,1),%edx
-	xorl	%ebx,		%edi
-	movl	24(%esi),	%ebp
-	addl	%edi,		%edx
-	movl	$-1,		%edi
-	roll	$10,		%edx
-	xorl	%ebx,		%edi
-	addl	%eax,		%edx
-	/* R3 58 */
-	orl	%edx,		%edi
-	leal	2734768916(%ecx,%ebp,1),%ecx
-	xorl	%eax,		%edi
-	movl	52(%esi),	%ebp
-	addl	%edi,		%ecx
-	movl	$-1,		%edi
-	roll	$15,		%ecx
-	xorl	%eax,		%edi
-	addl	%edx,		%ecx
-	/* R3 59 */
-	orl	%ecx,		%edi
-	leal	1309151649(%ebx,%ebp,1),%ebx
-	xorl	%edx,		%edi
-	movl	16(%esi),	%ebp
-	addl	%edi,		%ebx
-	movl	$-1,		%edi
-	roll	$21,		%ebx
-	xorl	%edx,		%edi
-	addl	%ecx,		%ebx
-	/* R3 60 */
-	orl	%ebx,		%edi
-	leal	4149444226(%eax,%ebp,1),%eax
-	xorl	%ecx,		%edi
-	movl	44(%esi),	%ebp
-	addl	%edi,		%eax
-	movl	$-1,		%edi
-	roll	$6,		%eax
-	xorl	%ecx,		%edi
-	addl	%ebx,		%eax
-	/* R3 61 */
-	orl	%eax,		%edi
-	leal	3174756917(%edx,%ebp,1),%edx
-	xorl	%ebx,		%edi
-	movl	8(%esi),	%ebp
-	addl	%edi,		%edx
-	movl	$-1,		%edi
-	roll	$10,		%edx
-	xorl	%ebx,		%edi
-	addl	%eax,		%edx
-	/* R3 62 */
-	orl	%edx,		%edi
-	leal	718787259(%ecx,%ebp,1),%ecx
-	xorl	%eax,		%edi
-	movl	36(%esi),	%ebp
-	addl	%edi,		%ecx
-	movl	$-1,		%edi
-	roll	$15,		%ecx
-	xorl	%eax,		%edi
-	addl	%edx,		%ecx
-	/* R3 63 */
-	orl	%ecx,		%edi
-	leal	3951481745(%ebx,%ebp,1),%ebx
-	xorl	%edx,		%edi
-	movl	24(%esp),	%ebp
-	addl	%edi,		%ebx
-	addl	$64,		%esi
-	roll	$21,		%ebx
-	movl	(%ebp),		%edi
-	addl	%ecx,		%ebx
-	addl	%edi,		%eax
-	movl	4(%ebp),	%edi
-	addl	%edi,		%ebx
-	movl	8(%ebp),	%edi
-	addl	%edi,		%ecx
-	movl	12(%ebp),	%edi
-	addl	%edi,		%edx
-	movl	%eax,		(%ebp)
-	movl	%ebx,		4(%ebp)
-	movl	(%esp),		%edi
-	movl	%ecx,		8(%ebp)
-	movl	%edx,		12(%ebp)
-	cmpl	%esi,		%edi
-	jge	.L000start
-	popl	%eax
-	popl	%ebx
-	popl	%ebp
-	popl	%edi
-	popl	%esi
-	ret
-.md5_block_x86_end:
-	SIZE(md5_block_x86,.md5_block_x86_end-md5_block_x86)
-.ident	"desasm.pl"
diff --git a/src/lib/libcrypto/md5/md5.c b/src/lib/libcrypto/md5/md5.c
index 9d6f5a6003..7ed0024ae1 100644
--- a/src/lib/libcrypto/md5/md5.c
+++ b/src/lib/libcrypto/md5/md5.c
@@ -58,23 +58,17 @@
 
 #include <stdio.h>
 #include <stdlib.h>
-#include "md5.h"
+#include <openssl/md5.h>
 
 #define BUFSIZE	1024*16
 
-#ifndef NOPROTO
 void do_fp(FILE *f);
 void pt(unsigned char *md);
+#ifndef _OSD_POSIX
 int read(int, void *, unsigned int);
-#else
-void do_fp();
-void pt();
-int read();
 #endif
 
-int main(argc, argv)
-int argc;
-char **argv;
+int main(int argc, char **argv)
 	{
 	int i,err=0;
 	FILE *IN;
@@ -102,8 +96,7 @@ char **argv;
 	exit(err);
 	}
 
-void do_fp(f)
-FILE *f;
+void do_fp(FILE *f)
 	{
 	MD5_CTX c;
 	unsigned char md[MD5_DIGEST_LENGTH];
@@ -123,8 +116,7 @@ FILE *f;
 	pt(md);
 	}
 
-void pt(md)
-unsigned char *md;
+void pt(unsigned char *md)
 	{
 	int i;
 
diff --git a/src/lib/libcrypto/md5/md5.h b/src/lib/libcrypto/md5/md5.h
index 357c6c625d..bdab6d45e8 100644
--- a/src/lib/libcrypto/md5/md5.h
+++ b/src/lib/libcrypto/md5/md5.h
@@ -63,35 +63,50 @@
 extern "C" {
 #endif
 
+#ifdef NO_MD5
+#error MD5 is disabled.
+#endif
+
+/*
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ * ! MD5_LONG has to be at least 32 bits wide. If it's wider, then !
+ * ! MD5_LONG_LOG2 has to be defined along.			   !
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ */
+
+#if defined(WIN16) || defined(__LP32__)
+#define MD5_LONG unsigned long
+#elif defined(_CRAY) || defined(__ILP64__)
+#define MD5_LONG unsigned long
+#define MD5_LONG_LOG2 3
+/*
+ * _CRAY note. I could declare short, but I have no idea what impact
+ * does it have on performance on none-T3E machines. I could declare
+ * int, but at least on C90 sizeof(int) can be chosen at compile time.
+ * So I've chosen long...
+ *					<appro@fy.chalmers.se>
+ */
+#else
+#define MD5_LONG unsigned int
+#endif
+
 #define MD5_CBLOCK	64
-#define MD5_LBLOCK	16
-#define MD5_BLOCK	16
-#define MD5_LAST_BLOCK  56
-#define MD5_LENGTH_BLOCK 8
+#define MD5_LBLOCK	(MD5_CBLOCK/4)
 #define MD5_DIGEST_LENGTH 16
 
 typedef struct MD5state_st
 	{
-	unsigned long A,B,C,D;
-	unsigned long Nl,Nh;
-	unsigned long data[MD5_LBLOCK];
+	MD5_LONG A,B,C,D;
+	MD5_LONG Nl,Nh;
+	MD5_LONG data[MD5_LBLOCK];
 	int num;
 	} MD5_CTX;
 
-#ifndef NOPROTO
 void MD5_Init(MD5_CTX *c);
-void MD5_Update(MD5_CTX *c, unsigned char *data, unsigned long len);
+void MD5_Update(MD5_CTX *c, const unsigned char *data, unsigned long len);
 void MD5_Final(unsigned char *md, MD5_CTX *c);
 unsigned char *MD5(unsigned char *d, unsigned long n, unsigned char *md);
-void MD5_Transform(MD5_CTX *c, unsigned char *b);
-#else
-void MD5_Init();
-void MD5_Update();
-void MD5_Final();
-unsigned char *MD5();
-void MD5_Transform();
-#endif
-
+void MD5_Transform(MD5_CTX *c, const unsigned char *b);
 #ifdef  __cplusplus
 }
 #endif
diff --git a/src/lib/libcrypto/md5/md5_dgst.c b/src/lib/libcrypto/md5/md5_dgst.c
index 43b3498d92..ba0115ae79 100644
--- a/src/lib/libcrypto/md5/md5_dgst.c
+++ b/src/lib/libcrypto/md5/md5_dgst.c
@@ -58,8 +58,9 @@
 
 #include <stdio.h>
 #include "md5_locl.h"
+#include <openssl/opensslv.h>
 
-char *MD5_version="MD5 part of SSLeay 0.9.0b 29-Jun-1998";
+char *MD5_version="MD5" OPENSSL_VERSION_PTEXT;
 
 /* Implemented from RFC1321 The MD5 Message-Digest Algorithm
  */
@@ -69,24 +70,7 @@ char *MD5_version="MD5 part of SSLeay 0.9.0b 29-Jun-1998";
 #define INIT_DATA_C (unsigned long)0x98badcfeL
 #define INIT_DATA_D (unsigned long)0x10325476L
 
-#ifndef NOPROTO
-#  ifdef MD5_ASM
-     void md5_block_x86(MD5_CTX *c, unsigned long *p,int num);
-#    define md5_block md5_block_x86
-#  else
-     static void md5_block(MD5_CTX *c, unsigned long *p,int num);
-#  endif
-#else
-#  ifdef MD5_ASM
-     void md5_block_x86();
-#    define md5_block md5_block_x86
-#  else
-     static void md5_block();
-#  endif
-#endif
-
-void MD5_Init(c)
-MD5_CTX *c;
+void MD5_Init(MD5_CTX *c)
 	{
 	c->A=INIT_DATA_A;
 	c->B=INIT_DATA_B;
@@ -97,190 +81,32 @@ MD5_CTX *c;
 	c->num=0;
 	}
 
-void MD5_Update(c, data, len)
-MD5_CTX *c;
-register unsigned char *data;
-unsigned long len;
-	{
-	register ULONG *p;
-	int sw,sc;
-	ULONG l;
-
-	if (len == 0) return;
-
-	l=(c->Nl+(len<<3))&0xffffffffL;
-	/* 95-05-24 eay Fixed a bug with the overflow handling, thanks to
-	 * Wei Dai <weidai@eskimo.com> for pointing it out. */
-	if (l < c->Nl) /* overflow */
-		c->Nh++;
-	c->Nh+=(len>>29);
-	c->Nl=l;
-
-	if (c->num != 0)
-		{
-		p=c->data;
-		sw=c->num>>2;
-		sc=c->num&0x03;
-
-		if ((c->num+len) >= MD5_CBLOCK)
-			{
-			l= p[sw];
-			p_c2l(data,l,sc);
-			p[sw++]=l;
-			for (; sw<MD5_LBLOCK; sw++)
-				{
-				c2l(data,l);
-				p[sw]=l;
-				}
-			len-=(MD5_CBLOCK-c->num);
-
-			md5_block(c,p,64);
-			c->num=0;
-			/* drop through and do the rest */
-			}
-		else
-			{
-			int ew,ec;
-
-			c->num+=(int)len;
-			if ((sc+len) < 4) /* ugly, add char's to a word */
-				{
-				l= p[sw];
-				p_c2l_p(data,l,sc,len);
-				p[sw]=l;
-				}
-			else
-				{
-				ew=(c->num>>2);
-				ec=(c->num&0x03);
-				l= p[sw];
-				p_c2l(data,l,sc);
-				p[sw++]=l;
-				for (; sw < ew; sw++)
-					{ c2l(data,l); p[sw]=l; }
-				if (ec)
-					{
-					c2l_p(data,l,ec);
-					p[sw]=l;
-					}
-				}
-			return;
-			}
-		}
-	/* we now can process the input data in blocks of MD5_CBLOCK
-	 * chars and save the leftovers to c->data. */
-#ifdef L_ENDIAN
-	if ((((unsigned long)data)%sizeof(ULONG)) == 0)
-		{
-		sw=(int)len/MD5_CBLOCK;
-		if (sw > 0)
-			{
-			sw*=MD5_CBLOCK;
-			md5_block(c,(ULONG *)data,sw);
-			data+=sw;
-			len-=sw;
-			}
-		}
-#endif
-	p=c->data;
-	while (len >= MD5_CBLOCK)
-		{
-#if defined(L_ENDIAN) || defined(B_ENDIAN)
-		if (p != (unsigned long *)data)
-			memcpy(p,data,MD5_CBLOCK);
-		data+=MD5_CBLOCK;
-#ifdef B_ENDIAN
-		for (sw=(MD5_LBLOCK/4); sw; sw--)
-			{
-			Endian_Reverse32(p[0]);
-			Endian_Reverse32(p[1]);
-			Endian_Reverse32(p[2]);
-			Endian_Reverse32(p[3]);
-			p+=4;
-			}
-#endif
-#else
-		for (sw=(MD5_LBLOCK/4); sw; sw--)
-			{
-			c2l(data,l); *(p++)=l;
-			c2l(data,l); *(p++)=l;
-			c2l(data,l); *(p++)=l;
-			c2l(data,l); *(p++)=l; 
-			} 
-#endif
-		p=c->data;
-		md5_block(c,p,64);
-		len-=MD5_CBLOCK;
-		}
-	sc=(int)len;
-	c->num=sc;
-	if (sc)
-		{
-		sw=sc>>2;	/* words to copy */
-#ifdef L_ENDIAN
-		p[sw]=0;
-		memcpy(p,data,sc);
-#else
-		sc&=0x03;
-		for ( ; sw; sw--)
-			{ c2l(data,l); *(p++)=l; }
-		c2l_p(data,l,sc);
-		*p=l;
-#endif
-		}
-	}
-
-void MD5_Transform(c,b)
-MD5_CTX *c;
-unsigned char *b;
+#ifndef md5_block_host_order
+void md5_block_host_order (MD5_CTX *c, const void *data, int num)
 	{
-	ULONG p[16];
-#if !defined(L_ENDIAN)
-	ULONG *q;
-	int i;
-#endif
-
-#if defined(B_ENDIAN) || defined(L_ENDIAN)
-	memcpy(p,b,64);
-#ifdef B_ENDIAN
-	q=p;
-	for (i=(MD5_LBLOCK/4); i; i--)
-		{
-		Endian_Reverse32(q[0]);
-		Endian_Reverse32(q[1]);
-		Endian_Reverse32(q[2]);
-		Endian_Reverse32(q[3]);
-		q+=4;
-		}
-#endif
-#else
-	q=p;
-	for (i=(MD5_LBLOCK/4); i; i--)
-		{
-		ULONG l;
-		c2l(b,l); *(q++)=l;
-		c2l(b,l); *(q++)=l;
-		c2l(b,l); *(q++)=l;
-		c2l(b,l); *(q++)=l; 
-		} 
-#endif
-	md5_block(c,p,64);
-	}
-
-#ifndef MD5_ASM
-
-static void md5_block(c, X, num)
-MD5_CTX *c;
-register ULONG *X;
-int num;
-	{
-	register ULONG A,B,C,D;
+	const MD5_LONG *X=data;
+	register unsigned long A,B,C,D;
+	/*
+	 * In case you wonder why A-D are declared as long and not
+	 * as MD5_LONG. Doing so results in slight performance
+	 * boost on LP64 architectures. The catch is we don't
+	 * really care if 32 MSBs of a 64-bit register get polluted
+	 * with eventual overflows as we *save* only 32 LSBs in
+	 * *either* case. Now declaring 'em long excuses the compiler
+	 * from keeping 32 MSBs zeroed resulting in 13% performance
+	 * improvement under SPARC Solaris7/64 and 5% under AlphaLinux.
+	 * Well, to be honest it should say that this *prevents* 
+	 * performance degradation.
+	 *
+	 *				<appro@fy.chalmers.se>
+	 */
 
 	A=c->A;
 	B=c->B;
 	C=c->C;
 	D=c->D;
-	for (;;)
+
+	for (;num--;X+=HASH_LBLOCK)
 		{
 	/* Round 0 */
 	R0(A,B,C,D,X[ 0], 7,0xd76aa478L);
@@ -351,80 +177,131 @@ int num;
 	R3(C,D,A,B,X[ 2],15,0x2ad7d2bbL);
 	R3(B,C,D,A,X[ 9],21,0xeb86d391L);
 
-	A+=c->A&0xffffffffL;
-	B+=c->B&0xffffffffL;
-	c->A=A;
-	c->B=B;
-	C+=c->C&0xffffffffL;
-	D+=c->D&0xffffffffL;
-	c->C=C;
-	c->D=D;
-	X+=16;
-	num-=64;
-	if (num <= 0) break;
+	A = c->A += A;
+	B = c->B += B;
+	C = c->C += C;
+	D = c->D += D;
 		}
 	}
 #endif
 
-void MD5_Final(md, c)
-unsigned char *md;
-MD5_CTX *c;
+#ifndef md5_block_data_order
+void md5_block_data_order (MD5_CTX *c, const void *data_, int num)
 	{
-	register int i,j;
-	register ULONG l;
-	register ULONG *p;
-	static unsigned char end[4]={0x80,0x00,0x00,0x00};
-	unsigned char *cp=end;
+	const unsigned char *data=data_;
+	register unsigned long A,B,C,D,l;
+	/*
+	 * In case you wonder why A-D are declared as long and not
+	 * as MD5_LONG. Doing so results in slight performance
+	 * boost on LP64 architectures. The catch is we don't
+	 * really care if 32 MSBs of a 64-bit register get polluted
+	 * with eventual overflows as we *save* only 32 LSBs in
+	 * *either* case. Now declaring 'em long excuses the compiler
+	 * from keeping 32 MSBs zeroed resulting in 13% performance
+	 * improvement under SPARC Solaris7/64 and 5% under AlphaLinux.
+	 * Well, to be honest it should say that this *prevents* 
+	 * performance degradation.
+	 *
+	 *				<appro@fy.chalmers.se>
+	 */
+	MD5_LONG X[MD5_LBLOCK];
+	/*
+	 * In case you wonder why don't I use c->data for this.
+	 * RISCs usually have a handful of registers and if X is
+	 * declared as automatic array good optimizing compiler
+	 * shall accomodate at least part of it in register bank
+	 * instead of memory.
+	 *
+	 *				<appro@fy.chalmers.se>
+	 */
 
-	/* c->num should definitly have room for at least one more byte. */
-	p=c->data;
-	j=c->num;
-	i=j>>2;
+	A=c->A;
+	B=c->B;
+	C=c->C;
+	D=c->D;
 
-	/* purify often complains about the following line as an
-	 * Uninitialized Memory Read.  While this can be true, the
-	 * following p_c2l macro will reset l when that case is true.
-	 * This is because j&0x03 contains the number of 'valid' bytes
-	 * already in p[i].  If and only if j&0x03 == 0, the UMR will
-	 * occur but this is also the only time p_c2l will do
-	 * l= *(cp++) instead of l|= *(cp++)
-	 * Many thanks to Alex Tang <altitude@cic.net> for pickup this
-	 * 'potential bug' */
-#ifdef PURIFY
-	if ((j&0x03) == 0) p[i]=0;
-#endif
-	l=p[i];
-	p_c2l(cp,l,j&0x03);
-	p[i]=l;
-	i++;
-	/* i is the next 'undefined word' */
-	if (c->num >= MD5_LAST_BLOCK)
+	for (;num--;)
 		{
-		for (; i<MD5_LBLOCK; i++)
-			p[i]=0;
-		md5_block(c,p,64);
-		i=0;
-		}
-	for (; i<(MD5_LBLOCK-2); i++)
-		p[i]=0;
-	p[MD5_LBLOCK-2]=c->Nl;
-	p[MD5_LBLOCK-1]=c->Nh;
-	md5_block(c,p,64);
-	cp=md;
-	l=c->A; l2c(l,cp);
-	l=c->B; l2c(l,cp);
-	l=c->C; l2c(l,cp);
-	l=c->D; l2c(l,cp);
+	HOST_c2l(data,l); X[ 0]=l;		HOST_c2l(data,l); X[ 1]=l;
+	/* Round 0 */
+	R0(A,B,C,D,X[ 0], 7,0xd76aa478L);	HOST_c2l(data,l); X[ 2]=l;
+	R0(D,A,B,C,X[ 1],12,0xe8c7b756L);	HOST_c2l(data,l); X[ 3]=l;
+	R0(C,D,A,B,X[ 2],17,0x242070dbL);	HOST_c2l(data,l); X[ 4]=l;
+	R0(B,C,D,A,X[ 3],22,0xc1bdceeeL);	HOST_c2l(data,l); X[ 5]=l;
+	R0(A,B,C,D,X[ 4], 7,0xf57c0fafL);	HOST_c2l(data,l); X[ 6]=l;
+	R0(D,A,B,C,X[ 5],12,0x4787c62aL);	HOST_c2l(data,l); X[ 7]=l;
+	R0(C,D,A,B,X[ 6],17,0xa8304613L);	HOST_c2l(data,l); X[ 8]=l;
+	R0(B,C,D,A,X[ 7],22,0xfd469501L);	HOST_c2l(data,l); X[ 9]=l;
+	R0(A,B,C,D,X[ 8], 7,0x698098d8L);	HOST_c2l(data,l); X[10]=l;
+	R0(D,A,B,C,X[ 9],12,0x8b44f7afL);	HOST_c2l(data,l); X[11]=l;
+	R0(C,D,A,B,X[10],17,0xffff5bb1L);	HOST_c2l(data,l); X[12]=l;
+	R0(B,C,D,A,X[11],22,0x895cd7beL);	HOST_c2l(data,l); X[13]=l;
+	R0(A,B,C,D,X[12], 7,0x6b901122L);	HOST_c2l(data,l); X[14]=l;
+	R0(D,A,B,C,X[13],12,0xfd987193L);	HOST_c2l(data,l); X[15]=l;
+	R0(C,D,A,B,X[14],17,0xa679438eL);
+	R0(B,C,D,A,X[15],22,0x49b40821L);
+	/* Round 1 */
+	R1(A,B,C,D,X[ 1], 5,0xf61e2562L);
+	R1(D,A,B,C,X[ 6], 9,0xc040b340L);
+	R1(C,D,A,B,X[11],14,0x265e5a51L);
+	R1(B,C,D,A,X[ 0],20,0xe9b6c7aaL);
+	R1(A,B,C,D,X[ 5], 5,0xd62f105dL);
+	R1(D,A,B,C,X[10], 9,0x02441453L);
+	R1(C,D,A,B,X[15],14,0xd8a1e681L);
+	R1(B,C,D,A,X[ 4],20,0xe7d3fbc8L);
+	R1(A,B,C,D,X[ 9], 5,0x21e1cde6L);
+	R1(D,A,B,C,X[14], 9,0xc33707d6L);
+	R1(C,D,A,B,X[ 3],14,0xf4d50d87L);
+	R1(B,C,D,A,X[ 8],20,0x455a14edL);
+	R1(A,B,C,D,X[13], 5,0xa9e3e905L);
+	R1(D,A,B,C,X[ 2], 9,0xfcefa3f8L);
+	R1(C,D,A,B,X[ 7],14,0x676f02d9L);
+	R1(B,C,D,A,X[12],20,0x8d2a4c8aL);
+	/* Round 2 */
+	R2(A,B,C,D,X[ 5], 4,0xfffa3942L);
+	R2(D,A,B,C,X[ 8],11,0x8771f681L);
+	R2(C,D,A,B,X[11],16,0x6d9d6122L);
+	R2(B,C,D,A,X[14],23,0xfde5380cL);
+	R2(A,B,C,D,X[ 1], 4,0xa4beea44L);
+	R2(D,A,B,C,X[ 4],11,0x4bdecfa9L);
+	R2(C,D,A,B,X[ 7],16,0xf6bb4b60L);
+	R2(B,C,D,A,X[10],23,0xbebfbc70L);
+	R2(A,B,C,D,X[13], 4,0x289b7ec6L);
+	R2(D,A,B,C,X[ 0],11,0xeaa127faL);
+	R2(C,D,A,B,X[ 3],16,0xd4ef3085L);
+	R2(B,C,D,A,X[ 6],23,0x04881d05L);
+	R2(A,B,C,D,X[ 9], 4,0xd9d4d039L);
+	R2(D,A,B,C,X[12],11,0xe6db99e5L);
+	R2(C,D,A,B,X[15],16,0x1fa27cf8L);
+	R2(B,C,D,A,X[ 2],23,0xc4ac5665L);
+	/* Round 3 */
+	R3(A,B,C,D,X[ 0], 6,0xf4292244L);
+	R3(D,A,B,C,X[ 7],10,0x432aff97L);
+	R3(C,D,A,B,X[14],15,0xab9423a7L);
+	R3(B,C,D,A,X[ 5],21,0xfc93a039L);
+	R3(A,B,C,D,X[12], 6,0x655b59c3L);
+	R3(D,A,B,C,X[ 3],10,0x8f0ccc92L);
+	R3(C,D,A,B,X[10],15,0xffeff47dL);
+	R3(B,C,D,A,X[ 1],21,0x85845dd1L);
+	R3(A,B,C,D,X[ 8], 6,0x6fa87e4fL);
+	R3(D,A,B,C,X[15],10,0xfe2ce6e0L);
+	R3(C,D,A,B,X[ 6],15,0xa3014314L);
+	R3(B,C,D,A,X[13],21,0x4e0811a1L);
+	R3(A,B,C,D,X[ 4], 6,0xf7537e82L);
+	R3(D,A,B,C,X[11],10,0xbd3af235L);
+	R3(C,D,A,B,X[ 2],15,0x2ad7d2bbL);
+	R3(B,C,D,A,X[ 9],21,0xeb86d391L);
 
-	/* clear stuff, md5_block may be leaving some stuff on the stack
-	 * but I'm not worried :-) */
-	c->num=0;
-/*	memset((char *)&c,0,sizeof(c));*/
+	A = c->A += A;
+	B = c->B += B;
+	C = c->C += C;
+	D = c->D += D;
+		}
 	}
+#endif
 
 #ifdef undef
-int printit(l)
-unsigned long *l;
+int printit(unsigned long *l)
 	{
 	int i,ii;
 
diff --git a/src/lib/libcrypto/md5/md5_locl.h b/src/lib/libcrypto/md5/md5_locl.h
index dbbe1b71ca..9d04696dbd 100644
--- a/src/lib/libcrypto/md5/md5_locl.h
+++ b/src/lib/libcrypto/md5/md5_locl.h
@@ -56,102 +56,84 @@
  * [including the GNU Public Licence.]
  */
 
-/* On sparc, this actually slows things down :-( */
-#if defined(sun)
-#undef B_ENDIAN
-#endif
-
 #include <stdlib.h>
 #include <string.h>
-#include "md5.h"
-
-#define ULONG	unsigned long
-#define UCHAR	unsigned char
-#define UINT	unsigned int
+#include <openssl/opensslconf.h>
+#include <openssl/md5.h>
 
-#if defined(NOCONST)
-#define const
+#ifndef MD5_LONG_LOG2
+#define MD5_LONG_LOG2 2 /* default to 32 bits */
 #endif
 
-#undef c2l
-#define c2l(c,l)	(l = ((unsigned long)(*((c)++)))     , \
-			 l|=(((unsigned long)(*((c)++)))<< 8), \
-			 l|=(((unsigned long)(*((c)++)))<<16), \
-			 l|=(((unsigned long)(*((c)++)))<<24))
-
-#undef p_c2l
-#define p_c2l(c,l,n)	{ \
-			switch (n) { \
-			case 0: l =((unsigned long)(*((c)++))); \
-			case 1: l|=((unsigned long)(*((c)++)))<< 8; \
-			case 2: l|=((unsigned long)(*((c)++)))<<16; \
-			case 3: l|=((unsigned long)(*((c)++)))<<24; \
-				} \
-			}
-
-/* NOTE the pointer is not incremented at the end of this */
-#undef c2l_p
-#define c2l_p(c,l,n)	{ \
-			l=0; \
-			(c)+=n; \
-			switch (n) { \
-			case 3: l =((unsigned long)(*(--(c))))<<16; \
-			case 2: l|=((unsigned long)(*(--(c))))<< 8; \
-			case 1: l|=((unsigned long)(*(--(c))))    ; \
-				} \
-			}
+#ifdef MD5_ASM
+# if defined(__i386) || defined(_M_IX86)
+#  define md5_block_host_order md5_block_asm_host_order
+# elif defined(__sparc) && defined(ULTRASPARC)
+   void md5_block_asm_data_order_aligned (MD5_CTX *c, const MD5_LONG *p,int num);
+#  define HASH_BLOCK_DATA_ORDER_ALIGNED md5_block_asm_data_order_aligned
+# endif
+#endif
 
-#undef p_c2l_p
-#define p_c2l_p(c,l,sc,len) { \
-			switch (sc) \
-				{ \
-			case 0: l =((unsigned long)(*((c)++))); \
-				if (--len == 0) break; \
-			case 1: l|=((unsigned long)(*((c)++)))<< 8; \
-				if (--len == 0) break; \
-			case 2: l|=((unsigned long)(*((c)++)))<<16; \
-				} \
-			}
+void md5_block_host_order (MD5_CTX *c, const void *p,int num);
+void md5_block_data_order (MD5_CTX *c, const void *p,int num);
 
-#undef l2c
-#define l2c(l,c)	(*((c)++)=(unsigned char)(((l)    )&0xff), \
-			 *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
-			 *((c)++)=(unsigned char)(((l)>>16)&0xff), \
-			 *((c)++)=(unsigned char)(((l)>>24)&0xff))
+#if defined(__i386) || defined(_M_IX86)
+/*
+ * *_block_host_order is expected to handle aligned data while
+ * *_block_data_order - unaligned. As algorithm and host (x86)
+ * are in this case of the same "endianess" these two are
+ * otherwise indistinguishable. But normally you don't want to
+ * call the same function because unaligned access in places
+ * where alignment is expected is usually a "Bad Thing". Indeed,
+ * on RISCs you get punished with BUS ERROR signal or *severe*
+ * performance degradation. Intel CPUs are in turn perfectly
+ * capable of loading unaligned data without such drastic side
+ * effect. Yes, they say it's slower than aligned load, but no
+ * exception is generated and therefore performance degradation
+ * is *incomparable* with RISCs. What we should weight here is
+ * costs of unaligned access against costs of aligning data.
+ * According to my measurements allowing unaligned access results
+ * in ~9% performance improvement on Pentium II operating at
+ * 266MHz. I won't be surprised if the difference will be higher
+ * on faster systems:-)
+ *
+ *				<appro@fy.chalmers.se>
+ */
+#define md5_block_data_order md5_block_host_order
+#endif
 
-/* NOTE - c is not incremented as per l2c */
-#undef l2cn
-#define l2cn(l1,l2,c,n)	{ \
-			c+=n; \
-			switch (n) { \
-			case 8: *(--(c))=(unsigned char)(((l2)>>24)&0xff); \
-			case 7: *(--(c))=(unsigned char)(((l2)>>16)&0xff); \
-			case 6: *(--(c))=(unsigned char)(((l2)>> 8)&0xff); \
-			case 5: *(--(c))=(unsigned char)(((l2)    )&0xff); \
-			case 4: *(--(c))=(unsigned char)(((l1)>>24)&0xff); \
-			case 3: *(--(c))=(unsigned char)(((l1)>>16)&0xff); \
-			case 2: *(--(c))=(unsigned char)(((l1)>> 8)&0xff); \
-			case 1: *(--(c))=(unsigned char)(((l1)    )&0xff); \
-				} \
-			}
+#define DATA_ORDER_IS_LITTLE_ENDIAN
+
+#define HASH_LONG		MD5_LONG
+#define HASH_LONG_LOG2		MD5_LONG_LOG2
+#define HASH_CTX		MD5_CTX
+#define HASH_CBLOCK		MD5_CBLOCK
+#define HASH_LBLOCK		MD5_LBLOCK
+#define HASH_UPDATE		MD5_Update
+#define HASH_TRANSFORM		MD5_Transform
+#define HASH_FINAL		MD5_Final
+#define HASH_BLOCK_HOST_ORDER	md5_block_host_order
+#if !defined(L_ENDIAN) || defined(md5_block_data_order)
+#define	HASH_BLOCK_DATA_ORDER	md5_block_data_order
+/*
+ * Little-endians (Intel and Alpha) feel better without this.
+ * It looks like memcpy does better job than generic
+ * md5_block_data_order on copying-n-aligning input data.
+ * But franlky speaking I didn't expect such result on Alpha.
+ * On the other hand I've got this with egcs-1.0.2 and if
+ * program is compiled with another (better?) compiler it
+ * might turn out other way around.
+ *
+ *				<appro@fy.chalmers.se>
+ */
+#endif
 
-/* A nice byte order reversal from Wei Dai <weidai@eskimo.com> */
-#if defined(WIN32)
-/* 5 instructions with rotate instruction, else 9 */
-#define Endian_Reverse32(a) \
-	{ \
-	unsigned long l=(a); \
-	(a)=((ROTATE(l,8)&0x00FF00FF)|(ROTATE(l,24)&0xFF00FF00)); \
-	}
+#ifndef FLAT_INC
+#include "../md32_common.h"
 #else
-/* 6 instructions with rotate instruction, else 8 */
-#define Endian_Reverse32(a) \
-	{ \
-	unsigned long l=(a); \
-	l=(((l&0xFF00FF00)>>8L)|((l&0x00FF00FF)<<8L)); \
-	(a)=ROTATE(l,16L); \
-	}
+#include "md32_common.h"
 #endif
+
 /*
 #define	F(x,y,z)	(((x) & (y))  |  ((~(x)) & (z)))
 #define	G(x,y,z)	(((x) & (z))  |  ((y) & (~(z))))
@@ -166,14 +148,6 @@
 #define	H(b,c,d)	((b) ^ (c) ^ (d))
 #define	I(b,c,d)	(((~(d)) | (b)) ^ (c))
 
-#undef ROTATE
-#if defined(WIN32)
-#define ROTATE(a,n)     _lrotl(a,n)
-#else
-#define ROTATE(a,n)     (((a)<<(n))|(((a)&0xffffffff)>>(32-(n))))
-#endif
-
-
 #define R0(a,b,c,d,k,s,t) { \
 	a+=((k)+(t)+F((b),(c),(d))); \
 	a=ROTATE(a,s); \
diff --git a/src/lib/libcrypto/md5/md5_one.c b/src/lib/libcrypto/md5/md5_one.c
index ab6bb435f9..4b10e7f940 100644
--- a/src/lib/libcrypto/md5/md5_one.c
+++ b/src/lib/libcrypto/md5/md5_one.c
@@ -57,19 +57,37 @@
  */
 
 #include <stdio.h>
-#include "md5_locl.h"
+#include <string.h>
+#include <openssl/md5.h>
 
-unsigned char *MD5(d, n, md)
-unsigned char *d;
-unsigned long n;
-unsigned char *md;
+#ifdef CHARSET_EBCDIC
+#include <openssl/ebcdic.h>
+#endif
+
+unsigned char *MD5(unsigned char *d, unsigned long n, unsigned char *md)
 	{
 	MD5_CTX c;
 	static unsigned char m[MD5_DIGEST_LENGTH];
 
 	if (md == NULL) md=m;
 	MD5_Init(&c);
+#ifndef CHARSET_EBCDIC
 	MD5_Update(&c,d,n);
+#else
+	{
+		char temp[1024];
+		unsigned long chunk;
+
+		while (n > 0)
+		{
+			chunk = (n > sizeof(temp)) ? sizeof(temp) : n;
+			ebcdic2ascii(temp, d, chunk);
+			MD5_Update(&c,temp,chunk);
+			n -= chunk;
+			d += chunk;
+		}
+	}
+#endif
 	MD5_Final(md,&c);
 	memset(&c,0,sizeof(c)); /* security consideration */
 	return(md);
diff --git a/src/lib/libcrypto/md5/md5s.cpp b/src/lib/libcrypto/md5/md5s.cpp
index ef8e175df0..dd343fd4e6 100644
--- a/src/lib/libcrypto/md5/md5s.cpp
+++ b/src/lib/libcrypto/md5/md5s.cpp
@@ -32,7 +32,7 @@ void GetTSC(unsigned long& tsc)
 
 #include <stdio.h>
 #include <stdlib.h>
-#include "md5.h"
+#include <openssl/md5.h>
 
 extern "C" {
 void md5_block_x86(MD5_CTX *ctx, unsigned char *buffer,int num);
diff --git a/src/lib/libcrypto/md5/md5test.c b/src/lib/libcrypto/md5/md5test.c
index 74b84bc67f..a192a62bb3 100644
--- a/src/lib/libcrypto/md5/md5test.c
+++ b/src/lib/libcrypto/md5/md5test.c
@@ -59,7 +59,15 @@
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
-#include "md5.h"
+
+#ifdef NO_MD5
+int main(int argc, char *argv[])
+{
+    printf("No MD5 support\n");
+    return(0);
+}
+#else
+#include <openssl/md5.h>
 
 char *test[]={
 	"",
@@ -82,15 +90,8 @@ char *ret[]={
 	"57edf4a22be3c955ac49da2e2107b67a",
 	};
 
-#ifndef NOPROTO
 static char *pt(unsigned char *md);
-#else
-static char *pt();
-#endif
-
-int main(argc,argv)
-int argc;
-char *argv[];
+int main(int argc, char *argv[])
 	{
 	int i,err=0;
 	unsigned char **P,**R;
@@ -118,8 +119,7 @@ char *argv[];
 	return(0);
 	}
 
-static char *pt(md)
-unsigned char *md;
+static char *pt(unsigned char *md)
 	{
 	int i;
 	static char buf[80];
@@ -128,3 +128,4 @@ unsigned char *md;
 		sprintf(&(buf[i*2]),"%02x",md[i]);
 	return(buf);
 	}
+#endif
-- 
cgit v1.2.3-55-g6feb