1 /* crypto/des/cfb64ede.c */

     2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)

     3  * All rights reserved.

     4  *

     5  * This package is an SSL implementation written

     6  * by Eric Young (eay@cryptsoft.com).

     7  * The implementation was written so as to conform with Netscapes SSL.

     8  * 

     9  * This library is free for commercial and non-commercial use as long as

    10  * the following conditions are aheared to.  The following conditions

    11  * apply to all code found in this distribution, be it the RC4, RSA,

    12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation

    13  * included with this distribution is covered by the same copyright terms

    14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).

    15  * 

    16  * Copyright remains Eric Young's, and as such any Copyright notices in

    17  * the code are not to be removed.

    18  * If this package is used in a product, Eric Young should be given attribution

    19  * as the author of the parts of the library used.

    20  * This can be in the form of a textual message at program startup or

    21  * in documentation (online or textual) provided with the package.

    22  * 

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

    24  * modification, are permitted provided that the following conditions

    25  * are met:

    26  * 1. Redistributions of source code must retain the copyright

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

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

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

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

    31  * 3. All advertising materials mentioning features or use of this software

    32  *    must display the following acknowledgement:

    33  *    "This product includes cryptographic software written by

    34  *     Eric Young (eay@cryptsoft.com)"

    35  *    The word 'cryptographic' can be left out if the rouines from the library

    36  *    being used are not cryptographic related :-).

    37  * 4. If you include any Windows specific code (or a derivative thereof) from 

    38  *    the apps directory (application code) you must include an acknowledgement:

    39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"

    40  * 

    41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND

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

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

    44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE

    45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

    46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

    47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

    48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

    49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

    50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

    51  * SUCH DAMAGE.

    52  * 

    53  * The licence and distribution terms for any publically available version or

    54  * derivative of this code cannot be changed.  i.e. this code cannot simply be

    55  * copied and put under another distribution licence

    56  * [including the GNU Public Licence.]

    57  */

    58 

    59 #include "des_locl.h"

    60 #include "e_os.h"

    61 

    62 /* The input and output encrypted as though 64bit cfb mode is being

    63  * used.  The extra state information to record how much of the

    64  * 64bit block we have used is contained in *num;

    65  */

    66 

    67 EXPORT_C void DES_ede3_cfb64_encrypt(const unsigned char *in, unsigned char *out,

    68 			    long length, DES_key_schedule *ks1,

    69 			    DES_key_schedule *ks2, DES_key_schedule *ks3,

    70 			    DES_cblock *ivec, int *num, int enc)

    71 	{

    72 	register DES_LONG v0,v1;

    73 	register long l=length;

    74 	register int n= *num;

    75 	DES_LONG ti[2];

    76 	unsigned char *iv,c,cc;

    77 

    78 	iv=&(*ivec)[0];

    79 	if (enc)

    80 		{

    81 		while (l--)

    82 			{

    83 			if (n == 0)

    84 				{

    85 				c2l(iv,v0);

    86 				c2l(iv,v1);

    87 

    88 				ti[0]=v0;

    89 				ti[1]=v1;

    90 				DES_encrypt3(ti,ks1,ks2,ks3);

    91 				v0=ti[0];

    92 				v1=ti[1];

    93 

    94 				iv = &(*ivec)[0];

    95 				l2c(v0,iv);

    96 				l2c(v1,iv);

    97 				iv = &(*ivec)[0];

    98 				}

    99 			c= *(in++)^iv[n];

   100 			*(out++)=c;

   101 			iv[n]=c;

   102 			n=(n+1)&0x07;

   103 			}

   104 		}

   105 	else

   106 		{

   107 		while (l--)

   108 			{

   109 			if (n == 0)

   110 				{

   111 				c2l(iv,v0);

   112 				c2l(iv,v1);

   113 

   114 				ti[0]=v0;

   115 				ti[1]=v1;

   116 				DES_encrypt3(ti,ks1,ks2,ks3);

   117 				v0=ti[0];

   118 				v1=ti[1];

   119 

   120 				iv = &(*ivec)[0];

   121 				l2c(v0,iv);

   122 				l2c(v1,iv);

   123 				iv = &(*ivec)[0];

   124 				}

   125 			cc= *(in++);

   126 			c=iv[n];

   127 			iv[n]=cc;

   128 			*(out++)=c^cc;

   129 			n=(n+1)&0x07;

   130 			}

   131 		}

   132 	v0=v1=ti[0]=ti[1]=c=cc=0;

   133 	*num=n;

   134 	}

   135 

   136 #ifdef undef /* MACRO */

   137 EXPORT_C void DES_ede2_cfb64_encrypt(unsigned char *in, unsigned char *out, long length,

   138 	     DES_key_schedule ks1, DES_key_schedule ks2, DES_cblock (*ivec),

   139 	     int *num, int enc)

   140 	{

   141 	DES_ede3_cfb64_encrypt(in,out,length,ks1,ks2,ks1,ivec,num,enc);

   142 	}

   143 #endif

   144 

   145 /* This is compatible with the single key CFB-r for DES, even thought that's

   146  * not what EVP needs.

   147  */

   148 

   149 EXPORT_C void DES_ede3_cfb_encrypt(const unsigned char *in,unsigned char *out,

   150 			  int numbits,long length,DES_key_schedule *ks1,

   151 			  DES_key_schedule *ks2,DES_key_schedule *ks3,

   152 			  DES_cblock *ivec,int enc)

   153 	{

   154 	register DES_LONG d0,d1,v0,v1;

   155 	register unsigned long l=length,n=((unsigned int)numbits+7)/8;

   156 	register int num=numbits,i;

   157 	DES_LONG ti[2];

   158 	unsigned char *iv;

   159 	unsigned char ovec[16];

   160 

   161 	if (num > 64) return;

   162 	iv = &(*ivec)[0];

   163 	c2l(iv,v0);

   164 	c2l(iv,v1);

   165 	if (enc)

   166 		{

   167 		while (l >= n)

   168 			{

   169 			l-=n;

   170 			ti[0]=v0;

   171 			ti[1]=v1;

   172 			DES_encrypt3(ti,ks1,ks2,ks3);

   173 			c2ln(in,d0,d1,n);

   174 			in+=n;

   175 			d0^=ti[0];

   176 			d1^=ti[1];

   177 			l2cn(d0,d1,out,n);

   178 			out+=n;

   179 			/* 30-08-94 - eay - changed because l>>32 and

   180 			 * l<<32 are bad under gcc :-( */

   181 			if (num == 32)

   182 				{ v0=v1; v1=d0; }

   183 			else if (num == 64)

   184 				{ v0=d0; v1=d1; }

   185 			else

   186 				{

   187 				iv=&ovec[0];

   188 				l2c(v0,iv);

   189 				l2c(v1,iv);

   190 				l2c(d0,iv);

   191 				l2c(d1,iv);

   192 				/* shift ovec left most of the bits... */

   193 				memmove(ovec,ovec+num/8,8+(num%8 ? 1 : 0));

   194 				/* now the remaining bits */

   195 				if(num%8 != 0)

   196 					for(i=0 ; i < 8 ; ++i)

   197 						{

   198 						ovec[i]<<=num%8;

   199 						ovec[i]|=ovec[i+1]>>(8-num%8);

   200 						}

   201 				iv=&ovec[0];

   202 				c2l(iv,v0);

   203 				c2l(iv,v1);

   204 				}

   205 			}

   206 		}

   207 	else

   208 		{

   209 		while (l >= n)

   210 			{

   211 			l-=n;

   212 			ti[0]=v0;

   213 			ti[1]=v1;

   214 			DES_encrypt3(ti,ks1,ks2,ks3);

   215 			c2ln(in,d0,d1,n);

   216 			in+=n;

   217 			/* 30-08-94 - eay - changed because l>>32 and

   218 			 * l<<32 are bad under gcc :-( */

   219 			if (num == 32)

   220 				{ v0=v1; v1=d0; }

   221 			else if (num == 64)

   222 				{ v0=d0; v1=d1; }

   223 			else

   224 				{

   225 				iv=&ovec[0];

   226 				l2c(v0,iv);

   227 				l2c(v1,iv);

   228 				l2c(d0,iv);

   229 				l2c(d1,iv);

   230 				/* shift ovec left most of the bits... */

   231 				memmove(ovec,ovec+num/8,8+(num%8 ? 1 : 0));

   232 				/* now the remaining bits */

   233 				if(num%8 != 0)

   234 					for(i=0 ; i < 8 ; ++i)

   235 						{

   236 						ovec[i]<<=num%8;

   237 						ovec[i]|=ovec[i+1]>>(8-num%8);

   238 						}

   239 				iv=&ovec[0];

   240 				c2l(iv,v0);

   241 				c2l(iv,v1);

   242 				}

   243 			d0^=ti[0];

   244 			d1^=ti[1];

   245 			l2cn(d0,d1,out,n);

   246 			out+=n;

   247 			}

   248 		}

   249 	iv = &(*ivec)[0];

   250 	l2c(v0,iv);

   251 	l2c(v1,iv);

   252 	v0=v1=d0=d1=ti[0]=ti[1]=0;

   253 	}

   254