diff --git a/lib/des/cbc3_enc.c b/lib/des/cbc3_enc.c
index 3b3f2821d..59deaf46e 100644
--- a/lib/des/cbc3_enc.c
+++ b/lib/des/cbc3_enc.c
@@ -59,41 +59,41 @@
 #include "des_locl.h"
 
 /* HAS BUGS? DON'T USE */
-void des_3cbc_encrypt(input, output, length, ks1, ks2, iv1, iv2, encrypt)
-des_cblock (*input);
-des_cblock (*output);
+void DES_3cbc_encrypt(input, output, length, ks1, ks2, iv1, iv2, encrypt)
+DES_cblock (*input);
+DES_cblock (*output);
 long length;
-des_key_schedule ks1;
-des_key_schedule ks2;
-des_cblock (*iv1);
-des_cblock (*iv2);
+DES_key_schedule *ks1;
+DES_key_schedule *ks2;
+DES_cblock (*iv1);
+DES_cblock (*iv2);
 int encrypt;
 	{
 	int off=((int)length-1)/8;
 	long l8=((length+7)/8)*8;
-	des_cblock niv1,niv2;
+	DES_cblock niv1,niv2;
 
 	if (encrypt == DES_ENCRYPT)
 		{
-		des_cbc_encrypt(input,output,length,ks1,iv1,encrypt);
-		if (length >= sizeof(des_cblock))
-			memcpy(niv1,output[off],sizeof(des_cblock));
-		des_cbc_encrypt(output,output,l8,ks2,iv1,!encrypt);
-		des_cbc_encrypt(output,output,l8,ks1,iv2, encrypt);
-		if (length >= sizeof(des_cblock))
-			memcpy(niv2,output[off],sizeof(des_cblock));
+		DES_cbc_encrypt(input,output,length,ks1,iv1,encrypt);
+		if (length >= sizeof(DES_cblock))
+			memcpy(niv1,output[off],sizeof(DES_cblock));
+		DES_cbc_encrypt(output,output,l8,ks2,iv1,!encrypt);
+		DES_cbc_encrypt(output,output,l8,ks1,iv2, encrypt);
+		if (length >= sizeof(DES_cblock))
+			memcpy(niv2,output[off],sizeof(DES_cblock));
 		}
 	else
 		{
-		if (length >= sizeof(des_cblock))
-			memcpy(niv2,input[off],sizeof(des_cblock));
-		des_cbc_encrypt(input,output,l8,ks1,iv2,encrypt);
-		des_cbc_encrypt(output,output,l8,ks2,iv1,!encrypt);
-		if (length >= sizeof(des_cblock))
-			memcpy(niv1,output[off],sizeof(des_cblock));
-		des_cbc_encrypt(output,output,length,ks1,iv1, encrypt);
+		if (length >= sizeof(DES_cblock))
+			memcpy(niv2,input[off],sizeof(DES_cblock));
+		DES_cbc_encrypt(input,output,l8,ks1,iv2,encrypt);
+		DES_cbc_encrypt(output,output,l8,ks2,iv1,!encrypt);
+		if (length >= sizeof(DES_cblock))
+			memcpy(niv1,output[off],sizeof(DES_cblock));
+		DES_cbc_encrypt(output,output,length,ks1,iv1, encrypt);
 		}
-	memcpy(*iv1,niv1,sizeof(des_cblock));
-	memcpy(*iv2,niv2,sizeof(des_cblock));
+	memcpy(*iv1,niv1,sizeof(DES_cblock));
+	memcpy(*iv2,niv2,sizeof(DES_cblock));
 	}
 
diff --git a/lib/des/cbc_cksm.c b/lib/des/cbc_cksm.c
index 5dfa9b8a6..7a8e45ec3 100644
--- a/lib/des/cbc_cksm.c
+++ b/lib/des/cbc_cksm.c
@@ -58,12 +58,12 @@
 
 #include "des_locl.h"
 
-DES_LONG des_cbc_cksum(input, output, length, schedule, ivec)
-des_cblock (*input);
-des_cblock (*output);
+DES_LONG DES_cbc_cksum(input, output, length, schedule, ivec)
+DES_cblock (*input);
+DES_cblock (*output);
 long length;
-des_key_schedule schedule;
-des_cblock (*ivec);
+DES_key_schedule *schedule;
+DES_cblock (*ivec);
 	{
 	register DES_LONG tout0,tout1,tin0,tin1;
 	register long l=length;
@@ -88,7 +88,7 @@ des_cblock (*ivec);
 			
 		tin0^=tout0; tin[0]=tin0;
 		tin1^=tout1; tin[1]=tin1;
-		des_encrypt((DES_LONG *)tin,schedule,DES_ENCRYPT);
+		DES_encrypt((DES_LONG *)tin,schedule,DES_ENCRYPT);
 		/* fix 15/10/91 eay - thanks to keithr@sco.COM */
 		tout0=tin[0];
 		tout1=tin[1];
diff --git a/lib/des/cbc_enc.c b/lib/des/cbc_enc.c
index e7a90ce98..a95f34a94 100644
--- a/lib/des/cbc_enc.c
+++ b/lib/des/cbc_enc.c
@@ -58,12 +58,12 @@
 
 #include "des_locl.h"
 
-void des_cbc_encrypt(input, output, length, schedule, ivec, encrypt)
-des_cblock (*input);
-des_cblock (*output);
+void DES_cbc_encrypt(input, output, length, schedule, ivec, encrypt)
+DES_cblock (*input);
+DES_cblock (*output);
 long length;
-des_key_schedule schedule;
-des_cblock (*ivec);
+DES_key_schedule *schedule;
+DES_cblock (*ivec);
 int encrypt;
 	{
 	register DES_LONG tin0,tin1;
@@ -87,7 +87,7 @@ int encrypt;
 			c2l(in,tin1);
 			tin0^=tout0; tin[0]=tin0;
 			tin1^=tout1; tin[1]=tin1;
-			des_encrypt((DES_LONG *)tin,schedule,DES_ENCRYPT);
+			DES_encrypt((DES_LONG *)tin,schedule,DES_ENCRYPT);
 			tout0=tin[0]; l2c(tout0,out);
 			tout1=tin[1]; l2c(tout1,out);
 			}
@@ -96,7 +96,7 @@ int encrypt;
 			c2ln(in,tin0,tin1,l+8);
 			tin0^=tout0; tin[0]=tin0;
 			tin1^=tout1; tin[1]=tin1;
-			des_encrypt((DES_LONG *)tin,schedule,DES_ENCRYPT);
+			DES_encrypt((DES_LONG *)tin,schedule,DES_ENCRYPT);
 			tout0=tin[0]; l2c(tout0,out);
 			tout1=tin[1]; l2c(tout1,out);
 			}
