Symaptic: os/ossrv/ssl/libcrypto/src/crypto/des/des

     1 /* crypto/des/des_locl.h */

     2 /* Copyright (C) 1995-1997 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  */

    59 #ifndef HEADER_DES_LOCL_H

    60 #define HEADER_DES_LOCL_H

    62 #include <openssl/e_os2.h>

    64 #if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WIN16)

    65 #ifndef OPENSSL_SYS_MSDOS

    66 #define OPENSSL_SYS_MSDOS

    67 #endif

    68 #endif

    70 #include <stdio.h>

    71 #include <stdlib.h>

    73 #ifndef OPENSSL_SYS_MSDOS

    74 #if !defined(OPENSSL_SYS_VMS) || defined(__DECC)

    75 #ifdef OPENSSL_UNISTD

    76 # include OPENSSL_UNISTD

    77 #else

    78 # include <unistd.h>

    79 #endif

    80 #include <math.h>

    81 #endif

    82 #endif

    83 #include <openssl/des.h>

    85 #ifdef OPENSSL_SYS_MSDOS		/* Visual C++ 2.1 (Windows NT/95) */

    86 #include <stdlib.h>

    87 #include <errno.h>

    88 #include <time.h>

    89 #include <io.h>

    90 #endif

    92 #if defined(__STDC__) || defined(OPENSSL_SYS_VMS) || defined(M_XENIX) || defined(OPENSSL_SYS_MSDOS)

    93 #include <string.h>

    94 #endif

    96 #ifdef OPENSSL_BUILD_SHLIBCRYPTO

    97 # undef OPENSSL_EXTERN

    98 # define OPENSSL_EXTERN OPENSSL_EXPORT

    99 #endif

   101 #define ITERATIONS 16

   102 #define HALF_ITERATIONS 8

   104 /* used in des_read and des_write */

   105 #define MAXWRITE	(1024*16)

   106 #define BSIZE		(MAXWRITE+4)

   108 #define c2l(c,l)	(l =((DES_LONG)(*((c)++)))    , \

   109 			 l|=((DES_LONG)(*((c)++)))<< 8L, \

   110 			 l|=((DES_LONG)(*((c)++)))<<16L, \

   111 			 l|=((DES_LONG)(*((c)++)))<<24L)

   113 /* NOTE - c is not incremented as per c2l */

   114 #define c2ln(c,l1,l2,n)	{ \

   115 			c+=n; \

   116 			l1=l2=0; \

   117 			switch (n) { \

   118 			case 8: l2 =((DES_LONG)(*(--(c))))<<24L; \

   119 			case 7: l2|=((DES_LONG)(*(--(c))))<<16L; \

   120 			case 6: l2|=((DES_LONG)(*(--(c))))<< 8L; \

   121 			case 5: l2|=((DES_LONG)(*(--(c))));     \

   122 			case 4: l1 =((DES_LONG)(*(--(c))))<<24L; \

   123 			case 3: l1|=((DES_LONG)(*(--(c))))<<16L; \

   124 			case 2: l1|=((DES_LONG)(*(--(c))))<< 8L; \

   125 			case 1: l1|=((DES_LONG)(*(--(c))));     \

   126 				} \

   127 			}

   129 #define l2c(l,c)	(*((c)++)=(unsigned char)(((l)     )&0xff), \

   130 			 *((c)++)=(unsigned char)(((l)>> 8L)&0xff), \

   131 			 *((c)++)=(unsigned char)(((l)>>16L)&0xff), \

   132 			 *((c)++)=(unsigned char)(((l)>>24L)&0xff))

   134 /* replacements for htonl and ntohl since I have no idea what to do

   135  * when faced with machines with 8 byte longs. */

   136 #define HDRSIZE 4

   138 #define n2l(c,l)	(l =((DES_LONG)(*((c)++)))<<24L, \

   139 			 l|=((DES_LONG)(*((c)++)))<<16L, \

   140 			 l|=((DES_LONG)(*((c)++)))<< 8L, \

   141 			 l|=((DES_LONG)(*((c)++))))

   143 #define l2n(l,c)	(*((c)++)=(unsigned char)(((l)>>24L)&0xff), \

   144 			 *((c)++)=(unsigned char)(((l)>>16L)&0xff), \

   145 			 *((c)++)=(unsigned char)(((l)>> 8L)&0xff), \

   146 			 *((c)++)=(unsigned char)(((l)     )&0xff))

   148 /* NOTE - c is not incremented as per l2c */

   149 #define l2cn(l1,l2,c,n)	{ \

   150 			c+=n; \

   151 			switch (n) { \

   152 			case 8: *(--(c))=(unsigned char)(((l2)>>24L)&0xff); \

   153 			case 7: *(--(c))=(unsigned char)(((l2)>>16L)&0xff); \

   154 			case 6: *(--(c))=(unsigned char)(((l2)>> 8L)&0xff); \

   155 			case 5: *(--(c))=(unsigned char)(((l2)     )&0xff); \

   156 			case 4: *(--(c))=(unsigned char)(((l1)>>24L)&0xff); \

   157 			case 3: *(--(c))=(unsigned char)(((l1)>>16L)&0xff); \

   158 			case 2: *(--(c))=(unsigned char)(((l1)>> 8L)&0xff); \

   159 			case 1: *(--(c))=(unsigned char)(((l1)     )&0xff); \

   160 				} \

   161 			}

   163 #if (defined(OPENSSL_SYS_WIN32) && defined(_MSC_VER)) || defined(__ICC)

   164 #define	ROTATE(a,n)	(_lrotr(a,n))

   165 #elif defined(__GNUC__) && __GNUC__>=2 && !defined(__STRICT_ANSI__) && !defined(OPENSSL_NO_ASM) && !defined(OPENSSL_NO_INLINE_ASM) && !defined(PEDANTIC)

   166 # if defined(__i386) || defined(__i386__) || defined(__x86_64) || defined(__x86_64__)

   167 #  define ROTATE(a,n)	({ register unsigned int ret;	\

   168 				asm ("rorl %1,%0"	\

   169 					: "=r"(ret)	\

   170 					: "I"(n),"0"(a)	\

   171 					: "cc");	\

   172 			   ret;				\

   173 			})

   174 # endif

   175 #endif

   176 #ifndef ROTATE

   177 #define	ROTATE(a,n)	(((a)>>(n))+((a)<<(32-(n))))

   178 #endif

   180 /* Don't worry about the LOAD_DATA() stuff, that is used by

   181  * fcrypt() to add it's little bit to the front */

   183 #ifdef DES_FCRYPT

   185 #define LOAD_DATA_tmp(R,S,u,t,E0,E1) \

   186 	{ DES_LONG tmp; LOAD_DATA(R,S,u,t,E0,E1,tmp); }

   188 #define LOAD_DATA(R,S,u,t,E0,E1,tmp) \

   189 	t=R^(R>>16L); \

   190 	u=t&E0; t&=E1; \

   191 	tmp=(u<<16); u^=R^s[S  ]; u^=tmp; \

   192 	tmp=(t<<16); t^=R^s[S+1]; t^=tmp

   193 #else

   194 #define LOAD_DATA_tmp(a,b,c,d,e,f) LOAD_DATA(a,b,c,d,e,f,g)

   195 #define LOAD_DATA(R,S,u,t,E0,E1,tmp) \

   196 	u=R^s[S  ]; \

   197 	t=R^s[S+1]

   198 #endif

   200 /* The changes to this macro may help or hinder, depending on the

   201  * compiler and the architecture.  gcc2 always seems to do well :-).

   202  * Inspired by Dana How <how@isl.stanford.edu>

   203  * DO NOT use the alternative version on machines with 8 byte longs.

   204  * It does not seem to work on the Alpha, even when DES_LONG is 4

   205  * bytes, probably an issue of accessing non-word aligned objects :-( */

   206 #ifdef DES_PTR

   208 /* It recently occurred to me that 0^0^0^0^0^0^0 == 0, so there

   209  * is no reason to not xor all the sub items together.  This potentially

   210  * saves a register since things can be xored directly into L */

   212 #if defined(DES_RISC1) || defined(DES_RISC2)

   213 #ifdef DES_RISC1

   214 #define D_ENCRYPT(LL,R,S) { \

   215 	unsigned int u1,u2,u3; \

   216 	LOAD_DATA(R,S,u,t,E0,E1,u1); \

   217 	u2=(int)u>>8L; \

   218 	u1=(int)u&0xfc; \

   219 	u2&=0xfc; \

   220 	t=ROTATE(t,4); \

   221 	u>>=16L; \

   222 	LL^= *(const DES_LONG *)(des_SP      +u1); \

   223 	LL^= *(const DES_LONG *)(des_SP+0x200+u2); \

   224 	u3=(int)(u>>8L); \

   225 	u1=(int)u&0xfc; \

   226 	u3&=0xfc; \

   227 	LL^= *(const DES_LONG *)(des_SP+0x400+u1); \

   228 	LL^= *(const DES_LONG *)(des_SP+0x600+u3); \

   229 	u2=(int)t>>8L; \

   230 	u1=(int)t&0xfc; \

   231 	u2&=0xfc; \

   232 	t>>=16L; \

   233 	LL^= *(const DES_LONG *)(des_SP+0x100+u1); \

   234 	LL^= *(const DES_LONG *)(des_SP+0x300+u2); \

   235 	u3=(int)t>>8L; \

   236 	u1=(int)t&0xfc; \

   237 	u3&=0xfc; \

   238 	LL^= *(const DES_LONG *)(des_SP+0x500+u1); \

   239 	LL^= *(const DES_LONG *)(des_SP+0x700+u3); }

   240 #endif

   241 #ifdef DES_RISC2

   242 #define D_ENCRYPT(LL,R,S) { \

   243 	unsigned int u1,u2,s1,s2; \

   244 	LOAD_DATA(R,S,u,t,E0,E1,u1); \

   245 	u2=(int)u>>8L; \

   246 	u1=(int)u&0xfc; \

   247 	u2&=0xfc; \

   248 	t=ROTATE(t,4); \

   249 	LL^= *(const DES_LONG *)(des_SP      +u1); \

   250 	LL^= *(const DES_LONG *)(des_SP+0x200+u2); \

   251 	s1=(int)(u>>16L); \

   252 	s2=(int)(u>>24L); \

   253 	s1&=0xfc; \

   254 	s2&=0xfc; \

   255 	LL^= *(const DES_LONG *)(des_SP+0x400+s1); \

   256 	LL^= *(const DES_LONG *)(des_SP+0x600+s2); \

   257 	u2=(int)t>>8L; \

   258 	u1=(int)t&0xfc; \

   259 	u2&=0xfc; \

   260 	LL^= *(const DES_LONG *)(des_SP+0x100+u1); \

   261 	LL^= *(const DES_LONG *)(des_SP+0x300+u2); \

   262 	s1=(int)(t>>16L); \

   263 	s2=(int)(t>>24L); \

   264 	s1&=0xfc; \

   265 	s2&=0xfc; \

   266 	LL^= *(const DES_LONG *)(des_SP+0x500+s1); \

   267 	LL^= *(const DES_LONG *)(des_SP+0x700+s2); }

   268 #endif

   269 #else

   270 #define D_ENCRYPT(LL,R,S) { \

   271 	LOAD_DATA_tmp(R,S,u,t,E0,E1); \

   272 	t=ROTATE(t,4); \

   273 	LL^= \

   274 	*(const DES_LONG *)(des_SP      +((u     )&0xfc))^ \

   275 	*(const DES_LONG *)(des_SP+0x200+((u>> 8L)&0xfc))^ \

   276 	*(const DES_LONG *)(des_SP+0x400+((u>>16L)&0xfc))^ \

   277 	*(const DES_LONG *)(des_SP+0x600+((u>>24L)&0xfc))^ \

   278 	*(const DES_LONG *)(des_SP+0x100+((t     )&0xfc))^ \

   279 	*(const DES_LONG *)(des_SP+0x300+((t>> 8L)&0xfc))^ \

   280 	*(const DES_LONG *)(des_SP+0x500+((t>>16L)&0xfc))^ \

   281 	*(const DES_LONG *)(des_SP+0x700+((t>>24L)&0xfc)); }

   282 #endif

   284 #else /* original version */

   286 #if defined(DES_RISC1) || defined(DES_RISC2)

   287 #ifdef DES_RISC1

   288 #define D_ENCRYPT(LL,R,S) {\

   289 	unsigned int u1,u2,u3; \

   290 	LOAD_DATA(R,S,u,t,E0,E1,u1); \

   291 	u>>=2L; \

   292 	t=ROTATE(t,6); \

   293 	u2=(int)u>>8L; \

   294 	u1=(int)u&0x3f; \

   295 	u2&=0x3f; \

   296 	u>>=16L; \

   297 	LL^=DES_SPtrans[0][u1]; \

   298 	LL^=DES_SPtrans[2][u2]; \

   299 	u3=(int)u>>8L; \

   300 	u1=(int)u&0x3f; \

   301 	u3&=0x3f; \

   302 	LL^=DES_SPtrans[4][u1]; \

   303 	LL^=DES_SPtrans[6][u3]; \

   304 	u2=(int)t>>8L; \

   305 	u1=(int)t&0x3f; \

   306 	u2&=0x3f; \

   307 	t>>=16L; \

   308 	LL^=DES_SPtrans[1][u1]; \

   309 	LL^=DES_SPtrans[3][u2]; \

   310 	u3=(int)t>>8L; \

   311 	u1=(int)t&0x3f; \

   312 	u3&=0x3f; \

   313 	LL^=DES_SPtrans[5][u1]; \

   314 	LL^=DES_SPtrans[7][u3]; }

   315 #endif

   316 #ifdef DES_RISC2

   317 #define D_ENCRYPT(LL,R,S) {\

   318 	unsigned int u1,u2,s1,s2; \

   319 	LOAD_DATA(R,S,u,t,E0,E1,u1); \

   320 	u>>=2L; \

   321 	t=ROTATE(t,6); \

   322 	u2=(int)u>>8L; \

   323 	u1=(int)u&0x3f; \

   324 	u2&=0x3f; \

   325 	LL^=DES_SPtrans[0][u1]; \

   326 	LL^=DES_SPtrans[2][u2]; \

   327 	s1=(int)u>>16L; \

   328 	s2=(int)u>>24L; \

   329 	s1&=0x3f; \

   330 	s2&=0x3f; \

   331 	LL^=DES_SPtrans[4][s1]; \

   332 	LL^=DES_SPtrans[6][s2]; \

   333 	u2=(int)t>>8L; \

   334 	u1=(int)t&0x3f; \

   335 	u2&=0x3f; \

   336 	LL^=DES_SPtrans[1][u1]; \

   337 	LL^=DES_SPtrans[3][u2]; \

   338 	s1=(int)t>>16; \

   339 	s2=(int)t>>24L; \

   340 	s1&=0x3f; \

   341 	s2&=0x3f; \

   342 	LL^=DES_SPtrans[5][s1]; \

   343 	LL^=DES_SPtrans[7][s2]; }

   344 #endif

   346 #else

   348 #define D_ENCRYPT(LL,R,S) {\

   349 	LOAD_DATA_tmp(R,S,u,t,E0,E1); \

   350 	t=ROTATE(t,4); \

   351 	LL^=\

   352 		DES_SPtrans[0][(u>> 2L)&0x3f]^ \

   353 		DES_SPtrans[2][(u>>10L)&0x3f]^ \

   354 		DES_SPtrans[4][(u>>18L)&0x3f]^ \

   355 		DES_SPtrans[6][(u>>26L)&0x3f]^ \

   356 		DES_SPtrans[1][(t>> 2L)&0x3f]^ \

   357 		DES_SPtrans[3][(t>>10L)&0x3f]^ \

   358 		DES_SPtrans[5][(t>>18L)&0x3f]^ \

   359 		DES_SPtrans[7][(t>>26L)&0x3f]; }

   360 #endif

   361 #endif

   363 	/* IP and FP

   364 	 * The problem is more of a geometric problem that random bit fiddling.

   365 	 0  1  2  3  4  5  6  7      62 54 46 38 30 22 14  6

   366 	 8  9 10 11 12 13 14 15      60 52 44 36 28 20 12  4

   367 	16 17 18 19 20 21 22 23      58 50 42 34 26 18 10  2

   368 	24 25 26 27 28 29 30 31  to  56 48 40 32 24 16  8  0

   370 	32 33 34 35 36 37 38 39      63 55 47 39 31 23 15  7

   371 	40 41 42 43 44 45 46 47      61 53 45 37 29 21 13  5

   372 	48 49 50 51 52 53 54 55      59 51 43 35 27 19 11  3

   373 	56 57 58 59 60 61 62 63      57 49 41 33 25 17  9  1

   375 	The output has been subject to swaps of the form

   376 	0 1 -> 3 1 but the odd and even bits have been put into

   377 	2 3    2 0

   378 	different words.  The main trick is to remember that

   379 	t=((l>>size)^r)&(mask);

   380 	r^=t;

   381 	l^=(t<<size);

   382 	can be used to swap and move bits between words.

   384 	So l =  0  1  2  3  r = 16 17 18 19

   385 	        4  5  6  7      20 21 22 23

   386 	        8  9 10 11      24 25 26 27

   387 	       12 13 14 15      28 29 30 31

   388 	becomes (for size == 2 and mask == 0x3333)

   389 	   t =   2^16  3^17 -- --   l =  0  1 16 17  r =  2  3 18 19

   390 		 6^20  7^21 -- --        4  5 20 21       6  7 22 23

   391 		10^24 11^25 -- --        8  9 24 25      10 11 24 25

   392 		14^28 15^29 -- --       12 13 28 29      14 15 28 29

   394 	Thanks for hints from Richard Outerbridge - he told me IP&FP

   395 	could be done in 15 xor, 10 shifts and 5 ands.

   396 	When I finally started to think of the problem in 2D

   397 	I first got ~42 operations without xors.  When I remembered

   398 	how to use xors :-) I got it to its final state.

   399 	*/

   400 #define PERM_OP(a,b,t,n,m) ((t)=((((a)>>(n))^(b))&(m)),\

   401 	(b)^=(t),\

   402 	(a)^=((t)<<(n)))

   404 #define IP(l,r) \

   405 	{ \

   406 	register DES_LONG tt; \

   407 	PERM_OP(r,l,tt, 4,0x0f0f0f0fL); \

   408 	PERM_OP(l,r,tt,16,0x0000ffffL); \

   409 	PERM_OP(r,l,tt, 2,0x33333333L); \

   410 	PERM_OP(l,r,tt, 8,0x00ff00ffL); \

   411 	PERM_OP(r,l,tt, 1,0x55555555L); \

   412 	}

   414 #define FP(l,r) \

   415 	{ \

   416 	register DES_LONG tt; \

   417 	PERM_OP(l,r,tt, 1,0x55555555L); \

   418 	PERM_OP(r,l,tt, 8,0x00ff00ffL); \

   419 	PERM_OP(l,r,tt, 2,0x33333333L); \

   420 	PERM_OP(r,l,tt,16,0x0000ffffL); \

   421 	PERM_OP(l,r,tt, 4,0x0f0f0f0fL); \

   422 	}

   424 extern const DES_LONG DES_SPtrans[8][64];

   426 IMPORT_C void fcrypt_body(DES_LONG *out,DES_key_schedule *ks,

   427 		 DES_LONG Eswap0, DES_LONG Eswap1);

   428 #endif

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--