diff options
Diffstat (limited to 'contrib/pgcrypto')
| -rw-r--r-- | contrib/pgcrypto/blf.c | 743 | ||||
| -rw-r--r-- | contrib/pgcrypto/blf.h | 56 | ||||
| -rw-r--r-- | contrib/pgcrypto/crypt-blowfish.c | 175 | ||||
| -rw-r--r-- | contrib/pgcrypto/crypt-des.c | 67 | ||||
| -rw-r--r-- | contrib/pgcrypto/crypt-gensalt.c | 103 | ||||
| -rw-r--r-- | contrib/pgcrypto/crypt-md5.c | 19 | ||||
| -rw-r--r-- | contrib/pgcrypto/internal.c | 280 | ||||
| -rw-r--r-- | contrib/pgcrypto/md5.c | 14 | ||||
| -rw-r--r-- | contrib/pgcrypto/mhash.c | 125 | ||||
| -rw-r--r-- | contrib/pgcrypto/misc.c | 2 | ||||
| -rw-r--r-- | contrib/pgcrypto/openssl.c | 242 | ||||
| -rw-r--r-- | contrib/pgcrypto/pgcrypto.c | 107 | ||||
| -rw-r--r-- | contrib/pgcrypto/pgcrypto.h | 4 | ||||
| -rw-r--r-- | contrib/pgcrypto/px-crypt.c | 85 | ||||
| -rw-r--r-- | contrib/pgcrypto/px-crypt.h | 18 | ||||
| -rw-r--r-- | contrib/pgcrypto/px-hmac.c | 8 | ||||
| -rw-r--r-- | contrib/pgcrypto/px.c | 164 | ||||
| -rw-r--r-- | contrib/pgcrypto/px.h | 150 | ||||
| -rw-r--r-- | contrib/pgcrypto/random.c | 60 | ||||
| -rw-r--r-- | contrib/pgcrypto/rijndael.c | 729 | ||||
| -rw-r--r-- | contrib/pgcrypto/rijndael.h | 78 | ||||
| -rw-r--r-- | contrib/pgcrypto/sha1.c | 12 | ||||
| -rw-r--r-- | contrib/pgcrypto/sha1.h | 3 |
23 files changed, 1801 insertions, 1443 deletions
diff --git a/contrib/pgcrypto/blf.c b/contrib/pgcrypto/blf.c index 28d44d9de9f..aae5b6033a4 100644 --- a/contrib/pgcrypto/blf.c +++ b/contrib/pgcrypto/blf.c @@ -11,15 +11,15 @@ * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. + * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by Niels Provos. + * must display the following acknowledgement: + * This product includes software developed by Niels Provos. * 4. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. + * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES @@ -46,338 +46,354 @@ #undef inline #ifdef __GNUC__ #define inline __inline -#else /* !__GNUC__ */ +#else /* !__GNUC__ */ #define inline -#endif /* !__GNUC__ */ +#endif /* !__GNUC__ */ /* Function for Feistel Networks */ -#define F(s, x) ((((s)[ (((x)>>24)&0xFF)] \ +#define F(s, x) ((((s)[ (((x)>>24)&0xFF)] \ + (s)[0x100 + (((x)>>16)&0xFF)]) \ ^ (s)[0x200 + (((x)>> 8)&0xFF)]) \ - + (s)[0x300 + ( (x) &0xFF)]) + + (s)[0x300 + ( (x) &0xFF)]) #define BLFRND(s,p,i,j,n) (i ^= F(s,j) ^ (p)[n]) void -Blowfish_encipher(blf_ctx *c, uint32 *x) +Blowfish_encipher(blf_ctx * c, uint32 *x) { - uint32 Xl; - uint32 Xr; - uint32 *s = c->S[0]; - uint32 *p = c->P; + uint32 Xl; + uint32 Xr; + uint32 *s = c->S[0]; + uint32 *p = c->P; Xl = x[0]; Xr = x[1]; Xl ^= p[0]; - BLFRND(s, p, Xr, Xl, 1); BLFRND(s, p, Xl, Xr, 2); - BLFRND(s, p, Xr, Xl, 3); BLFRND(s, p, Xl, Xr, 4); - BLFRND(s, p, Xr, Xl, 5); BLFRND(s, p, Xl, Xr, 6); - BLFRND(s, p, Xr, Xl, 7); BLFRND(s, p, Xl, Xr, 8); - BLFRND(s, p, Xr, Xl, 9); BLFRND(s, p, Xl, Xr, 10); - BLFRND(s, p, Xr, Xl, 11); BLFRND(s, p, Xl, Xr, 12); - BLFRND(s, p, Xr, Xl, 13); BLFRND(s, p, Xl, Xr, 14); - BLFRND(s, p, Xr, Xl, 15); BLFRND(s, p, Xl, Xr, 16); + BLFRND(s, p, Xr, Xl, 1); + BLFRND(s, p, Xl, Xr, 2); + BLFRND(s, p, Xr, Xl, 3); + BLFRND(s, p, Xl, Xr, 4); + BLFRND(s, p, Xr, Xl, 5); + BLFRND(s, p, Xl, Xr, 6); + BLFRND(s, p, Xr, Xl, 7); + BLFRND(s, p, Xl, Xr, 8); + BLFRND(s, p, Xr, Xl, 9); + BLFRND(s, p, Xl, Xr, 10); + BLFRND(s, p, Xr, Xl, 11); + BLFRND(s, p, Xl, Xr, 12); + BLFRND(s, p, Xr, Xl, 13); + BLFRND(s, p, Xl, Xr, 14); + BLFRND(s, p, Xr, Xl, 15); + BLFRND(s, p, Xl, Xr, 16); x[0] = Xr ^ p[17]; x[1] = Xl; } void -Blowfish_decipher(blf_ctx *c, uint32 *x) +Blowfish_decipher(blf_ctx * c, uint32 *x) { - uint32 Xl; - uint32 Xr; - uint32 *s = c->S[0]; - uint32 *p = c->P; + uint32 Xl; + uint32 Xr; + uint32 *s = c->S[0]; + uint32 *p = c->P; Xl = x[0]; Xr = x[1]; Xl ^= p[17]; - BLFRND(s, p, Xr, Xl, 16); BLFRND(s, p, Xl, Xr, 15); - BLFRND(s, p, Xr, Xl, 14); BLFRND(s, p, Xl, Xr, 13); - BLFRND(s, p, Xr, Xl, 12); BLFRND(s, p, Xl, Xr, 11); - BLFRND(s, p, Xr, Xl, 10); BLFRND(s, p, Xl, Xr, 9); - BLFRND(s, p, Xr, Xl, 8); BLFRND(s, p, Xl, Xr, 7); - BLFRND(s, p, Xr, Xl, 6); BLFRND(s, p, Xl, Xr, 5); - BLFRND(s, p, Xr, Xl, 4); BLFRND(s, p, Xl, Xr, 3); - BLFRND(s, p, Xr, Xl, 2); BLFRND(s, p, Xl, Xr, 1); + BLFRND(s, p, Xr, Xl, 16); + BLFRND(s, p, Xl, Xr, 15); + BLFRND(s, p, Xr, Xl, 14); + BLFRND(s, p, Xl, Xr, 13); + BLFRND(s, p, Xr, Xl, 12); + BLFRND(s, p, Xl, Xr, 11); + BLFRND(s, p, Xr, Xl, 10); + BLFRND(s, p, Xl, Xr, 9); + BLFRND(s, p, Xr, Xl, 8); + BLFRND(s, p, Xl, Xr, 7); + BLFRND(s, p, Xr, Xl, 6); + BLFRND(s, p, Xl, Xr, 5); + BLFRND(s, p, Xr, Xl, 4); + BLFRND(s, p, Xl, Xr, 3); + BLFRND(s, p, Xr, Xl, 2); + BLFRND(s, p, Xl, Xr, 1); x[0] = Xr ^ p[0]; x[1] = Xl; } void -Blowfish_initstate(blf_ctx *c) +Blowfish_initstate(blf_ctx * c) { /* P-box and S-box tables initialized with digits of Pi */ const blf_ctx initstate = - { { - { - 0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7, - 0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99, - 0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16, - 0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e, - 0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee, - 0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013, - 0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef, - 0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e, - 0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60, - 0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440, - 0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce, - 0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a, - 0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e, - 0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677, - 0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193, - 0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032, - 0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88, - 0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239, - 0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e, - 0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0, - 0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3, - 0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98, - 0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88, - 0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe, - 0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6, - 0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d, - 0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b, - 0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7, - 0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba, - 0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463, - 0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f, - 0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09, - 0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3, - 0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb, - 0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279, - 0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8, - 0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab, - 0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82, - 0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db, - 0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573, - 0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0, - 0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b, - 0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790, - 0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8, - 0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4, - 0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0, - 0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7, - 0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c, - 0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad, - 0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1, - 0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299, - 0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9, - 0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477, - 0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf, - 0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49, - 0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af, - 0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa, - 0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5, - 0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41, - 0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915, - 0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400, - 0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915, - 0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664, - 0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a}, - { - 0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623, - 0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266, - 0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1, - 0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e, - 0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6, - 0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1, - 0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e, - 0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1, - 0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737, - 0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8, - 0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff, - 0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd, - 0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701, - 0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7, - 0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41, - 0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331, - 0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf, - 0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af, - 0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e, - 0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87, - 0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c, - 0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2, - 0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16, - 0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd, - 0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b, - 0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509, - 0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e, - 0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3, - 0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f, - 0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a, - 0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4, - 0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960, - 0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66, - 0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28, - 0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802, - 0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84, - 0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510, - 0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf, - 0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14, - 0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e, - 0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50, - 0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7, - 0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8, - 0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281, - 0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99, - 0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696, - 0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128, - 0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73, - 0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0, - 0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0, - 0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105, - 0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250, - 0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3, - 0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285, - 0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00, - 0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061, - 0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb, - 0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e, - 0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735, - 0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc, - 0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9, - 0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340, - 0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20, - 0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7}, - { - 0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934, - 0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068, - 0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af, - 0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840, - 0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45, - 0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504, - 0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a, - 0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb, - 0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee, - 0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6, - 0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42, - 0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b, - 0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2, - 0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb, - 0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527, - 0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b, - 0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33, - 0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c, - 0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3, - 0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc, - 0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17, - 0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564, - 0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b, - 0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115, - 0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922, - 0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728, - 0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0, - 0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e, - 0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37, - 0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d, - 0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804, - 0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b, - 0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3, - 0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb, - 0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d, - 0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c, - 0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350, - 0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9, - 0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a, - 0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe, - 0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d, - 0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc, - 0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f, - 0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61, - 0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2, - 0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9, - 0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2, - 0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c, - 0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e, - 0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633, - 0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10, - 0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169, - 0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52, - 0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027, - 0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5, - 0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62, - 0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634, - 0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76, - 0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24, - 0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc, - 0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4, - 0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c, - 0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837, - 0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0}, - { - 0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b, - 0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe, - 0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b, - 0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4, - 0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8, - 0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6, - 0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304, - 0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22, - 0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4, - 0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6, - 0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9, - 0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59, - 0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593, - 0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51, - 0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28, - 0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c, - 0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b, - 0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28, - 0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c, - 0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd, - 0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a, - 0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319, - 0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb, - 0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f, - 0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991, - 0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32, - 0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680, - 0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166, - 0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae, - 0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb, - 0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5, - 0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47, - 0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370, - 0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d, - 0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84, - 0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048, - 0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8, - 0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd, - 0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9, - 0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7, - 0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38, - 0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f, - 0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c, - 0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525, - 0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1, - 0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442, - 0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964, - 0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e, - 0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8, - 0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d, - 0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f, - 0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299, - 0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02, - 0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc, - 0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614, - 0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a, - 0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6, - 0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b, - 0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0, - 0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060, - 0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e, - 0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9, - 0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f, - 0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6} + {{ + { + 0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7, + 0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99, + 0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16, + 0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e, + 0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee, + 0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013, + 0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef, + 0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e, + 0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60, + 0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440, + 0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce, + 0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a, + 0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e, + 0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677, + 0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193, + 0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032, + 0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88, + 0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239, + 0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e, + 0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0, + 0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3, + 0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98, + 0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88, + 0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe, + 0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6, + 0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d, + 0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b, + 0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7, + 0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba, + 0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463, + 0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f, + 0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09, + 0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3, + 0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb, + 0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279, + 0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8, + 0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab, + 0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82, + 0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db, + 0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573, + 0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0, + 0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b, + 0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790, + 0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8, + 0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4, + 0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0, + 0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7, + 0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c, + 0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad, + 0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1, + 0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299, + 0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9, + 0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477, + 0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf, + 0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49, + 0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af, + 0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa, + 0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5, + 0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41, + 0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915, + 0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400, + 0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915, + 0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664, + 0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a}, + { + 0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623, + 0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266, + 0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1, + 0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e, + 0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6, + 0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1, + 0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e, + 0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1, + 0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737, + 0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8, + 0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff, + 0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd, + 0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701, + 0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7, + 0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41, + 0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331, + 0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf, + 0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af, + 0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e, + 0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87, + 0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c, + 0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2, + 0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16, + 0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd, + 0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b, + 0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509, + 0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e, + 0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3, + 0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f, + 0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a, + 0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4, + 0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960, + 0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66, + 0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28, + 0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802, + 0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84, + 0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510, + 0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf, + 0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14, + 0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e, + 0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50, + 0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7, + 0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8, + 0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281, + 0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99, + 0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696, + 0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128, + 0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73, + 0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0, + 0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0, + 0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105, + 0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250, + 0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3, + 0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285, + 0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00, + 0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061, + 0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb, + 0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e, + 0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735, + 0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc, + 0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9, + 0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340, + 0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20, + 0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7}, + { + 0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934, + 0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068, + 0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af, + 0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840, + 0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45, + 0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504, + 0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a, + 0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb, + 0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee, + 0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6, + 0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42, + 0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b, + 0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2, + 0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb, + 0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527, + 0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b, + 0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33, + 0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c, + 0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3, + 0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc, + 0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17, + 0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564, + 0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b, + 0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115, + 0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922, + 0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728, + 0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0, + 0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e, + 0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37, + 0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d, + 0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804, + 0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b, + 0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3, + 0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb, + 0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d, + 0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c, + 0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350, + 0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9, + 0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a, + 0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe, + 0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d, + 0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc, + 0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f, + 0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61, + 0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2, + 0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9, + 0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2, + 0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c, + 0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e, + 0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633, + 0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10, + 0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169, + 0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52, + 0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027, + 0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5, + 0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62, + 0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634, + 0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76, + 0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24, + 0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc, + 0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4, + 0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c, + 0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837, + 0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0}, + { + 0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b, + 0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe, + 0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b, + 0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4, + 0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8, + 0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6, + 0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304, + 0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22, + 0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4, + 0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6, + 0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9, + 0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59, + 0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593, + 0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51, + 0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28, + 0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c, + 0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b, + 0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28, + 0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c, + 0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd, + 0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a, + 0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319, + 0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb, + 0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f, + 0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991, + 0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32, + 0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680, + 0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166, + 0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae, + 0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb, + 0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5, + 0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47, + 0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370, + 0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d, + 0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84, + 0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048, + 0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8, + 0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd, + 0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9, + 0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7, + 0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38, + 0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f, + 0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c, + 0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525, + 0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1, + 0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442, + 0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964, + 0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e, + 0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8, + 0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d, + 0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f, + 0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299, + 0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02, + 0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc, + 0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614, + 0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a, + 0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6, + 0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b, + 0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0, + 0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060, + 0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e, + 0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9, + 0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f, + 0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6} }, { 0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, @@ -385,7 +401,7 @@ Blowfish_initstate(blf_ctx *c) 0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c, 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917, 0x9216d5d9, 0x8979fb1b - } }; + }}; *c = initstate; @@ -394,14 +410,15 @@ Blowfish_initstate(blf_ctx *c) uint32 Blowfish_stream2word(const uint8 *data, uint16 databytes, uint16 *current) { - uint8 i; - uint16 j; - uint32 temp; + uint8 i; + uint16 j; + uint32 temp; temp = 0x00000000; j = *current; - for (i = 0; i < 4; i++, j++) { + for (i = 0; i < 4; i++, j++) + { if (j >= databytes) j = 0; temp = (temp << 8) | data[j]; @@ -412,16 +429,17 @@ Blowfish_stream2word(const uint8 *data, uint16 databytes, uint16 *current) } void -Blowfish_expand0state(blf_ctx *c, const uint8 *key, uint16 keybytes) +Blowfish_expand0state(blf_ctx * c, const uint8 *key, uint16 keybytes) { - uint16 i; - uint16 j; - uint16 k; - uint32 temp; - uint32 data[2]; + uint16 i; + uint16 j; + uint16 k; + uint32 temp; + uint32 data[2]; j = 0; - for (i = 0; i < BLF_N + 2; i++) { + for (i = 0; i < BLF_N + 2; i++) + { /* Extract 4 int8 to 1 int32 from keystream */ temp = Blowfish_stream2word(key, keybytes, &j); c->P[i] = c->P[i] ^ temp; @@ -430,15 +448,18 @@ Blowfish_expand0state(blf_ctx *c, const uint8 *key, uint16 keybytes) j = 0; data[0] = 0x00000000; data[1] = 0x00000000; - for (i = 0; i < BLF_N + 2; i += 2) { + for (i = 0; i < BLF_N + 2; i += 2) + { Blowfish_encipher(c, data); c->P[i] = data[0]; c->P[i + 1] = data[1]; } - for (i = 0; i < 4; i++) { - for (k = 0; k < 256; k += 2) { + for (i = 0; i < 4; i++) + { + for (k = 0; k < 256; k += 2) + { Blowfish_encipher(c, data); c->S[i][k] = data[0]; @@ -449,17 +470,18 @@ Blowfish_expand0state(blf_ctx *c, const uint8 *key, uint16 keybytes) void -Blowfish_expandstate(blf_ctx *c, const uint8 *data, uint16 databytes, - const uint8 *key, uint16 keybytes) +Blowfish_expandstate(blf_ctx * c, const uint8 *data, uint16 databytes, + const uint8 *key, uint16 keybytes) { - uint16 i; - uint16 j; - uint16 k; - uint32 temp; - uint32 d[2]; + uint16 i; + uint16 j; + uint16 k; + uint32 temp; + uint32 d[2]; j = 0; - for (i = 0; i < BLF_N + 2; i++) { + for (i = 0; i < BLF_N + 2; i++) + { /* Extract 4 int8 to 1 int32 from keystream */ temp = Blowfish_stream2word(key, keybytes, &j); c->P[i] = c->P[i] ^ temp; @@ -468,7 +490,8 @@ Blowfish_expandstate(blf_ctx *c, const uint8 *data, uint16 databytes, j = 0; d[0] = 0x00000000; d[1] = 0x00000000; - for (i = 0; i < BLF_N + 2; i += 2) { + for (i = 0; i < BLF_N + 2; i += 2) + { d[0] ^= Blowfish_stream2word(data, databytes, &j); d[1] ^= Blowfish_stream2word(data, databytes, &j); Blowfish_encipher(c, d); @@ -477,9 +500,11 @@ Blowfish_expandstate(blf_ctx *c, const uint8 *data, uint16 databytes, c->P[i + 1] = d[1]; } - for (i = 0; i < 4; i++) { - for (k = 0; k < 256; k += 2) { - d[0]^= Blowfish_stream2word(data, databytes, &j); + for (i = 0; i < 4; i++) + { + for (k = 0; k < 256; k += 2) + { + d[0] ^= Blowfish_stream2word(data, databytes, &j); d[1] ^= Blowfish_stream2word(data, databytes, &j); Blowfish_encipher(c, d); @@ -491,7 +516,7 @@ Blowfish_expandstate(blf_ctx *c, const uint8 *data, uint16 databytes, } void -blf_key(blf_ctx *c, const uint8 *k, uint16 len) +blf_key(blf_ctx * c, const uint8 *k, uint16 len) { /* Initalize S-boxes and subkeys with Pi */ Blowfish_initstate(c); @@ -501,38 +526,43 @@ blf_key(blf_ctx *c, const uint8 *k, uint16 len) } void -blf_enc(blf_ctx *c, uint32 *data, uint16 blocks) +blf_enc(blf_ctx * c, uint32 *data, uint16 blocks) { - uint32 *d; - uint16 i; + uint32 *d; + uint16 i; d = data; - for (i = 0; i < blocks; i++) { + for (i = 0; i < blocks; i++) + { Blowfish_encipher(c, d); d += 2; } } void -blf_dec(blf_ctx *c, uint32 *data, uint16 blocks) +blf_dec(blf_ctx * c, uint32 *data, uint16 blocks) { - uint32 *d; - uint16 i; + uint32 *d; + uint16 i; d = data; - for (i = 0; i < blocks; i++) { + for (i = 0; i < blocks; i++) + { Blowfish_decipher(c, d); d += 2; } } void -blf_ecb_encrypt(blf_ctx *c, uint8 *data, uint32 len) +blf_ecb_encrypt(blf_ctx * c, uint8 *data, uint32 len) { - uint32 l, r, d[2]; - uint32 i; + uint32 l, + r, + d[2]; + uint32 i; - for (i = 0; i < len; i += 8) { + for (i = 0; i < len; i += 8) + { l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]; r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]; d[0] = l; @@ -553,12 +583,15 @@ blf_ecb_encrypt(blf_ctx *c, uint8 *data, uint32 len) } void -blf_ecb_decrypt(blf_ctx *c, uint8 *data, uint32 len) +blf_ecb_decrypt(blf_ctx * c, uint8 *data, uint32 len) { - uint32 l, r, d[2]; - uint32 i; + uint32 l, + r, + d[2]; + uint32 i; - for (i = 0; i < len; i += 8) { + for (i = 0; i < len; i += 8) + { l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]; r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]; d[0] = l; @@ -579,12 +612,16 @@ blf_ecb_decrypt(blf_ctx *c, uint8 *data, uint32 len) } void -blf_cbc_encrypt(blf_ctx *c, uint8 *iv, uint8 *data, uint32 len) +blf_cbc_encrypt(blf_ctx * c, uint8 *iv, uint8 *data, uint32 len) { - uint32 l, r, d[2]; - uint32 i, j; + uint32 l, + r, + d[2]; + uint32 i, + j; - for (i = 0; i < len; i += 8) { + for (i = 0; i < len; i += 8) + { for (j = 0; j < 8; j++) data[j] ^= iv[j]; l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]; @@ -608,15 +645,19 @@ blf_cbc_encrypt(blf_ctx *c, uint8 *iv, uint8 *data, uint32 len) } void -blf_cbc_decrypt(blf_ctx *c, uint8 *iva, uint8 *data, uint32 len) +blf_cbc_decrypt(blf_ctx * c, uint8 *iva, uint8 *data, uint32 len) { - uint32 l, r, d[2]; - uint8 *iv; - uint32 i, j; + uint32 l, + r, + d[2]; + uint8 *iv; + uint32 i, + j; iv = data + len - 16; data = data + len - 8; - for (i = len - 8; i >= 8; i -= 8) { + for (i = len - 8; i >= 8; i -= 8) + { l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]; r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]; d[0] = l; diff --git a/contrib/pgcrypto/blf.h b/contrib/pgcrypto/blf.h index daf9703b775..37d40218035 100644 --- a/contrib/pgcrypto/blf.h +++ b/contrib/pgcrypto/blf.h @@ -1,4 +1,4 @@ -/* $OpenBSD: blf.h,v 1.3 2001/05/15 02:40:35 deraadt Exp $ */ +/* $OpenBSD: blf.h,v 1.3 2001/05/15 02:40:35 deraadt Exp $ */ /* * Blowfish - a fast block cipher designed by Bruce Schneier @@ -10,15 +10,15 @@ * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. + * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by Niels Provos. + * must display the following acknowledgement: + * This product includes software developed by Niels Provos. * 4. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. + * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES @@ -42,14 +42,15 @@ * of the key affect all cipherbits. */ -#define BLF_N 16 /* Number of Subkeys */ -#define BLF_MAXKEYLEN ((BLF_N-2)*4) /* 448 bits */ +#define BLF_N 16 /* Number of Subkeys */ +#define BLF_MAXKEYLEN ((BLF_N-2)*4) /* 448 bits */ /* Blowfish context */ -typedef struct BlowfishContext { - uint32 S[4][256]; /* S-Boxes */ - uint32 P[BLF_N + 2]; /* Subkeys */ -} blf_ctx; +typedef struct BlowfishContext +{ + uint32 S[4][256]; /* S-Boxes */ + uint32 P[BLF_N + 2]; /* Subkeys */ +} blf_ctx; /* Raw access to customized Blowfish * blf_key is just: @@ -57,26 +58,25 @@ typedef struct BlowfishContext { * Blowfish_expand0state( state, key, keylen ) */ -void Blowfish_encipher (blf_ctx *, uint32 *); -void Blowfish_decipher (blf_ctx *, uint32 *); -void Blowfish_initstate (blf_ctx *); -void Blowfish_expand0state (blf_ctx *, const uint8 *, uint16); -void Blowfish_expandstate - (blf_ctx *, const uint8 *, uint16, const uint8 *, uint16); +void Blowfish_encipher(blf_ctx *, uint32 *); +void Blowfish_decipher(blf_ctx *, uint32 *); +void Blowfish_initstate(blf_ctx *); +void Blowfish_expand0state(blf_ctx *, const uint8 *, uint16); +void Blowfish_expandstate + (blf_ctx *, const uint8 *, uint16, const uint8 *, uint16); /* Standard Blowfish */ -void blf_key (blf_ctx *, const uint8 *, uint16); -void blf_enc (blf_ctx *, uint32 *, uint16); -void blf_dec (blf_ctx *, uint32 *, uint16); +void blf_key(blf_ctx *, const uint8 *, uint16); +void blf_enc(blf_ctx *, uint32 *, uint16); +void blf_dec(blf_ctx *, uint32 *, uint16); /* Converts uint8 to uint32 */ -uint32 Blowfish_stream2word (const uint8 *, uint16, uint16 *); +uint32 Blowfish_stream2word(const uint8 *, uint16, uint16 *); -void blf_ecb_encrypt (blf_ctx *, uint8 *, uint32); -void blf_ecb_decrypt (blf_ctx *, uint8 *, uint32); - -void blf_cbc_encrypt (blf_ctx *, uint8 *, uint8 *, uint32); -void blf_cbc_decrypt (blf_ctx *, uint8 *, uint8 *, uint32); +void blf_ecb_encrypt(blf_ctx *, uint8 *, uint32); +void blf_ecb_decrypt(blf_ctx *, uint8 *, uint32); +void blf_cbc_encrypt(blf_ctx *, uint8 *, uint8 *, uint32); +void blf_cbc_decrypt(blf_ctx *, uint8 *, uint8 *, uint32); #endif diff --git a/contrib/pgcrypto/crypt-blowfish.c b/contrib/pgcrypto/crypt-blowfish.c index d60807f2417..3bc8e19fa90 100644 --- a/contrib/pgcrypto/crypt-blowfish.c +++ b/contrib/pgcrypto/crypt-blowfish.c @@ -57,10 +57,11 @@ typedef unsigned int BF_word; typedef BF_word BF_key[BF_N + 2]; -typedef struct { - BF_word S[4][0x100]; - BF_key P; -} BF_ctx; +typedef struct +{ + BF_word S[4][0x100]; + BF_key P; +} BF_ctx; /* * Magic IV for 64 Blowfish encryptions that we do at the end. @@ -347,7 +348,7 @@ static BF_ctx BF_init_state = { }; static unsigned char BF_itoa64[64 + 1] = - "./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; +"./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; static unsigned char BF_atoi64[0x60] = { 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 0, 1, @@ -367,22 +368,30 @@ do { \ (dst) = tmp; \ } while (0) -static int BF_decode(BF_word *dst, const char *src, int size) +static int +BF_decode(BF_word * dst, const char *src, int size) { - unsigned char *dptr = (unsigned char *)dst; + unsigned char *dptr = (unsigned char *) dst; unsigned char *end = dptr + size; - unsigned char *sptr = (unsigned char *)src; - unsigned int tmp, c1, c2, c3, c4; - - do { + unsigned char *sptr = (unsigned char *) src; + unsigned int tmp, + c1, + c2, + c3, + c4; + + do + { BF_safe_atoi64(c1, *sptr++); BF_safe_atoi64(c2, *sptr++); *dptr++ = (c1 << 2) | ((c2 & 0x30) >> 4); - if (dptr >= end) break; + if (dptr >= end) + break; BF_safe_atoi64(c3, *sptr++); *dptr++ = ((c2 & 0x0F) << 4) | ((c3 & 0x3C) >> 2); - if (dptr >= end) break; + if (dptr >= end) + break; BF_safe_atoi64(c4, *sptr++); *dptr++ = ((c3 & 0x03) << 6) | c4; @@ -391,18 +400,22 @@ static int BF_decode(BF_word *dst, const char *src, int size) return 0; } -static void BF_encode(char *dst, const BF_word *src, int size) +static void +BF_encode(char *dst, const BF_word * src, int size) { - unsigned char *sptr = (unsigned char *)src; + unsigned char *sptr = (unsigned char *) src; unsigned char *end = sptr + size; - unsigned char *dptr = (unsigned char *)dst; - unsigned int c1, c2; + unsigned char *dptr = (unsigned char *) dst; + unsigned int c1, + c2; - do { + do + { c1 = *sptr++; *dptr++ = BF_itoa64[c1 >> 2]; c1 = (c1 & 0x03) << 4; - if (sptr >= end) { + if (sptr >= end) + { *dptr++ = BF_itoa64[c1]; break; } @@ -411,7 +424,8 @@ static void BF_encode(char *dst, const BF_word *src, int size) c1 |= c2 >> 4; *dptr++ = BF_itoa64[c1]; c1 = (c2 & 0x0f) << 2; - if (sptr >= end) { + if (sptr >= end) + { *dptr++ = BF_itoa64[c1]; break; } @@ -423,18 +437,20 @@ static void BF_encode(char *dst, const BF_word *src, int size) } while (sptr < end); } -static void BF_swap(BF_word *x, int count) +static void +BF_swap(BF_word * x, int count) { - static int endianness_check = 1; - char *is_little_endian = (char *)&endianness_check; - BF_word tmp; + static int endianness_check = 1; + char *is_little_endian = (char *) &endianness_check; + BF_word tmp; if (*is_little_endian) - do { - tmp = *x; - tmp = (tmp << 16) | (tmp >> 16); - *x++ = ((tmp & 0x00FF00FF) << 8) | ((tmp >> 8) & 0x00FF00FF); - } while (--count); + do + { + tmp = *x; + tmp = (tmp << 16) | (tmp >> 16); + *x++ = ((tmp & 0x00FF00FF) << 8) | ((tmp >> 8) & 0x00FF00FF); + } while (--count); } #if BF_SCALE @@ -504,7 +520,8 @@ static void BF_swap(BF_word *x, int count) #if BF_ASM -extern void _BF_body_r(BF_ctx *ctx); +extern void _BF_body_r(BF_ctx * ctx); + #define BF_body() \ _BF_body_r(&data.ctx); @@ -527,22 +544,28 @@ extern void _BF_body_r(BF_ctx *ctx); *(ptr - 2) = L; \ *(ptr - 1) = R; \ } while (ptr < &data.ctx.S[3][0xFF]); - #endif -static void BF_set_key(const char *key, BF_key expanded, BF_key initial) +static void +BF_set_key(const char *key, BF_key expanded, BF_key initial) { const char *ptr = key; - int i, j; - BF_word tmp; + int i, + j; + BF_word tmp; - for (i = 0; i < BF_N + 2; i++) { + for (i = 0; i < BF_N + 2; i++) + { tmp = 0; - for (j = 0; j < 4; j++) { + for (j = 0; j < 4; j++) + { tmp <<= 8; tmp |= *ptr; - if (!*ptr) ptr = key; else ptr++; + if (!*ptr) + ptr = key; + else + ptr++; } expanded[i] = tmp; @@ -550,41 +573,51 @@ static void BF_set_key(const char *key, BF_key expanded, BF_key initial) } } -char *_crypt_blowfish_rn(const char *key, const char *setting, - char *output, int size) +char * +_crypt_blowfish_rn(const char *key, const char *setting, + char *output, int size) { - struct { - BF_ctx ctx; - BF_key expanded_key; - union { - BF_word salt[4]; - BF_word output[6]; - } binary; - } data; - BF_word L, R; - BF_word tmp1, tmp2, tmp3, tmp4; - BF_word *ptr; - BF_word count; - int i; - - if (size < 7 + 22 + 31 + 1) { + struct + { + BF_ctx ctx; + BF_key expanded_key; + union + { + BF_word salt[4]; + BF_word output[6]; + } binary; + } data; + BF_word L, + R; + BF_word tmp1, + tmp2, + tmp3, + tmp4; + BF_word *ptr; + BF_word count; + int i; + + if (size < 7 + 22 + 31 + 1) + { __set_errno(ERANGE); return NULL; } if (setting[0] != '$' || - setting[1] != '2' || - setting[2] != 'a' || - setting[3] != '$' || - setting[4] < '0' || setting[4] > '3' || - setting[5] < '0' || setting[5] > '9' || - setting[6] != '$') { + setting[1] != '2' || + setting[2] != 'a' || + setting[3] != '$' || + setting[4] < '0' || setting[4] > '3' || + setting[5] < '0' || setting[5] > '9' || + setting[6] != '$') + { __set_errno(EINVAL); return NULL; } - count = (BF_word)1 << ((setting[4] - '0') * 10 + (setting[5] - '0')); - if (count < 16 || BF_decode(data.binary.salt, &setting[7], 16)) { + count = (BF_word) 1 << ((setting[4] - '0') * 10 + (setting[5] - '0')); + if (count < 16 || BF_decode(data.binary.salt, &setting[7], 16)) + { memset(data.binary.salt, 0, sizeof(data.binary.salt)); __set_errno(EINVAL); return NULL; @@ -596,7 +629,8 @@ char *_crypt_blowfish_rn(const char *key, const char *setting, memcpy(data.ctx.S, BF_init_state.S, sizeof(data.ctx.S)); L = R = 0; - for (i = 0; i < BF_N + 2; i += 2) { + for (i = 0; i < BF_N + 2; i += 2) + { L ^= data.binary.salt[i & 2]; R ^= data.binary.salt[(i & 2) + 1]; BF_ENCRYPT; @@ -605,7 +639,8 @@ char *_crypt_blowfish_rn(const char *key, const char *setting, } ptr = data.ctx.S[0]; - do { + do + { ptr += 4; L ^= data.binary.salt[(BF_N + 2) & 3]; R ^= data.binary.salt[(BF_N + 3) & 3]; @@ -620,7 +655,8 @@ char *_crypt_blowfish_rn(const char *key, const char *setting, *(ptr - 1) = R; } while (ptr < &data.ctx.S[3][0xFF]); - do { + do + { data.ctx.P[0] ^= data.expanded_key[0]; data.ctx.P[1] ^= data.expanded_key[1]; data.ctx.P[2] ^= data.expanded_key[2]; @@ -668,12 +704,14 @@ char *_crypt_blowfish_rn(const char *key, const char *setting, BF_body(); } while (--count); - for (i = 0; i < 6; i += 2) { + for (i = 0; i < 6; i += 2) + { L = BF_magic_w[i]; R = BF_magic_w[i + 1]; count = 64; - do { + do + { BF_ENCRYPT; } while (--count); @@ -683,7 +721,7 @@ char *_crypt_blowfish_rn(const char *key, const char *setting, memcpy(output, setting, 7 + 22 - 1); output[7 + 22 - 1] = BF_itoa64[(int) - BF_atoi64[(int)setting[7 + 22 - 1] - 0x20] & 0x30]; + BF_atoi64[(int) setting[7 + 22 - 1] - 0x20] & 0x30]; /* This has to be bug-compatible with the original implementation, so * only encode 23 of the 24 bytes. :-) */ @@ -698,4 +736,3 @@ char *_crypt_blowfish_rn(const char *key, const char *setting, return output; } - diff --git a/contrib/pgcrypto/crypt-des.c b/contrib/pgcrypto/crypt-des.c index de6b1865e37..eacb192ad08 100644 --- a/contrib/pgcrypto/crypt-des.c +++ b/contrib/pgcrypto/crypt-des.c @@ -244,8 +244,8 @@ des_init() } /* - * Convert the inverted S-boxes into 4 arrays of 8 bits. - * Each will handle 12 bits of the S-box input. + * Convert the inverted S-boxes into 4 arrays of 8 bits. Each will + * handle 12 bits of the S-box input. */ for (b = 0; b < 4; b++) for (i = 0; i < 64; i++) @@ -409,10 +409,9 @@ des_setkey(const char *key) && rawkey1 == old_rawkey1) { /* - * Already setup for this key. - * This optimisation fails on a zero key (which is weak and - * has bad parity anyway) in order to simplify the starting - * conditions. + * Already setup for this key. This optimisation fails on a zero + * key (which is weak and has bad parity anyway) in order to + * simplify the starting conditions. */ return (0); } @@ -420,7 +419,7 @@ des_setkey(const char *key) old_rawkey1 = rawkey1; /* - * Do key permutation and split into two 28-bit subkeys. + * Do key permutation and split into two 28-bit subkeys. */ k0 = key_perm_maskl[0][rawkey0 >> 25] | key_perm_maskl[1][(rawkey0 >> 17) & 0x7f] @@ -438,8 +437,9 @@ des_setkey(const char *key) | key_perm_maskr[5][(rawkey1 >> 17) & 0x7f] | key_perm_maskr[6][(rawkey1 >> 9) & 0x7f] | key_perm_maskr[7][(rawkey1 >> 1) & 0x7f]; + /* - * Rotate subkeys and do compression permutation. + * Rotate subkeys and do compression permutation. */ shifts = 0; for (round = 0; round < 16; round++) @@ -476,10 +476,10 @@ des_setkey(const char *key) } static int -do_des(uint32 l_in, uint32 r_in, uint32 * l_out, uint32 * r_out, int count) +do_des(uint32 l_in, uint32 r_in, uint32 *l_out, uint32 *r_out, int count) { /* - * l_in, r_in, l_out, and r_out are in pseudo-"big-endian" format. + * l_in, r_in, l_out, and r_out are in pseudo-"big-endian" format. */ uint32 l, r, @@ -513,7 +513,7 @@ do_des(uint32 l_in, uint32 r_in, uint32 * l_out, uint32 * r_out, int count) } /* - * Do initial permutation (IP). + * Do initial permutation (IP). */ l = ip_maskl[0][l_in >> 24] | ip_maskl[1][(l_in >> 16) & 0xff] @@ -556,21 +556,24 @@ do_des(uint32 l_in, uint32 r_in, uint32 * l_out, uint32 * r_out, int count) | ((r & 0x000001f8) << 3) | ((r & 0x0000001f) << 1) | ((r & 0x80000000) >> 31); + /* - * Do salting for crypt() and friends, and - * XOR with the permuted key. + * Do salting for crypt() and friends, and XOR with the + * permuted key. */ f = (r48l ^ r48r) & saltbits; r48l ^= f ^ *kl++; r48r ^= f ^ *kr++; + /* - * Do sbox lookups (which shrink it back to 32 bits) - * and do the pbox permutation at the same time. + * Do sbox lookups (which shrink it back to 32 bits) and do + * the pbox permutation at the same time. */ f = psbox[0][m_sbox[0][r48l >> 12]] | psbox[1][m_sbox[1][r48l & 0xfff]] | psbox[2][m_sbox[2][r48r >> 12]] | psbox[3][m_sbox[3][r48r & 0xfff]]; + /* * Now that we've permuted things, complete f(). */ @@ -581,6 +584,7 @@ do_des(uint32 l_in, uint32 r_in, uint32 * l_out, uint32 * r_out, int count) r = l; l = f; } + /* * Do final permutation (inverse of IP). */ @@ -654,8 +658,8 @@ px_crypt_des(const char *key, const char *setting) /* - * Copy the key, shifting each character up by one bit - * and padding with zeros. + * Copy the key, shifting each character up by one bit and padding + * with zeros. */ q = (uint8 *) keybuf; while (q - (uint8 *) keybuf - 8) @@ -670,9 +674,8 @@ px_crypt_des(const char *key, const char *setting) if (*setting == _PASSWORD_EFMT1) { /* - * "new"-style: - * setting - underscore, 4 bytes of count, 4 bytes of salt - * key - unlimited characters + * "new"-style: setting - underscore, 4 bytes of count, 4 bytes of + * salt key - unlimited characters */ for (i = 1, count = 0L; i < 5; i++) count |= ascii_to_bin(setting[i]) << (i - 1) * 6; @@ -687,6 +690,7 @@ px_crypt_des(const char *key, const char *setting) */ if (des_cipher((uint8 *) keybuf, (uint8 *) keybuf, 0L, 1)) return (NULL); + /* * And XOR with the next 8 characters of the key. */ @@ -700,11 +704,10 @@ px_crypt_des(const char *key, const char *setting) strncpy(output, setting, 9); /* - * Double check that we weren't given a short setting. - * If we were, the above code will probably have created - * wierd values for count and salt, but we don't really care. - * Just make sure the output string doesn't have an extra - * NUL in it. + * Double check that we weren't given a short setting. If we were, + * the above code will probably have created wierd values for + * count and salt, but we don't really care. Just make sure the + * output string doesn't have an extra NUL in it. */ output[9] = '\0'; p = output + strlen(output); @@ -713,9 +716,7 @@ px_crypt_des(const char *key, const char *setting) #endif /* !DISABLE_XDES */ { /* - * "old"-style: - * setting - 2 bytes of salt - * key - up to 8 characters + * "old"-style: setting - 2 bytes of salt key - up to 8 characters */ count = 25; @@ -723,22 +724,24 @@ px_crypt_des(const char *key, const char *setting) | ascii_to_bin(setting[0]); output[0] = setting[0]; + /* - * If the encrypted password that the salt was extracted from - * is only 1 character long, the salt will be corrupted. We - * need to ensure that the output string doesn't have an extra - * NUL in it! + * If the encrypted password that the salt was extracted from is + * only 1 character long, the salt will be corrupted. We need to + * ensure that the output string doesn't have an extra NUL in it! */ output[1] = setting[1] ? setting[1] : output[0]; p = output + 2; } setup_salt(salt); + /* * Do it. */ if (do_des(0L, 0L, &r0, &r1, count)) return (NULL); + /* * Now encode the result... */ diff --git a/contrib/pgcrypto/crypt-gensalt.c b/contrib/pgcrypto/crypt-gensalt.c index 69138268424..9c017b0e4d0 100644 --- a/contrib/pgcrypto/crypt-gensalt.c +++ b/contrib/pgcrypto/crypt-gensalt.c @@ -7,7 +7,7 @@ * entirely in crypt_blowfish.c. * * Put bcrypt generator also here as crypt-blowfish.c - * may not be compiled always. -- marko + * may not be compiled always. -- marko */ #include "postgres.h" @@ -22,48 +22,55 @@ typedef unsigned int BF_word; unsigned char _crypt_itoa64[64 + 1] = - "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; +"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; -char *_crypt_gensalt_traditional_rn(unsigned long count, - const char *input, int size, char *output, int output_size) +char * +_crypt_gensalt_traditional_rn(unsigned long count, + const char *input, int size, char *output, int output_size) { - if (size < 2 || output_size < 2 + 1 || (count && count != 25)) { - if (output_size > 0) output[0] = '\0'; + if (size < 2 || output_size < 2 + 1 || (count && count != 25)) + { + if (output_size > 0) + output[0] = '\0'; __set_errno((output_size < 2 + 1) ? ERANGE : EINVAL); return NULL; } - output[0] = _crypt_itoa64[(unsigned int)input[0] & 0x3f]; - output[1] = _crypt_itoa64[(unsigned int)input[1] & 0x3f]; + output[0] = _crypt_itoa64[(unsigned int) input[0] & 0x3f]; + output[1] = _crypt_itoa64[(unsigned int) input[1] & 0x3f]; output[2] = '\0'; return output; } -char *_crypt_gensalt_extended_rn(unsigned long count, - const char *input, int size, char *output, int output_size) +char * +_crypt_gensalt_extended_rn(unsigned long count, + const char *input, int size, char *output, int output_size) { unsigned long value; /* Even iteration counts make it easier to detect weak DES keys from a look * at the hash, so they should be avoided */ if (size < 3 || output_size < 1 + 4 + 4 + 1 || - (count && (count > 0xffffff || !(count & 1)))) { - if (output_size > 0) output[0] = '\0'; + (count && (count > 0xffffff || !(count & 1)))) + { + if (output_size > 0) + output[0] = '\0'; __set_errno((output_size < 1 + 4 + 4 + 1) ? ERANGE : EINVAL); return NULL; } - if (!count) count = 725; + if (!count) + count = 725; output[0] = '_'; output[1] = _crypt_itoa64[count & 0x3f]; output[2] = _crypt_itoa64[(count >> 6) & 0x3f]; output[3] = _crypt_itoa64[(count >> 12) & 0x3f]; output[4] = _crypt_itoa64[(count >> 18) & 0x3f]; - value = (unsigned long)input[0] | - ((unsigned long)input[1] << 8) | - ((unsigned long)input[2] << 16); + value = (unsigned long) input[0] | + ((unsigned long) input[1] << 8) | + ((unsigned long) input[2] << 16); output[5] = _crypt_itoa64[value & 0x3f]; output[6] = _crypt_itoa64[(value >> 6) & 0x3f]; output[7] = _crypt_itoa64[(value >> 12) & 0x3f]; @@ -73,13 +80,16 @@ char *_crypt_gensalt_extended_rn(unsigned long count, return output; } -char *_crypt_gensalt_md5_rn(unsigned long count, - const char *input, int size, char *output, int output_size) +char * +_crypt_gensalt_md5_rn(unsigned long count, + const char *input, int size, char *output, int output_size) { unsigned long value; - if (size < 3 || output_size < 3 + 4 + 1 || (count && count != 1000)) { - if (output_size > 0) output[0] = '\0'; + if (size < 3 || output_size < 3 + 4 + 1 || (count && count != 1000)) + { + if (output_size > 0) + output[0] = '\0'; __set_errno((output_size < 3 + 4 + 1) ? ERANGE : EINVAL); return NULL; } @@ -87,19 +97,20 @@ char *_crypt_gensalt_md5_rn(unsigned long count, output[0] = '$'; output[1] = '1'; output[2] = '$'; - value = (unsigned long)input[0] | - ((unsigned long)input[1] << 8) | - ((unsigned long)input[2] << 16); + value = (unsigned long) input[0] | + ((unsigned long) input[1] << 8) | + ((unsigned long) input[2] << 16); output[3] = _crypt_itoa64[value & 0x3f]; output[4] = _crypt_itoa64[(value >> 6) & 0x3f]; output[5] = _crypt_itoa64[(value >> 12) & 0x3f]; output[6] = _crypt_itoa64[(value >> 18) & 0x3f]; output[7] = '\0'; - if (size >= 6 && output_size >= 3 + 4 + 4 + 1) { - value = (unsigned long)input[3] | - ((unsigned long)input[4] << 8) | - ((unsigned long)input[5] << 16); + if (size >= 6 && output_size >= 3 + 4 + 4 + 1) + { + value = (unsigned long) input[3] | + ((unsigned long) input[4] << 8) | + ((unsigned long) input[5] << 16); output[7] = _crypt_itoa64[value & 0x3f]; output[8] = _crypt_itoa64[(value >> 6) & 0x3f]; output[9] = _crypt_itoa64[(value >> 12) & 0x3f]; @@ -113,20 +124,24 @@ char *_crypt_gensalt_md5_rn(unsigned long count, static unsigned char BF_itoa64[64 + 1] = - "./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; +"./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; -static void BF_encode(char *dst, const BF_word *src, int size) +static void +BF_encode(char *dst, const BF_word * src, int size) { - unsigned char *sptr = (unsigned char *)src; + unsigned char *sptr = (unsigned char *) src; unsigned char *end = sptr + size; - unsigned char *dptr = (unsigned char *)dst; - unsigned int c1, c2; + unsigned char *dptr = (unsigned char *) dst; + unsigned int c1, + c2; - do { + do + { c1 = *sptr++; *dptr++ = BF_itoa64[c1 >> 2]; c1 = (c1 & 0x03) << 4; - if (sptr >= end) { + if (sptr >= end) + { *dptr++ = BF_itoa64[c1]; break; } @@ -135,7 +150,8 @@ static void BF_encode(char *dst, const BF_word *src, int size) c1 |= c2 >> 4; *dptr++ = BF_itoa64[c1]; c1 = (c2 & 0x0f) << 2; - if (sptr >= end) { + if (sptr >= end) + { *dptr++ = BF_itoa64[c1]; break; } @@ -147,17 +163,21 @@ static void BF_encode(char *dst, const BF_word *src, int size) } while (sptr < end); } -char *_crypt_gensalt_blowfish_rn(unsigned long count, - const char *input, int size, char *output, int output_size) +char * +_crypt_gensalt_blowfish_rn(unsigned long count, + const char *input, int size, char *output, int output_size) { if (size < 16 || output_size < 7 + 22 + 1 || - (count && (count < 4 || count > 31))) { - if (output_size > 0) output[0] = '\0'; + (count && (count < 4 || count > 31))) + { + if (output_size > 0) + output[0] = '\0'; __set_errno((output_size < 7 + 22 + 1) ? ERANGE : EINVAL); return NULL; } - if (!count) count = 5; + if (!count) + count = 5; output[0] = '$'; output[1] = '2'; @@ -167,9 +187,8 @@ char *_crypt_gensalt_blowfish_rn(unsigned long count, output[5] = '0' + count % 10; output[6] = '$'; - BF_encode(&output[7], (BF_word *)input, 16); + BF_encode(&output[7], (BF_word *) input, 16); output[7 + 22] = '\0'; return output; } - diff --git a/contrib/pgcrypto/crypt-md5.c b/contrib/pgcrypto/crypt-md5.c index 02fba694965..7b45bb2151b 100644 --- a/contrib/pgcrypto/crypt-md5.c +++ b/contrib/pgcrypto/crypt-md5.c @@ -9,7 +9,7 @@ * $FreeBSD: src/lib/libcrypt/crypt-md5.c,v 1.5 1999/12/17 20:21:45 peter Exp $ * */ -/* $Id: crypt-md5.c,v 1.1 2001/08/21 01:32:01 momjian Exp $ */ +/* $Id: crypt-md5.c,v 1.2 2001/10/25 05:49:19 momjian Exp $ */ #include <postgres.h> #include "px.h" @@ -23,12 +23,9 @@ char * px_crypt_md5(const char *pw, const char *salt, char *passwd, unsigned dstlen) { - static char *magic = "$1$"; /* - * This string is magic for - * this algorithm. Having - * it this way, we can get - * get better later on - */ + static char *magic = "$1$"; /* This string is magic for this + * algorithm. Having it this way, we can + * get get better later on */ static char *p; static const char *sp, *ep; @@ -43,7 +40,7 @@ px_crypt_md5(const char *pw, const char *salt, char *passwd, unsigned dstlen) if (!passwd || dstlen < 120) return NULL; - + /* Refine the Salt first */ sp = salt; @@ -99,9 +96,9 @@ px_crypt_md5(const char *pw, const char *salt, char *passwd, unsigned dstlen) px_md_finish(ctx, final); /* - * and now, just to make sure things don't run too fast - * On a 60 Mhz Pentium this takes 34 msec, so you would - * need 30 seconds to build a 1000 entry dictionary... + * and now, just to make sure things don't run too fast On a 60 Mhz + * Pentium this takes 34 msec, so you would need 30 seconds to build a + * 1000 entry dictionary... */ for (i = 0; i < 1000; i++) { diff --git a/contrib/pgcrypto/internal.c b/contrib/pgcrypto/internal.c index 421f5f17392..00ff81e5b7a 100644 --- a/contrib/pgcrypto/internal.c +++ b/contrib/pgcrypto/internal.c @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: internal.c,v 1.5 2001/10/15 19:12:48 tgl Exp $ + * $Id: internal.c,v 1.6 2001/10/25 05:49:19 momjian Exp $ */ @@ -61,11 +61,18 @@ static struct int_digest { char *name; void (*init) (PX_MD * h); -} int_digest_list[] = +} int_digest_list[] = + { - { "md5", init_md5 }, - { "sha1", init_sha1 }, - { NULL, NULL } + { + "md5", init_md5 + }, + { + "sha1", init_sha1 + }, + { + NULL, NULL + } }; /* MD5 */ @@ -83,7 +90,7 @@ int_md5_block_len(PX_MD * h) } static void -int_md5_update(PX_MD * h, const uint8 * data, uint dlen) +int_md5_update(PX_MD * h, const uint8 *data, uint dlen) { MD5_CTX *ctx = (MD5_CTX *) h->p.ptr; @@ -99,7 +106,7 @@ int_md5_reset(PX_MD * h) } static void -int_md5_finish(PX_MD * h, uint8 * dst) +int_md5_finish(PX_MD * h, uint8 *dst) { MD5_CTX *ctx = (MD5_CTX *) h->p.ptr; @@ -130,7 +137,7 @@ int_sha1_block_len(PX_MD * h) } static void -int_sha1_update(PX_MD * h, const uint8 * data, uint dlen) +int_sha1_update(PX_MD * h, const uint8 *data, uint dlen) { SHA1_CTX *ctx = (SHA1_CTX *) h->p.ptr; @@ -146,7 +153,7 @@ int_sha1_reset(PX_MD * h) } static void -int_sha1_finish(PX_MD * h, uint8 * dst) +int_sha1_finish(PX_MD * h, uint8 *dst) { SHA1_CTX *ctx = (SHA1_CTX *) h->p.ptr; @@ -209,22 +216,27 @@ init_sha1(PX_MD * md) #define INT_MAX_KEY (512/8) #define INT_MAX_IV (128/8) -struct int_ctx { - uint8 keybuf[INT_MAX_KEY]; - uint8 iv[INT_MAX_IV]; - union { - blf_ctx bf; +struct int_ctx +{ + uint8 keybuf[INT_MAX_KEY]; + uint8 iv[INT_MAX_IV]; + union + { + blf_ctx bf; rijndael_ctx rj; - } ctx; - uint keylen; - int is_init; - int mode; + } ctx; + uint keylen; + int is_init; + int mode; }; -static void intctx_free(PX_Cipher *c) +static void +intctx_free(PX_Cipher * c) { - struct int_ctx *cx = (struct int_ctx *)c->ptr; - if (cx) { + struct int_ctx *cx = (struct int_ctx *) c->ptr; + + if (cx) + { memset(cx, 0, sizeof *cx); px_free(cx); } @@ -238,78 +250,88 @@ static void intctx_free(PX_Cipher *c) #define MODE_ECB 0 #define MODE_CBC 1 -static uint rj_block_size(PX_Cipher *c) +static uint +rj_block_size(PX_Cipher * c) { - return 128/8; + return 128 / 8; } -static uint rj_key_size(PX_Cipher *c) +static uint +rj_key_size(PX_Cipher * c) { - return 256/8; + return 256 / 8; } -static uint rj_iv_size(PX_Cipher *c) +static uint +rj_iv_size(PX_Cipher * c) { - return 128/8; + return 128 / 8; } -static int rj_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv) +static int +rj_init(PX_Cipher * c, const uint8 *key, uint klen, const uint8 *iv) { - struct int_ctx *cx = (struct int_ctx *)c->ptr; + struct int_ctx *cx = (struct int_ctx *) c->ptr; - if (klen <= 128/8) - cx->keylen = 128/8; - else if (klen <= 192/8) - cx->keylen = 192/8; - else if (klen <= 256/8) - cx->keylen = 256/8; + if (klen <= 128 / 8) + cx->keylen = 128 / 8; + else if (klen <= 192 / 8) + cx->keylen = 192 / 8; + else if (klen <= 256 / 8) + cx->keylen = 256 / 8; else return -1; memcpy(&cx->keybuf, key, klen); if (iv) - memcpy(cx->iv, iv, 128/8); + memcpy(cx->iv, iv, 128 / 8); return 0; } -static int rj_real_init(struct int_ctx *cx, int dir) +static int +rj_real_init(struct int_ctx * cx, int dir) { - aes_set_key(&cx->ctx.rj, cx->keybuf, cx->keylen*8, dir); + aes_set_key(&cx->ctx.rj, cx->keybuf, cx->keylen * 8, dir); return 0; } -static int rj_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +static int +rj_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - struct int_ctx *cx = (struct int_ctx *)c->ptr; - - if (!cx->is_init) { + struct int_ctx *cx = (struct int_ctx *) c->ptr; + + if (!cx->is_init) + { if (rj_real_init(cx, 1)) return -1; } - + if (dlen == 0) return 0; - if ((dlen & 15) || (((unsigned)res) & 3)) + if ((dlen & 15) || (((unsigned) res) & 3)) return -1; memcpy(res, data, dlen); - if (cx->mode == MODE_CBC) { + if (cx->mode == MODE_CBC) + { aes_cbc_encrypt(&cx->ctx.rj, cx->iv, res, dlen); memcpy(cx->iv, res + dlen - 16, 16); - } else + } + else aes_ecb_encrypt(&cx->ctx.rj, res, dlen); - + return 0; } -static int rj_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +static int +rj_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - struct int_ctx *cx = (struct int_ctx *)c->ptr; - + struct int_ctx *cx = (struct int_ctx *) c->ptr; + if (!cx->is_init) if (rj_real_init(cx, 0)) return -1; @@ -317,17 +339,19 @@ static int rj_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) if (dlen == 0) return 0; - if ((dlen & 15) || (((unsigned)res) & 3)) + if ((dlen & 15) || (((unsigned) res) & 3)) return -1; memcpy(res, data, dlen); - if (cx->mode == MODE_CBC) { + if (cx->mode == MODE_CBC) + { aes_cbc_decrypt(&cx->ctx.rj, cx->iv, res, dlen); memcpy(cx->iv, data + dlen - 16, 16); - } else + } + else aes_ecb_decrypt(&cx->ctx.rj, res, dlen); - + return 0; } @@ -335,11 +359,12 @@ static int rj_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) * initializers */ -static PX_Cipher * rj_load(int mode) +static PX_Cipher * +rj_load(int mode) { - PX_Cipher *c; + PX_Cipher *c; struct int_ctx *cx; - + c = px_alloc(sizeof *c); memset(c, 0, sizeof *c); @@ -363,24 +388,28 @@ static PX_Cipher * rj_load(int mode) * blowfish */ -static uint bf_block_size(PX_Cipher *c) +static uint +bf_block_size(PX_Cipher * c) { return 8; } -static uint bf_key_size(PX_Cipher *c) +static uint +bf_key_size(PX_Cipher * c) { return BLF_MAXKEYLEN; } -static uint bf_iv_size(PX_Cipher *c) +static uint +bf_iv_size(PX_Cipher * c) { return 8; } -static int bf_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv) +static int +bf_init(PX_Cipher * c, const uint8 *key, uint klen, const uint8 *iv) { - struct int_ctx *cx = (struct int_ctx *)c->ptr; + struct int_ctx *cx = (struct int_ctx *) c->ptr; blf_key(&cx->ctx.bf, key, klen); if (iv) @@ -389,55 +418,60 @@ static int bf_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv) return 0; } -static int bf_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +static int +bf_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - struct int_ctx *cx = (struct int_ctx *)c->ptr; + struct int_ctx *cx = (struct int_ctx *) c->ptr; if (dlen == 0) return 0; - - if ((dlen & 7) || (((unsigned)res) & 3)) + + if ((dlen & 7) || (((unsigned) res) & 3)) return -1; memcpy(res, data, dlen); - switch (cx->mode) { - case MODE_ECB: - blf_ecb_encrypt(&cx->ctx.bf, res, dlen); - break; - case MODE_CBC: - blf_cbc_encrypt(&cx->ctx.bf, cx->iv, res, dlen); - memcpy(cx->iv, res + dlen - 8, 8); + switch (cx->mode) + { + case MODE_ECB: + blf_ecb_encrypt(&cx->ctx.bf, res, dlen); + break; + case MODE_CBC: + blf_cbc_encrypt(&cx->ctx.bf, cx->iv, res, dlen); + memcpy(cx->iv, res + dlen - 8, 8); } return 0; } -static int bf_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +static int +bf_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - struct int_ctx *cx = (struct int_ctx *)c->ptr; + struct int_ctx *cx = (struct int_ctx *) c->ptr; if (dlen == 0) return 0; - if ((dlen & 7) || (((unsigned)res) & 3)) + if ((dlen & 7) || (((unsigned) res) & 3)) return -1; memcpy(res, data, dlen); - switch (cx->mode) { - case MODE_ECB: - blf_ecb_decrypt(&cx->ctx.bf, res, dlen); - break; - case MODE_CBC: - blf_cbc_decrypt(&cx->ctx.bf, cx->iv, res, dlen); - memcpy(cx->iv, data + dlen - 8, 8); + switch (cx->mode) + { + case MODE_ECB: + blf_ecb_decrypt(&cx->ctx.bf, res, dlen); + break; + case MODE_CBC: + blf_cbc_decrypt(&cx->ctx.bf, cx->iv, res, dlen); + memcpy(cx->iv, data + dlen - 8, 8); } return 0; } -static PX_Cipher * bf_load(int mode) +static PX_Cipher * +bf_load(int mode) { - PX_Cipher *c; + PX_Cipher *c; struct int_ctx *cx; - + c = px_alloc(sizeof *c); memset(c, 0, sizeof *c); @@ -458,47 +492,64 @@ static PX_Cipher * bf_load(int mode) /* ciphers */ -static PX_Cipher * rj_128_ecb() +static PX_Cipher * +rj_128_ecb() { return rj_load(MODE_ECB); } -static PX_Cipher * rj_128_cbc() +static PX_Cipher * +rj_128_cbc() { return rj_load(MODE_CBC); } -static PX_Cipher * bf_ecb_load() +static PX_Cipher * +bf_ecb_load() { return bf_load(MODE_ECB); } -static PX_Cipher * bf_cbc_load() +static PX_Cipher * +bf_cbc_load() { return bf_load(MODE_CBC); } -static struct { - char *name; - PX_Cipher *(*load)(void); -} int_ciphers [] = { - { "bf-cbc", bf_cbc_load }, - { "bf-ecb", bf_ecb_load }, - { "aes-128-cbc", rj_128_cbc }, - { "aes-128-ecb", rj_128_ecb }, - { NULL, NULL } +static struct +{ + char *name; + PX_Cipher *(*load) (void); +} int_ciphers[] = + +{ + { + "bf-cbc", bf_cbc_load + }, + { + "bf-ecb", bf_ecb_load + }, + { + "aes-128-cbc", rj_128_cbc + }, + { + "aes-128-ecb", rj_128_ecb + }, + { + NULL, NULL + } }; -static PX_Alias int_aliases [] = { - { "bf", "bf-cbc" }, - { "blowfish", "bf-cbc" }, - { "aes", "aes-128-cbc" }, - { "aes-ecb", "aes-128-ecb" }, - { "aes-cbc", "aes-128-cbc" }, - { "aes-128", "aes-128-cbc" }, - { "rijndael", "aes-128-cbc" }, - { "rijndael-128", "aes-128-cbc" }, - { NULL, NULL } +static PX_Alias int_aliases[] = { + {"bf", "bf-cbc"}, + {"blowfish", "bf-cbc"}, + {"aes", "aes-128-cbc"}, + {"aes-ecb", "aes-128-ecb"}, + {"aes-cbc", "aes-128-cbc"}, + {"aes-128", "aes-128-cbc"}, + {"rijndael", "aes-128-cbc"}, + {"rijndael-128", "aes-128-cbc"}, + {NULL, NULL} }; /* PUBLIC FUNCTIONS */ @@ -523,15 +574,16 @@ px_find_digest(const char *name, PX_MD ** res) } int -px_find_cipher(const char *name, PX_Cipher **res) +px_find_cipher(const char *name, PX_Cipher ** res) { - int i; - PX_Cipher *c = NULL; + int i; + PX_Cipher *c = NULL; name = px_resolve_alias(int_aliases, name); for (i = 0; int_ciphers[i].name; i++) - if (!strcmp(int_ciphers[i].name, name)) { + if (!strcmp(int_ciphers[i].name, name)) + { c = int_ciphers[i].load(); break; } @@ -542,5 +594,3 @@ px_find_cipher(const char *name, PX_Cipher **res) *res = c; return 0; } - - diff --git a/contrib/pgcrypto/md5.c b/contrib/pgcrypto/md5.c index d022d61627f..4b03f196067 100644 --- a/contrib/pgcrypto/md5.c +++ b/contrib/pgcrypto/md5.c @@ -1,4 +1,4 @@ -/* $Id: md5.c,v 1.7 2001/10/25 01:29:37 momjian Exp $ */ +/* $Id: md5.c,v 1.8 2001/10/25 05:49:19 momjian Exp $ */ /* $KAME: md5.c,v 1.3 2000/02/22 14:01:17 itojun Exp $ */ /* @@ -132,7 +132,7 @@ static const uint8 md5_paddat[MD5_BUFLEN] = { static void md5_calc(uint8 *, md5_ctxt *); void -md5_init(md5_ctxt *ctxt) +md5_init(md5_ctxt * ctxt) { ctxt->md5_n = 0; ctxt->md5_i = 0; @@ -144,7 +144,7 @@ md5_init(md5_ctxt *ctxt) } void -md5_loop(md5_ctxt *ctxt, const uint8 *input, unsigned len) +md5_loop(md5_ctxt * ctxt, const uint8 *input, unsigned len) { unsigned int gap, i; @@ -173,7 +173,7 @@ md5_loop(md5_ctxt *ctxt, const uint8 *input, unsigned len) } void -md5_pad(md5_ctxt *ctxt) +md5_pad(md5_ctxt * ctxt) { unsigned int gap; @@ -215,7 +215,7 @@ md5_pad(md5_ctxt *ctxt) } void -md5_result(uint8 *digest, md5_ctxt *ctxt) +md5_result(uint8 *digest, md5_ctxt * ctxt) { /* 4 byte words */ #if BYTE_ORDER == LITTLE_ENDIAN @@ -242,11 +242,11 @@ md5_result(uint8 *digest, md5_ctxt *ctxt) } #if BYTE_ORDER == BIG_ENDIAN -static uint32 X[16]; +static uint32 X[16]; #endif static void -md5_calc(uint8 *b64, md5_ctxt *ctxt) +md5_calc(uint8 *b64, md5_ctxt * ctxt) { uint32 A = ctxt->md5_sta; uint32 B = ctxt->md5_stb; diff --git a/contrib/pgcrypto/mhash.c b/contrib/pgcrypto/mhash.c index 36d70471a99..8811232c37e 100644 --- a/contrib/pgcrypto/mhash.c +++ b/contrib/pgcrypto/mhash.c @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: mhash.c,v 1.4 2001/08/21 00:42:41 momjian Exp $ + * $Id: mhash.c,v 1.5 2001/10/25 05:49:19 momjian Exp $ */ #include <postgres.h> @@ -75,7 +75,7 @@ digest_reset(PX_MD * h) } static void -digest_update(PX_MD * h, const uint8 * data, uint dlen) +digest_update(PX_MD * h, const uint8 *data, uint dlen) { MHASH mh = (MHASH) h->p.ptr; @@ -83,7 +83,7 @@ digest_update(PX_MD * h, const uint8 * data, uint dlen) } static void -digest_finish(PX_MD * h, uint8 * dst) +digest_finish(PX_MD * h, uint8 *dst) { MHASH mh = (MHASH) h->p.ptr; uint hlen = digest_result_size(h); @@ -111,34 +111,37 @@ digest_free(PX_MD * h) /* ENCRYPT / DECRYPT */ static uint -cipher_block_size(PX_Cipher *c) +cipher_block_size(PX_Cipher * c) { - MCRYPT ctx = (MCRYPT)c->ptr; + MCRYPT ctx = (MCRYPT) c->ptr; + return mcrypt_enc_get_block_size(ctx); } static uint -cipher_key_size(PX_Cipher *c) +cipher_key_size(PX_Cipher * c) { - MCRYPT ctx = (MCRYPT)c->ptr; + MCRYPT ctx = (MCRYPT) c->ptr; + return mcrypt_enc_get_key_size(ctx); } static uint -cipher_iv_size(PX_Cipher *c) +cipher_iv_size(PX_Cipher * c) { - MCRYPT ctx = (MCRYPT)c->ptr; + MCRYPT ctx = (MCRYPT) c->ptr; + return mcrypt_enc_mode_has_iv(ctx) ? mcrypt_enc_get_iv_size(ctx) : 0; } static int -cipher_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv) +cipher_init(PX_Cipher * c, const uint8 *key, uint klen, const uint8 *iv) { - int err; - MCRYPT ctx = (MCRYPT)c->ptr; + int err; + MCRYPT ctx = (MCRYPT) c->ptr; - err = mcrypt_generic_init(ctx, (char *)key, klen, (char*)iv); + err = mcrypt_generic_init(ctx, (char *) key, klen, (char *) iv); if (err < 0) elog(ERROR, "mcrypt_generic_init error: %s", mcrypt_strerror(err)); @@ -147,10 +150,10 @@ cipher_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv) } static int -cipher_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +cipher_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - int err; - MCRYPT ctx = (MCRYPT)c->ptr; + int err; + MCRYPT ctx = (MCRYPT) c->ptr; memcpy(res, data, dlen); @@ -161,10 +164,10 @@ cipher_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) } static int -cipher_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +cipher_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - int err; - MCRYPT ctx = (MCRYPT)c->ptr; + int err; + MCRYPT ctx = (MCRYPT) c->ptr; memcpy(res, data, dlen); @@ -176,15 +179,15 @@ cipher_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) static void -cipher_free(PX_Cipher *c) +cipher_free(PX_Cipher * c) { - MCRYPT ctx = (MCRYPT)c->ptr; + MCRYPT ctx = (MCRYPT) c->ptr; if (c->pstat) mcrypt_generic_end(ctx); else mcrypt_module_close(ctx); - + px_free(c); } @@ -223,33 +226,34 @@ static char *modes[] = { }; static PX_Alias aliases[] = { - {"bf", "blowfish" }, - {"3des", "tripledes" }, - {"des3", "tripledes" }, - {"aes", "rijndael-128" }, - {"rijndael", "rijndael-128" }, - {"aes-128", "rijndael-128" }, - {"aes-192", "rijndael-192" }, - {"aes-256", "rijndael-256" }, - { NULL, NULL } + {"bf", "blowfish"}, + {"3des", "tripledes"}, + {"des3", "tripledes"}, + {"aes", "rijndael-128"}, + {"rijndael", "rijndael-128"}, + {"aes-128", "rijndael-128"}, + {"aes-192", "rijndael-192"}, + {"aes-256", "rijndael-256"}, + {NULL, NULL} }; static PX_Alias mode_aliases[] = { -#if 0 /* N/A */ - { "cfb", "ncfb" }, - { "ofb", "nofb" }, - { "cfb64", "ncfb" }, +#if 0 /* N/A */ + {"cfb", "ncfb"}, + {"ofb", "nofb"}, + {"cfb64", "ncfb"}, #endif /* { "ofb64", "nofb" }, not sure it works */ - { "cfb8", "cfb" }, - { "ofb8", "ofb" }, - { NULL, NULL } + {"cfb8", "cfb"}, + {"ofb8", "ofb"}, + {NULL, NULL} }; -static int is_mode(char *s) +static int +is_mode(char *s) { - char **p; - + char **p; + if (*s >= '0' && *s <= '9') return 0; @@ -263,7 +267,7 @@ static int is_mode(char *s) /* PUBLIC FUNCTIONS */ int -px_find_digest(const char *name, PX_MD **res) +px_find_digest(const char *name, PX_MD ** res) { PX_MD *h; MHASH mh; @@ -290,19 +294,21 @@ px_find_digest(const char *name, PX_MD **res) int -px_find_cipher(const char *name, PX_Cipher **res) +px_find_cipher(const char *name, PX_Cipher ** res) { - char nbuf[PX_MAX_NAMELEN + 1]; + char nbuf[PX_MAX_NAMELEN + 1]; const char *mode = NULL; - char *p; - MCRYPT ctx; + char *p; + MCRYPT ctx; - PX_Cipher *c; + PX_Cipher *c; strcpy(nbuf, name); - - if ((p = strrchr(nbuf, '-')) != NULL) { - if (is_mode(p + 1)) { + + if ((p = strrchr(nbuf, '-')) != NULL) + { + if (is_mode(p + 1)) + { mode = p + 1; *p = 0; } @@ -310,19 +316,19 @@ px_find_cipher(const char *name, PX_Cipher **res) name = px_resolve_alias(aliases, nbuf); - if (!mode) { + if (!mode) + { mode = "cbc"; + /* - if (mcrypt_module_is_block_algorithm(name, NULL)) - mode = "cbc"; - else - mode = "stream"; - */ + * if (mcrypt_module_is_block_algorithm(name, NULL)) mode = "cbc"; + * else mode = "stream"; + */ } mode = px_resolve_alias(mode_aliases, mode); - - ctx = mcrypt_module_open((char*)name, NULL, (char*)mode, NULL); - if (ctx == (void*)MCRYPT_FAILED) + + ctx = mcrypt_module_open((char *) name, NULL, (char *) mode, NULL); + if (ctx == (void *) MCRYPT_FAILED) return -1; c = palloc(sizeof *c); @@ -339,4 +345,3 @@ px_find_cipher(const char *name, PX_Cipher **res) *res = c; return 0; } - diff --git a/contrib/pgcrypto/misc.c b/contrib/pgcrypto/misc.c index 7a3c4297085..5c803c0d5b9 100644 --- a/contrib/pgcrypto/misc.c +++ b/contrib/pgcrypto/misc.c @@ -33,7 +33,7 @@ #include "px-crypt.h" char px_crypt_a64[] = - "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; +"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; /* 0000000000111111111122222222223333333333444444444455555555556666 */ /* 0123456789012345678901234567890123456789012345678901234567890123 */ diff --git a/contrib/pgcrypto/openssl.c b/contrib/pgcrypto/openssl.c index 6b2ae9c98a9..f9769b7e208 100644 --- a/contrib/pgcrypto/openssl.c +++ b/contrib/pgcrypto/openssl.c @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: openssl.c,v 1.5 2001/09/23 04:12:44 momjian Exp $ + * $Id: openssl.c,v 1.6 2001/10/25 05:49:19 momjian Exp $ */ #include <postgres.h> @@ -60,7 +60,7 @@ digest_reset(PX_MD * h) } static void -digest_update(PX_MD * h, const uint8 * data, uint dlen) +digest_update(PX_MD * h, const uint8 *data, uint dlen) { EVP_MD_CTX *ctx = (EVP_MD_CTX *) h->p.ptr; @@ -68,7 +68,7 @@ digest_update(PX_MD * h, const uint8 * data, uint dlen) } static void -digest_finish(PX_MD * h, uint8 * dst) +digest_finish(PX_MD * h, uint8 *dst) { EVP_MD_CTX *ctx = (EVP_MD_CTX *) h->p.ptr; @@ -94,50 +94,57 @@ digest_free(PX_MD * h) */ -typedef struct { - union { - struct { - BF_KEY key; - int num; - } bf; +typedef struct +{ + union + { + struct + { + BF_KEY key; + int num; + } bf; EVP_CIPHER_CTX evp_ctx; - } u; + } u; const EVP_CIPHER *evp_ciph; - uint8 key[EVP_MAX_KEY_LENGTH]; - uint8 iv[EVP_MAX_IV_LENGTH]; - uint klen; - uint init; -} ossldata; + uint8 key[EVP_MAX_KEY_LENGTH]; + uint8 iv[EVP_MAX_IV_LENGTH]; + uint klen; + uint init; +} ossldata; /* generic EVP */ static uint -gen_evp_block_size(PX_Cipher *c) +gen_evp_block_size(PX_Cipher * c) { - ossldata *od = (ossldata *)c->ptr; + ossldata *od = (ossldata *) c->ptr; + return EVP_CIPHER_block_size(od->evp_ciph); } static uint -gen_evp_key_size(PX_Cipher *c) +gen_evp_key_size(PX_Cipher * c) { - ossldata *od = (ossldata *)c->ptr; + ossldata *od = (ossldata *) c->ptr; + return EVP_CIPHER_key_length(od->evp_ciph); } static uint -gen_evp_iv_size(PX_Cipher *c) +gen_evp_iv_size(PX_Cipher * c) { - uint ivlen; - ossldata *od = (ossldata *)c->ptr; + uint ivlen; + ossldata *od = (ossldata *) c->ptr; + ivlen = EVP_CIPHER_iv_length(od->evp_ciph); return ivlen; } static void -gen_evp_free(PX_Cipher *c) +gen_evp_free(PX_Cipher * c) { - ossldata *od = (ossldata*)c->ptr; + ossldata *od = (ossldata *) c->ptr; + memset(od, 0, sizeof(*od)); pfree(od); pfree(c); @@ -146,13 +153,14 @@ gen_evp_free(PX_Cipher *c) /* fun */ static int -gen_evp_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv) +gen_evp_init(PX_Cipher * c, const uint8 *key, uint klen, const uint8 *iv) { - ossldata *od = (ossldata*)c->ptr; - uint bs = gen_evp_block_size(c); - if (iv) { + ossldata *od = (ossldata *) c->ptr; + uint bs = gen_evp_block_size(c); + + if (iv) memcpy(od->iv, iv, bs); - } else + else memset(od->iv, 0, bs); memcpy(od->key, key, klen); od->klen = klen; @@ -161,19 +169,20 @@ gen_evp_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv) } static void -_gen_init(PX_Cipher *c, int enc) +_gen_init(PX_Cipher * c, int enc) { - ossldata *od = c->ptr; - + ossldata *od = c->ptr; + od->evp_ciph->init(&od->u.evp_ctx, od->key, od->iv, enc); od->init = 1; od->u.evp_ctx.encrypt = enc; } static int -gen_evp_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +gen_evp_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - ossldata *od = c->ptr; + ossldata *od = c->ptr; + if (!od->init) _gen_init(c, 1); od->evp_ciph->do_cipher(&od->u.evp_ctx, res, data, dlen); @@ -181,9 +190,10 @@ gen_evp_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) } static int -gen_evp_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +gen_evp_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - ossldata *od = c->ptr; + ossldata *od = c->ptr; + if (!od->init) _gen_init(c, 0); od->evp_ciph->do_cipher(&od->u.evp_ctx, res, data, dlen); @@ -193,84 +203,95 @@ gen_evp_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) /* Blowfish */ static int -bf_init(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv) +bf_init(PX_Cipher * c, const uint8 *key, uint klen, const uint8 *iv) { - ossldata *od = c->ptr; + ossldata *od = c->ptr; + BF_set_key(&od->u.bf.key, klen, key); - if (iv) { + if (iv) memcpy(od->iv, iv, BF_BLOCK); - } else + else memset(od->iv, 0, BF_BLOCK); od->u.bf.num = 0; return 0; } static int -bf_ecb_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +bf_ecb_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - uint bs = gen_evp_block_size(c), i; - ossldata *od = c->ptr; + uint bs = gen_evp_block_size(c), + i; + ossldata *od = c->ptr; + for (i = 0; i < dlen / bs; i++) - BF_ecb_encrypt(data+i*bs, res+i*bs, &od->u.bf.key, BF_ENCRYPT); + BF_ecb_encrypt(data + i * bs, res + i * bs, &od->u.bf.key, BF_ENCRYPT); return 0; } static int -bf_ecb_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +bf_ecb_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - uint bs = gen_evp_block_size(c), i; - ossldata *od = c->ptr; + uint bs = gen_evp_block_size(c), + i; + ossldata *od = c->ptr; + for (i = 0; i < dlen / bs; i++) - BF_ecb_encrypt(data+i*bs, res+i*bs, &od->u.bf.key, BF_DECRYPT); + BF_ecb_encrypt(data + i * bs, res + i * bs, &od->u.bf.key, BF_DECRYPT); return 0; } static int -bf_cbc_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +bf_cbc_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - ossldata *od = c->ptr; + ossldata *od = c->ptr; + BF_cbc_encrypt(data, res, dlen, &od->u.bf.key, od->iv, BF_ENCRYPT); return 0; } static int -bf_cbc_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +bf_cbc_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - ossldata *od = c->ptr; + ossldata *od = c->ptr; + BF_cbc_encrypt(data, res, dlen, &od->u.bf.key, od->iv, BF_DECRYPT); return 0; } static int -bf_cfb64_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +bf_cfb64_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - ossldata *od = c->ptr; + ossldata *od = c->ptr; + BF_cfb64_encrypt(data, res, dlen, &od->u.bf.key, od->iv, - &od->u.bf.num, BF_ENCRYPT); + &od->u.bf.num, BF_ENCRYPT); return 0; } static int -bf_cfb64_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +bf_cfb64_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - ossldata *od = c->ptr; + ossldata *od = c->ptr; + BF_cfb64_encrypt(data, res, dlen, &od->u.bf.key, od->iv, - &od->u.bf.num, BF_DECRYPT); + &od->u.bf.num, BF_DECRYPT); return 0; } static int -bf_ofb64_encrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +bf_ofb64_encrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - ossldata *od = c->ptr; + ossldata *od = c->ptr; + BF_ofb64_encrypt(data, res, dlen, &od->u.bf.key, od->iv, &od->u.bf.num); return 0; } static int -bf_ofb64_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) +bf_ofb64_decrypt(PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res) { - ossldata *od = c->ptr; + ossldata *od = c->ptr; + BF_ofb64_encrypt(data, res, dlen, &od->u.bf.key, od->iv, &od->u.bf.num); return 0; } @@ -279,14 +300,14 @@ bf_ofb64_decrypt(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res) * aliases */ -static PX_Alias ossl_aliases [] = { - { "bf", "bf-cbc" }, - { "blowfish", "bf-cbc" }, - { "blowfish-cbc", "bf-cbc" }, - { "blowfish-ecb", "bf-ecb" }, - { "blowfish-cfb", "bf-cfb" }, - { "blowfish-ofb", "bf-ofb" }, - { NULL } +static PX_Alias ossl_aliases[] = { + {"bf", "bf-cbc"}, + {"blowfish", "bf-cbc"}, + {"blowfish-cbc", "bf-cbc"}, + {"blowfish-ecb", "bf-ecb"}, + {"blowfish-cfb", "bf-cfb"}, + {"blowfish-ofb", "bf-ofb"}, + {NULL} }; /* @@ -299,19 +320,44 @@ static PX_Alias ossl_mode_aliases [] = { /* * Special handlers */ -struct { - char *name; - PX_Cipher cf; -} spec_types [] = { - { "bf-cbc", { gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size, - bf_init, bf_cbc_encrypt, bf_cbc_decrypt, gen_evp_free}}, - { "bf-ecb", { gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size, - bf_init, bf_ecb_encrypt, bf_ecb_decrypt, gen_evp_free}}, - { "bf-cfb", { gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size, - bf_init, bf_cfb64_encrypt, bf_cfb64_decrypt, gen_evp_free}}, - { "bf-ofb", { gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size, - bf_init, bf_ofb64_encrypt, bf_ofb64_decrypt, gen_evp_free}}, - { NULL } +struct +{ + char *name; + PX_Cipher cf; +} spec_types[] = + +{ + { + "bf-cbc", + { + gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size, + bf_init, bf_cbc_encrypt, bf_cbc_decrypt, gen_evp_free + } + }, + { + "bf-ecb", + { + gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size, + bf_init, bf_ecb_encrypt, bf_ecb_decrypt, gen_evp_free + } + }, + { + "bf-cfb", + { + gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size, + bf_init, bf_cfb64_encrypt, bf_cfb64_decrypt, gen_evp_free + } + }, + { + "bf-ofb", + { + gen_evp_block_size, gen_evp_key_size, gen_evp_iv_size, + bf_init, bf_ofb64_encrypt, bf_ofb64_decrypt, gen_evp_free + } + }, + { + NULL + } }; /* @@ -322,7 +368,7 @@ static PX_Cipher gen_evp_handler = { gen_evp_init, gen_evp_encrypt, gen_evp_decrypt, gen_evp_free }; -static int px_openssl_initialized = 0; +static int px_openssl_initialized = 0; /* ATM not needed static void *o_alloc(uint s) { return px_alloc(s); } @@ -333,7 +379,7 @@ static void o_free(void *p) { px_free(p); } /* PUBLIC functions */ int -px_find_digest(const char *name, PX_MD **res) +px_find_digest(const char *name, PX_MD ** res) { const EVP_MD *md; EVP_MD_CTX *ctx; @@ -342,7 +388,7 @@ px_find_digest(const char *name, PX_MD **res) if (!px_openssl_initialized) { px_openssl_initialized = 1; - /*CRYPTO_set_mem_functions(o_alloc, o_realloc, o_free);*/ + /* CRYPTO_set_mem_functions(o_alloc, o_realloc, o_free); */ OpenSSL_add_all_algorithms(); } @@ -368,17 +414,19 @@ px_find_digest(const char *name, PX_MD **res) int -px_find_cipher(const char *name, PX_Cipher **res) +px_find_cipher(const char *name, PX_Cipher ** res) { - uint i; - PX_Cipher *c = NULL, *csrc; - ossldata *od; + uint i; + PX_Cipher *c = NULL, + *csrc; + ossldata *od; const EVP_CIPHER *evp_c; - if (!px_openssl_initialized) { + if (!px_openssl_initialized) + { px_openssl_initialized = 1; - /*CRYPTO_set_mem_functions(o_alloc, o_realloc, o_free);*/ + /* CRYPTO_set_mem_functions(o_alloc, o_realloc, o_free); */ OpenSSL_add_all_algorithms(); } @@ -390,23 +438,23 @@ px_find_cipher(const char *name, PX_Cipher **res) od = px_alloc(sizeof(*od)); memset(od, 0, sizeof(*od)); od->evp_ciph = evp_c; - + csrc = NULL; for (i = 0; spec_types[i].name; i++) - if (!strcmp(name, spec_types[i].name)) { + if (!strcmp(name, spec_types[i].name)) + { csrc = &spec_types[i].cf; break; } - + if (csrc == NULL) csrc = &gen_evp_handler; c = px_alloc(sizeof(*c)); memcpy(c, csrc, sizeof(*c)); c->ptr = od; - + *res = c; return 0; } - diff --git a/contrib/pgcrypto/pgcrypto.c b/contrib/pgcrypto/pgcrypto.c index 2bd9b21e167..a6424e61fb3 100644 --- a/contrib/pgcrypto/pgcrypto.c +++ b/contrib/pgcrypto/pgcrypto.c @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: pgcrypto.c,v 1.9 2001/09/23 04:12:44 momjian Exp $ + * $Id: pgcrypto.c,v 1.10 2001/10/25 05:49:19 momjian Exp $ */ #include <postgres.h> @@ -41,7 +41,7 @@ typedef int (*PFN) (const char *name, void **res); static void * - find_provider(text * name, PFN pf, char *desc, int silent); + find_provider(text *name, PFN pf, char *desc, int silent); /* SQL function: hash(text, text) returns text */ PG_FUNCTION_INFO_V1(pg_digest); @@ -313,17 +313,21 @@ PG_FUNCTION_INFO_V1(pg_encrypt); Datum pg_encrypt(PG_FUNCTION_ARGS) { - int err; - bytea *data, *key, *res; - text *type; - PX_Combo *c; - uint dlen, klen, rlen; - + int err; + bytea *data, + *key, + *res; + text *type; + PX_Combo *c; + uint dlen, + klen, + rlen; + if (PG_ARGISNULL(0) || PG_ARGISNULL(1) || PG_ARGISNULL(2)) PG_RETURN_NULL(); - + type = PG_GETARG_TEXT_P(2); - c = find_provider(type, (PFN)px_find_combo, "Cipher", 0); + c = find_provider(type, (PFN) px_find_combo, "Cipher", 0); data = PG_GETARG_BYTEA_P(0); key = PG_GETARG_BYTEA_P(1); @@ -341,8 +345,9 @@ pg_encrypt(PG_FUNCTION_ARGS) PG_FREE_IF_COPY(data, 0); PG_FREE_IF_COPY(key, 1); PG_FREE_IF_COPY(type, 2); - - if (err) { + + if (err) + { pfree(res); elog(ERROR, "encrypt error: %d", err); } @@ -357,17 +362,21 @@ PG_FUNCTION_INFO_V1(pg_decrypt); Datum pg_decrypt(PG_FUNCTION_ARGS) { - int err; - bytea *data, *key, *res; - text *type; - PX_Combo *c; - uint dlen, klen, rlen; - + int err; + bytea *data, + *key, + *res; + text *type; + PX_Combo *c; + uint dlen, + klen, + rlen; + if (PG_ARGISNULL(0) || PG_ARGISNULL(1) || PG_ARGISNULL(2)) PG_RETURN_NULL(); - + type = PG_GETARG_TEXT_P(2); - c = find_provider(type, (PFN)px_find_combo, "Cipher", 0); + c = find_provider(type, (PFN) px_find_combo, "Cipher", 0); data = PG_GETARG_BYTEA_P(0); key = PG_GETARG_BYTEA_P(1); @@ -401,18 +410,24 @@ PG_FUNCTION_INFO_V1(pg_encrypt_iv); Datum pg_encrypt_iv(PG_FUNCTION_ARGS) { - int err; - bytea *data, *key, *iv, *res; - text *type; - PX_Combo *c; - uint dlen, klen, ivlen, rlen; - + int err; + bytea *data, + *key, + *iv, + *res; + text *type; + PX_Combo *c; + uint dlen, + klen, + ivlen, + rlen; + if (PG_ARGISNULL(0) || PG_ARGISNULL(1) - || PG_ARGISNULL(2) || PG_ARGISNULL(3)) + || PG_ARGISNULL(2) || PG_ARGISNULL(3)) PG_RETURN_NULL(); - + type = PG_GETARG_TEXT_P(3); - c = find_provider(type, (PFN)px_find_combo, "Cipher", 0); + c = find_provider(type, (PFN) px_find_combo, "Cipher", 0); data = PG_GETARG_BYTEA_P(0); key = PG_GETARG_BYTEA_P(1); @@ -449,18 +464,24 @@ PG_FUNCTION_INFO_V1(pg_decrypt_iv); Datum pg_decrypt_iv(PG_FUNCTION_ARGS) { - int err; - bytea *data, *key, *iv, *res; - text *type; - PX_Combo *c; - uint dlen, klen, rlen, ivlen; - + int err; + bytea *data, + *key, + *iv, + *res; + text *type; + PX_Combo *c; + uint dlen, + klen, + rlen, + ivlen; + if (PG_ARGISNULL(0) || PG_ARGISNULL(1) - || PG_ARGISNULL(2) || PG_ARGISNULL(3)) + || PG_ARGISNULL(2) || PG_ARGISNULL(3)) PG_RETURN_NULL(); - + type = PG_GETARG_TEXT_P(3); - c = find_provider(type, (PFN)px_find_combo, "Cipher", 0); + c = find_provider(type, (PFN) px_find_combo, "Cipher", 0); data = PG_GETARG_BYTEA_P(0); key = PG_GETARG_BYTEA_P(1); @@ -480,7 +501,7 @@ pg_decrypt_iv(PG_FUNCTION_ARGS) if (err) elog(ERROR, "decrypt_iv error: %d", err); - + VARATT_SIZEP(res) = VARHDRSZ + rlen; PG_FREE_IF_COPY(data, 0); @@ -497,15 +518,15 @@ PG_FUNCTION_INFO_V1(pg_cipher_exists); Datum pg_cipher_exists(PG_FUNCTION_ARGS) { - text *arg; - PX_Combo *c; + text *arg; + PX_Combo *c; if (PG_ARGISNULL(0)) PG_RETURN_NULL(); arg = PG_GETARG_TEXT_P(0); - c = find_provider(arg, (PFN)px_find_combo, "Cipher", 1); + c = find_provider(arg, (PFN) px_find_combo, "Cipher", 1); if (c != NULL) px_combo_free(c); @@ -514,7 +535,7 @@ pg_cipher_exists(PG_FUNCTION_ARGS) static void * -find_provider(text * name, +find_provider(text *name, PFN provider_lookup, char *desc, int silent) { diff --git a/contrib/pgcrypto/pgcrypto.h b/contrib/pgcrypto/pgcrypto.h index 1b49c8d895b..26d04c5dc41 100644 --- a/contrib/pgcrypto/pgcrypto.h +++ b/contrib/pgcrypto/pgcrypto.h @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: pgcrypto.h,v 1.5 2001/09/23 04:12:44 momjian Exp $ + * $Id: pgcrypto.h,v 1.6 2001/10/25 05:49:20 momjian Exp $ */ #ifndef _PG_CRYPTO_H @@ -45,6 +45,4 @@ Datum pg_decrypt(PG_FUNCTION_ARGS); Datum pg_encrypt_iv(PG_FUNCTION_ARGS); Datum pg_decrypt_iv(PG_FUNCTION_ARGS); Datum pg_cipher_exists(PG_FUNCTION_ARGS); - #endif - diff --git a/contrib/pgcrypto/px-crypt.c b/contrib/pgcrypto/px-crypt.c index 7d767279b15..c0821408087 100644 --- a/contrib/pgcrypto/px-crypt.c +++ b/contrib/pgcrypto/px-crypt.c @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: px-crypt.c,v 1.2 2001/09/23 04:12:44 momjian Exp $ + * $Id: px-crypt.c,v 1.3 2001/10/25 05:49:20 momjian Exp $ */ #include <postgres.h> @@ -38,7 +38,7 @@ static char * run_crypt_des(const char *psw, const char *salt, - char *buf, unsigned len) + char *buf, unsigned len) { char *res; @@ -51,37 +51,51 @@ run_crypt_des(const char *psw, const char *salt, static char * run_crypt_md5(const char *psw, const char *salt, - char *buf, unsigned len) + char *buf, unsigned len) { char *res; + res = px_crypt_md5(psw, salt, buf, len); return res; } static char * run_crypt_bf(const char *psw, const char *salt, - char *buf, unsigned len) + char *buf, unsigned len) { char *res; + res = _crypt_blowfish_rn(psw, salt, buf, len); return res; } static struct { - char *id; + char *id; unsigned id_len; char *(*crypt) (const char *psw, const char *salt, char *buf, unsigned len); } px_crypt_list[] = { - { "$2a$", 4, run_crypt_bf }, - { "$2$", 3, NULL }, /* N/A */ - { "$1$", 3, run_crypt_md5 }, - { "_", 1, run_crypt_des }, - { "", 0, run_crypt_des }, - { NULL, 0, NULL } + { + "$2a$", 4, run_crypt_bf + }, + { + "$2$", 3, NULL + }, /* N/A */ + { + "$1$", 3, run_crypt_md5 + }, + { + "_", 1, run_crypt_des + }, + { + "", 0, run_crypt_des + }, + { + NULL, 0, NULL + } }; char * @@ -125,41 +139,45 @@ px_crypt(const char *psw, const char *salt, * salt generators */ -struct generator { - char *name; - char *(*gen)(unsigned long count, const char *input, int size, - char *output, int output_size); - int input_len; - int def_rounds; - int min_rounds; - int max_rounds; +struct generator +{ + char *name; + char *(*gen) (unsigned long count, const char *input, int size, + char *output, int output_size); + int input_len; + int def_rounds; + int min_rounds; + int max_rounds; }; -static struct generator gen_list [] = { - { "des", _crypt_gensalt_traditional_rn, 2, 0, 0, 0 }, - { "md5", _crypt_gensalt_md5_rn, 6, 0, 0, 0 }, - { "xdes", _crypt_gensalt_extended_rn, 3, PX_XDES_ROUNDS, 1, 0xFFFFFF }, - { "bf", _crypt_gensalt_blowfish_rn, 16, PX_BF_ROUNDS, 4, 31 }, - { NULL, NULL, 0, 0, 0 } +static struct generator gen_list[] = { + {"des", _crypt_gensalt_traditional_rn, 2, 0, 0, 0}, + {"md5", _crypt_gensalt_md5_rn, 6, 0, 0, 0}, + {"xdes", _crypt_gensalt_extended_rn, 3, PX_XDES_ROUNDS, 1, 0xFFFFFF}, + {"bf", _crypt_gensalt_blowfish_rn, 16, PX_BF_ROUNDS, 4, 31}, + {NULL, NULL, 0, 0, 0} }; uint px_gen_salt(const char *salt_type, char *buf, int rounds) { - int i, res; + int i, + res; struct generator *g; - char *p; - char rbuf[16]; - - for (i = 0; gen_list[i].name; i++) { + char *p; + char rbuf[16]; + + for (i = 0; gen_list[i].name; i++) + { g = &gen_list[i]; if (strcasecmp(g->name, salt_type) != 0) continue; - if (g->def_rounds) { + if (g->def_rounds) + { if (rounds == 0) rounds = g->def_rounds; - + if (rounds < g->min_rounds || rounds > g->max_rounds) return 0; } @@ -170,10 +188,9 @@ px_gen_salt(const char *salt_type, char *buf, int rounds) p = g->gen(rounds, rbuf, g->input_len, buf, PX_MAX_SALT_LEN); memset(rbuf, 0, sizeof(rbuf)); - + return p != NULL ? strlen(p) : 0; } return 0; } - diff --git a/contrib/pgcrypto/px-crypt.h b/contrib/pgcrypto/px-crypt.h index 5edebb3d3be..7265d414915 100644 --- a/contrib/pgcrypto/px-crypt.h +++ b/contrib/pgcrypto/px-crypt.h @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: px-crypt.h,v 1.2 2001/09/23 04:12:44 momjian Exp $ + * $Id: px-crypt.h,v 1.3 2001/10/25 05:49:20 momjian Exp $ */ #ifndef _PX_CRYPT_H @@ -36,7 +36,7 @@ #define PX_MAX_CRYPT 128 /* max salt returned by gen_salt() */ -#define PX_MAX_SALT_LEN 128 +#define PX_MAX_SALT_LEN 128 /* default rounds for xdes salt */ /* NetBSD bin/passwd/local_passwd.c has (29 * 25)*/ @@ -58,19 +58,20 @@ unsigned px_gen_salt(const char *salt_type, char *dst, int rounds); /* misc.c */ extern void px_crypt_to64(char *s, unsigned long v, int n); extern char px_crypt_a64[]; + /* avoid conflicts with system libs */ #define _crypt_to64 px_crypt_to64 #define _crypt_a64 px_crypt_a64 /* crypt-gensalt.c */ char *_crypt_gensalt_traditional_rn(unsigned long count, - const char *input, int size, char *output, int output_size); + const char *input, int size, char *output, int output_size); char *_crypt_gensalt_extended_rn(unsigned long count, - const char *input, int size, char *output, int output_size); + const char *input, int size, char *output, int output_size); char *_crypt_gensalt_md5_rn(unsigned long count, - const char *input, int size, char *output, int output_size); + const char *input, int size, char *output, int output_size); char *_crypt_gensalt_blowfish_rn(unsigned long count, - const char *input, int size, char *output, int output_size); + const char *input, int size, char *output, int output_size); #ifndef PX_SYSTEM_CRYPT @@ -85,8 +86,7 @@ char *_crypt_blowfish_rn(const char *key, const char *setting, char *px_crypt_des(const char *key, const char *setting); /* crypt-md5.c */ -char *px_crypt_md5(const char *pw, const char *salt, - char *dst, unsigned dstlen); - +char *px_crypt_md5(const char *pw, const char *salt, + char *dst, unsigned dstlen); #endif /* !PX_SYSTEM_CRYPT */ #endif /* _PX_CRYPT_H */ diff --git a/contrib/pgcrypto/px-hmac.c b/contrib/pgcrypto/px-hmac.c index d635aba124c..147a559238e 100644 --- a/contrib/pgcrypto/px-hmac.c +++ b/contrib/pgcrypto/px-hmac.c @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: px-hmac.c,v 1.1 2001/08/21 01:32:01 momjian Exp $ + * $Id: px-hmac.c,v 1.2 2001/10/25 05:49:20 momjian Exp $ */ @@ -50,7 +50,7 @@ hmac_block_size(PX_HMAC * h) } static void -hmac_init(PX_HMAC * h, const uint8 * key, uint klen) +hmac_init(PX_HMAC * h, const uint8 *key, uint klen) { uint bs, hlen, @@ -95,13 +95,13 @@ hmac_reset(PX_HMAC * h) } static void -hmac_update(PX_HMAC * h, const uint8 * data, uint dlen) +hmac_update(PX_HMAC * h, const uint8 *data, uint dlen) { px_md_update(h->md, data, dlen); } static void -hmac_finish(PX_HMAC * h, uint8 * dst) +hmac_finish(PX_HMAC * h, uint8 *dst) { PX_MD *md = h->md; uint bs, diff --git a/contrib/pgcrypto/px.c b/contrib/pgcrypto/px.c index 9c18f6f250e..20550bf1003 100644 --- a/contrib/pgcrypto/px.c +++ b/contrib/pgcrypto/px.c @@ -1,7 +1,7 @@ /* * px.c * Various cryptographic stuff for PostgreSQL. - * + * * Copyright (c) 2001 Marko Kreen * All rights reserved. * @@ -9,15 +9,15 @@ * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. + * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: px.c,v 1.2 2001/09/06 03:21:39 momjian Exp $ + * $Id: px.c,v 1.3 2001/10/25 05:49:20 momjian Exp $ */ #include <postgres.h> @@ -35,9 +35,10 @@ const char * -px_resolve_alias(const PX_Alias *list, const char *name) +px_resolve_alias(const PX_Alias * list, const char *name) { - while (list->name) { + while (list->name) + { if (!strcasecmp(list->alias, name)) return list->name; list++; @@ -50,32 +51,35 @@ px_resolve_alias(const PX_Alias *list, const char *name) */ static uint -combo_encrypt_len(PX_Combo *cx, uint dlen) +combo_encrypt_len(PX_Combo * cx, uint dlen) { return dlen + 512; } static uint -combo_decrypt_len(PX_Combo *cx, uint dlen) +combo_decrypt_len(PX_Combo * cx, uint dlen) { return dlen; } static int -combo_init(PX_Combo *cx, const uint8 *key, uint klen, - const uint8 *iv, uint ivlen) +combo_init(PX_Combo * cx, const uint8 *key, uint klen, + const uint8 *iv, uint ivlen) { - int err; - uint bs, ks, ivs; - PX_Cipher *c = cx->cipher; - uint8 *ivbuf = NULL; - uint8 *keybuf; + int err; + uint bs, + ks, + ivs; + PX_Cipher *c = cx->cipher; + uint8 *ivbuf = NULL; + uint8 *keybuf; bs = px_cipher_block_size(c); ks = px_cipher_key_size(c); ivs = px_cipher_iv_size(c); - if (ivs > 0) { + if (ivs > 0) + { ivbuf = px_alloc(ivs); memset(ivbuf, 0, ivs); if (ivlen > ivs) @@ -97,39 +101,48 @@ combo_init(PX_Combo *cx, const uint8 *key, uint klen, } static int -combo_encrypt(PX_Combo *cx, const uint8 *data, uint dlen, - uint8 *res, uint *rlen) +combo_encrypt(PX_Combo * cx, const uint8 *data, uint dlen, + uint8 *res, uint *rlen) { - int err = 0; - uint8 *bbuf; - uint bs, maxlen, bpos, i, pad; + int err = 0; + uint8 *bbuf; + uint bs, + maxlen, + bpos, + i, + pad; - PX_Cipher *c = cx->cipher; + PX_Cipher *c = cx->cipher; bbuf = NULL; maxlen = *rlen; bs = px_cipher_block_size(c); - + /* encrypt */ - if (bs > 1) { + if (bs > 1) + { bbuf = px_alloc(bs * 4); bpos = dlen % bs; *rlen = dlen - bpos; memcpy(bbuf, data + *rlen, bpos); /* encrypt full-block data */ - if (*rlen) { + if (*rlen) + { err = px_cipher_encrypt(c, data, *rlen, res); if (err) goto out; } - + /* bbuf has now bpos bytes of stuff */ - if (cx->padding) { + if (cx->padding) + { pad = bs - (bpos % bs); for (i = 0; i < pad; i++) bbuf[bpos++] = pad; - } else if (bpos % bs) { + } + else if (bpos % bs) + { /* ERROR? */ pad = bs - (bpos % bs); for (i = 0; i < pad; i++) @@ -137,11 +150,14 @@ combo_encrypt(PX_Combo *cx, const uint8 *data, uint dlen, } /* encrypt the rest - pad */ - if (bpos) { + if (bpos) + { err = px_cipher_encrypt(c, bbuf, bpos, res + *rlen); *rlen += bpos; } - } else { + } + else + { /* stream cipher/mode - no pad needed */ err = px_cipher_encrypt(c, data, dlen, res); if (err) @@ -149,48 +165,53 @@ combo_encrypt(PX_Combo *cx, const uint8 *data, uint dlen, *rlen = dlen; } out: - if (bbuf) px_free(bbuf); + if (bbuf) + px_free(bbuf); return err; } static int -combo_decrypt(PX_Combo *cx, const uint8 *data, uint dlen, - uint8 *res, uint *rlen) +combo_decrypt(PX_Combo * cx, const uint8 *data, uint dlen, + uint8 *res, uint *rlen) { - uint bs, i, pad; - uint pad_ok; + uint bs, + i, + pad; + uint pad_ok; - PX_Cipher *c = cx->cipher; + PX_Cipher *c = cx->cipher; bs = px_cipher_block_size(c); - if (bs > 1 && (dlen % bs) != 0) { + if (bs > 1 && (dlen % bs) != 0) goto block_error; - } - + /* decrypt */ *rlen = dlen; px_cipher_decrypt(c, data, dlen, res); - + /* unpad */ - if (bs > 1 && cx->padding) { + if (bs > 1 && cx->padding) + { pad = res[*rlen - 1]; pad_ok = 0; - if (pad > 0 && pad <= bs && pad <= *rlen) { + if (pad > 0 && pad <= bs && pad <= *rlen) + { pad_ok = 1; for (i = *rlen - pad; i < *rlen; i++) - if (res[i] != pad) { + if (res[i] != pad) + { pad_ok = 0; break; } } - + if (pad_ok) *rlen -= pad; } return 0; - + /* error reporting should be done in pgcrypto.c */ block_error: elog(NOTICE, "Data not a multiple of block size"); @@ -198,7 +219,7 @@ block_error: } static void -combo_free(PX_Combo *cx) +combo_free(PX_Combo * cx) { if (cx->cipher) px_cipher_free(cx->cipher); @@ -211,31 +232,38 @@ combo_free(PX_Combo *cx) static int parse_cipher_name(char *full, char **cipher, char **pad) { - char *p, *p2, *q; + char *p, + *p2, + *q; + *cipher = full; *pad = NULL; - + p = strchr(full, '/'); if (p != NULL) *p++ = 0; - while (p != NULL) { + while (p != NULL) + { if ((q = strchr(p, '/')) != NULL) *q++ = 0; - - if (!*p) { + + if (!*p) + { p = q; continue; } p2 = strchr(p, ':'); - if (p2 != NULL) { + if (p2 != NULL) + { *p2++ = 0; if (!strcmp(p, "pad")) *pad = p2; else return -1; - } else + } + else return -1; - + p = q; } return 0; @@ -244,12 +272,14 @@ parse_cipher_name(char *full, char **cipher, char **pad) /* provider */ int -px_find_combo(const char *name, PX_Combo **res) +px_find_combo(const char *name, PX_Combo ** res) { - int err; - char *buf, *s_cipher, *s_pad; + int err; + char *buf, + *s_cipher, + *s_pad; - PX_Combo *cx; + PX_Combo *cx; cx = px_alloc(sizeof(*cx)); memset(cx, 0, sizeof(*cx)); @@ -258,7 +288,8 @@ px_find_combo(const char *name, PX_Combo **res) strcpy(buf, name); err = parse_cipher_name(buf, &s_cipher, &s_pad); - if (err) { + if (err) + { px_free(buf); px_free(cx); return err; @@ -267,15 +298,17 @@ px_find_combo(const char *name, PX_Combo **res) err = px_find_cipher(s_cipher, &cx->cipher); if (err) goto err1; - - if (s_pad != NULL) { + + if (s_pad != NULL) + { if (!strcmp(s_pad, "pkcs")) cx->padding = 1; else if (!strcmp(s_pad, "none")) cx->padding = 0; else goto err1; - } else + } + else cx->padding = 1; cx->init = combo_init; @@ -290,7 +323,7 @@ px_find_combo(const char *name, PX_Combo **res) *res = cx; return 0; - + err1: if (cx->cipher) px_cipher_free(cx->cipher); @@ -298,4 +331,3 @@ err1: px_free(buf); return -1; } - diff --git a/contrib/pgcrypto/px.h b/contrib/pgcrypto/px.h index d4cffc3c069..d2a87b26e19 100644 --- a/contrib/pgcrypto/px.h +++ b/contrib/pgcrypto/px.h @@ -1,7 +1,7 @@ /* * px.h * Header file for pgcrypto. - * + * * Copyright (c) 2001 Marko Kreen * All rights reserved. * @@ -9,15 +9,15 @@ * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. + * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: px.h,v 1.2 2001/09/23 04:12:44 momjian Exp $ + * $Id: px.h,v 1.3 2001/10/25 05:49:20 momjian Exp $ */ #ifndef __PX_H @@ -36,22 +36,21 @@ #define px_alloc(s) palloc(s) #define px_realloc(p, s) prealloc(p, s) -#define px_free(p) pfree(p) +#define px_free(p) pfree(p) #else -void *xalloc(size_t s); -void *xrealloc(void *p, size_t s); -void xfree(void *p); +void *xalloc(size_t s); +void *xrealloc(void *p, size_t s); +void xfree(void *p); #define px_alloc(s) xalloc(s) #define px_realloc(p, s) xrealloc(p, s) -#define px_free(p) xfree(p) - +#define px_free(p) xfree(p) #endif /* max len of 'type' parms */ -#define PX_MAX_NAMELEN 128 +#define PX_MAX_NAMELEN 128 /* max salt returned */ #define PX_MAX_SALT_LEN 128 @@ -63,79 +62,86 @@ typedef struct px_hmac PX_HMAC; typedef struct px_cipher PX_Cipher; typedef struct px_combo PX_Combo; -struct px_digest { - uint (*result_size)(PX_MD *h); - uint (*block_size)(PX_MD *h); - void (*reset)(PX_MD *h); - void (*update)(PX_MD *h, const uint8 *data, uint dlen); - void (*finish)(PX_MD *h, uint8 *dst); - void (*free)(PX_MD *h); +struct px_digest +{ + uint (*result_size) (PX_MD * h); + uint (*block_size) (PX_MD * h); + void (*reset) (PX_MD * h); + void (*update) (PX_MD * h, const uint8 *data, uint dlen); + void (*finish) (PX_MD * h, uint8 *dst); + void (*free) (PX_MD * h); /* private */ - union { - uint code; + union + { + uint code; const void *ptr; - } p; + } p; }; -struct px_alias { - char *alias; - char *name; +struct px_alias +{ + char *alias; + char *name; }; -struct px_hmac { - uint (*result_size)(PX_HMAC *h); - uint (*block_size)(PX_HMAC *h); - void (*reset)(PX_HMAC *h); - void (*update)(PX_HMAC *h, const uint8 *data, uint dlen); - void (*finish)(PX_HMAC *h, uint8 *dst); - void (*free)(PX_HMAC *h); - void (*init)(PX_HMAC *h, const uint8 *key, uint klen); - - PX_MD *md; +struct px_hmac +{ + uint (*result_size) (PX_HMAC * h); + uint (*block_size) (PX_HMAC * h); + void (*reset) (PX_HMAC * h); + void (*update) (PX_HMAC * h, const uint8 *data, uint dlen); + void (*finish) (PX_HMAC * h, uint8 *dst); + void (*free) (PX_HMAC * h); + void (*init) (PX_HMAC * h, const uint8 *key, uint klen); + + PX_MD *md; /* private */ - struct { - uint8 *ipad; - uint8 *opad; - } p; + struct + { + uint8 *ipad; + uint8 *opad; + } p; }; -struct px_cipher { - uint (*block_size)(PX_Cipher *c); - uint (*key_size)(PX_Cipher *c); /* max key len */ - uint (*iv_size)(PX_Cipher *c); - - int (*init)(PX_Cipher *c, const uint8 *key, uint klen, const uint8 *iv); - int (*encrypt)(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res); - int (*decrypt)(PX_Cipher *c, const uint8 *data, uint dlen, uint8 *res); - void (*free)(PX_Cipher *c); +struct px_cipher +{ + uint (*block_size) (PX_Cipher * c); + uint (*key_size) (PX_Cipher * c); /* max key len */ + uint (*iv_size) (PX_Cipher * c); + + int (*init) (PX_Cipher * c, const uint8 *key, uint klen, const uint8 *iv); + int (*encrypt) (PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res); + int (*decrypt) (PX_Cipher * c, const uint8 *data, uint dlen, uint8 *res); + void (*free) (PX_Cipher * c); /* private */ - void *ptr; - int pstat; /* mcrypt uses it */ + void *ptr; + int pstat; /* mcrypt uses it */ }; -struct px_combo { - int (*init)(PX_Combo *cx, const uint8 *key, uint klen, - const uint8 *iv, uint ivlen); - int (*encrypt)(PX_Combo *cx, const uint8 *data, uint dlen, - uint8 *res, uint *rlen); - int (*decrypt)(PX_Combo *cx, const uint8 *data, uint dlen, - uint8 *res, uint *rlen); - uint (*encrypt_len)(PX_Combo *cx, uint dlen); - uint (*decrypt_len)(PX_Combo *cx, uint dlen); - void (*free)(PX_Combo *cx); - - PX_Cipher *cipher; - uint padding; +struct px_combo +{ + int (*init) (PX_Combo * cx, const uint8 *key, uint klen, + const uint8 *iv, uint ivlen); + int (*encrypt) (PX_Combo * cx, const uint8 *data, uint dlen, + uint8 *res, uint *rlen); + int (*decrypt) (PX_Combo * cx, const uint8 *data, uint dlen, + uint8 *res, uint *rlen); + uint (*encrypt_len) (PX_Combo * cx, uint dlen); + uint (*decrypt_len) (PX_Combo * cx, uint dlen); + void (*free) (PX_Combo * cx); + + PX_Cipher *cipher; + uint padding; }; -int px_find_digest(const char *name, PX_MD **res); -int px_find_hmac(const char *name, PX_HMAC **res); -int px_find_cipher(const char *name, PX_Cipher **res); -int px_find_combo(const char *name, PX_Combo **res); +int px_find_digest(const char *name, PX_MD ** res); +int px_find_hmac(const char *name, PX_HMAC ** res); +int px_find_cipher(const char *name, PX_Cipher ** res); +int px_find_combo(const char *name, PX_Combo ** res); -int px_get_random_bytes(uint8 *dst, unsigned count); +int px_get_random_bytes(uint8 *dst, unsigned count); -const char *px_resolve_alias(const PX_Alias *aliases, const char *name); +const char *px_resolve_alias(const PX_Alias * aliases, const char *name); #define px_md_result_size(md) (md)->result_size(md) #define px_md_block_size(md) (md)->block_size(md) @@ -174,6 +180,4 @@ const char *px_resolve_alias(const PX_Alias *aliases, const char *name); (c)->decrypt(c, data, dlen, res, rlen) #define px_combo_free(c) (c)->free(c) - -#endif /* __PX_H */ - +#endif /* __PX_H */ diff --git a/contrib/pgcrypto/random.c b/contrib/pgcrypto/random.c index 179d450ef9b..559e40c4561 100644 --- a/contrib/pgcrypto/random.c +++ b/contrib/pgcrypto/random.c @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: random.c,v 1.2 2001/09/29 03:12:51 momjian Exp $ + * $Id: random.c,v 1.3 2001/10/25 05:49:20 momjian Exp $ */ @@ -44,13 +44,15 @@ static int safe_read(int fd, void *buf, size_t count) { - int done = 0; - char *p = buf; - int res; - - while (count) { + int done = 0; + char *p = buf; + int res; + + while (count) + { res = read(fd, p, count); - if (res <= 0) { + if (res <= 0) + { if (errno == EINTR) continue; return -1; @@ -65,8 +67,8 @@ safe_read(int fd, void *buf, size_t count) int px_get_random_bytes(uint8 *dst, unsigned count) { - int fd; - int res; + int fd; + int res; fd = open(RAND_DEV, O_RDONLY); if (fd == -1) @@ -75,21 +77,20 @@ px_get_random_bytes(uint8 *dst, unsigned count) close(fd); return res; } - -#endif /* RAND_DEV */ +#endif /* RAND_DEV */ #ifdef RAND_SILLY -int px_get_random_bytes(uint8 *dst, unsigned count) +int +px_get_random_bytes(uint8 *dst, unsigned count) { - int i; - for (i = 0; i < count; i++) { + int i; + + for (i = 0; i < count; i++) *dst++ = random(); - } return i; } - -#endif /* RAND_SILLY */ +#endif /* RAND_SILLY */ #ifdef RAND_OPENSSL @@ -98,30 +99,29 @@ int px_get_random_bytes(uint8 *dst, unsigned count) #include <openssl/rand.h> #include <openssl/err.h> -static int openssl_random_init = 0; +static int openssl_random_init = 0; -int px_get_random_bytes(uint8 *dst, unsigned count) +int +px_get_random_bytes(uint8 *dst, unsigned count) { - int res; + int res; - if (!openssl_random_init) { - if (RAND_get_rand_method() == NULL) { + if (!openssl_random_init) + { + if (RAND_get_rand_method() == NULL) RAND_set_rand_method(RAND_SSLeay()); - } openssl_random_init = 1; } - + /* - * OpenSSL random should re-feeded occasionally. - * From /dev/urandom preferrably. + * OpenSSL random should re-feeded occasionally. From /dev/urandom + * preferrably. */ - + res = RAND_bytes(dst, count); if (res > 0) return count; return -1; } - -#endif /* RAND_OPENSSL */ - +#endif /* RAND_OPENSSL */ diff --git a/contrib/pgcrypto/rijndael.c b/contrib/pgcrypto/rijndael.c index 258202fa991..cca8759e8b6 100644 --- a/contrib/pgcrypto/rijndael.c +++ b/contrib/pgcrypto/rijndael.c @@ -1,40 +1,40 @@ -/* $OpenBSD: rijndael.c,v 1.6 2000/12/09 18:51:34 markus Exp $ */ - -/* This is an independent implementation of the encryption algorithm: */ -/* */ -/* RIJNDAEL by Joan Daemen and Vincent Rijmen */ -/* */ -/* which is a candidate algorithm in the Advanced Encryption Standard */ -/* programme of the US National Institute of Standards and Technology. */ -/* */ -/* Copyright in this implementation is held by Dr B R Gladman but I */ +/* $OpenBSD: rijndael.c,v 1.6 2000/12/09 18:51:34 markus Exp $ */ + +/* This is an independent implementation of the encryption algorithm: */ +/* */ +/* RIJNDAEL by Joan Daemen and Vincent Rijmen */ +/* */ +/* which is a candidate algorithm in the Advanced Encryption Standard */ +/* programme of the US National Institute of Standards and Technology. */ +/* */ +/* Copyright in this implementation is held by Dr B R Gladman but I */ /* hereby give permission for its free direct or derivative use subject */ -/* to acknowledgment of its origin and compliance with any conditions */ -/* that the originators of the algorithm place on its exploitation. */ -/* */ -/* Dr Brian Gladman ([email protected]) 14th January 1999 */ +/* to acknowledgment of its origin and compliance with any conditions */ +/* that the originators of the algorithm place on its exploitation. */ +/* */ +/* Dr Brian Gladman ([email protected]) 14th January 1999 */ /* Timing data for Rijndael (rijndael.c) Algorithm: rijndael (rijndael.c) 128 bit key: -Key Setup: 305/1389 cycles (encrypt/decrypt) -Encrypt: 374 cycles = 68.4 mbits/sec -Decrypt: 352 cycles = 72.7 mbits/sec -Mean: 363 cycles = 70.5 mbits/sec +Key Setup: 305/1389 cycles (encrypt/decrypt) +Encrypt: 374 cycles = 68.4 mbits/sec +Decrypt: 352 cycles = 72.7 mbits/sec +Mean: 363 cycles = 70.5 mbits/sec 192 bit key: -Key Setup: 277/1595 cycles (encrypt/decrypt) -Encrypt: 439 cycles = 58.3 mbits/sec -Decrypt: 425 cycles = 60.2 mbits/sec -Mean: 432 cycles = 59.3 mbits/sec +Key Setup: 277/1595 cycles (encrypt/decrypt) +Encrypt: 439 cycles = 58.3 mbits/sec +Decrypt: 425 cycles = 60.2 mbits/sec +Mean: 432 cycles = 59.3 mbits/sec 256 bit key: -Key Setup: 374/1960 cycles (encrypt/decrypt) -Encrypt: 502 cycles = 51.0 mbits/sec -Decrypt: 498 cycles = 51.4 mbits/sec -Mean: 500 cycles = 51.2 mbits/sec +Key Setup: 374/1960 cycles (encrypt/decrypt) +Encrypt: 502 cycles = 51.0 mbits/sec +Decrypt: 498 cycles = 51.4 mbits/sec +Mean: 500 cycles = 51.2 mbits/sec */ @@ -47,29 +47,29 @@ Mean: 500 cycles = 51.2 mbits/sec static void gen_tabs(void); -/* 3. Basic macros for speeding up generic operations */ +/* 3. Basic macros for speeding up generic operations */ -/* Circular rotate of 32 bit values */ +/* Circular rotate of 32 bit values */ -#define rotr(x,n) (((x) >> ((int)(n))) | ((x) << (32 - (int)(n)))) -#define rotl(x,n) (((x) << ((int)(n))) | ((x) >> (32 - (int)(n)))) +#define rotr(x,n) (((x) >> ((int)(n))) | ((x) << (32 - (int)(n)))) +#define rotl(x,n) (((x) << ((int)(n))) | ((x) >> (32 - (int)(n)))) -/* Invert byte order in a 32 bit variable */ +/* Invert byte order in a 32 bit variable */ -#define bswap(x) ((rotl(x, 8) & 0x00ff00ff) | (rotr(x, 8) & 0xff00ff00)) +#define bswap(x) ((rotl(x, 8) & 0x00ff00ff) | (rotr(x, 8) & 0xff00ff00)) -/* Extract byte from a 32 bit quantity (little endian notation) */ +/* Extract byte from a 32 bit quantity (little endian notation) */ -#define byte(x,n) ((u1byte)((x) >> (8 * n))) +#define byte(x,n) ((u1byte)((x) >> (8 * n))) #if BYTE_ORDER != LITTLE_ENDIAN #define BYTE_SWAP #endif -#ifdef BYTE_SWAP -#define io_swap(x) bswap(x) +#ifdef BYTE_SWAP +#define io_swap(x) bswap(x) #else -#define io_swap(x) (x) +#define io_swap(x) (x) #endif #ifdef PRINT_TABS @@ -81,279 +81,311 @@ static void gen_tabs(void); #include "rijndael.tbl" #define tab_gen 1 -#else /* !PRE_CALC_TABLES */ +#else /* !PRE_CALC_TABLES */ -static u1byte pow_tab[256]; -static u1byte log_tab[256]; -static u1byte sbx_tab[256]; -static u1byte isb_tab[256]; -static u4byte rco_tab[ 10]; -static u4byte ft_tab[4][256]; -static u4byte it_tab[4][256]; +static u1byte pow_tab[256]; +static u1byte log_tab[256]; +static u1byte sbx_tab[256]; +static u1byte isb_tab[256]; +static u4byte rco_tab[10]; +static u4byte ft_tab[4][256]; +static u4byte it_tab[4][256]; -#ifdef LARGE_TABLES -static u4byte fl_tab[4][256]; -static u4byte il_tab[4][256]; +#ifdef LARGE_TABLES +static u4byte fl_tab[4][256]; +static u4byte il_tab[4][256]; #endif -static u4byte tab_gen = 0; -#endif /* !PRE_CALC_TABLES */ +static u4byte tab_gen = 0; +#endif /* !PRE_CALC_TABLES */ -#define ff_mult(a,b) (a && b ? pow_tab[(log_tab[a] + log_tab[b]) % 255] : 0) +#define ff_mult(a,b) (a && b ? pow_tab[(log_tab[a] + log_tab[b]) % 255] : 0) -#define f_rn(bo, bi, n, k) \ - bo[n] = ft_tab[0][byte(bi[n],0)] ^ \ - ft_tab[1][byte(bi[(n + 1) & 3],1)] ^ \ - ft_tab[2][byte(bi[(n + 2) & 3],2)] ^ \ - ft_tab[3][byte(bi[(n + 3) & 3],3)] ^ *(k + n) +#define f_rn(bo, bi, n, k) \ + bo[n] = ft_tab[0][byte(bi[n],0)] ^ \ + ft_tab[1][byte(bi[(n + 1) & 3],1)] ^ \ + ft_tab[2][byte(bi[(n + 2) & 3],2)] ^ \ + ft_tab[3][byte(bi[(n + 3) & 3],3)] ^ *(k + n) -#define i_rn(bo, bi, n, k) \ - bo[n] = it_tab[0][byte(bi[n],0)] ^ \ - it_tab[1][byte(bi[(n + 3) & 3],1)] ^ \ - it_tab[2][byte(bi[(n + 2) & 3],2)] ^ \ - it_tab[3][byte(bi[(n + 1) & 3],3)] ^ *(k + n) +#define i_rn(bo, bi, n, k) \ + bo[n] = it_tab[0][byte(bi[n],0)] ^ \ + it_tab[1][byte(bi[(n + 3) & 3],1)] ^ \ + it_tab[2][byte(bi[(n + 2) & 3],2)] ^ \ + it_tab[3][byte(bi[(n + 1) & 3],3)] ^ *(k + n) #ifdef LARGE_TABLES -#define ls_box(x) \ - ( fl_tab[0][byte(x, 0)] ^ \ - fl_tab[1][byte(x, 1)] ^ \ - fl_tab[2][byte(x, 2)] ^ \ - fl_tab[3][byte(x, 3)] ) +#define ls_box(x) \ + ( fl_tab[0][byte(x, 0)] ^ \ + fl_tab[1][byte(x, 1)] ^ \ + fl_tab[2][byte(x, 2)] ^ \ + fl_tab[3][byte(x, 3)] ) -#define f_rl(bo, bi, n, k) \ - bo[n] = fl_tab[0][byte(bi[n],0)] ^ \ - fl_tab[1][byte(bi[(n + 1) & 3],1)] ^ \ - fl_tab[2][byte(bi[(n + 2) & 3],2)] ^ \ - fl_tab[3][byte(bi[(n + 3) & 3],3)] ^ *(k + n) +#define f_rl(bo, bi, n, k) \ + bo[n] = fl_tab[0][byte(bi[n],0)] ^ \ + fl_tab[1][byte(bi[(n + 1) & 3],1)] ^ \ + fl_tab[2][byte(bi[(n + 2) & 3],2)] ^ \ + fl_tab[3][byte(bi[(n + 3) & 3],3)] ^ *(k + n) -#define i_rl(bo, bi, n, k) \ - bo[n] = il_tab[0][byte(bi[n],0)] ^ \ - il_tab[1][byte(bi[(n + 3) & 3],1)] ^ \ - il_tab[2][byte(bi[(n + 2) & 3],2)] ^ \ - il_tab[3][byte(bi[(n + 1) & 3],3)] ^ *(k + n) +#define i_rl(bo, bi, n, k) \ + bo[n] = il_tab[0][byte(bi[n],0)] ^ \ + il_tab[1][byte(bi[(n + 3) & 3],1)] ^ \ + il_tab[2][byte(bi[(n + 2) & 3],2)] ^ \ + il_tab[3][byte(bi[(n + 1) & 3],3)] ^ *(k + n) #else -#define ls_box(x) \ - ((u4byte)sbx_tab[byte(x, 0)] << 0) ^ \ - ((u4byte)sbx_tab[byte(x, 1)] << 8) ^ \ - ((u4byte)sbx_tab[byte(x, 2)] << 16) ^ \ - ((u4byte)sbx_tab[byte(x, 3)] << 24) - -#define f_rl(bo, bi, n, k) \ - bo[n] = (u4byte)sbx_tab[byte(bi[n],0)] ^ \ - rotl(((u4byte)sbx_tab[byte(bi[(n + 1) & 3],1)]), 8) ^ \ - rotl(((u4byte)sbx_tab[byte(bi[(n + 2) & 3],2)]), 16) ^ \ - rotl(((u4byte)sbx_tab[byte(bi[(n + 3) & 3],3)]), 24) ^ *(k + n) - -#define i_rl(bo, bi, n, k) \ - bo[n] = (u4byte)isb_tab[byte(bi[n],0)] ^ \ - rotl(((u4byte)isb_tab[byte(bi[(n + 3) & 3],1)]), 8) ^ \ - rotl(((u4byte)isb_tab[byte(bi[(n + 2) & 3],2)]), 16) ^ \ - rotl(((u4byte)isb_tab[byte(bi[(n + 1) & 3],3)]), 24) ^ *(k + n) - +#define ls_box(x) \ + ((u4byte)sbx_tab[byte(x, 0)] << 0) ^ \ + ((u4byte)sbx_tab[byte(x, 1)] << 8) ^ \ + ((u4byte)sbx_tab[byte(x, 2)] << 16) ^ \ + ((u4byte)sbx_tab[byte(x, 3)] << 24) + +#define f_rl(bo, bi, n, k) \ + bo[n] = (u4byte)sbx_tab[byte(bi[n],0)] ^ \ + rotl(((u4byte)sbx_tab[byte(bi[(n + 1) & 3],1)]), 8) ^ \ + rotl(((u4byte)sbx_tab[byte(bi[(n + 2) & 3],2)]), 16) ^ \ + rotl(((u4byte)sbx_tab[byte(bi[(n + 3) & 3],3)]), 24) ^ *(k + n) + +#define i_rl(bo, bi, n, k) \ + bo[n] = (u4byte)isb_tab[byte(bi[n],0)] ^ \ + rotl(((u4byte)isb_tab[byte(bi[(n + 3) & 3],1)]), 8) ^ \ + rotl(((u4byte)isb_tab[byte(bi[(n + 2) & 3],2)]), 16) ^ \ + rotl(((u4byte)isb_tab[byte(bi[(n + 1) & 3],3)]), 24) ^ *(k + n) #endif static void gen_tabs(void) { #ifndef PRE_CALC_TABLES - u4byte i, t; - u1byte p, q; + u4byte i, + t; + u1byte p, + q; - /* log and power tables for GF(2**8) finite field with */ - /* 0x11b as modular polynomial - the simplest prmitive */ - /* root is 0x11, used here to generate the tables */ + /* log and power tables for GF(2**8) finite field with */ + /* 0x11b as modular polynomial - the simplest prmitive */ + /* root is 0x11, used here to generate the tables */ - for(i = 0,p = 1; i < 256; ++i) { - pow_tab[i] = (u1byte)p; log_tab[p] = (u1byte)i; + for (i = 0, p = 1; i < 256; ++i) + { + pow_tab[i] = (u1byte) p; + log_tab[p] = (u1byte) i; p = p ^ (p << 1) ^ (p & 0x80 ? 0x01b : 0); } - log_tab[1] = 0; p = 1; + log_tab[1] = 0; + p = 1; - for(i = 0; i < 10; ++i) { - rco_tab[i] = p; + for (i = 0; i < 10; ++i) + { + rco_tab[i] = p; p = (p << 1) ^ (p & 0x80 ? 0x1b : 0); } - /* note that the affine byte transformation matrix in */ - /* rijndael specification is in big endian format with */ - /* bit 0 as the most significant bit. In the remainder */ - /* of the specification the bits are numbered from the */ - /* least significant end of a byte. */ - - for(i = 0; i < 256; ++i) { - p = (i ? pow_tab[255 - log_tab[i]] : 0); q = p; - q = (q >> 7) | (q << 1); p ^= q; - q = (q >> 7) | (q << 1); p ^= q; - q = (q >> 7) | (q << 1); p ^= q; - q = (q >> 7) | (q << 1); p ^= q ^ 0x63; - sbx_tab[i] = (u1byte)p; isb_tab[p] = (u1byte)i; + /* note that the affine byte transformation matrix in */ + /* rijndael specification is in big endian format with */ + /* bit 0 as the most significant bit. In the remainder */ + /* of the specification the bits are numbered from the */ + /* least significant end of a byte. */ + + for (i = 0; i < 256; ++i) + { + p = (i ? pow_tab[255 - log_tab[i]] : 0); + q = p; + q = (q >> 7) | (q << 1); + p ^= q; + q = (q >> 7) | (q << 1); + p ^= q; + q = (q >> 7) | (q << 1); + p ^= q; + q = (q >> 7) | (q << 1); + p ^= q ^ 0x63; + sbx_tab[i] = (u1byte) p; + isb_tab[p] = (u1byte) i; } - for(i = 0; i < 256; ++i) { - p = sbx_tab[i]; + for (i = 0; i < 256; ++i) + { + p = sbx_tab[i]; -#ifdef LARGE_TABLES - - t = p; fl_tab[0][i] = t; - fl_tab[1][i] = rotl(t, 8); +#ifdef LARGE_TABLES + + t = p; + fl_tab[0][i] = t; + fl_tab[1][i] = rotl(t, 8); fl_tab[2][i] = rotl(t, 16); fl_tab[3][i] = rotl(t, 24); #endif - t = ((u4byte)ff_mult(2, p)) | - ((u4byte)p << 8) | - ((u4byte)p << 16) | - ((u4byte)ff_mult(3, p) << 24); - + t = ((u4byte) ff_mult(2, p)) | + ((u4byte) p << 8) | + ((u4byte) p << 16) | + ((u4byte) ff_mult(3, p) << 24); + ft_tab[0][i] = t; - ft_tab[1][i] = rotl(t, 8); + ft_tab[1][i] = rotl(t, 8); ft_tab[2][i] = rotl(t, 16); ft_tab[3][i] = rotl(t, 24); - p = isb_tab[i]; + p = isb_tab[i]; -#ifdef LARGE_TABLES - - t = p; il_tab[0][i] = t; - il_tab[1][i] = rotl(t, 8); - il_tab[2][i] = rotl(t, 16); +#ifdef LARGE_TABLES + + t = p; + il_tab[0][i] = t; + il_tab[1][i] = rotl(t, 8); + il_tab[2][i] = rotl(t, 16); il_tab[3][i] = rotl(t, 24); -#endif - t = ((u4byte)ff_mult(14, p)) | - ((u4byte)ff_mult( 9, p) << 8) | - ((u4byte)ff_mult(13, p) << 16) | - ((u4byte)ff_mult(11, p) << 24); - - it_tab[0][i] = t; - it_tab[1][i] = rotl(t, 8); - it_tab[2][i] = rotl(t, 16); - it_tab[3][i] = rotl(t, 24); +#endif + t = ((u4byte) ff_mult(14, p)) | + ((u4byte) ff_mult(9, p) << 8) | + ((u4byte) ff_mult(13, p) << 16) | + ((u4byte) ff_mult(11, p) << 24); + + it_tab[0][i] = t; + it_tab[1][i] = rotl(t, 8); + it_tab[2][i] = rotl(t, 16); + it_tab[3][i] = rotl(t, 24); } tab_gen = 1; -#endif /* !PRE_CALC_TABLES */ +#endif /* !PRE_CALC_TABLES */ } #define star_x(x) (((x) & 0x7f7f7f7f) << 1) ^ ((((x) & 0x80808080) >> 7) * 0x1b) -#define imix_col(y,x) \ - u = star_x(x); \ - v = star_x(u); \ - w = star_x(v); \ - t = w ^ (x); \ - (y) = u ^ v ^ w; \ +#define imix_col(y,x) \ + u = star_x(x); \ + v = star_x(u); \ + w = star_x(v); \ + t = w ^ (x); \ + (y) = u ^ v ^ w; \ (y) ^= rotr(u ^ t, 8) ^ \ - rotr(v ^ t, 16) ^ \ - rotr(t,24) + rotr(v ^ t, 16) ^ \ + rotr(t,24) -/* initialise the key schedule from the user supplied key */ +/* initialise the key schedule from the user supplied key */ -#define loop4(i) \ -do { t = ls_box(rotr(t, 8)) ^ rco_tab[i]; \ - t ^= e_key[4 * i]; e_key[4 * i + 4] = t; \ - t ^= e_key[4 * i + 1]; e_key[4 * i + 5] = t; \ - t ^= e_key[4 * i + 2]; e_key[4 * i + 6] = t; \ - t ^= e_key[4 * i + 3]; e_key[4 * i + 7] = t; \ +#define loop4(i) \ +do { t = ls_box(rotr(t, 8)) ^ rco_tab[i]; \ + t ^= e_key[4 * i]; e_key[4 * i + 4] = t; \ + t ^= e_key[4 * i + 1]; e_key[4 * i + 5] = t; \ + t ^= e_key[4 * i + 2]; e_key[4 * i + 6] = t; \ + t ^= e_key[4 * i + 3]; e_key[4 * i + 7] = t; \ } while (0) -#define loop6(i) \ -do { t = ls_box(rotr(t, 8)) ^ rco_tab[i]; \ - t ^= e_key[6 * i]; e_key[6 * i + 6] = t; \ - t ^= e_key[6 * i + 1]; e_key[6 * i + 7] = t; \ - t ^= e_key[6 * i + 2]; e_key[6 * i + 8] = t; \ - t ^= e_key[6 * i + 3]; e_key[6 * i + 9] = t; \ - t ^= e_key[6 * i + 4]; e_key[6 * i + 10] = t; \ - t ^= e_key[6 * i + 5]; e_key[6 * i + 11] = t; \ +#define loop6(i) \ +do { t = ls_box(rotr(t, 8)) ^ rco_tab[i]; \ + t ^= e_key[6 * i]; e_key[6 * i + 6] = t; \ + t ^= e_key[6 * i + 1]; e_key[6 * i + 7] = t; \ + t ^= e_key[6 * i + 2]; e_key[6 * i + 8] = t; \ + t ^= e_key[6 * i + 3]; e_key[6 * i + 9] = t; \ + t ^= e_key[6 * i + 4]; e_key[6 * i + 10] = t; \ + t ^= e_key[6 * i + 5]; e_key[6 * i + 11] = t; \ } while (0) -#define loop8(i) \ -do { t = ls_box(rotr(t, 8)) ^ rco_tab[i]; \ - t ^= e_key[8 * i]; e_key[8 * i + 8] = t; \ - t ^= e_key[8 * i + 1]; e_key[8 * i + 9] = t; \ - t ^= e_key[8 * i + 2]; e_key[8 * i + 10] = t; \ - t ^= e_key[8 * i + 3]; e_key[8 * i + 11] = t; \ - t = e_key[8 * i + 4] ^ ls_box(t); \ - e_key[8 * i + 12] = t; \ - t ^= e_key[8 * i + 5]; e_key[8 * i + 13] = t; \ - t ^= e_key[8 * i + 6]; e_key[8 * i + 14] = t; \ - t ^= e_key[8 * i + 7]; e_key[8 * i + 15] = t; \ +#define loop8(i) \ +do { t = ls_box(rotr(t, 8)) ^ rco_tab[i]; \ + t ^= e_key[8 * i]; e_key[8 * i + 8] = t; \ + t ^= e_key[8 * i + 1]; e_key[8 * i + 9] = t; \ + t ^= e_key[8 * i + 2]; e_key[8 * i + 10] = t; \ + t ^= e_key[8 * i + 3]; e_key[8 * i + 11] = t; \ + t = e_key[8 * i + 4] ^ ls_box(t); \ + e_key[8 * i + 12] = t; \ + t ^= e_key[8 * i + 5]; e_key[8 * i + 13] = t; \ + t ^= e_key[8 * i + 6]; e_key[8 * i + 14] = t; \ + t ^= e_key[8 * i + 7]; e_key[8 * i + 15] = t; \ } while (0) rijndael_ctx * -rijndael_set_key(rijndael_ctx *ctx, const u4byte *in_key, const u4byte key_len, - int encrypt) -{ - u4byte i, t, u, v, w; - u4byte *e_key = ctx->e_key; - u4byte *d_key = ctx->d_key; +rijndael_set_key(rijndael_ctx * ctx, const u4byte * in_key, const u4byte key_len, + int encrypt) +{ + u4byte i, + t, + u, + v, + w; + u4byte *e_key = ctx->e_key; + u4byte *d_key = ctx->d_key; ctx->decrypt = !encrypt; - if(!tab_gen) + if (!tab_gen) gen_tabs(); ctx->k_len = (key_len + 31) / 32; - e_key[0] = io_swap(in_key[0]); e_key[1] = io_swap(in_key[1]); - e_key[2] = io_swap(in_key[2]); e_key[3] = io_swap(in_key[3]); - - switch(ctx->k_len) { - case 4: t = e_key[3]; - for(i = 0; i < 10; ++i) - loop4(i); - break; - - case 6: e_key[4] = io_swap(in_key[4]); t = e_key[5] = io_swap(in_key[5]); - for(i = 0; i < 8; ++i) - loop6(i); - break; - - case 8: e_key[4] = io_swap(in_key[4]); e_key[5] = io_swap(in_key[5]); - e_key[6] = io_swap(in_key[6]); t = e_key[7] = io_swap(in_key[7]); - for(i = 0; i < 7; ++i) - loop8(i); - break; + e_key[0] = io_swap(in_key[0]); + e_key[1] = io_swap(in_key[1]); + e_key[2] = io_swap(in_key[2]); + e_key[3] = io_swap(in_key[3]); + + switch (ctx->k_len) + { + case 4: + t = e_key[3]; + for (i = 0; i < 10; ++i) + loop4(i); + break; + + case 6: + e_key[4] = io_swap(in_key[4]); + t = e_key[5] = io_swap(in_key[5]); + for (i = 0; i < 8; ++i) + loop6(i); + break; + + case 8: + e_key[4] = io_swap(in_key[4]); + e_key[5] = io_swap(in_key[5]); + e_key[6] = io_swap(in_key[6]); + t = e_key[7] = io_swap(in_key[7]); + for (i = 0; i < 7; ++i) + loop8(i); + break; } - if (!encrypt) { - d_key[0] = e_key[0]; d_key[1] = e_key[1]; - d_key[2] = e_key[2]; d_key[3] = e_key[3]; + if (!encrypt) + { + d_key[0] = e_key[0]; + d_key[1] = e_key[1]; + d_key[2] = e_key[2]; + d_key[3] = e_key[3]; - for(i = 4; i < 4 * ctx->k_len + 24; ++i) { + for (i = 4; i < 4 * ctx->k_len + 24; ++i) imix_col(d_key[i], e_key[i]); - } } return ctx; } -/* encrypt a block of text */ +/* encrypt a block of text */ #define f_nround(bo, bi, k) \ - f_rn(bo, bi, 0, k); \ - f_rn(bo, bi, 1, k); \ - f_rn(bo, bi, 2, k); \ - f_rn(bo, bi, 3, k); \ - k += 4 + f_rn(bo, bi, 0, k); \ + f_rn(bo, bi, 1, k); \ + f_rn(bo, bi, 2, k); \ + f_rn(bo, bi, 3, k); \ + k += 4 #define f_lround(bo, bi, k) \ - f_rl(bo, bi, 0, k); \ - f_rl(bo, bi, 1, k); \ - f_rl(bo, bi, 2, k); \ - f_rl(bo, bi, 3, k) + f_rl(bo, bi, 0, k); \ + f_rl(bo, bi, 1, k); \ + f_rl(bo, bi, 2, k); \ + f_rl(bo, bi, 3, k) void -rijndael_encrypt(rijndael_ctx *ctx, const u4byte *in_blk, u4byte *out_blk) -{ - u4byte k_len = ctx->k_len; - u4byte *e_key = ctx->e_key; - u4byte b0[4], b1[4], *kp; +rijndael_encrypt(rijndael_ctx * ctx, const u4byte * in_blk, u4byte * out_blk) +{ + u4byte k_len = ctx->k_len; + u4byte *e_key = ctx->e_key; + u4byte b0[4], + b1[4], + *kp; b0[0] = io_swap(in_blk[0]) ^ e_key[0]; b0[1] = io_swap(in_blk[1]) ^ e_key[1]; @@ -362,46 +394,59 @@ rijndael_encrypt(rijndael_ctx *ctx, const u4byte *in_blk, u4byte *out_blk) kp = e_key + 4; - if(k_len > 6) { - f_nround(b1, b0, kp); f_nround(b0, b1, kp); + if (k_len > 6) + { + f_nround(b1, b0, kp); + f_nround(b0, b1, kp); } - if(k_len > 4) { - f_nround(b1, b0, kp); f_nround(b0, b1, kp); + if (k_len > 4) + { + f_nround(b1, b0, kp); + f_nround(b0, b1, kp); } - f_nround(b1, b0, kp); f_nround(b0, b1, kp); - f_nround(b1, b0, kp); f_nround(b0, b1, kp); - f_nround(b1, b0, kp); f_nround(b0, b1, kp); - f_nround(b1, b0, kp); f_nround(b0, b1, kp); - f_nround(b1, b0, kp); f_lround(b0, b1, kp); - - out_blk[0] = io_swap(b0[0]); out_blk[1] = io_swap(b0[1]); - out_blk[2] = io_swap(b0[2]); out_blk[3] = io_swap(b0[3]); + f_nround(b1, b0, kp); + f_nround(b0, b1, kp); + f_nround(b1, b0, kp); + f_nround(b0, b1, kp); + f_nround(b1, b0, kp); + f_nround(b0, b1, kp); + f_nround(b1, b0, kp); + f_nround(b0, b1, kp); + f_nround(b1, b0, kp); + f_lround(b0, b1, kp); + + out_blk[0] = io_swap(b0[0]); + out_blk[1] = io_swap(b0[1]); + out_blk[2] = io_swap(b0[2]); + out_blk[3] = io_swap(b0[3]); } -/* decrypt a block of text */ +/* decrypt a block of text */ #define i_nround(bo, bi, k) \ - i_rn(bo, bi, 0, k); \ - i_rn(bo, bi, 1, k); \ - i_rn(bo, bi, 2, k); \ - i_rn(bo, bi, 3, k); \ - k -= 4 + i_rn(bo, bi, 0, k); \ + i_rn(bo, bi, 1, k); \ + i_rn(bo, bi, 2, k); \ + i_rn(bo, bi, 3, k); \ + k -= 4 #define i_lround(bo, bi, k) \ - i_rl(bo, bi, 0, k); \ - i_rl(bo, bi, 1, k); \ - i_rl(bo, bi, 2, k); \ - i_rl(bo, bi, 3, k) + i_rl(bo, bi, 0, k); \ + i_rl(bo, bi, 1, k); \ + i_rl(bo, bi, 2, k); \ + i_rl(bo, bi, 3, k) void -rijndael_decrypt(rijndael_ctx *ctx, const u4byte *in_blk, u4byte *out_blk) -{ - u4byte b0[4], b1[4], *kp; - u4byte k_len = ctx->k_len; - u4byte *e_key = ctx->e_key; - u4byte *d_key = ctx->d_key; +rijndael_decrypt(rijndael_ctx * ctx, const u4byte * in_blk, u4byte * out_blk) +{ + u4byte b0[4], + b1[4], + *kp; + u4byte k_len = ctx->k_len; + u4byte *e_key = ctx->e_key; + u4byte *d_key = ctx->d_key; b0[0] = io_swap(in_blk[0]) ^ e_key[4 * k_len + 24]; b0[1] = io_swap(in_blk[1]) ^ e_key[4 * k_len + 25]; @@ -410,22 +455,33 @@ rijndael_decrypt(rijndael_ctx *ctx, const u4byte *in_blk, u4byte *out_blk) kp = d_key + 4 * (k_len + 5); - if(k_len > 6) { - i_nround(b1, b0, kp); i_nround(b0, b1, kp); + if (k_len > 6) + { + i_nround(b1, b0, kp); + i_nround(b0, b1, kp); } - if(k_len > 4) { - i_nround(b1, b0, kp); i_nround(b0, b1, kp); + if (k_len > 4) + { + i_nround(b1, b0, kp); + i_nround(b0, b1, kp); } - i_nround(b1, b0, kp); i_nround(b0, b1, kp); - i_nround(b1, b0, kp); i_nround(b0, b1, kp); - i_nround(b1, b0, kp); i_nround(b0, b1, kp); - i_nround(b1, b0, kp); i_nround(b0, b1, kp); - i_nround(b1, b0, kp); i_lround(b0, b1, kp); - - out_blk[0] = io_swap(b0[0]); out_blk[1] = io_swap(b0[1]); - out_blk[2] = io_swap(b0[2]); out_blk[3] = io_swap(b0[3]); + i_nround(b1, b0, kp); + i_nround(b0, b1, kp); + i_nround(b1, b0, kp); + i_nround(b0, b1, kp); + i_nround(b1, b0, kp); + i_nround(b0, b1, kp); + i_nround(b1, b0, kp); + i_nround(b0, b1, kp); + i_nround(b1, b0, kp); + i_lround(b0, b1, kp); + + out_blk[0] = io_swap(b0[0]); + out_blk[1] = io_swap(b0[1]); + out_blk[2] = io_swap(b0[2]); + out_blk[3] = io_swap(b0[3]); } /* @@ -435,19 +491,24 @@ rijndael_decrypt(rijndael_ctx *ctx, const u4byte *in_blk, u4byte *out_blk) * should be true for PX. -marko */ -void aes_set_key(rijndael_ctx * ctx, const uint8 *key, uint keybits, int enc) +void +aes_set_key(rijndael_ctx * ctx, const uint8 *key, uint keybits, int enc) { - uint32 *k; - k = (uint32*)key; + uint32 *k; + + k = (uint32 *) key; rijndael_set_key(ctx, k, keybits, enc); } -void aes_ecb_encrypt(rijndael_ctx *ctx, uint8 *data, unsigned len) +void +aes_ecb_encrypt(rijndael_ctx * ctx, uint8 *data, unsigned len) { - unsigned bs = 16; - uint32 *d; - while (len >= bs) { - d = (uint32*)data; + unsigned bs = 16; + uint32 *d; + + while (len >= bs) + { + d = (uint32 *) data; rijndael_encrypt(ctx, d, d); len -= bs; @@ -455,12 +516,15 @@ void aes_ecb_encrypt(rijndael_ctx *ctx, uint8 *data, unsigned len) } } -void aes_ecb_decrypt(rijndael_ctx *ctx, uint8 *data, unsigned len) +void +aes_ecb_decrypt(rijndael_ctx * ctx, uint8 *data, unsigned len) { - unsigned bs = 16; - uint32 *d; - while (len >= bs) { - d = (uint32*)data; + unsigned bs = 16; + uint32 *d; + + while (len >= bs) + { + d = (uint32 *) data; rijndael_decrypt(ctx, d, d); len -= bs; @@ -468,42 +532,55 @@ void aes_ecb_decrypt(rijndael_ctx *ctx, uint8 *data, unsigned len) } } -void aes_cbc_encrypt(rijndael_ctx *ctx, uint8 *iva, uint8 *data, unsigned len) +void +aes_cbc_encrypt(rijndael_ctx * ctx, uint8 *iva, uint8 *data, unsigned len) { - uint32 *iv = (uint32 *)iva; - uint32 *d = (uint32 *)data; - unsigned bs = 16; - - while (len >= bs) { - d[0] ^= iv[0]; d[1] ^= iv[1]; - d[2] ^= iv[2]; d[3] ^= iv[3]; - + uint32 *iv = (uint32 *) iva; + uint32 *d = (uint32 *) data; + unsigned bs = 16; + + while (len >= bs) + { + d[0] ^= iv[0]; + d[1] ^= iv[1]; + d[2] ^= iv[2]; + d[3] ^= iv[3]; + rijndael_encrypt(ctx, d, d); iv = d; - d += bs/4; + d += bs / 4; len -= bs; } } -void aes_cbc_decrypt(rijndael_ctx *ctx, uint8 *iva, uint8 *data, unsigned len) +void +aes_cbc_decrypt(rijndael_ctx * ctx, uint8 *iva, uint8 *data, unsigned len) { - uint32 *d = (uint32 *)data; - unsigned bs = 16; - uint32 buf[4], iv[4]; + uint32 *d = (uint32 *) data; + unsigned bs = 16; + uint32 buf[4], + iv[4]; memcpy(iv, iva, bs); - while (len >= bs) { - buf[0] = d[0]; buf[1] = d[1]; - buf[2] = d[2]; buf[3] = d[3]; - + while (len >= bs) + { + buf[0] = d[0]; + buf[1] = d[1]; + buf[2] = d[2]; + buf[3] = d[3]; + rijndael_decrypt(ctx, buf, d); - - d[0] ^= iv[0]; d[1] ^= iv[1]; - d[2] ^= iv[2]; d[3] ^= iv[3]; - - iv[0] = buf[0]; iv[1] = buf[1]; - iv[2] = buf[2]; iv[3] = buf[3]; + + d[0] ^= iv[0]; + d[1] ^= iv[1]; + d[2] ^= iv[2]; + d[3] ^= iv[3]; + + iv[0] = buf[0]; + iv[1] = buf[1]; + iv[2] = buf[2]; + iv[3] = buf[3]; d += 4; len -= bs; } @@ -514,15 +591,18 @@ void aes_cbc_decrypt(rijndael_ctx *ctx, uint8 *iva, uint8 *data, unsigned len) * * On i386 lifts 17k from .bss to .rodata * and avoids 1k code and setup time. - * -marko + * -marko */ #ifdef PRINT_TABS -static void show256u8(char *name, uint8 *data) +static void +show256u8(char *name, uint8 *data) { - int i; + int i; + printf("static const u1byte %s[256] = {\n ", name); - for (i = 0; i < 256; ) { + for (i = 0; i < 256;) + { printf("%u", pow_tab[i++]); if (i < 256) printf(i % 16 ? ", " : ",\n "); @@ -531,12 +611,17 @@ static void show256u8(char *name, uint8 *data) } -static void show4x256u32(char *name, uint32 data[4][256]) +static void +show4x256u32(char *name, uint32 data[4][256]) { - int i, j; + int i, + j; + printf("static const u4byte %s[4][256] = {\n{\n ", name); - for (i = 0; i < 4; i++) { - for (j = 0; j < 256; ) { + for (i = 0; i < 4; i++) + { + for (j = 0; j < 256;) + { printf("0x%08x", data[i][j]); j++; if (j < 256) @@ -547,11 +632,12 @@ static void show4x256u32(char *name, uint32 data[4][256]) printf("};\n\n"); } -int main() +int +main() { - int i; - char *hdr = "/* Generated by rijndael.c */\n\n"; - + int i; + char *hdr = "/* Generated by rijndael.c */\n\n"; + gen_tabs(); printf(hdr); @@ -559,7 +645,7 @@ int main() show256u8("log_tab", log_tab); show256u8("sbx_tab", sbx_tab); show256u8("isb_tab", isb_tab); - + show4x256u32("ft_tab", ft_tab); show4x256u32("it_tab", it_tab); #ifdef LARGE_TABLES @@ -567,14 +653,15 @@ int main() show4x256u32("il_tab", il_tab); #endif printf("static const u4byte rco_tab[10] = {\n "); - for (i = 0; i < 10; i++) { + for (i = 0; i < 10; i++) + { printf("0x%08x", rco_tab[i]); - if (i < 9) printf(", "); - if (i == 4) printf("\n "); + if (i < 9) + printf(", "); + if (i == 4) + printf("\n "); } printf("\n};\n\n"); return 0; } - #endif - diff --git a/contrib/pgcrypto/rijndael.h b/contrib/pgcrypto/rijndael.h index bdefda828ff..2f54e0c738f 100644 --- a/contrib/pgcrypto/rijndael.h +++ b/contrib/pgcrypto/rijndael.h @@ -1,57 +1,57 @@ -/* $OpenBSD: rijndael.h,v 1.3 2001/05/09 23:01:32 markus Exp $ */ - -/* This is an independent implementation of the encryption algorithm: */ -/* */ -/* RIJNDAEL by Joan Daemen and Vincent Rijmen */ -/* */ -/* which is a candidate algorithm in the Advanced Encryption Standard */ -/* programme of the US National Institute of Standards and Technology. */ -/* */ -/* Copyright in this implementation is held by Dr B R Gladman but I */ +/* $OpenBSD: rijndael.h,v 1.3 2001/05/09 23:01:32 markus Exp $ */ + +/* This is an independent implementation of the encryption algorithm: */ +/* */ +/* RIJNDAEL by Joan Daemen and Vincent Rijmen */ +/* */ +/* which is a candidate algorithm in the Advanced Encryption Standard */ +/* programme of the US National Institute of Standards and Technology. */ +/* */ +/* Copyright in this implementation is held by Dr B R Gladman but I */ /* hereby give permission for its free direct or derivative use subject */ -/* to acknowledgment of its origin and compliance with any conditions */ -/* that the originators of the algorithm place on its exploitation. */ -/* */ -/* Dr Brian Gladman ([email protected]) 14th January 1999 */ +/* to acknowledgment of its origin and compliance with any conditions */ +/* that the originators of the algorithm place on its exploitation. */ +/* */ +/* Dr Brian Gladman ([email protected]) 14th January 1999 */ #ifndef _RIJNDAEL_H_ #define _RIJNDAEL_H_ -/* 1. Standard types for AES cryptography source code */ +/* 1. Standard types for AES cryptography source code */ -typedef uint8 u1byte; /* an 8 bit unsigned character type */ -typedef uint16 u2byte; /* a 16 bit unsigned integer type */ -typedef uint32 u4byte; /* a 32 bit unsigned integer type */ +typedef uint8 u1byte; /* an 8 bit unsigned character type */ +typedef uint16 u2byte; /* a 16 bit unsigned integer type */ +typedef uint32 u4byte; /* a 32 bit unsigned integer type */ -typedef int8 s1byte; /* an 8 bit signed character type */ -typedef int16 s2byte; /* a 16 bit signed integer type */ -typedef int32 s4byte; /* a 32 bit signed integer type */ +typedef int8 s1byte; /* an 8 bit signed character type */ +typedef int16 s2byte; /* a 16 bit signed integer type */ +typedef int32 s4byte; /* a 32 bit signed integer type */ -typedef struct _rijndael_ctx { - u4byte k_len; - int decrypt; - u4byte e_key[64]; - u4byte d_key[64]; -} rijndael_ctx; +typedef struct _rijndael_ctx +{ + u4byte k_len; + int decrypt; + u4byte e_key[64]; + u4byte d_key[64]; +} rijndael_ctx; -/* 2. Standard interface for AES cryptographic routines */ +/* 2. Standard interface for AES cryptographic routines */ /* These are all based on 32 bit unsigned values and will therefore */ -/* require endian conversions for big-endian architectures */ +/* require endian conversions for big-endian architectures */ rijndael_ctx * -rijndael_set_key (rijndael_ctx *, const u4byte *, const u4byte, int); -void rijndael_encrypt (rijndael_ctx *, const u4byte *, u4byte *); -void rijndael_decrypt (rijndael_ctx *, const u4byte *, u4byte *); + rijndael_set_key(rijndael_ctx *, const u4byte *, const u4byte, int); +void rijndael_encrypt(rijndael_ctx *, const u4byte *, u4byte *); +void rijndael_decrypt(rijndael_ctx *, const u4byte *, u4byte *); /* conventional interface */ -void aes_set_key(rijndael_ctx * ctx, const uint8 *key, uint keybits, int enc); -void aes_ecb_encrypt(rijndael_ctx *ctx, uint8 *data, unsigned len); -void aes_ecb_decrypt(rijndael_ctx *ctx, uint8 *data, unsigned len); -void aes_cbc_encrypt(rijndael_ctx *ctx, uint8 *iva, uint8 *data, unsigned len); -void aes_cbc_decrypt(rijndael_ctx *ctx, uint8 *iva, uint8 *data, unsigned len); +void aes_set_key(rijndael_ctx * ctx, const uint8 *key, uint keybits, int enc); +void aes_ecb_encrypt(rijndael_ctx * ctx, uint8 *data, unsigned len); +void aes_ecb_decrypt(rijndael_ctx * ctx, uint8 *data, unsigned len); +void aes_cbc_encrypt(rijndael_ctx * ctx, uint8 *iva, uint8 *data, unsigned len); +void aes_cbc_decrypt(rijndael_ctx * ctx, uint8 *iva, uint8 *data, unsigned len); - -#endif /* _RIJNDAEL_H_ */ +#endif /* _RIJNDAEL_H_ */ diff --git a/contrib/pgcrypto/sha1.c b/contrib/pgcrypto/sha1.c index 20c6230540b..26095697907 100644 --- a/contrib/pgcrypto/sha1.c +++ b/contrib/pgcrypto/sha1.c @@ -1,4 +1,4 @@ -/* $Id: sha1.c,v 1.7 2001/10/25 01:29:37 momjian Exp $ */ +/* $Id: sha1.c,v 1.8 2001/10/25 05:49:20 momjian Exp $ */ /* $KAME: sha1.c,v 1.3 2000/02/22 14:01:18 itojun Exp $ */ /* @@ -87,7 +87,7 @@ do { \ static void sha1_step(struct sha1_ctxt *); static void -sha1_step(struct sha1_ctxt *ctxt) +sha1_step(struct sha1_ctxt * ctxt) { uint32 a, b, @@ -232,7 +232,7 @@ sha1_step(struct sha1_ctxt *ctxt) /*------------------------------------------------------------*/ void -sha1_init(struct sha1_ctxt *ctxt) +sha1_init(struct sha1_ctxt * ctxt) { bzero(ctxt, sizeof(struct sha1_ctxt)); H(0) = 0x67452301; @@ -243,7 +243,7 @@ sha1_init(struct sha1_ctxt *ctxt) } void -sha1_pad(struct sha1_ctxt *ctxt) +sha1_pad(struct sha1_ctxt * ctxt) { size_t padlen; /* pad length in bytes */ size_t padstart; @@ -286,7 +286,7 @@ sha1_pad(struct sha1_ctxt *ctxt) } void -sha1_loop(struct sha1_ctxt *ctxt, const uint8 *input0, size_t len) +sha1_loop(struct sha1_ctxt * ctxt, const uint8 *input0, size_t len) { const uint8 *input; size_t gaplen; @@ -314,7 +314,7 @@ sha1_loop(struct sha1_ctxt *ctxt, const uint8 *input0, size_t len) } void -sha1_result(struct sha1_ctxt *ctxt, uint8 *digest0) +sha1_result(struct sha1_ctxt * ctxt, uint8 *digest0) { uint8 *digest; diff --git a/contrib/pgcrypto/sha1.h b/contrib/pgcrypto/sha1.h index c83bd7191a5..03c6443ccc4 100644 --- a/contrib/pgcrypto/sha1.h +++ b/contrib/pgcrypto/sha1.h @@ -1,4 +1,4 @@ -/* $Id: sha1.h,v 1.5 2001/08/21 00:42:41 momjian Exp $ */ +/* $Id: sha1.h,v 1.6 2001/10/25 05:49:20 momjian Exp $ */ /* $KAME: sha1.h,v 1.4 2000/02/22 14:01:18 itojun Exp $ */ /* @@ -71,5 +71,4 @@ typedef struct sha1_ctxt SHA1_CTX; #define SHA1Final(x, y) sha1_result((y), (x)) #define SHA1_RESULTLEN (160/8) - #endif /* _NETINET6_SHA1_H_ */ |