@@ -109,7 +109,7 @@ int encrypt;
 			{
 			c2l(in,tin0); tin[0]=tin0;
 			c2l(in,tin1); tin[1]=tin1;
-			des_encrypt((DES_LONG *)tin,schedule,DES_DECRYPT);
+			DES_encrypt((DES_LONG *)tin,schedule,DES_DECRYPT);
 			tout0=tin[0]^xor0;
 			tout1=tin[1]^xor1;
 			l2c(tout0,out);
@@ -121,7 +121,7 @@ int encrypt;
 			{
 			c2l(in,tin0); tin[0]=tin0;
 			c2l(in,tin1); tin[1]=tin1;
-			des_encrypt((DES_LONG *)tin,schedule,DES_DECRYPT);
+			DES_encrypt((DES_LONG *)tin,schedule,DES_DECRYPT);
 			tout0=tin[0]^xor0;
 			tout1=tin[1]^xor1;
 			l2cn(tout0,tout1,out,l+8);
diff --git a/lib/des/cfb64ede.c b/lib/des/cfb64ede.c
index b1e127a1e..b2c3f56b0 100644
--- a/lib/des/cfb64ede.c
+++ b/lib/des/cfb64ede.c
@@ -63,12 +63,12 @@
  * 64bit block we have used is contained in *num;
  */
 
-void des_ede3_cfb64_encrypt(in, out, length, ks1,ks2,ks3, ivec, num, encrypt)
+void DES_ede3_cfb64_encrypt(in, out, length, ks1,ks2,ks3, ivec, num, encrypt)
 unsigned char *in;
 unsigned char *out;
 long length;
-des_key_schedule ks1,ks2,ks3;
-des_cblock (*ivec);
+DES_key_schedule *ks1,*ks2,*ks3;
+DES_cblock (*ivec);
 int *num;
 int encrypt;
 	{
@@ -90,7 +90,7 @@ int encrypt;
 
 				ti[0]=v0;
 				ti[1]=v1;
-				des_encrypt3((DES_LONG *)ti,ks1,ks2,ks3);
+				DES_encrypt3((DES_LONG *)ti,ks1,ks2,ks3);
 				v0=ti[0];
 				v1=ti[1];
 
@@ -116,7 +116,7 @@ int encrypt;
 
 				ti[0]=v0;
 				ti[1]=v1;
-				des_encrypt3((DES_LONG *)ti,ks1,ks2,ks3);
+				DES_encrypt3((DES_LONG *)ti,ks1,ks2,ks3);
 				v0=ti[0];
 				v1=ti[1];
 
@@ -137,15 +137,15 @@ int encrypt;
 	}
 
 #ifdef undef /* MACRO */
-void des_ede2_cfb64_encrypt(in, out, length, ks1,ks2, ivec, num, encrypt)
+void DES_ede2_cfb64_encrypt(in, out, length, ks1,ks2, ivec, num, encrypt)
 unsigned char *in;
 unsigned char *out;
 long length;
-des_key_schedule ks1,ks2;
-des_cblock (*ivec);
+DES_key_schedule ks1,ks2;
+DES_cblock (*ivec);
 int *num;
 int encrypt;
 	{
-	des_ede3_cfb64_encrypt(in,out,length,ks1,ks2,ks1,ivec,num,encrypt);
+	DES_ede3_cfb64_encrypt(in,out,length,ks1,ks2,ks1,ivec,num,encrypt);
 	}
 #endif
diff --git a/lib/des/cfb64enc.c b/lib/des/cfb64enc.c
index 66c944a82..854fcf2c3 100644
--- a/lib/des/cfb64enc.c
+++ b/lib/des/cfb64enc.c
@@ -63,12 +63,12 @@
  * 64bit block we have used is contained in *num;
  */
 
-void des_cfb64_encrypt(in, out, length, schedule, ivec, num, encrypt)
+void DES_cfb64_encrypt(in, out, length, schedule, ivec, num, encrypt)
 unsigned char *in;
 unsigned char *out;
 long length;
-des_key_schedule schedule;
-des_cblock (*ivec);
+DES_key_schedule *schedule;
+DES_cblock (*ivec);
 int *num;
 int encrypt;
 	{
@@ -87,7 +87,7 @@ int encrypt;
 				{
 				c2l(iv,v0); ti[0]=v0;
 				c2l(iv,v1); ti[1]=v1;
-				des_encrypt((DES_LONG *)ti,
+				DES_encrypt((DES_LONG *)ti,
 					schedule,DES_ENCRYPT);
 				iv=(unsigned char *)ivec;
 				v0=ti[0]; l2c(v0,iv);
@@ -108,7 +108,7 @@ int encrypt;
 				{
 				c2l(iv,v0); ti[0]=v0;
 				c2l(iv,v1); ti[1]=v1;
-				des_encrypt((DES_LONG *)ti,
+				DES_encrypt((DES_LONG *)ti,
 					schedule,DES_ENCRYPT);
 				iv=(unsigned char *)ivec;
 				v0=ti[0]; l2c(v0,iv);
diff --git a/lib/des/cfb_enc.c b/lib/des/cfb_enc.c
index 52a360dcb..df1c419e3 100644
--- a/lib/des/cfb_enc.c
+++ b/lib/des/cfb_enc.c
@@ -64,13 +64,13 @@
  * the second.  The second 12 bits will come from the 3rd and half the 4th
  * byte.
  */
-void des_cfb_encrypt(in, out, numbits, length, schedule, ivec, encrypt)
+void DES_cfb_encrypt(in, out, numbits, length, schedule, ivec, encrypt)
 unsigned char *in;
 unsigned char *out;
 int numbits;
 long length;
-des_key_schedule schedule;
-des_cblock (*ivec);
+DES_key_schedule *schedule;
+DES_cblock (*ivec);
 int encrypt;
 	{
 	register DES_LONG d0,d1,v0,v1,n=(numbits+7)/8;
@@ -106,7 +106,7 @@ int encrypt;
 			l-=n;
 			ti[0]=v0;
 			ti[1]=v1;
-			des_encrypt((DES_LONG *)ti,schedule,DES_ENCRYPT);
+			DES_encrypt((DES_LONG *)ti,schedule,DES_ENCRYPT);
 			c2ln(in,d0,d1,n);
 			in+=n;
 			d0=(d0^ti[0])&mask0;
@@ -138,7 +138,7 @@ int encrypt;
 			l-=n;
 			ti[0]=v0;
 			ti[1]=v1;
-			des_encrypt((DES_LONG *)ti,schedule,DES_ENCRYPT);
+			DES_encrypt((DES_LONG *)ti,schedule,DES_ENCRYPT);
 			c2ln(in,d0,d1,n);
 			in+=n;
 			/* 30-08-94 - eay - changed because l>>32 and
diff --git a/lib/des/des.c b/lib/des/des.c
index a8d0bc5e2..c9a633ddc 100644
--- a/lib/des/des.c
+++ b/lib/des/des.c
@@ -128,7 +128,7 @@ int uubufnum=0;
 #define OUTUUBUF	(65*100)
 unsigned char b[OUTUUBUF];
 unsigned char bb[300];
-des_cblock cksum={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
+DES_cblock cksum={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
 char cksumname[200]="";
 
 int vflag,cflag,eflag,dflag,kflag,bflag,fflag,sflag,uflag,flag3,hflag,error;
@@ -283,7 +283,7 @@ char **argv;
 			}
 
 	if (!kflag)
-		if (des_read_pw_string(key,KEYSIZB+1,"Enter key:",eflag?VERIFY:0))
+		if (UI_UTIL_read_pw_string(key,KEYSIZB+1,"Enter key:",eflag?VERIFY:0))
 			{
 			fputs("password error\n",stderr);
 			EXIT(2);
@@ -373,11 +373,11 @@ void doencryption()
 #endif
 
 	register int i;
-	des_key_schedule ks,ks2;
+	DES_key_schedule ks,ks2;
 	unsigned char iv[8],iv2[8];
 	char *p;
 	int num=0,j,k,l,rem,ll,len,last,ex=0;
-	des_cblock kk,k2;
+	DES_cblock kk,k2;
 	FILE *O;
 	int Exit=0;
 #ifndef MSDOS
@@ -435,19 +435,19 @@ void doencryption()
 			else
 				k2[i-8]=k;
 			}
-		des_set_key((C_Block *)k2,ks2);
+		DES_set_key((C_Block *)k2,&ks2);
 		memset(k2,0,sizeof(k2));
 		}
 	else if (longk || flag3)
 		{
 		if (flag3)
 			{
-			des_string_to_2keys(key,(C_Block *)kk,(C_Block *)k2);
-			des_set_key((C_Block *)k2,ks2);
+			DES_string_to_2keys(key,(C_Block *)kk,(C_Block *)k2);
+			DES_set_key((C_Block *)k2,&ks2);
 			memset(k2,0,sizeof(k2));
 			}
 		else
-			des_string_to_key(key,(C_Block *)kk);
+			DES_string_to_key(key,(C_Block *)kk);
 		}
 	else
 		for (i=0; i<KEYSIZ; i++)
@@ -465,7 +465,7 @@ void doencryption()
 				kk[i]=key[i]|0x80;
 			}
 
-	des_set_key((C_Block *)kk,ks);
+	DES_set_key((C_Block *)kk,&ks);
 	memset(key,0,sizeof(key));
 	memset(kk,0,sizeof(kk));
 	/* woops - A bug that does not showup under unix :-( */
@@ -505,8 +505,8 @@ void doencryption()
 
 			if (cflag)
 				{
-				des_cbc_cksum((C_Block *)buf,(C_Block *)cksum,
-					(long)len,ks,(C_Block *)cksum);
+				DES_cbc_cksum((C_Block *)buf,(C_Block *)cksum,
+					(long)len,&ks,(C_Block *)cksum);
 				if (!eflag)
 					{
 					if (feof(DES_IN)) break;
@@ -516,34 +516,34 @@ void doencryption()
 
 			if (bflag && !flag3)
 				for (i=0; i<l; i+=8)
-					des_ecb_encrypt(
-						(des_cblock *)&(buf[i]),
-						(des_cblock *)&(obuf[i]),
-						ks,do_encrypt);
+					DES_ecb_encrypt(
+						(DES_cblock *)&(buf[i]),
+						(DES_cblock *)&(obuf[i]),
+						&ks,do_encrypt);
 			else if (flag3 && bflag)
 				for (i=0; i<l; i+=8)
-					des_ecb2_encrypt(
-						(des_cblock *)&(buf[i]),
-						(des_cblock *)&(obuf[i]),
-						ks,ks2,do_encrypt);
+					DES_ecb2_encrypt(
+						(DES_cblock *)&(buf[i]),
+						(DES_cblock *)&(obuf[i]),
+						&ks,&ks2,do_encrypt);
 			else if (flag3 && !bflag)
 				{
 				char tmpbuf[8];
 
 				if (rem) memcpy(tmpbuf,&(buf[l]),
 					(unsigned int)rem);
-				des_3cbc_encrypt(
-					(des_cblock *)buf,(des_cblock *)obuf,
-					(long)l,ks,ks2,(des_cblock *)iv,
-					(des_cblock *)iv2,do_encrypt);
+				DES_3cbc_encrypt(
+					(DES_cblock *)buf,(DES_cblock *)obuf,
+					(long)l,&ks,&ks2,(DES_cblock *)iv,
+					(DES_cblock *)iv2,do_encrypt);
 				if (rem) memcpy(&(buf[l]),tmpbuf,
 					(unsigned int)rem);
 				}
 			else
 				{
-				des_cbc_encrypt(
-					(des_cblock *)buf,(des_cblock *)obuf,
-					(long)l,ks,(des_cblock *)iv,do_encrypt);
+				DES_cbc_encrypt(
+					(DES_cblock *)buf,(DES_cblock *)obuf,
+					(long)l,&ks,(DES_cblock *)iv,do_encrypt);
 				if (l >= 8) memcpy(iv,&(obuf[l-8]),8);
 				}
 			if (rem) memcpy(buf,&(buf[l]),(unsigned int)rem);
@@ -595,28 +595,28 @@ void doencryption()
 
 			if (bflag && !flag3)
 				for (i=0; i<l; i+=8)
-					des_ecb_encrypt(
-						(des_cblock *)&(buf[i]),
-						(des_cblock *)&(obuf[i]),
-						ks,do_encrypt);
+					DES_ecb_encrypt(
+						(DES_cblock *)&(buf[i]),
+						(DES_cblock *)&(obuf[i]),
+						&ks,do_encrypt);
 			else if (flag3 && bflag)
 				for (i=0; i<l; i+=8)
-					des_ecb2_encrypt(
-						(des_cblock *)&(buf[i]),
-						(des_cblock *)&(obuf[i]),
-						ks,ks2,do_encrypt);
+					DES_ecb2_encrypt(
+						(DES_cblock *)&(buf[i]),
+						(DES_cblock *)&(obuf[i]),
+						&ks,&ks2,do_encrypt);
 			else if (flag3 && !bflag)
 				{
-				des_3cbc_encrypt(
-					(des_cblock *)buf,(des_cblock *)obuf,
-					(long)l,ks,ks2,(des_cblock *)iv,
-					(des_cblock *)iv2,do_encrypt);
+				DES_3cbc_encrypt(
+					(DES_cblock *)buf,(DES_cblock *)obuf,
+					(long)l,&ks,&ks2,(DES_cblock *)iv,
+					(DES_cblock *)iv2,do_encrypt);
 				}
 			else
 				{
-				des_cbc_encrypt(
-					(des_cblock *)buf,(des_cblock *)obuf,
-				 	(long)l,ks,(des_cblock *)iv,do_encrypt);
+				DES_cbc_encrypt(
+					(DES_cblock *)buf,(DES_cblock *)obuf,
+				 	(long)l,&ks,(DES_cblock *)iv,do_encrypt);
 				if (l >= 8) memcpy(iv,&(buf[l-8]),8);
 				}
 
@@ -641,8 +641,8 @@ void doencryption()
 				l=l-8+last;
 				}
 			i=0;
-			if (cflag) des_cbc_cksum((C_Block *)obuf,
-				(C_Block *)cksum,(long)l/8*8,ks,
+			if (cflag) DES_cbc_cksum((C_Block *)obuf,
+				(C_Block *)cksum,(long)l/8*8,&ks,
 				(C_Block *)cksum);
 			while (i != l)
 				{
@@ -678,8 +678,8 @@ void doencryption()
 problems:
 	memset(buf,0,sizeof(buf));
 	memset(obuf,0,sizeof(obuf));
-	memset(ks,0,sizeof(ks));
-	memset(ks2,0,sizeof(ks2));
+	memset(&ks,0,sizeof(ks));
+	memset(&ks2,0,sizeof(ks2));
 	memset(iv,0,sizeof(iv));
 	memset(iv2,0,sizeof(iv2));
 	memset(kk,0,sizeof(kk));
diff --git a/lib/des/des.h b/lib/des/des.h
index 611df417b..a39ac9f5e 100644
--- a/lib/des/des.h
+++ b/lib/des/des.h
@@ -56,8 +56,8 @@
  * [including the GNU Public Licence.]
  */
 
-#ifndef HEADER_DES_H
-#define HEADER_DES_H
+#ifndef HEADER_NEW_DES_H
+#define HEADER_NEW_DES_H
 
 #ifdef  __cplusplus
 extern "C" {
@@ -85,21 +85,21 @@ extern "C" {
 #endif
 #endif
 
-typedef unsigned char des_cblock[8];
-typedef struct des_ks_struct
+typedef unsigned char DES_cblock[8];
+typedef struct DES_ks_struct
 	{
 	union	{
-		des_cblock _;
+		DES_cblock _;
 		/* make sure things are correct size on machines with
 		 * 8 byte longs */
 		DES_LONG pad[2];
-		} ks;
+		} ks[16];
 #undef _
 #define _	ks._
-	} des_key_schedule[16];
+	} DES_key_schedule;
 
-#define DES_KEY_SZ 	(sizeof(des_cblock))
-#define DES_SCHEDULE_SZ (sizeof(des_key_schedule))
+#define DES_KEY_SZ 	(sizeof(DES_cblock))
+#define DES_SCHEDULE_SZ (sizeof(DES_key_schedule))
 
 #define DES_ENCRYPT	1
 #define DES_DECRYPT	0
@@ -107,45 +107,49 @@ typedef struct des_ks_struct
 #define DES_CBC_MODE	0
 #define DES_PCBC_MODE	1
 
-#define des_ecb2_encrypt(i,o,k1,k2,e) \
-	des_ecb3_encrypt((i),(o),(k1),(k2),(k1),(e))
+#define DES_ecb2_encrypt(i,o,k1,k2,e) \
+	DES_ecb3_encrypt((i),(o),(k1),(k2),(k1),(e))
 
-#define des_ede2_cbc_encrypt(i,o,l,k1,k2,iv,e) \
-	des_ede3_cbc_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(e))
+#define DES_ede2_cbc_encrypt(i,o,l,k1,k2,iv,e) \
+	DES_ede3_cbc_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(e))
 
-#define des_ede2_cfb64_encrypt(i,o,l,k1,k2,iv,n,e) \
-	des_ede3_cfb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n),(e))
+#define DES_ede2_cfb64_encrypt(i,o,l,k1,k2,iv,n,e) \
+	DES_ede3_cfb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n),(e))
 
-#define des_ede2_ofb64_encrypt(i,o,l,k1,k2,iv,n) \
-	des_ede3_ofb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n))
+#define DES_ede2_ofb64_encrypt(i,o,l,k1,k2,iv,n) \
+	DES_ede3_ofb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n))
+
+#define C_Block DES_cblock
+#define Key_schedule DES_key_schedule
+
+/* some glue for openssl compat */
+#define UI_UTIL_read_pw_string DES_read_pw_string
 
-#define C_Block des_cblock
-#define Key_schedule des_key_schedule
 #ifdef KERBEROS
 #define ENCRYPT DES_ENCRYPT
 #define DECRYPT DES_DECRYPT
 #endif
 #define KEY_SZ DES_KEY_SZ
-#define string_to_key des_string_to_key
-#define read_pw_string des_read_pw_string
-#define random_key des_random_key
-#define pcbc_encrypt des_pcbc_encrypt
-#define set_key des_set_key
-#define key_sched des_key_sched
-#define ecb_encrypt des_ecb_encrypt
-#define cbc_encrypt des_cbc_encrypt
-#define ncbc_encrypt des_ncbc_encrypt
-#define xcbc_encrypt des_xcbc_encrypt
-#define cbc_cksum des_cbc_cksum
-#define quad_cksum des_quad_cksum
+#define string_to_key DES_string_to_key
+#define read_pw_string DES_read_pw_string
+#define random_key DES_random_key
+#define pcbc_encrypt DES_pcbc_encrypt
+#define set_key DES_set_key
+#define key_sched DES_key_sched
+#define ecb_encrypt DES_ecb_encrypt
+#define cbc_encrypt DES_cbc_encrypt
+#define ncbc_encrypt DES_ncbc_encrypt
+#define xcbc_encrypt DES_xcbc_encrypt
+#define cbc_cksum DES_cbc_cksum
+#define quad_cksum DES_quad_cksum
 
 /* For compatibility with the MIT lib - eay 20/05/92 */
-typedef des_key_schedule bit_64;
-#define des_fixup_key_parity des_set_odd_parity
-#define des_check_key_parity check_parity
+typedef DES_key_schedule bit_64;
+#define DES_fixup_key_parity DES_set_odd_parity
+#define DES_check_key_parity check_parity
 
-extern int des_check_key;	/* defaults to false */
-extern int des_rw_mode;		/* defaults to DES_PCBC_MODE */
+extern int DES_check_key;	/* defaults to false */
+extern int DES_rw_mode;		/* defaults to DES_PCBC_MODE */
 
 #ifdef cplusplus
 extern "C" {
@@ -158,49 +162,49 @@ extern "C" {
 #undef NOPROTO
 #endif
 #ifndef NOPROTO
-char *DES_LIB_FUNCTION des_options(void);
-void DES_LIB_FUNCTION des_ecb3_encrypt(des_cblock *input,des_cblock *output,
-	des_key_schedule ks1,des_key_schedule ks2,
-	des_key_schedule ks3, int enc);
-DES_LONG DES_LIB_FUNCTION des_cbc_cksum(des_cblock *input,des_cblock *output,
-	long length,des_key_schedule schedule,des_cblock *ivec);
-void DES_LIB_FUNCTION des_cbc_encrypt(des_cblock *input,des_cblock *output,long length,
-	des_key_schedule schedule,des_cblock *ivec,int enc);
-void DES_LIB_FUNCTION des_ncbc_encrypt(des_cblock *input,des_cblock *output,long length,
-	des_key_schedule schedule,des_cblock *ivec,int enc);
-void DES_LIB_FUNCTION des_xcbc_encrypt(des_cblock *input,des_cblock *output,long length,
-	des_key_schedule schedule,des_cblock *ivec,
-	des_cblock *inw,des_cblock *outw,int enc);
-void DES_LIB_FUNCTION des_3cbc_encrypt(des_cblock *input,des_cblock *output,long length,
-	des_key_schedule sk1,des_key_schedule sk2,
-	des_cblock *ivec1,des_cblock *ivec2,int enc);
-void DES_LIB_FUNCTION des_cfb_encrypt(unsigned char *in,unsigned char *out,int numbits,
-	long length,des_key_schedule schedule,des_cblock *ivec,int enc);
-void DES_LIB_FUNCTION des_ecb_encrypt(des_cblock *input,des_cblock *output,
-	des_key_schedule ks,int enc);
-void DES_LIB_FUNCTION des_encrypt(DES_LONG *data,des_key_schedule ks, int enc);
-void DES_LIB_FUNCTION des_encrypt2(DES_LONG *data,des_key_schedule ks, int enc);
-void DES_LIB_FUNCTION des_encrypt3(DES_LONG *data, des_key_schedule ks1,
-	des_key_schedule ks2, des_key_schedule ks3);
-void DES_LIB_FUNCTION des_decrypt3(DES_LONG *data, des_key_schedule ks1,
-	des_key_schedule ks2, des_key_schedule ks3);
-void DES_LIB_FUNCTION des_ede3_cbc_encrypt(des_cblock *input, des_cblock *output, 
-	long length, des_key_schedule ks1, des_key_schedule ks2, 
-	des_key_schedule ks3, des_cblock *ivec, int enc);
-void DES_LIB_FUNCTION des_ede3_cfb64_encrypt(unsigned char *in, unsigned char *out,
-	long length, des_key_schedule ks1, des_key_schedule ks2,
-	des_key_schedule ks3, des_cblock *ivec, int *num, int encrypt);
-void DES_LIB_FUNCTION des_ede3_ofb64_encrypt(unsigned char *in, unsigned char *out,
-	long length, des_key_schedule ks1, des_key_schedule ks2,
-	des_key_schedule ks3, des_cblock *ivec, int *num);
+char *DES_LIB_FUNCTION DES_options(void);
+void DES_LIB_FUNCTION DES_ecb3_encrypt(DES_cblock *input,DES_cblock *output,
+	DES_key_schedule *ks1,DES_key_schedule *ks2,
+	DES_key_schedule *ks3, int enc);
+DES_LONG DES_LIB_FUNCTION DES_cbc_cksum(DES_cblock *input,DES_cblock *output,
+	long length,DES_key_schedule *schedule,DES_cblock *ivec);
+void DES_LIB_FUNCTION DES_cbc_encrypt(DES_cblock *input,DES_cblock *output,long length,
+	DES_key_schedule *schedule,DES_cblock *ivec,int enc);
+void DES_LIB_FUNCTION DES_ncbc_encrypt(DES_cblock *input,DES_cblock *output,long length,
+	DES_key_schedule *schedule,DES_cblock *ivec,int enc);
+void DES_LIB_FUNCTION DES_xcbc_encrypt(DES_cblock *input,DES_cblock *output,long length,
+	DES_key_schedule *schedule,DES_cblock *ivec,
+	DES_cblock *inw,DES_cblock *outw,int enc);
+void DES_LIB_FUNCTION DES_3cbc_encrypt(DES_cblock *input,DES_cblock *output,long length,
+	DES_key_schedule *sk1,DES_key_schedule *sk2,
+	DES_cblock *ivec1,DES_cblock *ivec2,int enc);
+void DES_LIB_FUNCTION DES_cfb_encrypt(unsigned char *in,unsigned char *out,int numbits,
+	long length,DES_key_schedule *schedule,DES_cblock *ivec,int enc);
+void DES_LIB_FUNCTION DES_ecb_encrypt(DES_cblock *input,DES_cblock *output,
+	DES_key_schedule *ks,int enc);
+void DES_LIB_FUNCTION DES_encrypt(DES_LONG *data,DES_key_schedule *ks, int enc);
+void DES_LIB_FUNCTION DES_encrypt2(DES_LONG *data,DES_key_schedule *ks, int enc);
+void DES_LIB_FUNCTION DES_encrypt3(DES_LONG *data, DES_key_schedule *ks1,
+	DES_key_schedule *ks2, DES_key_schedule *ks3);
+void DES_LIB_FUNCTION DES_decrypt3(DES_LONG *data, DES_key_schedule *ks1,
+	DES_key_schedule *ks2, DES_key_schedule *ks3);
+void DES_LIB_FUNCTION DES_ede3_cbc_encrypt(DES_cblock *input, DES_cblock *output, 
+	long length, DES_key_schedule *ks1, DES_key_schedule *ks2, 
+	DES_key_schedule *ks3, DES_cblock *ivec, int enc);
+void DES_LIB_FUNCTION DES_ede3_cfb64_encrypt(unsigned char *in, unsigned char *out,
+	long length, DES_key_schedule *ks1, DES_key_schedule *ks2,
+	DES_key_schedule *ks3, DES_cblock *ivec, int *num, int encrypt);
+void DES_LIB_FUNCTION DES_ede3_ofb64_encrypt(unsigned char *in, unsigned char *out,
+	long length, DES_key_schedule *ks1, DES_key_schedule *ks2,
+	DES_key_schedule *ks3, DES_cblock *ivec, int *num);
 
-int DES_LIB_FUNCTION des_enc_read(int fd,char *buf,int len,des_key_schedule sched,
-	des_cblock *iv);
-int DES_LIB_FUNCTION des_enc_write(int fd,char *buf,int len,des_key_schedule sched,
-	des_cblock *iv);
-char *DES_LIB_FUNCTION des_fcrypt(const char *buf,const char *salt, char *ret);
+int DES_LIB_FUNCTION DES_enc_read(int fd,char *buf,int len,DES_key_schedule *sched,
+	DES_cblock *iv);
+int DES_LIB_FUNCTION DES_enc_write(int fd,char *buf,int len,DES_key_schedule *sched,
+	DES_cblock *iv);
+char *DES_LIB_FUNCTION DES_fcrypt(const char *buf,const char *salt, char *ret);
 #ifdef PERL5
-char *des_crypt(const char *buf,const char *salt);
+char *DES_crypt(const char *buf,const char *salt);
 #else
 /* some stupid compilers complain because I have declared char instead
  * of const char */
@@ -210,95 +214,95 @@ char *DES_LIB_FUNCTION crypt(const char *buf,const char *salt);
 char *crypt();
 #endif
 #endif
-void DES_LIB_FUNCTION des_ofb_encrypt(unsigned char *in,unsigned char *out,
-	int numbits,long length,des_key_schedule schedule,des_cblock *ivec);
-void DES_LIB_FUNCTION des_pcbc_encrypt(des_cblock *input,des_cblock *output,long length,
-	des_key_schedule schedule,des_cblock *ivec,int enc);
-DES_LONG DES_LIB_FUNCTION des_quad_cksum(des_cblock *input,des_cblock *output,
-	long length,int out_count,des_cblock *seed);
-void DES_LIB_FUNCTION des_random_seed(des_cblock key);
-void DES_LIB_FUNCTION des_random_key(des_cblock ret);
-int DES_LIB_FUNCTION des_read_password(des_cblock *key,char *prompt,int verify);
-int DES_LIB_FUNCTION des_read_2passwords(des_cblock *key1,des_cblock *key2,
+void DES_LIB_FUNCTION DES_ofb_encrypt(unsigned char *in,unsigned char *out,
+	int numbits,long length,DES_key_schedule *schedule,DES_cblock *ivec);
+void DES_LIB_FUNCTION DES_pcbc_encrypt(DES_cblock *input,DES_cblock *output,long length,
+	DES_key_schedule *schedule,DES_cblock *ivec,int enc);
+DES_LONG DES_LIB_FUNCTION DES_quad_cksum(DES_cblock *input,DES_cblock *output,
+	long length,int out_count,DES_cblock *seed);
+void DES_LIB_FUNCTION DES_random_seed(DES_cblock key);
+void DES_LIB_FUNCTION DES_random_key(DES_cblock ret);
+int DES_LIB_FUNCTION DES_read_password(DES_cblock *key,char *prompt,int verify);
+int DES_LIB_FUNCTION DES_read_2passwords(DES_cblock *key1,DES_cblock *key2,
 	char *prompt,int verify);
-int DES_LIB_FUNCTION des_read_pw_string(char *buf,int length,char *prompt,int verify);
-void DES_LIB_FUNCTION des_set_odd_parity(des_cblock *key);
-int DES_LIB_FUNCTION des_is_weak_key(des_cblock *key);
-int DES_LIB_FUNCTION des_set_key(des_cblock *key,des_key_schedule schedule);
-int DES_LIB_FUNCTION des_key_sched(des_cblock *key,des_key_schedule schedule);
-void DES_LIB_FUNCTION des_string_to_key(char *str,des_cblock *key);
-void DES_LIB_FUNCTION des_string_to_2keys(char *str,des_cblock *key1,des_cblock *key2);
-void DES_LIB_FUNCTION des_cfb64_encrypt(unsigned char *in, unsigned char *out, long length,
-	des_key_schedule schedule, des_cblock *ivec, int *num, int enc);
-void DES_LIB_FUNCTION des_ofb64_encrypt(unsigned char *in, unsigned char *out, long length,
-	des_key_schedule schedule, des_cblock *ivec, int *num);
+int DES_LIB_FUNCTION DES_read_pw_string(char *buf,int length,char *prompt,int verify);
+void DES_LIB_FUNCTION DES_set_odd_parity(DES_cblock *key);
+int DES_LIB_FUNCTION DES_is_weak_key(DES_cblock *key);
+int DES_LIB_FUNCTION DES_set_key(DES_cblock *key,DES_key_schedule *schedule);
+int DES_LIB_FUNCTION DES_key_sched(DES_cblock *key,DES_key_schedule *schedule);
+void DES_LIB_FUNCTION DES_string_to_key(char *str,DES_cblock *key);
+void DES_LIB_FUNCTION DES_string_to_2keys(char *str,DES_cblock *key1,DES_cblock *key2);
+void DES_LIB_FUNCTION DES_cfb64_encrypt(unsigned char *in, unsigned char *out, long length,
+	DES_key_schedule *schedule, DES_cblock *ivec, int *num, int enc);
+void DES_LIB_FUNCTION DES_ofb64_encrypt(unsigned char *in, unsigned char *out, long length,
+	DES_key_schedule *schedule, DES_cblock *ivec, int *num);
 
 /* Extra functions from Mark Murray <mark@grondar.za> */
-void DES_LIB_FUNCTION des_cblock_print_file(des_cblock *cb, FILE *fp);
+void DES_LIB_FUNCTION DES_cblock_print_file(DES_cblock *cb, FILE *fp);
 /* The following functions are not in the normal unix build or the
  * SSLeay build.  When using the SSLeay build, use RAND_seed()
  * and RAND_bytes() instead. */
-int DES_LIB_FUNCTION des_new_random_key(des_cblock *key);
-void DES_LIB_FUNCTION des_init_random_number_generator(des_cblock *key);
-void DES_LIB_FUNCTION des_set_random_generator_seed(des_cblock *key);
-void DES_LIB_FUNCTION des_set_sequence_number(des_cblock new_sequence_number);
-void DES_LIB_FUNCTION des_generate_random_block(des_cblock *block);
-void DES_LIB_FUNCTION des_rand_data(unsigned char *data, int size);
+int DES_LIB_FUNCTION DES_new_random_key(DES_cblock *key);
+void DES_LIB_FUNCTION DES_init_random_number_generator(DES_cblock *key);
+void DES_LIB_FUNCTION DES_set_random_generator_seed(DES_cblock *key);
+void DES_LIB_FUNCTION DES_set_sequence_number(DES_cblock new_sequence_number);
+void DES_LIB_FUNCTION DES_generate_random_block(DES_cblock *block);
+void DES_LIB_FUNCTION DES_rand_data(unsigned char *data, int size);
 
 #else
 
-char *des_options();
-void des_ecb3_encrypt();
-DES_LONG des_cbc_cksum();
-void des_cbc_encrypt();
-void des_ncbc_encrypt();
-void des_xcbc_encrypt();
-void des_3cbc_encrypt();
-void des_cfb_encrypt();
-void des_ede3_cfb64_encrypt();
-void des_ede3_ofb64_encrypt();
-void des_ecb_encrypt();
-void des_encrypt();
-void des_encrypt2();
-void des_encrypt3();
-void des_decrypt3();
-void des_ede3_cbc_encrypt();
-int des_enc_read();
-int des_enc_write();
-char *des_fcrypt();
+char *DES_options();
+void DES_ecb3_encrypt();
+DES_LONG DES_cbc_cksum();
+void DES_cbc_encrypt();
+void DES_ncbc_encrypt();
+void DES_xcbc_encrypt();
+void DES_3cbc_encrypt();
+void DES_cfb_encrypt();
+void DES_ede3_cfb64_encrypt();
+void DES_ede3_ofb64_encrypt();
+void DES_ecb_encrypt();
+void DES_encrypt();
+void DES_encrypt2();
+void DES_encrypt3();
+void DES_decrypt3();
+void DES_ede3_cbc_encrypt();
+int DES_enc_read();
+int DES_enc_write();
+char *DES_fcrypt();
 #ifdef PERL5
-char *des_crypt();
+char *DES_crypt();
 #else
 char *crypt();
 #endif
-void des_ofb_encrypt();
-void des_pcbc_encrypt();
-DES_LONG des_quad_cksum();
-void des_random_seed();
-void des_random_key();
-int des_read_password();
-int des_read_2passwords();
-int des_read_pw_string();
-void des_set_odd_parity();
-int des_is_weak_key();
-int des_set_key();
-int des_key_sched();
-void des_string_to_key();
-void des_string_to_2keys();
-void des_cfb64_encrypt();
-void des_ofb64_encrypt();
+void DES_ofb_encrypt();
+void DES_pcbc_encrypt();
+DES_LONG DES_quad_cksum();
+void DES_random_seed();
+void DES_random_key();
+int DES_read_password();
+int DES_read_2passwords();
+int DES_read_pw_string();
+void DES_set_odd_parity();
+int DES_is_weak_key();
+int DES_set_key();
+int DES_key_sched();
+void DES_string_to_key();
+void DES_string_to_2keys();
+void DES_cfb64_encrypt();
+void DES_ofb64_encrypt();
 
 /* Extra functions from Mark Murray <mark@grondar.za> */
-void des_cblock_print_file();
+void DES_cblock_print_file();
 /* The following functions are not in the normal unix build or the
  * SSLeay build.  When using the SSLeay build, use RAND_seed()
  * and RAND_bytes() instead. */
-int des_new_random_key();
-void des_init_random_number_generator();
-void des_set_random_generator_seed();
-void des_set_sequence_number();
-void des_generate_random_block();
-void des_rand_data();
+int DES_new_random_key();
+void DES_init_random_number_generator();
+void DES_set_random_generator_seed();
+void DES_set_sequence_number();
+void DES_generate_random_block();
+void DES_rand_data();
 
 #endif
 
diff --git a/lib/des/des_enc.c b/lib/des/des_enc.c
index d08fe6501..cd0ca6819 100644
--- a/lib/des/des_enc.c
+++ b/lib/des/des_enc.c
@@ -58,9 +58,9 @@
 
 #include "des_locl.h"
 
-void des_encrypt(data, ks, encrypt)
+void DES_encrypt(data, ks, encrypt)
 DES_LONG *data;
-des_key_schedule ks;
+DES_key_schedule *ks;
 int encrypt;
 	{
 	register DES_LONG l,r,t,u;
@@ -159,9 +159,9 @@ int encrypt;
 	l=r=t=u=0;
 	}
 
-void des_encrypt2(data, ks, encrypt)
+void DES_encrypt2(data, ks, encrypt)
 DES_LONG *data;
-des_key_schedule ks;
+DES_key_schedule *ks;
 int encrypt;
 	{
 	register DES_LONG l,r,t,u;
@@ -253,11 +253,11 @@ int encrypt;
 	l=r=t=u=0;
 	}
 
-void des_encrypt3(data,ks1,ks2,ks3)
+void DES_encrypt3(data,ks1,ks2,ks3)
 DES_LONG *data;
-des_key_schedule ks1;
-des_key_schedule ks2;
-des_key_schedule ks3;
+DES_key_schedule *ks1;
+DES_key_schedule *ks2;
+DES_key_schedule *ks3;
 	{
 	register DES_LONG l,r;
 
@@ -266,9 +266,9 @@ des_key_schedule ks3;
 	IP(l,r);
 	data[0]=l;
 	data[1]=r;
-	des_encrypt2((DES_LONG *)data,ks1,DES_ENCRYPT);
-	des_encrypt2((DES_LONG *)data,ks2,DES_DECRYPT);
-	des_encrypt2((DES_LONG *)data,ks3,DES_ENCRYPT);
+	DES_encrypt2((DES_LONG *)data,ks1,DES_ENCRYPT);
+	DES_encrypt2((DES_LONG *)data,ks2,DES_DECRYPT);
+	DES_encrypt2((DES_LONG *)data,ks3,DES_ENCRYPT);
 	l=data[0];
 	r=data[1];
 	FP(r,l);
@@ -276,11 +276,11 @@ des_key_schedule ks3;
 	data[1]=r;
 	}
 
-void des_decrypt3(data,ks1,ks2,ks3)
+void DES_decrypt3(data,ks1,ks2,ks3)
 DES_LONG *data;
-des_key_schedule ks1;
-des_key_schedule ks2;
-des_key_schedule ks3;
+DES_key_schedule *ks1;
+DES_key_schedule *ks2;
+DES_key_schedule *ks3;
 	{
 	register DES_LONG l,r;
 
@@ -289,9 +289,9 @@ des_key_schedule ks3;
 	IP(l,r);
 	data[0]=l;
 	data[1]=r;
-	des_encrypt2((DES_LONG *)data,ks3,DES_DECRYPT);
-	des_encrypt2((DES_LONG *)data,ks2,DES_ENCRYPT);
-	des_encrypt2((DES_LONG *)data,ks1,DES_DECRYPT);
+	DES_encrypt2((DES_LONG *)data,ks3,DES_DECRYPT);
+	DES_encrypt2((DES_LONG *)data,ks2,DES_ENCRYPT);
+	DES_encrypt2((DES_LONG *)data,ks1,DES_DECRYPT);
 	l=data[0];
 	r=data[1];
 	FP(r,l);
diff --git a/lib/des/des_opts.c b/lib/des/des_opts.c
index 90b035bae..667cc1130 100644
--- a/lib/des/des_opts.c
+++ b/lib/des/des_opts.c
@@ -450,9 +450,9 @@ char **argv;
 	fprintf(stderr,"program when this computer is idle.\n");
 #endif
 
-	des_set_key((C_Block *)key,sch);
-	des_set_key((C_Block *)key2,sch2);
-	des_set_key((C_Block *)key3,sch3);
+	des_set_key((C_Block *)key,&sch);
+	des_set_key((C_Block *)key2,&sch2);
+	des_set_key((C_Block *)key3,&sch3);
 
 #ifndef SIGALRM
 	fprintf(stderr,"First we calculate the approximate speed ...\n");
diff --git a/lib/des/destest.c b/lib/des/destest.c
index e0d3ec7b4..708ab7cdc 100644
--- a/lib/des/destest.c
+++ b/lib/des/destest.c
@@ -311,8 +311,8 @@ int argc;
 char *argv[];
 	{
 	int i,j,err=0;
-	des_cblock in,out,outin,iv3;
-	des_key_schedule ks,ks2,ks3;
+	DES_cblock in,out,outin,iv3;
+	DES_key_schedule ks,ks2,ks3;
 	unsigned char cbc_in[40];
 	unsigned char cbc_out[40];
 	DES_LONG cs;
@@ -331,7 +331,7 @@ char *argv[];
 	printf("Doing ecb\n");
 	for (i=0; i<NUM_TESTS; i++)
 		{
-		if ((j=des_key_sched((C_Block *)(key_data[i]),ks)) != 0)
+		if ((j=DES_key_sched((C_Block *)(key_data[i]),&ks)) != 0)
 			{
 			printf("Key error %2d:%d\n",i+1,j);
 			err=1;
@@ -339,8 +339,8 @@ char *argv[];
 		memcpy(in,plain_data[i],8);
 		memset(out,0,8);
 		memset(outin,0,8);
-		des_ecb_encrypt((C_Block *)in,(C_Block *)out,ks,DES_ENCRYPT);
-		des_ecb_encrypt((C_Block *)out,(C_Block *)outin,ks,DES_DECRYPT);
+		DES_ecb_encrypt((C_Block *)in,(C_Block *)out,&ks,DES_ENCRYPT);
+		DES_ecb_encrypt((C_Block *)out,(C_Block *)outin,&ks,DES_DECRYPT);
 
 		if (memcmp(out,cipher_data[i],8) != 0)
 			{
@@ -361,17 +361,17 @@ char *argv[];
 	printf("Doing ede ecb\n");
 	for (i=0; i<(NUM_TESTS-1); i++)
 		{
-		if ((j=des_key_sched((C_Block *)(key_data[i]),ks)) != 0)
+		if ((j=DES_key_sched((C_Block *)(key_data[i]),&ks)) != 0)
 			{
 			err=1;
 			printf("Key error %2d:%d\n",i+1,j);
 			}
-		if ((j=des_key_sched((C_Block *)(key_data[i+1]),ks2)) != 0)
+		if ((j=DES_key_sched((C_Block *)(key_data[i+1]),&ks2)) != 0)
 			{
 			printf("Key error %2d:%d\n",i+2,j);
 			err=1;
 			}
-		if ((j=des_key_sched((C_Block *)(key_data[i+2]),ks3)) != 0)
+		if ((j=DES_key_sched((C_Block *)(key_data[i+2]),&ks3)) != 0)
 			{
 			printf("Key error %2d:%d\n",i+3,j);
 			err=1;
@@ -379,9 +379,9 @@ char *argv[];
 		memcpy(in,plain_data[i],8);
 		memset(out,0,8);
 		memset(outin,0,8);
-		des_ecb2_encrypt((C_Block *)in,(C_Block *)out,ks,ks2,
+		DES_ecb2_encrypt((C_Block *)in,(C_Block *)out,&ks,&ks2,
 			DES_ENCRYPT);
-		des_ecb2_encrypt((C_Block *)out,(C_Block *)outin,ks,ks2,
+		DES_ecb2_encrypt((C_Block *)out,(C_Block *)outin,&ks,&ks2,
 			DES_DECRYPT);
 
 		if (memcmp(out,cipher_ecb2[i],8) != 0)
@@ -401,20 +401,20 @@ char *argv[];
 #endif
 
 	printf("Doing cbc\n");
-	if ((j=des_key_sched((C_Block *)cbc_key,ks)) != 0)
+	if ((j=DES_key_sched((C_Block *)cbc_key,&ks)) != 0)
 		{
 		printf("Key error %d\n",j);
 		err=1;
 		}
 	memset(cbc_out,0,40);
 	memset(cbc_in,0,40);
-	des_cbc_encrypt((C_Block *)cbc_data,(C_Block *)cbc_out,
-		(long)strlen((char *)cbc_data)+1,ks,
+	DES_cbc_encrypt((C_Block *)cbc_data,(C_Block *)cbc_out,
+		(long)strlen((char *)cbc_data)+1,&ks,
 		(C_Block *)cbc_iv,DES_ENCRYPT);
 	if (memcmp(cbc_out,cbc_ok,32) != 0)
 		printf("cbc_encrypt encrypt error\n");
-	des_cbc_encrypt((C_Block *)cbc_out,(C_Block *)cbc_in,
-		(long)strlen((char *)cbc_data)+1,ks,
+	DES_cbc_encrypt((C_Block *)cbc_out,(C_Block *)cbc_in,
+		(long)strlen((char *)cbc_data)+1,&ks,
 		(C_Block *)cbc_iv,DES_DECRYPT);
 	if (memcmp(cbc_in,cbc_data,strlen((char *)cbc_data)) != 0)
 		{
@@ -424,7 +424,7 @@ char *argv[];
 
 #ifndef LIBDES_LIT
 	printf("Doing desx cbc\n");
-	if ((j=des_key_sched((C_Block *)cbc_key,ks)) != 0)
+	if ((j=DES_key_sched((C_Block *)cbc_key,&ks)) != 0)
 		{
 		printf("Key error %d\n",j);
 		err=1;
@@ -432,38 +432,38 @@ char *argv[];
 	memset(cbc_out,0,40);
 	memset(cbc_in,0,40);
 	memcpy(iv3,cbc_iv,sizeof(cbc_iv));
-	des_xcbc_encrypt((C_Block *)cbc_data,(C_Block *)cbc_out,
-		(long)strlen((char *)cbc_data)+1,ks,
+	DES_xcbc_encrypt((C_Block *)cbc_data,(C_Block *)cbc_out,
+		(long)strlen((char *)cbc_data)+1,&ks,
 		(C_Block *)iv3,
 		(C_Block *)cbc2_key, (C_Block *)cbc3_key, DES_ENCRYPT);
 	if (memcmp(cbc_out,xcbc_ok,32) != 0)
 		{
-		printf("des_xcbc_encrypt encrypt error\n");
+		printf("DES_xcbc_encrypt encrypt error\n");
 		}
 	memcpy(iv3,cbc_iv,sizeof(cbc_iv));
-	des_xcbc_encrypt((C_Block *)cbc_out,(C_Block *)cbc_in,
-		(long)strlen((char *)cbc_data)+1,ks,
+	DES_xcbc_encrypt((C_Block *)cbc_out,(C_Block *)cbc_in,
+		(long)strlen((char *)cbc_data)+1,&ks,
 		(C_Block *)iv3,
 		(C_Block *)cbc2_key, (C_Block *)cbc3_key, DES_DECRYPT);
 	if (memcmp(cbc_in,cbc_data,32) != 0)
 		{
-		printf("des_xcbc_encrypt decrypt error\n");
+		printf("DES_xcbc_encrypt decrypt error\n");
 		err=1;
 		}
 #endif
 
 	printf("Doing ede cbc\n");
-	if ((j=des_key_sched((C_Block *)cbc_key,ks)) != 0)
+	if ((j=DES_key_sched((C_Block *)cbc_key,&ks)) != 0)
 		{
 		printf("Key error %d\n",j);
 		err=1;
 		}
-	if ((j=des_key_sched((C_Block *)cbc2_key,ks2)) != 0)
+	if ((j=DES_key_sched((C_Block *)cbc2_key,&ks2)) != 0)
 		{
 		printf("Key error %d\n",j);
 		err=1;
 		}
-	if ((j=des_key_sched((C_Block *)cbc3_key,ks3)) != 0)
+	if ((j=DES_key_sched((C_Block *)cbc3_key,&ks3)) != 0)
 		{
 		printf("Key error %d\n",j);
 		err=1;
@@ -474,11 +474,11 @@ char *argv[];
 	i=((i+7)/8)*8;
 	memcpy(iv3,cbc_iv,sizeof(cbc_iv));
 
-	des_ede3_cbc_encrypt((C_Block *)cbc_data,(C_Block *)cbc_out,
-		16L,ks,ks2,ks3,(C_Block *)iv3,DES_ENCRYPT);
-	des_ede3_cbc_encrypt((C_Block *)&(cbc_data[16]),
+	DES_ede3_cbc_encrypt((C_Block *)cbc_data,(C_Block *)cbc_out,
+		16L,&ks,&ks2,&ks3,(C_Block *)iv3,DES_ENCRYPT);
+	DES_ede3_cbc_encrypt((C_Block *)&(cbc_data[16]),
 		(C_Block *)&(cbc_out[16]),
-		(long)i-16,ks,ks2,ks3,(C_Block *)iv3,DES_ENCRYPT);
+		(long)i-16,&ks,&ks2,&ks3,(C_Block *)iv3,DES_ENCRYPT);
 	if (memcmp(cbc_out,cbc3_ok,
 		(unsigned int)(strlen((char *)cbc_data)+1+7)/8*8) != 0)
 		{
@@ -487,8 +487,8 @@ char *argv[];
 		}
 
 	memcpy(iv3,cbc_iv,sizeof(cbc_iv));
-	des_ede3_cbc_encrypt((C_Block *)cbc_out,(C_Block *)cbc_in,
-		(long)i,ks,ks2,ks3,(C_Block *)iv3,DES_DECRYPT);
+	DES_ede3_cbc_encrypt((C_Block *)cbc_out,(C_Block *)cbc_in,
+		(long)i,&ks,&ks2,&ks3,(C_Block *)iv3,DES_DECRYPT);
 	if (memcmp(cbc_in,cbc_data,strlen(cbc_data)+1) != 0)
 		{
 		printf("des_ede3_cbc_encrypt decrypt error\n");
@@ -497,22 +497,22 @@ char *argv[];
 
 #ifndef LIBDES_LIT
 	printf("Doing pcbc\n");
-	if ((j=des_key_sched((C_Block *)cbc_key,ks)) != 0)
+	if ((j=DES_key_sched((C_Block *)cbc_key,&ks)) != 0)
 		{
 		printf("Key error %d\n",j);
 		err=1;
 		}
 	memset(cbc_out,0,40);
 	memset(cbc_in,0,40);
-	des_pcbc_encrypt((C_Block *)cbc_data,(C_Block *)cbc_out,
-		(long)strlen(cbc_data)+1,ks,(C_Block *)cbc_iv,DES_ENCRYPT);
+	DES_pcbc_encrypt((C_Block *)cbc_data,(C_Block *)cbc_out,
+		(long)strlen(cbc_data)+1,&ks,(C_Block *)cbc_iv,DES_ENCRYPT);
 	if (memcmp(cbc_out,pcbc_ok,32) != 0)
 		{
 		printf("pcbc_encrypt encrypt error\n");
 		err=1;
 		}
-	des_pcbc_encrypt((C_Block *)cbc_out,(C_Block *)cbc_in,
-		(long)strlen(cbc_data)+1,ks,(C_Block *)cbc_iv,DES_DECRYPT);
+	DES_pcbc_encrypt((C_Block *)cbc_out,(C_Block *)cbc_in,
+		(long)strlen(cbc_data)+1,&ks,(C_Block *)cbc_iv,DES_DECRYPT);
 	if (memcmp(cbc_in,cbc_data,32) != 0)
 		{
 		printf("pcbc_encrypt decrypt error\n");
@@ -536,8 +536,8 @@ char *argv[];
 
 	memcpy(cfb_tmp,cfb_iv,sizeof(cfb_iv));
 	for (i=0; i<sizeof(plain); i++)
-		des_cfb_encrypt(&(plain[i]),&(cfb_buf1[i]),
-			8,(long)1,ks,(C_Block *)cfb_tmp,DES_ENCRYPT);
+		DES_cfb_encrypt(&(plain[i]),&(cfb_buf1[i]),
+			8,(long)1,&ks,(C_Block *)cfb_tmp,DES_ENCRYPT);
 	if (memcmp(cfb_cipher8,cfb_buf1,sizeof(plain)) != 0)
 		{
 		printf("cfb_encrypt small encrypt error\n");
@@ -546,8 +546,8 @@ char *argv[];
 
 	memcpy(cfb_tmp,cfb_iv,sizeof(cfb_iv));
 	for (i=0; i<sizeof(plain); i++)
-		des_cfb_encrypt(&(cfb_buf1[i]),&(cfb_buf2[i]),
-			8,(long)1,ks,(C_Block *)cfb_tmp,DES_DECRYPT);
+		DES_cfb_encrypt(&(cfb_buf1[i]),&(cfb_buf2[i]),
+			8,(long)1,&ks,(C_Block *)cfb_tmp,DES_DECRYPT);
 	if (memcmp(plain,cfb_buf2,sizeof(plain)) != 0)
 		{
 		printf("cfb_encrypt small decrypt error\n");
@@ -560,9 +560,9 @@ char *argv[];
 	printf("done\n");
 
 	printf("Doing ofb\n");
-	des_key_sched((C_Block *)ofb_key,ks);
+	DES_key_sched((C_Block *)ofb_key,&ks);
 	memcpy(ofb_tmp,ofb_iv,sizeof(ofb_iv));
-	des_ofb_encrypt(plain,ofb_buf1,64,(long)sizeof(plain)/8,ks,
+	DES_ofb_encrypt(plain,ofb_buf1,64,(long)sizeof(plain)/8,&ks,
 		(C_Block *)ofb_tmp);
 	if (memcmp(ofb_cipher,ofb_buf1,sizeof(ofb_buf1)) != 0)
 		{
@@ -570,7 +570,7 @@ char *argv[];
 		err=1;
 		}
 	memcpy(ofb_tmp,ofb_iv,sizeof(ofb_iv));
-	des_ofb_encrypt(ofb_buf1,ofb_buf2,64,(long)sizeof(ofb_buf1)/8,ks,
+	DES_ofb_encrypt(ofb_buf1,ofb_buf2,64,(long)sizeof(ofb_buf1)/8,&ks,
 		(C_Block *)ofb_tmp);
 	if (memcmp(plain,ofb_buf2,sizeof(ofb_buf2)) != 0)
 		{
@@ -579,14 +579,14 @@ char *argv[];
 		}
 
 	printf("Doing ofb64\n");
-	des_key_sched((C_Block *)ofb_key,ks);
+	DES_key_sched((C_Block *)ofb_key,&ks);
 	memcpy(ofb_tmp,ofb_iv,sizeof(ofb_iv));
 	memset(ofb_buf1,0,sizeof(ofb_buf1));
 	memset(ofb_buf2,0,sizeof(ofb_buf1));
 	num=0;
 	for (i=0; i<sizeof(plain); i++)
 		{
-		des_ofb64_encrypt(&(plain[i]),&(ofb_buf1[i]),1,ks,
+		DES_ofb64_encrypt(&(plain[i]),&(ofb_buf1[i]),1,&ks,
 			(C_Block *)ofb_tmp,&num);
 		}
 	if (memcmp(ofb_cipher,ofb_buf1,sizeof(ofb_buf1)) != 0)
@@ -596,7 +596,7 @@ char *argv[];
 		}
 	memcpy(ofb_tmp,ofb_iv,sizeof(ofb_iv));
 	num=0;
-	des_ofb64_encrypt(ofb_buf1,ofb_buf2,(long)sizeof(ofb_buf1),ks,
+	DES_ofb64_encrypt(ofb_buf1,ofb_buf2,(long)sizeof(ofb_buf1),&ks,
 		(C_Block *)ofb_tmp,&num);
 	if (memcmp(plain,ofb_buf2,sizeof(ofb_buf2)) != 0)
 		{
@@ -605,15 +605,16 @@ char *argv[];
 		}
 
 	printf("Doing ede_ofb64\n");
-	des_key_sched((C_Block *)ofb_key,ks);
+	DES_key_sched((C_Block *)ofb_key,&ks);
 	memcpy(ofb_tmp,ofb_iv,sizeof(ofb_iv));
 	memset(ofb_buf1,0,sizeof(ofb_buf1));
 	memset(ofb_buf2,0,sizeof(ofb_buf1));
 	num=0;
 	for (i=0; i<sizeof(plain); i++)
 		{
-		des_ede3_ofb64_encrypt(&(plain[i]),&(ofb_buf1[i]),1,ks,ks,ks,
-			(C_Block *)ofb_tmp,&num);
+		DES_ede3_ofb64_encrypt(&(plain[i]),&(ofb_buf1[i]),1,
+				       &ks,&ks,&ks,
+				       (C_Block *)ofb_tmp,&num);
 		}
 	if (memcmp(ofb_cipher,ofb_buf1,sizeof(ofb_buf1)) != 0)
 		{
@@ -622,8 +623,8 @@ char *argv[];
 		}
 	memcpy(ofb_tmp,ofb_iv,sizeof(ofb_iv));
 	num=0;
-	des_ede3_ofb64_encrypt(ofb_buf1,ofb_buf2,(long)sizeof(ofb_buf1),ks,
-		ks,ks,(C_Block *)ofb_tmp,&num);
+	DES_ede3_ofb64_encrypt(ofb_buf1,ofb_buf2,(long)sizeof(ofb_buf1),&ks,
+			       &ks,&ks,(C_Block *)ofb_tmp,&num);
 	if (memcmp(plain,ofb_buf2,sizeof(ofb_buf2)) != 0)
 		{
 		printf("ede_ofb64_encrypt decrypt error\n");
@@ -631,9 +632,9 @@ char *argv[];
 		}
 
 	printf("Doing cbc_cksum\n");
-	des_key_sched((C_Block *)cbc_key,ks);
-	cs=des_cbc_cksum((C_Block *)cbc_data,(C_Block *)cret,
-		(long)strlen(cbc_data),ks,(C_Block *)cbc_iv);
+	DES_key_sched((C_Block *)cbc_key,&ks);
+	cs=DES_cbc_cksum((C_Block *)cbc_data,(C_Block *)cret,
+		(long)strlen(cbc_data),&ks,(C_Block *)cbc_iv);
 	if (cs != cbc_cksum_ret)
 		{
 		printf("bad return value (%08lX), should be %08lX\n",
@@ -712,16 +713,16 @@ char *argv[];
 	for (i=0; i<4; i++)
 		{
 		printf(" %d",i);
-		des_cbc_encrypt((C_Block *)&(cbc_out[i]),(C_Block *)cbc_in,
-			(long)strlen(cbc_data)+1,ks,(C_Block *)cbc_iv,
+		DES_cbc_encrypt((C_Block *)&(cbc_out[i]),(C_Block *)cbc_in,
+			(long)strlen(cbc_data)+1,&ks,(C_Block *)cbc_iv,
 			DES_ENCRYPT);
 		}
 	printf("\noutput word alignment test");
 	for (i=0; i<4; i++)
 		{
 		printf(" %d",i);
-		des_cbc_encrypt((C_Block *)cbc_out,(C_Block *)&(cbc_in[i]),
-			(long)strlen(cbc_data)+1,ks,(C_Block *)cbc_iv,
+		DES_cbc_encrypt((C_Block *)cbc_out,(C_Block *)&(cbc_in[i]),
+			(long)strlen(cbc_data)+1,&ks,(C_Block *)cbc_iv,
 			DES_ENCRYPT);
 		}
 	printf("\n");
@@ -769,12 +770,12 @@ static int cfb_test(bits, cfb_cipher)
 int bits;
 unsigned char *cfb_cipher;
 	{
-	des_key_schedule ks;
+	DES_key_schedule ks;
 	int i,err=0;
 
-	des_key_sched((C_Block *)cfb_key,ks);
+	DES_key_sched((C_Block *)cfb_key,&ks);
 	memcpy(cfb_tmp,cfb_iv,sizeof(cfb_iv));
-	des_cfb_encrypt(plain,cfb_buf1,bits,(long)sizeof(plain),ks,
+	DES_cfb_encrypt(plain,cfb_buf1,bits,(long)sizeof(plain),&ks,
 		(C_Block *)cfb_tmp,DES_ENCRYPT);
 	if (memcmp(cfb_cipher,cfb_buf1,sizeof(plain)) != 0)
 		{
@@ -784,7 +785,7 @@ unsigned char *cfb_cipher;
 			printf("%s\n",pt(&(cfb_buf1[i])));
 		}
 	memcpy(cfb_tmp,cfb_iv,sizeof(cfb_iv));
-	des_cfb_encrypt(cfb_buf1,cfb_buf2,bits,(long)sizeof(plain),ks,
+	DES_cfb_encrypt(cfb_buf1,cfb_buf2,bits,(long)sizeof(plain),&ks,
 		(C_Block *)cfb_tmp,DES_DECRYPT);
 	if (memcmp(plain,cfb_buf2,sizeof(plain)) != 0)
 		{
@@ -799,16 +800,16 @@ unsigned char *cfb_cipher;
 static int cfb64_test(cfb_cipher)
 unsigned char *cfb_cipher;
 	{
-	des_key_schedule ks;
+	DES_key_schedule ks;
 	int err=0,i,n;
 
-	des_key_sched((C_Block *)cfb_key,ks);
+	DES_key_sched((C_Block *)cfb_key,&ks);
 	memcpy(cfb_tmp,cfb_iv,sizeof(cfb_iv));
 	n=0;
-	des_cfb64_encrypt(plain,cfb_buf1,(long)12,ks,
+	DES_cfb64_encrypt(plain,cfb_buf1,(long)12,&ks,
 		(C_Block *)cfb_tmp,&n,DES_ENCRYPT);
-	des_cfb64_encrypt(&(plain[12]),&(cfb_buf1[12]),
-		(long)sizeof(plain)-12,ks,
+	DES_cfb64_encrypt(&(plain[12]),&(cfb_buf1[12]),
+		(long)sizeof(plain)-12,&ks,
 		(C_Block *)cfb_tmp,&n,DES_ENCRYPT);
 	if (memcmp(cfb_cipher,cfb_buf1,sizeof(plain)) != 0)
 		{
@@ -819,10 +820,10 @@ unsigned char *cfb_cipher;
 		}
 	memcpy(cfb_tmp,cfb_iv,sizeof(cfb_iv));
 	n=0;
-	des_cfb64_encrypt(cfb_buf1,cfb_buf2,(long)17,ks,
+	DES_cfb64_encrypt(cfb_buf1,cfb_buf2,(long)17,&ks,
 		(C_Block *)cfb_tmp,&n,DES_DECRYPT);
-	des_cfb64_encrypt(&(cfb_buf1[17]),&(cfb_buf2[17]),
-		(long)sizeof(plain)-17,ks,
+	DES_cfb64_encrypt(&(cfb_buf1[17]),&(cfb_buf2[17]),
+		(long)sizeof(plain)-17,&ks,
 		(C_Block *)cfb_tmp,&n,DES_DECRYPT);
 	if (memcmp(plain,cfb_buf2,sizeof(plain)) != 0)
 		{
@@ -837,16 +838,16 @@ unsigned char *cfb_cipher;
 static int ede_cfb64_test(cfb_cipher)
 unsigned char *cfb_cipher;
 	{
-	des_key_schedule ks;
+	DES_key_schedule ks;
 	int err=0,i,n;
 
-	des_key_sched((C_Block *)cfb_key,ks);
+	DES_key_sched((C_Block *)cfb_key,&ks);
 	memcpy(cfb_tmp,cfb_iv,sizeof(cfb_iv));
 	n=0;
-	des_ede3_cfb64_encrypt(plain,cfb_buf1,(long)12,ks,ks,ks,
+	DES_ede3_cfb64_encrypt(plain,cfb_buf1,(long)12,&ks,&ks,&ks,
 		(C_Block *)cfb_tmp,&n,DES_ENCRYPT);
-	des_ede3_cfb64_encrypt(&(plain[12]),&(cfb_buf1[12]),
-		(long)sizeof(plain)-12,ks,ks,ks,
+	DES_ede3_cfb64_encrypt(&(plain[12]),&(cfb_buf1[12]),
+		(long)sizeof(plain)-12,&ks,&ks,&ks,
 		(C_Block *)cfb_tmp,&n,DES_ENCRYPT);
 	if (memcmp(cfb_cipher,cfb_buf1,sizeof(plain)) != 0)
 		{
@@ -857,10 +858,10 @@ unsigned char *cfb_cipher;
 		}
 	memcpy(cfb_tmp,cfb_iv,sizeof(cfb_iv));
 	n=0;
-	des_ede3_cfb64_encrypt(cfb_buf1,cfb_buf2,(long)17,ks,ks,ks,
+	DES_ede3_cfb64_encrypt(cfb_buf1,cfb_buf2,(long)17,&ks,&ks,&ks,
 		(C_Block *)cfb_tmp,&n,DES_DECRYPT);
-	des_ede3_cfb64_encrypt(&(cfb_buf1[17]),&(cfb_buf2[17]),
-		(long)sizeof(plain)-17,ks,ks,ks,
+	DES_ede3_cfb64_encrypt(&(cfb_buf1[17]),&(cfb_buf2[17]),
+		(long)sizeof(plain)-17,&ks,&ks,&ks,
 		(C_Block *)cfb_tmp,&n,DES_DECRYPT);
 	if (memcmp(plain,cfb_buf2,sizeof(plain)) != 0)
 		{
diff --git a/lib/des/ecb3_enc.c b/lib/des/ecb3_enc.c
index 03d8f8777..af1e81e04 100644
--- a/lib/des/ecb3_enc.c
+++ b/lib/des/ecb3_enc.c
@@ -58,12 +58,12 @@
 
 #include "des_locl.h"
 
-void des_ecb3_encrypt(input, output, ks1, ks2, ks3, encrypt)
-des_cblock (*input);
-des_cblock (*output);
-des_key_schedule ks1;
-des_key_schedule ks2;
-des_key_schedule ks3;
+void DES_ecb3_encrypt(input, output, ks1, ks2, ks3, encrypt)
+DES_cblock (*input);
+DES_cblock (*output);
+DES_key_schedule *ks1;
+DES_key_schedule *ks2;
+DES_key_schedule *ks3;
 int encrypt;
 	{
 	register DES_LONG l0,l1;
@@ -77,9 +77,9 @@ int encrypt;
 	ll[0]=l0;
 	ll[1]=l1;
 	if (encrypt)
-		des_encrypt3(ll,ks1,ks2,ks3);
+		DES_encrypt3(ll,ks1,ks2,ks3);
 	else
-		des_decrypt3(ll,ks1,ks2,ks3);
+		DES_decrypt3(ll,ks1,ks2,ks3);
 	l0=ll[0];
 	l1=ll[1];
 	l2c(l0,out);
diff --git a/lib/des/ecb_enc.c b/lib/des/ecb_enc.c
index 5fcaf1928..c86453f7e 100644
--- a/lib/des/ecb_enc.c
+++ b/lib/des/ecb_enc.c
@@ -62,7 +62,7 @@
 char *libdes_version="libdes v 4.01 - 13-Jan-1997 - eay";
 char *DES_version="DES part of SSLeay 0.6.6 14-Jan-1997";
 
-char *des_options()
+char *DES_options()
 	{
 	static int init=1;
 	static char buf[32];
@@ -102,10 +102,10 @@ char *des_options()
 	}
 		
 
-void des_ecb_encrypt(input, output, ks, encrypt)
-des_cblock (*input);
-des_cblock (*output);
-des_key_schedule ks;
+void DES_ecb_encrypt(input, output, ks, encrypt)
+DES_cblock (*input);
+DES_cblock (*output);
+DES_key_schedule *ks;
 int encrypt;
 	{
 	register DES_LONG l;
@@ -116,7 +116,7 @@ int encrypt;
 	out=(unsigned char *)output;
 	c2l(in,l); ll[0]=l;
 	c2l(in,l); ll[1]=l;
-	des_encrypt(ll,ks,encrypt);
+	DES_encrypt(ll,ks,encrypt);
 	l=ll[0]; l2c(l,out);
 	l=ll[1]; l2c(l,out);
 	l=ll[0]=ll[1]=0;
diff --git a/lib/des/ede_enc.c b/lib/des/ede_enc.c
index c62efac4e..b847656c1 100644
--- a/lib/des/ede_enc.c
+++ b/lib/des/ede_enc.c
@@ -58,14 +58,14 @@
 
 #include "des_locl.h"
 
-void des_ede3_cbc_encrypt(input, output, length, ks1, ks2, ks3, ivec, encrypt)
-des_cblock (*input);
-des_cblock (*output);
+void DES_ede3_cbc_encrypt(input, output, length, ks1, ks2, ks3, ivec, encrypt)
+DES_cblock (*input);
+DES_cblock (*output);
 long length;
-des_key_schedule ks1;
-des_key_schedule ks2;
-des_key_schedule ks3;
-des_cblock (*ivec);
+DES_key_schedule *ks1;
+DES_key_schedule *ks2;
+DES_key_schedule *ks3;
+DES_cblock (*ivec);
 int encrypt;
 	{
 	register DES_LONG tin0,tin1;
@@ -92,7 +92,7 @@ int encrypt;
 
 			tin[0]=tin0;
 			tin[1]=tin1;
-			des_encrypt3((DES_LONG *)tin,ks1,ks2,ks3);
+			DES_encrypt3((DES_LONG *)tin,ks1,ks2,ks3);
 			tout0=tin[0];
 			tout1=tin[1];
 
@@ -107,7 +107,7 @@ int encrypt;
 
 			tin[0]=tin0;
 			tin[1]=tin1;
-			des_encrypt3((DES_LONG *)tin,ks1,ks2,ks3);
+			DES_encrypt3((DES_LONG *)tin,ks1,ks2,ks3);
 			tout0=tin[0];
 			tout1=tin[1];
 
@@ -134,7 +134,7 @@ int encrypt;
 
 			tin[0]=tin0;
 			tin[1]=tin1;
-			des_decrypt3((DES_LONG *)tin,ks1,ks2,ks3);
+			DES_decrypt3((DES_LONG *)tin,ks1,ks2,ks3);
 			tout0=tin[0];
 			tout1=tin[1];
 
@@ -155,7 +155,7 @@ int encrypt;
 
 			tin[0]=tin0;
 			tin[1]=tin1;
-			des_decrypt3((DES_LONG *)tin,ks1,ks2,ks3);
+			DES_decrypt3((DES_LONG *)tin,ks1,ks2,ks3);
 			tout0=tin[0];
 			tout1=tin[1];
 
@@ -174,16 +174,16 @@ int encrypt;
 	}
 
 #ifdef undef /* MACRO */
-void des_ede2_cbc_encrypt(input, output, length, ks1, ks2, ivec, enc)
-des_cblock (*input);
-des_cblock (*output);
+void DES_ede2_cbc_encrypt(input, output, length, ks1, ks2, ivec, enc)
+DES_cblock (*input);
+DES_cblock (*output);
 long length;
 des_key_schedule ks1;
 des_key_schedule ks2;
-des_cblock (*ivec);
+DES_cblock (*ivec);
 int enc;
 	{
-	des_ede3_cbc_encrypt(input,output,length,ks1,ks2,ks1,ivec,enc);
+	DES_ede3_cbc_encrypt(input,output,length,ks1,ks2,ks1,ivec,enc);
 	}
 #endif
 
diff --git a/lib/des/enc_read.c b/lib/des/enc_read.c
index fa2612cd8..b42e0d3ce 100644
--- a/lib/des/enc_read.c
+++ b/lib/des/enc_read.c
@@ -62,14 +62,14 @@
 
 /* This has some uglies in it but it works - even over sockets. */
 /*extern int errno;*/
-int des_rw_mode=DES_PCBC_MODE;
+int DES_rw_mode=DES_PCBC_MODE;
 
-int des_enc_read(fd, buf, len, sched, iv)
+int DES_enc_read(fd, buf, len, sched, iv)
 int fd;
 char *buf;
 int len;
-des_key_schedule sched;
-des_cblock (*iv);
+DES_key_schedule *sched;
+DES_cblock (*iv);
 	{
 	/* data to be unencrypted */
 	int net_num=0;
@@ -160,11 +160,11 @@ des_cblock (*iv);
 	/* Check if there will be data left over. */
 	if (len < num)
 		{
-		if (des_rw_mode & DES_PCBC_MODE)
-			des_pcbc_encrypt((des_cblock *)net,(des_cblock *)unnet,
+		if (DES_rw_mode & DES_PCBC_MODE)
+			DES_pcbc_encrypt((DES_cblock *)net,(DES_cblock *)unnet,
 				num,sched,iv,DES_DECRYPT);
 		else
-			des_cbc_encrypt((des_cblock *)net,(des_cblock *)unnet,
+			DES_cbc_encrypt((DES_cblock *)net,(DES_cblock *)unnet,
 				num,sched,iv,DES_DECRYPT);
 		memcpy(buf,unnet,(unsigned int)len);
 		unnet_start=len;
@@ -184,13 +184,13 @@ des_cblock (*iv);
 		if (len < rnum)
 			{
 
-			if (des_rw_mode & DES_PCBC_MODE)
-				des_pcbc_encrypt((des_cblock *)net,
-					(des_cblock *)tmpbuf,
+			if (DES_rw_mode & DES_PCBC_MODE)
+				DES_pcbc_encrypt((DES_cblock *)net,
+					(DES_cblock *)tmpbuf,
 					num,sched,iv,DES_DECRYPT);
 			else
-				des_cbc_encrypt((des_cblock *)net,
-					(des_cblock *)tmpbuf,
+				DES_cbc_encrypt((DES_cblock *)net,
+					(DES_cblock *)tmpbuf,
 					num,sched,iv,DES_DECRYPT);
 
 			/* eay 26/08/92 fix a bug that returned more
@@ -199,13 +199,13 @@ des_cblock (*iv);
 			}
 		else
 			{
-			if (des_rw_mode & DES_PCBC_MODE)
-				des_pcbc_encrypt((des_cblock *)net,
-					(des_cblock *)buf,num,sched,iv,
+			if (DES_rw_mode & DES_PCBC_MODE)
+				DES_pcbc_encrypt((DES_cblock *)net,
+					(DES_cblock *)buf,num,sched,iv,
 					DES_DECRYPT);
 			else
-				des_cbc_encrypt((des_cblock *)net,
-					(des_cblock *)buf,num,sched,iv,
+				DES_cbc_encrypt((DES_cblock *)net,
+					(DES_cblock *)buf,num,sched,iv,
 					DES_DECRYPT);
 			}
 		}
diff --git a/lib/des/enc_writ.c b/lib/des/enc_writ.c
index fbc93e35d..90615d830 100644
--- a/lib/des/enc_writ.c
+++ b/lib/des/enc_writ.c
@@ -60,12 +60,12 @@
 #include <time.h>
 #include "des_locl.h"
 
-int des_enc_write(fd, buf, len, sched, iv)
+int DES_enc_write(fd, buf, len, sched, iv)
 int fd;
 char *buf;
 int len;
-des_key_schedule sched;
-des_cblock (*iv);
+DES_key_schedule *sched;
+DES_cblock (*iv);
 	{
 #ifdef _LIBC
 	extern int srandom();
@@ -100,7 +100,7 @@ des_cblock (*iv);
 		j=0;
 		for (i=0; i<len; i+=k)
 			{
-			k=des_enc_write(fd,&(buf[i]),
+			k=DES_enc_write(fd,&(buf[i]),
 				((len-i) > MAXWRITE)?MAXWRITE:(len-i),sched,iv);
 			if (k < 0)
 				return(k);
@@ -129,13 +129,13 @@ des_cblock (*iv);
 		rnum=((len+7)/8*8); /* round up to nearest eight */
 		}
 
-	if (des_rw_mode & DES_PCBC_MODE)
-		des_pcbc_encrypt((des_cblock *)p,
-			(des_cblock *)&(outbuf[HDRSIZE]),
+	if (DES_rw_mode & DES_PCBC_MODE)
+		DES_pcbc_encrypt((DES_cblock *)p,
+			(DES_cblock *)&(outbuf[HDRSIZE]),
 			(long)((len<8)?8:len),sched,iv,DES_ENCRYPT); 
 	else
-		des_cbc_encrypt((des_cblock *)p,
-			(des_cblock *)&(outbuf[HDRSIZE]),
+		DES_cbc_encrypt((DES_cblock *)p,
+			(DES_cblock *)&(outbuf[HDRSIZE]),
 			(long)((len<8)?8:len),sched,iv,DES_ENCRYPT); 
 
 	/* output */
diff --git a/lib/des/fcrypt.c b/lib/des/fcrypt.c
index c88d137f9..113d05423 100644
--- a/lib/des/fcrypt.c
+++ b/lib/des/fcrypt.c
@@ -258,7 +258,7 @@ crypt_md5(pw, salt)
 #ifndef NOPROTO
 
 STATIC int fcrypt_body(DES_LONG *out0, DES_LONG *out1,
-	des_key_schedule ks, DES_LONG Eswap0, DES_LONG Eswap1);
+	DES_key_schedule *ks, DES_LONG Eswap0, DES_LONG Eswap1);
 
 #else
 
@@ -302,20 +302,20 @@ static unsigned const char cov_2char[64]={
 
 #ifndef NOPROTO
 #ifdef PERL5
-char *des_crypt(const char *buf,const char *salt);
+char *DES_crypt(const char *buf,const char *salt);
 #else
 char *crypt(const char *buf,const char *salt);
 #endif
 #else
 #ifdef PERL5
-char *des_crypt();
+char *DES_crypt();
 #else
 char *crypt();
 #endif
 #endif
 
 #ifdef PERL5
-char *des_crypt(buf,salt)
+char *DES_crypt(buf,salt)
 #else
 char *crypt(buf,salt)
 #endif
@@ -329,11 +329,11 @@ const char *salt;
 		return crypt_md5(buf, salt);
 #endif
 
-	return(des_fcrypt(buf,salt,buff));
+	return(DES_fcrypt(buf,salt,buff));
 	}
 
 
-char *des_fcrypt(buf,salt,ret)
+char *DES_fcrypt(buf,salt,ret)
 const char *buf;
 const char *salt;
 char *ret;
@@ -341,8 +341,8 @@ char *ret;
 	unsigned int i,j,x,y;
 	DES_LONG Eswap0,Eswap1;
 	DES_LONG out[2],ll;
-	des_cblock key;
-	des_key_schedule ks;
+	DES_cblock key;
+	DES_key_schedule ks;
 	unsigned char bb[9];
 	unsigned char *b=bb;
 	unsigned char c,u;
@@ -373,8 +373,8 @@ r=(r+7)/8;
 	for (; i<8; i++)
 		key[i]=0;
 
-	des_set_key((des_cblock *)(key),ks);
-	fcrypt_body(&(out[0]),&(out[1]),ks,Eswap0,Eswap1);
+	DES_set_key((DES_cblock *)(key),&ks);
+	fcrypt_body(&(out[0]),&(out[1]),&ks,Eswap0,Eswap1);
 
 	ll=out[0]; l2c(ll,b);
 	ll=out[1]; l2c(ll,b);
@@ -404,7 +404,7 @@ r=(r+7)/8;
 STATIC int fcrypt_body(out0, out1, ks, Eswap0, Eswap1)
 DES_LONG *out0;
 DES_LONG *out1;
-des_key_schedule ks;
+DES_key_schedule *ks;
 DES_LONG Eswap0;
 DES_LONG Eswap1;
 	{
diff --git a/lib/des/key_par.c b/lib/des/key_par.c
index 0b7e69463..9ab6e83be 100644
--- a/lib/des/key_par.c
+++ b/lib/des/key_par.c
@@ -35,14 +35,14 @@
 
 /* MIT Link and source compatibility */
 
-#ifdef des_fixup_key_parity
-#undef des_fixup_key_parity
-#endif /* des_fixup_key_parity */
+#ifdef DES_fixup_key_parity
+#undef DES_fixup_key_parity
+#endif /* DES_fixup_key_parity */
 
-void des_fixup_key_parity(des_cblock *key);
+void DES_fixup_key_parity(DES_cblock *key);
 
 void
-des_fixup_key_parity(des_cblock *key)
+DES_fixup_key_parity(DES_cblock *key)
 {
-  des_set_odd_parity(key);
+  DES_set_odd_parity(key);
 }
diff --git a/lib/des/ncbc_enc.c b/lib/des/ncbc_enc.c
index 4a972ac54..f8e0e185e 100644
--- a/lib/des/ncbc_enc.c
+++ b/lib/des/ncbc_enc.c
@@ -58,12 +58,12 @@
 
 #include "des_locl.h"
 
-void des_ncbc_encrypt(input, output, length, schedule, ivec, encrypt)
-des_cblock (*input);
-des_cblock (*output);
+void DES_ncbc_encrypt(input, output, length, schedule, ivec, encrypt)
+DES_cblock (*input);
+DES_cblock (*output);
 long length;
-des_key_schedule schedule;
-des_cblock (*ivec);
+DES_key_schedule *schedule;
+DES_cblock (*ivec);
 int encrypt;
 	{
 	register DES_LONG tin0,tin1;
@@ -87,7 +87,7 @@ int encrypt;
 			c2l(in,tin1);
 			tin0^=tout0; tin[0]=tin0;
 			tin1^=tout1; tin[1]=tin1;
-			des_encrypt((DES_LONG *)tin,schedule,DES_ENCRYPT);
+			DES_encrypt((DES_LONG *)tin,schedule,DES_ENCRYPT);
 			tout0=tin[0]; l2c(tout0,out);
 			tout1=tin[1]; l2c(tout1,out);
 			}
@@ -96,7 +96,7 @@ int encrypt;
 			c2ln(in,tin0,tin1,l+8);
 			tin0^=tout0; tin[0]=tin0;
 			tin1^=tout1; tin[1]=tin1;
-			des_encrypt((DES_LONG *)tin,schedule,DES_ENCRYPT);
+			DES_encrypt((DES_LONG *)tin,schedule,DES_ENCRYPT);
 			tout0=tin[0]; l2c(tout0,out);
 			tout1=tin[1]; l2c(tout1,out);
 			}
@@ -112,7 +112,7 @@ int encrypt;
 			{
 			c2l(in,tin0); tin[0]=tin0;
 			c2l(in,tin1); tin[1]=tin1;
-			des_encrypt((DES_LONG *)tin,schedule,DES_DECRYPT);
+			DES_encrypt((DES_LONG *)tin,schedule,DES_DECRYPT);
 			tout0=tin[0]^xor0;
 			tout1=tin[1]^xor1;
 			l2c(tout0,out);
@@ -124,7 +124,7 @@ int encrypt;
 			{
 			c2l(in,tin0); tin[0]=tin0;
 			c2l(in,tin1); tin[1]=tin1;
-			des_encrypt((DES_LONG *)tin,schedule,DES_DECRYPT);
+			DES_encrypt((DES_LONG *)tin,schedule,DES_DECRYPT);
 			tout0=tin[0]^xor0;
 			tout1=tin[1]^xor1;
 			l2cn(tout0,tout1,out,l+8);
diff --git a/lib/des/ofb64ede.c b/lib/des/ofb64ede.c
index b33deef10..72ce8d6c7 100644
--- a/lib/des/ofb64ede.c
+++ b/lib/des/ofb64ede.c
@@ -62,18 +62,18 @@
  * used.  The extra state information to record how much of the
  * 64bit block we have used is contained in *num;
  */
-void des_ede3_ofb64_encrypt(in, out, length, k1,k2,k3, ivec, num)
+void DES_ede3_ofb64_encrypt(in, out, length, k1,k2,k3, ivec, num)
 register unsigned char *in;
 register unsigned char *out;
 long length;
-des_key_schedule k1,k2,k3;
-des_cblock (*ivec);
+DES_key_schedule *k1,*k2,*k3;
+DES_cblock (*ivec);
 int *num;
 	{
 	register DES_LONG v0,v1;
 	register int n= *num;
 	register long l=length;
-	des_cblock d;
+	DES_cblock d;
 	register char *dp;
 	DES_LONG ti[2];
 	unsigned char *iv;
@@ -93,7 +93,7 @@ int *num;
 			{
 			ti[0]=v0;
 			ti[1]=v1;
-			des_encrypt3((DES_LONG *)ti,k1,k2,k3);
+			DES_encrypt3((DES_LONG *)ti,k1,k2,k3);
 			v0=ti[0];
 			v1=ti[1];
 
@@ -118,14 +118,14 @@ int *num;
 	}
 
 #ifdef undef /* MACRO */
-void des_ede2_ofb64_encrypt(in, out, length, k1,k2, ivec, num)
+void DES_ede2_ofb64_encrypt(in, out, length, k1,k2, ivec, num)
 register unsigned char *in;
 register unsigned char *out;
 long length;
-des_key_schedule k1,k2;
-des_cblock (*ivec);
+DES_key_schedule *k1,*k2;
+DES_cblock (*ivec);
 int *num;
 	{
-	des_ede3_ofb64_encrypt(in, out, length, k1,k2,k1, ivec, num);
+	DES_ede3_ofb64_encrypt(in, out, length, k1,k2,k1, ivec, num);
 	}
 #endif
diff --git a/lib/des/ofb64enc.c b/lib/des/ofb64enc.c
index 041f5b52b..dae9445ad 100644
--- a/lib/des/ofb64enc.c
+++ b/lib/des/ofb64enc.c
@@ -62,18 +62,18 @@
  * used.  The extra state information to record how much of the
  * 64bit block we have used is contained in *num;
  */
-void des_ofb64_encrypt(in, out, length, schedule, ivec, num)
+void DES_ofb64_encrypt(in, out, length, schedule, ivec, num)
 register unsigned char *in;
 register unsigned char *out;
 long length;
-des_key_schedule schedule;
-des_cblock (*ivec);
+DES_key_schedule *schedule;
+DES_cblock (*ivec);
 int *num;
 	{
 	register DES_LONG v0,v1,t;
 	register int n= *num;
 	register long l=length;
-	des_cblock d;
+	DES_cblock d;
 	register char *dp;
 	DES_LONG ti[2];
 	unsigned char *iv;
@@ -91,7 +91,7 @@ int *num;
 		{
 		if (n == 0)
 			{
-			des_encrypt((DES_LONG *)ti,schedule,DES_ENCRYPT);
+			DES_encrypt((DES_LONG *)ti,schedule,DES_ENCRYPT);
 			dp=(char *)d;
 			t=ti[0]; l2c(t,dp);
 			t=ti[1]; l2c(t,dp);
diff --git a/lib/des/ofb_enc.c b/lib/des/ofb_enc.c
index d0506100d..a7bc8ac14 100644
--- a/lib/des/ofb_enc.c
+++ b/lib/des/ofb_enc.c
@@ -64,13 +64,13 @@
  * the second.  The second 12 bits will come from the 3rd and half the 4th
  * byte.
  */
-void des_ofb_encrypt(in, out, numbits, length, schedule, ivec)
+void DES_ofb_encrypt(in, out, numbits, length, schedule, ivec)
 unsigned char *in;
 unsigned char *out;
 int numbits;
 long length;
-des_key_schedule schedule;
-des_cblock (*ivec);
+DES_key_schedule *schedule;
+DES_cblock (*ivec);
 	{
 	register DES_LONG d0,d1,v0,v1,n=(numbits+7)/8;
 	register DES_LONG mask0,mask1;
@@ -104,7 +104,7 @@ des_cblock (*ivec);
 	ti[1]=v1;
 	while (l-- > 0)
 		{
-		des_encrypt((DES_LONG *)ti,schedule,DES_ENCRYPT);
+		DES_encrypt((DES_LONG *)ti,schedule,DES_ENCRYPT);
 		c2ln(in,d0,d1,n);
 		in+=n;
 		d0=(d0^ti[0])&mask0;
diff --git a/lib/des/pcbc_enc.c b/lib/des/pcbc_enc.c
index cb2e785cf..8997dd093 100644
--- a/lib/des/pcbc_enc.c
+++ b/lib/des/pcbc_enc.c
@@ -58,12 +58,12 @@
 
 #include "des_locl.h"
 
-void des_pcbc_encrypt(input, output, length, schedule, ivec, encrypt)
-des_cblock (*input);
-des_cblock (*output);
+void DES_pcbc_encrypt(input, output, length, schedule, ivec, encrypt)
+DES_cblock (*input);
+DES_cblock (*output);
 long length;
-des_key_schedule schedule;
-des_cblock (*ivec);
+DES_key_schedule *schedule;
+DES_cblock (*ivec);
 int encrypt;
 	{
 	register DES_LONG sin0,sin1,xor0,xor1,tout0,tout1;
@@ -89,7 +89,7 @@ int encrypt;
 				c2ln(in,sin0,sin1,length);
 			tin[0]=sin0^xor0;
 			tin[1]=sin1^xor1;
-			des_encrypt((DES_LONG *)tin,schedule,DES_ENCRYPT);
+			DES_encrypt((DES_LONG *)tin,schedule,DES_ENCRYPT);
 			tout0=tin[0];
 			tout1=tin[1];
 			xor0=sin0^tout0;
@@ -107,7 +107,7 @@ int encrypt;
 			c2l(in,sin1);
 			tin[0]=sin0;
 			tin[1]=sin1;
-			des_encrypt((DES_LONG *)tin,schedule,DES_DECRYPT);
+			DES_encrypt((DES_LONG *)tin,schedule,DES_DECRYPT);
 			tout0=tin[0]^xor0;
 			tout1=tin[1]^xor1;
 			if (length >= 8)
diff --git a/lib/des/qud_cksm.c b/lib/des/qud_cksm.c
index 783274854..e9d84d541 100644
--- a/lib/des/qud_cksm.c
+++ b/lib/des/qud_cksm.c
@@ -73,12 +73,12 @@
 /* Got the value MIT uses via brute force :-) 2/10/90 eay */
 #define NOISE	((DES_LONG)83653421L)
 
-DES_LONG des_quad_cksum(input, output, length, out_count, seed)
-     des_cblock (*input);
-     des_cblock (*output);
+DES_LONG DES_quad_cksum(input, output, length, out_count, seed)
+     DES_cblock (*input);
+     DES_cblock (*output);
      long length;
      int out_count;
-     des_cblock (*seed);
+     DES_cblock (*seed);
 {
     DES_LONG z0,z1,t0,t1;
     int i;
diff --git a/lib/des/read_pwd.c b/lib/des/read_pwd.c
index e968eb8a3..3b592ef8b 100644
--- a/lib/des/read_pwd.c
+++ b/lib/des/read_pwd.c
@@ -173,8 +173,8 @@ static void (*savsig[NX509_SIG])();
 #endif
 static jmp_buf save;
 
-int des_read_password(key, prompt, verify)
-des_cblock (*key);
+int DES_read_password(key, prompt, verify)
+DES_cblock (*key);
 char *prompt;
 int verify;
 	{
@@ -182,15 +182,15 @@ int verify;
 	char buf[BUFSIZ],buff[BUFSIZ];
 
 	if ((ok=read_pw(buf,buff,BUFSIZ,prompt,verify)) == 0)
-		des_string_to_key(buf,key);
+		DES_string_to_key(buf,key);
 	memset(buf,0,BUFSIZ);
 	memset(buff,0,BUFSIZ);
 	return(ok);
 	}
 
-int des_read_2passwords(key1, key2, prompt, verify)
-des_cblock (*key1);
-des_cblock (*key2);
+int DES_read_2passwords(key1, key2, prompt, verify)
+DES_cblock (*key1);
+DES_cblock (*key2);
 char *prompt;
 int verify;
 	{
@@ -198,13 +198,13 @@ int verify;
 	char buf[BUFSIZ],buff[BUFSIZ];
 
 	if ((ok=read_pw(buf,buff,BUFSIZ,prompt,verify)) == 0)
-		des_string_to_2keys(buf,key1,key2);
+		DES_string_to_2keys(buf,key1,key2);
 	memset(buf,0,BUFSIZ);
 	memset(buff,0,BUFSIZ);
 	return(ok);
 	}
 
-int des_read_pw_string(buf, length, prompt, verify)
+int UI_UTIL_read_pw_string(buf, length, prompt, verify)
 char *buf;
 int length;
 char *prompt;
diff --git a/lib/des/rnd_keys.c b/lib/des/rnd_keys.c
index 04e7d8f90..9a1761536 100644
--- a/lib/des/rnd_keys.c
+++ b/lib/des/rnd_keys.c
@@ -149,7 +149,7 @@ md5sumFile (const char *name, int len, int32_t sum[4])
  * The sequence is indexed with a long long and 
  * based on an initial des key used as a seed.
  */
-static des_key_schedule sequence_seed;
+static DES_key_schedule sequence_seed;
 static u_int32_t sequence_index[2];
 
 /* 
@@ -242,7 +242,7 @@ static RETSIGTYPE
  * It's not neccessary to be root to run it.
  */
 void
-des_rand_data(unsigned char *data, int size)
+DES_rand_data(unsigned char *data, int size)
 {
     struct itimerval tv, otv;
     RETSIGTYPE (*osa)(int);
@@ -312,36 +312,39 @@ des_rand_data(unsigned char *data, int size)
 }
 #else
 void
-des_rand_data(unsigned char *p, int s)
+DES_rand_data(unsigned char *p, int s)
 {
-  des_not_rand_data (p, s);
+  DES_not_rand_data (p, s);
 }
 #endif
 
 void
-des_generate_random_block(des_cblock *block)
+DES_generate_random_block(DES_cblock *block)
 {
-  des_rand_data((unsigned char *)block, sizeof(*block));
+  DES_rand_data((unsigned char *)block, sizeof(*block));
 }
 
+void
+DES_rand_data_key(DES_cblock *key);
+
 /*
  * Generate a "random" DES key.
  */
 void
-des_rand_data_key(des_cblock *key)
+DES_rand_data_key(DES_cblock *key)
 {
     unsigned char data[8];
-    des_key_schedule sched;
+    DES_key_schedule sched;
     do {
-	des_rand_data(data, sizeof(data));
-	des_rand_data((unsigned char*)key, sizeof(des_cblock));
-	des_set_odd_parity(key);
-	des_key_sched(key, sched);
-	des_ecb_encrypt(&data, key, sched, DES_ENCRYPT);
+	DES_rand_data(data, sizeof(data));
+	DES_rand_data((unsigned char*)key, sizeof(DES_cblock));
+	DES_set_odd_parity(key);
+	DES_key_sched(key, &sched);
+	DES_ecb_encrypt(&data, key, &sched, DES_ENCRYPT);
 	memset(&data, 0, sizeof(data));
 	memset(&sched, 0, sizeof(sched));
-	des_set_odd_parity(key);
-    } while(des_is_weak_key(key));
+	DES_set_odd_parity(key);
+    } while(DES_is_weak_key(key));
 }
 
 /*
@@ -351,7 +354,10 @@ des_rand_data_key(des_cblock *key)
  * problems with permissions.
  */
 int
-des_mem_rand8(unsigned char *data)
+DES_mem_rand8(unsigned char *data);
+
+int
+DES_mem_rand8(unsigned char *data)
 {
   return 1;
 }
@@ -364,12 +370,12 @@ static int initialized;
 static void
 do_initialize(void)
 {
-    des_cblock default_seed;
+    DES_cblock default_seed;
     do {
-	des_generate_random_block(&default_seed);
-	des_set_odd_parity(&default_seed);
-    } while (des_is_weak_key(&default_seed));
-    des_init_random_number_generator(&default_seed);
+	DES_generate_random_block(&default_seed);
+	DES_set_odd_parity(&default_seed);
+    } while (DES_is_weak_key(&default_seed));
+    DES_init_random_number_generator(&default_seed);
 }
 
 #define zero_long_long(ll) do { ll[0] = ll[1] = 0; } while (0)
@@ -383,7 +389,7 @@ memcpy((char *)sequence_index, (ll), sizeof(sequence_index));
  * Set the sequnce number to this value (a long long).
  */
 void
-des_set_sequence_number(unsigned char *ll)
+DES_set_sequence_number(unsigned char *ll)
 {
     set_sequence_number(ll);
 }
@@ -392,9 +398,9 @@ des_set_sequence_number(unsigned char *ll)
  * Set the generator seed and reset the sequence number to 0.
  */
 void
-des_set_random_generator_seed(des_cblock *seed)
+DES_set_random_generator_seed(DES_cblock *seed)
 {
-    des_key_sched(seed, sequence_seed);
+    DES_key_sched(seed, &sequence_seed);
     zero_long_long(sequence_index);
     initialized = 1;
 }
@@ -405,20 +411,20 @@ des_set_random_generator_seed(des_cblock *seed)
  * parity and skip weak keys.
  */
 int
-des_new_random_key(des_cblock *key)
+DES_new_random_key(DES_cblock *key)
 {
     if (!initialized)
 	do_initialize();
 
     do {
-	des_ecb_encrypt((des_cblock *) sequence_index,
+	DES_ecb_encrypt((DES_cblock *) sequence_index,
 			key,
-			sequence_seed,
+			&sequence_seed,
 			DES_ENCRYPT);
 	incr_long_long(sequence_index);
 	/* random key must have odd parity and not be weak */
-	des_set_odd_parity(key);
-    } while (des_is_weak_key(key));
+	DES_set_odd_parity(key);
+    } while (DES_is_weak_key(key));
     return(0);
 }
 
@@ -431,34 +437,34 @@ des_new_random_key(des_cblock *key)
  *
  */
 void 
-des_init_random_number_generator(des_cblock *seed)
+DES_init_random_number_generator(DES_cblock *seed)
 {
     struct timeval now;
-    des_cblock uniq;
-    des_cblock new_key;
+    DES_cblock uniq;
+    DES_cblock new_key;
 
     gettimeofday(&now, (struct timezone *)0);
-    des_generate_random_block(&uniq);
+    DES_generate_random_block(&uniq);
 
     /* Pick a unique random key from the shared sequence. */
-    des_set_random_generator_seed(seed);
+    DES_set_random_generator_seed(seed);
     set_sequence_number((unsigned char *)&uniq);
-    des_new_random_key(&new_key);
+    DES_new_random_key(&new_key);
 
     /* Select a new nonshared sequence, */
-    des_set_random_generator_seed(&new_key);
+    DES_set_random_generator_seed(&new_key);
 
     /* and use the current time to pick a key for the new sequence. */
     set_sequence_number((unsigned char *)&now);
-    des_new_random_key(&new_key);
-    des_set_random_generator_seed(&new_key);
+    DES_new_random_key(&new_key);
+    DES_set_random_generator_seed(&new_key);
 }
 
 /* This is for backwards compatibility. */
 void
-des_random_key(des_cblock ret)
+DES_random_key(DES_cblock ret)
 {
-    des_new_random_key((des_cblock *)ret);
+    DES_new_random_key((DES_cblock *)ret);
 }
 
 #ifdef TESTRUN
@@ -483,13 +489,13 @@ main()
 int
 main()
 {
-    des_cblock data;
+    DES_cblock data;
     int i;
 
     while (1)
         {
 	    do_initialize();
-            des_random_key(data);
+            DES_random_key(data);
             for (i = 0; i < 8; i++)
                 printf("%02x", data[i]);
             printf("\n");
diff --git a/lib/des/set_key.c b/lib/des/set_key.c
index a6f307efe..a1ba0a7ed 100644
--- a/lib/des/set_key.c
+++ b/lib/des/set_key.c
@@ -68,15 +68,15 @@
 #include "sk.h"
 
 #ifndef NOPROTO
-static int check_parity(des_cblock (*key));
+static int check_parity(DES_cblock (*key));
 #else
 static int check_parity();
 #endif
 
-int des_check_key=0;
+int DES_check_key=0;
 
-void des_set_odd_parity(key)
-des_cblock (*key);
+void DES_set_odd_parity(key)
+DES_cblock (*key);
 	{
 	int i;
 
@@ -85,7 +85,7 @@ des_cblock (*key);
 	}
 
 static int check_parity(key)
-des_cblock (*key);
+DES_cblock (*key);
 	{
 	int i;
 
@@ -112,7 +112,7 @@ des_cblock (*key);
  */
 
 #define NUM_WEAK_KEY	16
-static des_cblock weak_keys[NUM_WEAK_KEY]={
+static DES_cblock weak_keys[NUM_WEAK_KEY]={
 	/* weak keys */
 	{0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01},
 	{0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE},
@@ -132,8 +132,8 @@ static des_cblock weak_keys[NUM_WEAK_KEY]={
 	{0xE0,0xFE,0xE0,0xFE,0xF1,0xFE,0xF1,0xFE},
 	{0xFE,0xE0,0xFE,0xE0,0xFE,0xF1,0xFE,0xF1}};
 
-int des_is_weak_key(key)
-des_cblock (*key);
+int DES_is_weak_key(key)
+DES_cblock (*key);
 	{
 	int i;
 
@@ -160,9 +160,9 @@ des_cblock (*key);
  * return -1 if key parity error,
  * return -2 if illegal weak key.
  */
-int des_set_key(key, schedule)
-des_cblock (*key);
-des_key_schedule schedule;
+int DES_set_key(key, schedule)
+DES_cblock (*key);
+DES_key_schedule *schedule;
 	{
 	static int shifts2[16]={0,0,1,1,1,1,1,1,0,1,1,1,1,1,1,0};
 	register DES_LONG c,d,t,s,t2;
@@ -170,12 +170,12 @@ des_key_schedule schedule;
 	register DES_LONG *k;
 	register int i;
 
-	if (des_check_key)
+	if (DES_check_key)
 		{
 		if (!check_parity(key))
 			return(-1);
 
-		if (des_is_weak_key(key))
+		if (DES_is_weak_key(key))
 			return(-2);
 		}
 
@@ -241,9 +241,9 @@ des_key_schedule schedule;
 	return(0);
 	}
 
-int des_key_sched(key, schedule)
-des_cblock (*key);
-des_key_schedule schedule;
+int DES_key_sched(key, schedule)
+DES_cblock (*key);
+DES_key_schedule *schedule;
 	{
-	return(des_set_key(key,schedule));
+	return(DES_set_key(key,schedule));
 	}
diff --git a/lib/des/str2key.c b/lib/des/str2key.c
index c86368c8c..b06738180 100644
--- a/lib/des/str2key.c
+++ b/lib/des/str2key.c
@@ -58,13 +58,13 @@
 
 #include "des_locl.h"
 
-extern int des_check_key;
+extern int DES_check_key;
 
-void des_string_to_key(str, key)
+void DES_string_to_key(str, key)
 char *str;
-des_cblock (*key);
+DES_cblock (*key);
 	{
-	des_key_schedule ks;
+	DES_key_schedule ks;
 	int i,length;
 	register unsigned char j;
 
@@ -89,25 +89,25 @@ des_cblock (*key);
 			}
 		}
 #endif
-	des_set_odd_parity((des_cblock *)key);
-	i=des_check_key;
-	des_check_key=0;
-	if(des_is_weak_key((des_cblock *)key))
+	DES_set_odd_parity((DES_cblock *)key);
+	i=DES_check_key;
+	DES_check_key=0;
+	if(DES_is_weak_key((DES_cblock *)key))
 	    (*key)[7] ^= 0xF0;
-	des_set_key((des_cblock *)key,ks);
-	des_check_key=i;
-	des_cbc_cksum((des_cblock *)str,(des_cblock *)key,(long)length,ks,
-		(des_cblock *)key);
-	memset(ks,0,sizeof(ks));
-	des_set_odd_parity((des_cblock *)key);
+	DES_set_key((DES_cblock *)key,&ks);
+	DES_check_key=i;
+	DES_cbc_cksum((DES_cblock *)str,(DES_cblock *)key,(long)length,&ks,
+		(DES_cblock *)key);
+	memset(&ks,0,sizeof(ks));
+	DES_set_odd_parity((DES_cblock *)key);
 	}
 
-void des_string_to_2keys(str, key1, key2)
+void DES_string_to_2keys(str, key1, key2)
 char *str;
-des_cblock (*key1);
-des_cblock (*key2);
+DES_cblock (*key1);
+DES_cblock (*key2);
 	{
-	des_key_schedule ks;
+	DES_key_schedule ks;
 	int i,length;
 	register unsigned char j;
 
@@ -156,22 +156,22 @@ des_cblock (*key2);
 		}
 	if (length <= 8) memcpy(key2,key1,8);
 #endif
-	des_set_odd_parity((des_cblock *)key1);
-	des_set_odd_parity((des_cblock *)key2);
-	i=des_check_key;
-	des_check_key=0;
-	if(des_is_weak_key((des_cblock *)key1))
+	DES_set_odd_parity((DES_cblock *)key1);
+	DES_set_odd_parity((DES_cblock *)key2);
+	i=DES_check_key;
+	DES_check_key=0;
+	if(DES_is_weak_key((DES_cblock *)key1))
 	    (*key1)[7] ^= 0xF0;
-	des_set_key((des_cblock *)key1,ks);
-	des_cbc_cksum((des_cblock *)str,(des_cblock *)key1,(long)length,ks,
-		(des_cblock *)key1);
-	if(des_is_weak_key((des_cblock *)key2))
+	DES_set_key((DES_cblock *)key1,&ks);
+	DES_cbc_cksum((DES_cblock *)str,(DES_cblock *)key1,(long)length,&ks,
+		(DES_cblock *)key1);
+	if(DES_is_weak_key((DES_cblock *)key2))
 	    (*key2)[7] ^= 0xF0;
-	des_set_key((des_cblock *)key2,ks);
-	des_cbc_cksum((des_cblock *)str,(des_cblock *)key2,(long)length,ks,
-		(des_cblock *)key2);
-	des_check_key=i;
-	memset(ks,0,sizeof(ks));
-	des_set_odd_parity(key1);
-	des_set_odd_parity(key2);
+	DES_set_key((DES_cblock *)key2,&ks);
+	DES_cbc_cksum((DES_cblock *)str,(DES_cblock *)key2,(long)length,&ks,
+		(DES_cblock *)key2);
+	DES_check_key=i;
+	memset(&ks,0,sizeof(ks));
+	DES_set_odd_parity(key1);
+	DES_set_odd_parity(key2);
 	}
diff --git a/lib/des/xcbc_enc.c b/lib/des/xcbc_enc.c
index 6a8626171..c17ce67f7 100644
--- a/lib/des/xcbc_enc.c
+++ b/lib/des/xcbc_enc.c
@@ -79,10 +79,12 @@ static unsigned char desx_white_in2out[256]={
 0xA7,0x1C,0xC9,0x09,0x69,0x9A,0x83,0xCF,0x29,0x39,0xB9,0xE9,0x4C,0xFF,0x43,0xAB,
 	};
 
-void des_xwhite_in2out(des_key,in_white,out_white)
-des_cblock (*des_key);
-des_cblock (*in_white);
-des_cblock (*out_white);
+void DES_xwhite_in2out(DES_cblock *,DES_cblock *, DES_cblock *);
+
+void DES_xwhite_in2out(des_key,in_white,out_white)
+DES_cblock (*des_key);
+DES_cblock (*in_white);
+DES_cblock (*out_white);
 	{
 	unsigned char *key,*in,*out;
 	int out0,out1;
@@ -111,14 +113,14 @@ des_cblock (*out_white);
 		}
 	}
 
-void des_xcbc_encrypt(input, output, length, schedule, ivec, inw,outw,encrypt)
-des_cblock (*input);
-des_cblock (*output);
+void DES_xcbc_encrypt(input, output, length, schedule, ivec, inw,outw,encrypt)
+DES_cblock (*input);
+DES_cblock (*output);
 long length;
-des_key_schedule schedule;
-des_cblock (*ivec);
-des_cblock (*inw);
-des_cblock (*outw);
+DES_key_schedule *schedule;
+DES_cblock (*ivec);
+DES_cblock (*inw);
+DES_cblock (*outw);
 int encrypt;
 	{
 	register DES_LONG tin0,tin1;
@@ -150,7 +152,7 @@ int encrypt;
 			c2l(in,tin1);
 			tin0^=tout0^inW0; tin[0]=tin0;
 			tin1^=tout1^inW1; tin[1]=tin1;
-			des_encrypt((DES_LONG *)tin,schedule,DES_ENCRYPT);
+			DES_encrypt((DES_LONG *)tin,schedule,DES_ENCRYPT);
 			tout0=tin[0]^outW0; l2c(tout0,out);
 			tout1=tin[1]^outW1; l2c(tout1,out);
 			}
@@ -159,7 +161,7 @@ int encrypt;
 			c2ln(in,tin0,tin1,l+8);
 			tin0^=tout0^inW0; tin[0]=tin0;
 			tin1^=tout1^inW1; tin[1]=tin1;
-			des_encrypt((DES_LONG *)tin,schedule,DES_ENCRYPT);
+			DES_encrypt((DES_LONG *)tin,schedule,DES_ENCRYPT);
 			tout0=tin[0]^outW0; l2c(tout0,out);
 			tout1=tin[1]^outW1; l2c(tout1,out);
 			}
@@ -175,7 +177,7 @@ int encrypt;
 			{
 			c2l(in,tin0); tin[0]=tin0^outW0;
 			c2l(in,tin1); tin[1]=tin1^outW1;
-			des_encrypt((DES_LONG *)tin,schedule,DES_DECRYPT);
+			DES_encrypt((DES_LONG *)tin,schedule,DES_DECRYPT);
 			tout0=tin[0]^xor0^inW0;
 			tout1=tin[1]^xor1^inW1;
 			l2c(tout0,out);
@@ -187,7 +189,7 @@ int encrypt;
 			{
 			c2l(in,tin0); tin[0]=tin0^outW0;
 			c2l(in,tin1); tin[1]=tin1^outW1;
-			des_encrypt((DES_LONG *)tin,schedule,DES_DECRYPT);
+			DES_encrypt((DES_LONG *)tin,schedule,DES_DECRYPT);
 			tout0=tin[0]^xor0^inW0;
 			tout1=tin[1]^xor1^inW1;
 			l2cn(tout0,tout1,out,l+8);