Return to bf_locl.h CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / plugins / blowfish |
1.1 misho 1: /* crypto/bf/bf_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 adhered 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 routines 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 publicly 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: #ifndef HEADER_BF_LOCL_H 60: #define HEADER_BF_LOCL_H 61: 62: #undef c2l 63: #define c2l(c,l) (l =((unsigned long)(*((c)++))) , \ 64: l|=((unsigned long)(*((c)++)))<< 8L, \ 65: l|=((unsigned long)(*((c)++)))<<16L, \ 66: l|=((unsigned long)(*((c)++)))<<24L) 67: 68: /* NOTE - c is not incremented as per c2l */ 69: #undef c2ln 70: #define c2ln(c,l1,l2,n) { \ 71: c+=n; \ 72: l1=l2=0; \ 73: switch (n) { \ 74: case 8: l2 =((unsigned long)(*(--(c))))<<24L; \ 75: case 7: l2|=((unsigned long)(*(--(c))))<<16L; \ 76: case 6: l2|=((unsigned long)(*(--(c))))<< 8L; \ 77: case 5: l2|=((unsigned long)(*(--(c)))); \ 78: case 4: l1 =((unsigned long)(*(--(c))))<<24L; \ 79: case 3: l1|=((unsigned long)(*(--(c))))<<16L; \ 80: case 2: l1|=((unsigned long)(*(--(c))))<< 8L; \ 81: case 1: l1|=((unsigned long)(*(--(c)))); \ 82: } \ 83: } 84: 85: #undef l2c 86: #define l2c(l,c) (*((c)++)=(unsigned char)(((l) )&0xff), \ 87: *((c)++)=(unsigned char)(((l)>> 8L)&0xff), \ 88: *((c)++)=(unsigned char)(((l)>>16L)&0xff), \ 89: *((c)++)=(unsigned char)(((l)>>24L)&0xff)) 90: 91: /* NOTE - c is not incremented as per l2c */ 92: #undef l2cn 93: #define l2cn(l1,l2,c,n) { \ 94: c+=n; \ 95: switch (n) { \ 96: case 8: *(--(c))=(unsigned char)(((l2)>>24L)&0xff); \ 97: case 7: *(--(c))=(unsigned char)(((l2)>>16L)&0xff); \ 98: case 6: *(--(c))=(unsigned char)(((l2)>> 8L)&0xff); \ 99: case 5: *(--(c))=(unsigned char)(((l2) )&0xff); \ 100: case 4: *(--(c))=(unsigned char)(((l1)>>24L)&0xff); \ 101: case 3: *(--(c))=(unsigned char)(((l1)>>16L)&0xff); \ 102: case 2: *(--(c))=(unsigned char)(((l1)>> 8L)&0xff); \ 103: case 1: *(--(c))=(unsigned char)(((l1) )&0xff); \ 104: } \ 105: } 106: 107: /* NOTE - c is not incremented as per n2l */ 108: #define n2ln(c,l1,l2,n) { \ 109: c+=n; \ 110: l1=l2=0; \ 111: switch (n) { \ 112: case 8: l2 =((unsigned long)(*(--(c)))) ; \ 113: case 7: l2|=((unsigned long)(*(--(c))))<< 8; \ 114: case 6: l2|=((unsigned long)(*(--(c))))<<16; \ 115: case 5: l2|=((unsigned long)(*(--(c))))<<24; \ 116: case 4: l1 =((unsigned long)(*(--(c)))) ; \ 117: case 3: l1|=((unsigned long)(*(--(c))))<< 8; \ 118: case 2: l1|=((unsigned long)(*(--(c))))<<16; \ 119: case 1: l1|=((unsigned long)(*(--(c))))<<24; \ 120: } \ 121: } 122: 123: /* NOTE - c is not incremented as per l2n */ 124: #define l2nn(l1,l2,c,n) { \ 125: c+=n; \ 126: switch (n) { \ 127: case 8: *(--(c))=(unsigned char)(((l2) )&0xff); \ 128: case 7: *(--(c))=(unsigned char)(((l2)>> 8)&0xff); \ 129: case 6: *(--(c))=(unsigned char)(((l2)>>16)&0xff); \ 130: case 5: *(--(c))=(unsigned char)(((l2)>>24)&0xff); \ 131: case 4: *(--(c))=(unsigned char)(((l1) )&0xff); \ 132: case 3: *(--(c))=(unsigned char)(((l1)>> 8)&0xff); \ 133: case 2: *(--(c))=(unsigned char)(((l1)>>16)&0xff); \ 134: case 1: *(--(c))=(unsigned char)(((l1)>>24)&0xff); \ 135: } \ 136: } 137: 138: #undef n2l 139: #define n2l(c,l) (l =((unsigned long)(*((c)++)))<<24L, \ 140: l|=((unsigned long)(*((c)++)))<<16L, \ 141: l|=((unsigned long)(*((c)++)))<< 8L, \ 142: l|=((unsigned long)(*((c)++)))) 143: 144: #undef l2n 145: #define l2n(l,c) (*((c)++)=(unsigned char)(((l)>>24L)&0xff), \ 146: *((c)++)=(unsigned char)(((l)>>16L)&0xff), \ 147: *((c)++)=(unsigned char)(((l)>> 8L)&0xff), \ 148: *((c)++)=(unsigned char)(((l) )&0xff)) 149: 150: /* This is actually a big endian algorithm, the most significant byte 151: * is used to lookup array 0 */ 152: 153: #if defined(BF_PTR2) 154: 155: /* 156: * This is basically a special Intel version. Point is that Intel 157: * doesn't have many registers, but offers a reach choice of addressing 158: * modes. So we spare some registers by directly traversing BF_KEY 159: * structure and hiring the most decorated addressing mode. The code 160: * generated by EGCS is *perfectly* competitive with assembler 161: * implementation! 162: */ 163: #define BF_ENC(LL,R,KEY,Pi) (\ 164: LL^=KEY[Pi], \ 165: t= KEY[BF_ROUNDS+2 + 0 + ((R>>24)&0xFF)], \ 166: t+= KEY[BF_ROUNDS+2 + 256 + ((R>>16)&0xFF)], \ 167: t^= KEY[BF_ROUNDS+2 + 512 + ((R>>8 )&0xFF)], \ 168: t+= KEY[BF_ROUNDS+2 + 768 + ((R )&0xFF)], \ 169: LL^=t \ 170: ) 171: 172: #elif defined(BF_PTR) 173: 174: #ifndef BF_LONG_LOG2 175: #define BF_LONG_LOG2 2 /* default to BF_LONG being 32 bits */ 176: #endif 177: #define BF_M (0xFF<<BF_LONG_LOG2) 178: #define BF_0 (24-BF_LONG_LOG2) 179: #define BF_1 (16-BF_LONG_LOG2) 180: #define BF_2 ( 8-BF_LONG_LOG2) 181: #define BF_3 BF_LONG_LOG2 /* left shift */ 182: 183: /* 184: * This is normally very good on RISC platforms where normally you 185: * have to explicitly "multiply" array index by sizeof(BF_LONG) 186: * in order to calculate the effective address. This implementation 187: * excuses CPU from this extra work. Power[PC] uses should have most 188: * fun as (R>>BF_i)&BF_M gets folded into a single instruction, namely 189: * rlwinm. So let'em double-check if their compiler does it. 190: */ 191: 192: #define BF_ENC(LL,R,S,P) ( \ 193: LL^=P, \ 194: LL^= (((*(BF_LONG *)((unsigned char *)&(S[ 0])+((R>>BF_0)&BF_M))+ \ 195: *(BF_LONG *)((unsigned char *)&(S[256])+((R>>BF_1)&BF_M)))^ \ 196: *(BF_LONG *)((unsigned char *)&(S[512])+((R>>BF_2)&BF_M)))+ \ 197: *(BF_LONG *)((unsigned char *)&(S[768])+((R<<BF_3)&BF_M))) \ 198: ) 199: #else 200: 201: /* 202: * This is a *generic* version. Seem to perform best on platforms that 203: * offer explicit support for extraction of 8-bit nibbles preferably 204: * complemented with "multiplying" of array index by sizeof(BF_LONG). 205: * For the moment of this writing the list comprises Alpha CPU featuring 206: * extbl and s[48]addq instructions. 207: */ 208: 209: #define BF_ENC(LL,R,S,P) ( \ 210: LL^=P, \ 211: LL^=((( S[ ((int)(R>>24)&0xff)] + \ 212: S[0x0100+((int)(R>>16)&0xff)])^ \ 213: S[0x0200+((int)(R>> 8)&0xff)])+ \ 214: S[0x0300+((int)(R )&0xff)])&0xffffffffL \ 215: ) 216: #endif 217: 218: #endif