├── .gitignore ├── README.md ├── bcrypt.nim ├── bcrypt.nimble └── bcrypt ├── arc4random.c ├── blowfish.c ├── blowfish.h ├── build └── crypt-blowfish.c /.gitignore: -------------------------------------------------------------------------------- 1 | *~ 2 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | bcrypt 2 | ====== 3 | 4 | This is a Nimrod wrapper for the bcrypt C functions. It also includes some BSD code for arc4random. 5 | Since these are FreeBSD/OpenBSD code files, the license is BSD, or as stated at the top of the source files. "This product includes software developed by Niels Provos." 6 | 7 | bcrypt is useful for hashing passwords. 8 | 9 | ### Usage example: 10 | 11 | ```nimrod 12 | import bcrypt, os 13 | 14 | var salt = "" 15 | 16 | if existsFile("salt"): 17 | salt = readFile("salt") 18 | else: 19 | salt = genSalt(10) 20 | writeFile("salt", salt) 21 | 22 | echo("salt is " & salt) 23 | 24 | echo("Hashed password: ", hash("myPaSword2",salt)) 25 | ``` 26 | 27 | -------------------------------------------------------------------------------- /bcrypt.nim: -------------------------------------------------------------------------------- 1 | {.compile: "bcrypt/arc4random.c".} 2 | {.compile: "bcrypt/blowfish.c".} 3 | {.compile: "bcrypt/crypt-blowfish.c".} 4 | {.pragma: mydll.} 5 | 6 | proc bcrypt_gensalt(rounds: int8): cstring {.cdecl, mydll, importc: "bcrypt_gensalt".} 7 | 8 | proc genSalt*(rounds: int8): string = 9 | return $(bcrypt_gensalt(rounds)) 10 | 11 | proc blowfish(key, salt, encrypted: cstring) : int {.cdecl, mydll, importc: "crypt_blowfish".} 12 | 13 | proc hash*(key, salt:string): string = 14 | var encrypted = newString(60) 15 | var ret = blowfish(key, salt, encrypted.cstring) 16 | var result:string = $encrypted 17 | return result 18 | 19 | proc compare_string(s1, s2: cstring): int {.cdecl, mydll, importc: "compare_string".} 20 | 21 | proc compare*(s1, s2: string): bool = 22 | var ret = compare_string(s1,s2) 23 | if ret == 0: 24 | return false 25 | else: 26 | return true 27 | 28 | 29 | when isMainModule: 30 | var salt = genSalt(5) 31 | echo "salt is " & salt 32 | var password = "testPass01%" 33 | echo("test password is " & password) 34 | var hashed = hash(password, salt) 35 | echo "bcrypt hashed is **" & hashed & "**" 36 | 37 | var passMatches = "testPass01%" 38 | var hashed2 = hash(passMatches, salt) 39 | var same = compare(hashed, hashed2) 40 | 41 | if same: 42 | echo("Hashes match. Correct") 43 | else: 44 | echo("Hashes do not match. Incorrect!") 45 | 46 | var passDifferent = "testpass02" 47 | var hashed3 = hash(passDifferent, salt) 48 | var same2 = compare(hashed, hashed3) 49 | 50 | if same2: 51 | echo("Hashes for different passwords match. Incorrect!") 52 | else: 53 | echo("Hashes for different passwords don't match. Correct.") 54 | 55 | -------------------------------------------------------------------------------- /bcrypt.nimble: -------------------------------------------------------------------------------- 1 | [Package] 2 | name = "bcrypt" 3 | version = "0.2.1" 4 | author = "Jason Livesay" 5 | description = "Wraps the bcrypt (blowfish) library for creating encrypted hashes (useful for passwords)" 6 | license = "BSD" 7 | installExt = "c,h" 8 | 9 | [Deps] 10 | Requires: "nimrod >= 0.9.2" 11 | -------------------------------------------------------------------------------- /bcrypt/arc4random.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Arc4 random number generator for OpenBSD. 3 | * Copyright 1996 David Mazieres . 4 | * 5 | * Modification and redistribution in source and binary forms is 6 | * permitted provided that due credit is given to the author and the 7 | * OpenBSD project (for instance by leaving this copyright notice 8 | * intact). 9 | */ 10 | 11 | /* 12 | * This code is derived from section 17.1 of Applied Cryptography, 13 | * second edition, which describes a stream cipher allegedly 14 | * compatible with RSA Labs "RC4" cipher (the actual description of 15 | * which is a trade secret). The same algorithm is used as a stream 16 | * cipher called "arcfour" in Tatu Ylonen's ssh package. 17 | * 18 | * Here the stream cipher has been modified always to include the time 19 | * when initializing the state. That makes it impossible to 20 | * regenerate the same random sequence twice, so this can't be used 21 | * for encryption, but will generate good random numbers. 22 | * 23 | * RC4 is a registered trademark of RSA Laboratories. 24 | */ 25 | 26 | #include 27 | 28 | //#include "namespace.h" 29 | #include 30 | #include 31 | #include 32 | #include 33 | #include 34 | #include 35 | #include 36 | #include 37 | 38 | #define __isthreaded 1 39 | 40 | #define _open open 41 | #define _close close 42 | #define _read read 43 | 44 | #define _pthread_mutex_lock pthread_mutex_lock 45 | #define _pthread_mutex_unlock pthread_mutex_unlock 46 | 47 | struct arc4_stream { 48 | u_int8_t i; 49 | u_int8_t j; 50 | u_int8_t s[256]; 51 | }; 52 | 53 | static pthread_mutex_t arc4random_mtx = PTHREAD_MUTEX_INITIALIZER; 54 | 55 | #define RANDOMDEV "/dev/urandom" 56 | #define THREAD_LOCK() \ 57 | do { \ 58 | if (__isthreaded) \ 59 | _pthread_mutex_lock(&arc4random_mtx); \ 60 | } while (0) 61 | 62 | #define THREAD_UNLOCK() \ 63 | do { \ 64 | if (__isthreaded) \ 65 | _pthread_mutex_unlock(&arc4random_mtx); \ 66 | } while (0) 67 | 68 | static struct arc4_stream rs; 69 | static int rs_initialized; 70 | static int rs_stired; 71 | 72 | static inline u_int8_t arc4_getbyte(struct arc4_stream *); 73 | static void arc4_stir(struct arc4_stream *); 74 | 75 | static inline void 76 | arc4_init(as) 77 | struct arc4_stream *as; 78 | { 79 | int n; 80 | 81 | for (n = 0; n < 256; n++) 82 | as->s[n] = n; 83 | as->i = 0; 84 | as->j = 0; 85 | } 86 | 87 | static inline void 88 | arc4_addrandom(as, dat, datlen) 89 | struct arc4_stream *as; 90 | u_char *dat; 91 | int datlen; 92 | { 93 | int n; 94 | u_int8_t si; 95 | 96 | as->i--; 97 | for (n = 0; n < 256; n++) { 98 | as->i = (as->i + 1); 99 | si = as->s[as->i]; 100 | as->j = (as->j + si + dat[n % datlen]); 101 | as->s[as->i] = as->s[as->j]; 102 | as->s[as->j] = si; 103 | } 104 | } 105 | 106 | static void 107 | arc4_stir(as) 108 | struct arc4_stream *as; 109 | { 110 | int fd, n; 111 | struct { 112 | struct timeval tv; 113 | pid_t pid; 114 | u_int8_t rnd[128 - sizeof(struct timeval) - sizeof(pid_t)]; 115 | } rdat; 116 | 117 | gettimeofday(&rdat.tv, NULL); 118 | rdat.pid = getpid(); 119 | fd = _open(RANDOMDEV, O_RDONLY, 0); 120 | if (fd >= 0) { 121 | (void) _read(fd, rdat.rnd, sizeof(rdat.rnd)); 122 | _close(fd); 123 | } 124 | /* fd < 0? Ah, what the heck. We'll just take whatever was on the 125 | * stack... */ 126 | 127 | arc4_addrandom(as, (void *) &rdat, sizeof(rdat)); 128 | 129 | /* 130 | * Throw away the first N bytes of output, as suggested in the 131 | * paper "Weaknesses in the Key Scheduling Algorithm of RC4" 132 | * by Fluher, Mantin, and Shamir. N=1024 is based on 133 | * suggestions in the paper "(Not So) Random Shuffles of RC4" 134 | * by Ilya Mironov. 135 | */ 136 | for (n = 0; n < 1024; n++) 137 | arc4_getbyte(as); 138 | } 139 | 140 | static inline u_int8_t 141 | arc4_getbyte(as) 142 | struct arc4_stream *as; 143 | { 144 | u_int8_t si, sj; 145 | 146 | as->i = (as->i + 1); 147 | si = as->s[as->i]; 148 | as->j = (as->j + si); 149 | sj = as->s[as->j]; 150 | as->s[as->i] = sj; 151 | as->s[as->j] = si; 152 | 153 | return (as->s[(si + sj) & 0xff]); 154 | } 155 | 156 | static inline u_int32_t 157 | arc4_getword(as) 158 | struct arc4_stream *as; 159 | { 160 | u_int32_t val; 161 | 162 | val = arc4_getbyte(as) << 24; 163 | val |= arc4_getbyte(as) << 16; 164 | val |= arc4_getbyte(as) << 8; 165 | val |= arc4_getbyte(as); 166 | 167 | return (val); 168 | } 169 | 170 | static void 171 | arc4_check_init(void) 172 | { 173 | if (!rs_initialized) { 174 | arc4_init(&rs); 175 | rs_initialized = 1; 176 | } 177 | } 178 | 179 | static void 180 | arc4_check_stir(void) 181 | { 182 | if (!rs_stired) { 183 | arc4_stir(&rs); 184 | rs_stired = 1; 185 | } 186 | } 187 | 188 | void 189 | arc4random_stir() 190 | { 191 | THREAD_LOCK(); 192 | arc4_check_init(); 193 | arc4_stir(&rs); 194 | THREAD_UNLOCK(); 195 | } 196 | 197 | void 198 | arc4random_addrandom(dat, datlen) 199 | u_char *dat; 200 | int datlen; 201 | { 202 | THREAD_LOCK(); 203 | arc4_check_init(); 204 | arc4_check_stir(); 205 | arc4_addrandom(&rs, dat, datlen); 206 | THREAD_UNLOCK(); 207 | } 208 | 209 | u_int32_t 210 | arc4random() 211 | { 212 | u_int32_t rnd; 213 | 214 | THREAD_LOCK(); 215 | arc4_check_init(); 216 | arc4_check_stir(); 217 | rnd = arc4_getword(&rs); 218 | THREAD_UNLOCK(); 219 | 220 | return (rnd); 221 | } 222 | 223 | #if 0 224 | /*-------- Test code for i386 --------*/ 225 | #include 226 | int 227 | main(int argc, char **argv) 228 | { 229 | const int iter = 1000000; 230 | int i; 231 | 232 | arc4random(); 233 | 234 | printf("ok\n"); 235 | } 236 | #endif 237 | -------------------------------------------------------------------------------- /bcrypt/blowfish.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Blowfish block cipher 3 | * Copyright 1997 Niels Provos 4 | * All rights reserved. 5 | * 6 | * Implementation advice by David Mazieres . 7 | * 8 | * Redistribution and use in source and binary forms, with or without 9 | * modification, are permitted provided that the following conditions 10 | * are met: 11 | * 1. Redistributions of source code must retain the above copyright 12 | * notice, this list of conditions and the following disclaimer. 13 | * 2. Redistributions in binary form must reproduce the above copyright 14 | * notice, this list of conditions and the following disclaimer in the 15 | * documentation and/or other materials provided with the distribution. 16 | * 3. All advertising materials mentioning features or use of this software 17 | * must display the following acknowledgement: 18 | * This product includes software developed by Niels Provos. 19 | * 4. The name of the author may not be used to endorse or promote products 20 | * derived from this software without specific prior written permission. 21 | * 22 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 23 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 24 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 25 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 26 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 27 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 31 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 | */ 33 | 34 | #include 35 | 36 | /* 37 | * This code is derived from section 14.3 and the given source 38 | * in section V of Applied Cryptography, second edition. 39 | * Blowfish is an unpatented fast block cipher designed by 40 | * Bruce Schneier. 41 | */ 42 | 43 | /* 44 | * FreeBSD implementation by Paul Herman 45 | */ 46 | 47 | #if 0 48 | #include /* used for debugging */ 49 | #include 50 | #endif 51 | 52 | #include 53 | #include "blowfish.h" 54 | 55 | /* Function for Feistel Networks */ 56 | 57 | #define _F(s, x) ((((s)[ (((x)>>24)&0xFF)] \ 58 | + (s)[0x100 + (((x)>>16)&0xFF)]) \ 59 | ^ (s)[0x200 + (((x)>> 8)&0xFF)]) \ 60 | + (s)[0x300 + ( (x) &0xFF)]) 61 | 62 | #define BLFRND(s, p, i, j, n) (i ^= _F(s, j) ^ (p)[n]) 63 | 64 | void 65 | Blowfish_encipher(blf_ctx *c, u_int32_t *xl, u_int32_t *xr) 66 | { 67 | u_int32_t Xl; 68 | u_int32_t Xr; 69 | u_int32_t *s = c->S[0]; 70 | u_int32_t *p = c->P; 71 | 72 | Xl = *xl; 73 | Xr = *xr; 74 | 75 | Xl ^= p[0]; 76 | BLFRND(s, p, Xr, Xl, 1); BLFRND(s, p, Xl, Xr, 2); 77 | BLFRND(s, p, Xr, Xl, 3); BLFRND(s, p, Xl, Xr, 4); 78 | BLFRND(s, p, Xr, Xl, 5); BLFRND(s, p, Xl, Xr, 6); 79 | BLFRND(s, p, Xr, Xl, 7); BLFRND(s, p, Xl, Xr, 8); 80 | BLFRND(s, p, Xr, Xl, 9); BLFRND(s, p, Xl, Xr, 10); 81 | BLFRND(s, p, Xr, Xl, 11); BLFRND(s, p, Xl, Xr, 12); 82 | BLFRND(s, p, Xr, Xl, 13); BLFRND(s, p, Xl, Xr, 14); 83 | BLFRND(s, p, Xr, Xl, 15); BLFRND(s, p, Xl, Xr, 16); 84 | 85 | *xl = Xr ^ p[17]; 86 | *xr = Xl; 87 | } 88 | 89 | void 90 | Blowfish_decipher(blf_ctx *c, u_int32_t *xl, u_int32_t *xr) 91 | { 92 | u_int32_t Xl; 93 | u_int32_t Xr; 94 | u_int32_t *s = c->S[0]; 95 | u_int32_t *p = c->P; 96 | 97 | Xl = *xl; 98 | Xr = *xr; 99 | 100 | Xl ^= p[17]; 101 | BLFRND(s, p, Xr, Xl, 16); BLFRND(s, p, Xl, Xr, 15); 102 | BLFRND(s, p, Xr, Xl, 14); BLFRND(s, p, Xl, Xr, 13); 103 | BLFRND(s, p, Xr, Xl, 12); BLFRND(s, p, Xl, Xr, 11); 104 | BLFRND(s, p, Xr, Xl, 10); BLFRND(s, p, Xl, Xr, 9); 105 | BLFRND(s, p, Xr, Xl, 8); BLFRND(s, p, Xl, Xr, 7); 106 | BLFRND(s, p, Xr, Xl, 6); BLFRND(s, p, Xl, Xr, 5); 107 | BLFRND(s, p, Xr, Xl, 4); BLFRND(s, p, Xl, Xr, 3); 108 | BLFRND(s, p, Xr, Xl, 2); BLFRND(s, p, Xl, Xr, 1); 109 | 110 | *xl = Xr ^ p[0]; 111 | *xr = Xl; 112 | } 113 | 114 | void 115 | Blowfish_initstate(blf_ctx *c) 116 | { 117 | 118 | /* P-box and S-box tables initialized with digits of Pi */ 119 | 120 | const blf_ctx initstate = 121 | 122 | { { 123 | { 124 | 0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7, 125 | 0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99, 126 | 0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16, 127 | 0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e, 128 | 0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee, 129 | 0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013, 130 | 0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef, 131 | 0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e, 132 | 0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60, 133 | 0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440, 134 | 0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce, 135 | 0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a, 136 | 0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e, 137 | 0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677, 138 | 0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193, 139 | 0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032, 140 | 0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88, 141 | 0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239, 142 | 0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e, 143 | 0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0, 144 | 0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3, 145 | 0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98, 146 | 0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88, 147 | 0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe, 148 | 0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6, 149 | 0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d, 150 | 0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b, 151 | 0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7, 152 | 0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba, 153 | 0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463, 154 | 0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f, 155 | 0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09, 156 | 0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3, 157 | 0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb, 158 | 0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279, 159 | 0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8, 160 | 0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab, 161 | 0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82, 162 | 0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db, 163 | 0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573, 164 | 0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0, 165 | 0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b, 166 | 0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790, 167 | 0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8, 168 | 0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4, 169 | 0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0, 170 | 0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7, 171 | 0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c, 172 | 0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad, 173 | 0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1, 174 | 0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299, 175 | 0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9, 176 | 0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477, 177 | 0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf, 178 | 0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49, 179 | 0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af, 180 | 0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa, 181 | 0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5, 182 | 0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41, 183 | 0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915, 184 | 0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400, 185 | 0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915, 186 | 0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664, 187 | 0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a}, 188 | { 189 | 0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623, 190 | 0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266, 191 | 0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1, 192 | 0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e, 193 | 0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6, 194 | 0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1, 195 | 0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e, 196 | 0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1, 197 | 0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737, 198 | 0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8, 199 | 0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff, 200 | 0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd, 201 | 0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701, 202 | 0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7, 203 | 0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41, 204 | 0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331, 205 | 0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf, 206 | 0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af, 207 | 0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e, 208 | 0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87, 209 | 0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c, 210 | 0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2, 211 | 0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16, 212 | 0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd, 213 | 0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b, 214 | 0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509, 215 | 0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e, 216 | 0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3, 217 | 0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f, 218 | 0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a, 219 | 0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4, 220 | 0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960, 221 | 0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66, 222 | 0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28, 223 | 0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802, 224 | 0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84, 225 | 0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510, 226 | 0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf, 227 | 0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14, 228 | 0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e, 229 | 0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50, 230 | 0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7, 231 | 0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8, 232 | 0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281, 233 | 0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99, 234 | 0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696, 235 | 0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128, 236 | 0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73, 237 | 0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0, 238 | 0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0, 239 | 0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105, 240 | 0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250, 241 | 0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3, 242 | 0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285, 243 | 0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00, 244 | 0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061, 245 | 0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb, 246 | 0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e, 247 | 0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735, 248 | 0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc, 249 | 0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9, 250 | 0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340, 251 | 0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20, 252 | 0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7}, 253 | { 254 | 0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934, 255 | 0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068, 256 | 0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af, 257 | 0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840, 258 | 0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45, 259 | 0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504, 260 | 0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a, 261 | 0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb, 262 | 0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee, 263 | 0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6, 264 | 0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42, 265 | 0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b, 266 | 0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2, 267 | 0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb, 268 | 0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527, 269 | 0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b, 270 | 0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33, 271 | 0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c, 272 | 0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3, 273 | 0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc, 274 | 0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17, 275 | 0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564, 276 | 0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b, 277 | 0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115, 278 | 0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922, 279 | 0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728, 280 | 0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0, 281 | 0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e, 282 | 0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37, 283 | 0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d, 284 | 0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804, 285 | 0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b, 286 | 0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3, 287 | 0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb, 288 | 0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d, 289 | 0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c, 290 | 0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350, 291 | 0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9, 292 | 0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a, 293 | 0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe, 294 | 0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d, 295 | 0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc, 296 | 0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f, 297 | 0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61, 298 | 0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2, 299 | 0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9, 300 | 0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2, 301 | 0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c, 302 | 0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e, 303 | 0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633, 304 | 0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10, 305 | 0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169, 306 | 0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52, 307 | 0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027, 308 | 0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5, 309 | 0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62, 310 | 0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634, 311 | 0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76, 312 | 0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24, 313 | 0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc, 314 | 0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4, 315 | 0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c, 316 | 0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837, 317 | 0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0}, 318 | { 319 | 0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b, 320 | 0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe, 321 | 0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b, 322 | 0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4, 323 | 0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8, 324 | 0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6, 325 | 0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304, 326 | 0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22, 327 | 0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4, 328 | 0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6, 329 | 0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9, 330 | 0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59, 331 | 0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593, 332 | 0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51, 333 | 0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28, 334 | 0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c, 335 | 0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b, 336 | 0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28, 337 | 0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c, 338 | 0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd, 339 | 0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a, 340 | 0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319, 341 | 0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb, 342 | 0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f, 343 | 0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991, 344 | 0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32, 345 | 0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680, 346 | 0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166, 347 | 0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae, 348 | 0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb, 349 | 0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5, 350 | 0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47, 351 | 0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370, 352 | 0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d, 353 | 0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84, 354 | 0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048, 355 | 0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8, 356 | 0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd, 357 | 0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9, 358 | 0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7, 359 | 0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38, 360 | 0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f, 361 | 0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c, 362 | 0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525, 363 | 0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1, 364 | 0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442, 365 | 0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964, 366 | 0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e, 367 | 0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8, 368 | 0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d, 369 | 0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f, 370 | 0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299, 371 | 0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02, 372 | 0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc, 373 | 0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614, 374 | 0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a, 375 | 0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6, 376 | 0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b, 377 | 0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0, 378 | 0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060, 379 | 0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e, 380 | 0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9, 381 | 0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f, 382 | 0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6} 383 | }, 384 | { 385 | 0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, 386 | 0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89, 387 | 0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c, 388 | 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917, 389 | 0x9216d5d9, 0x8979fb1b 390 | } }; 391 | 392 | *c = initstate; 393 | 394 | } 395 | 396 | u_int32_t 397 | Blowfish_stream2word(const u_int8_t *data, u_int16_t databytes, 398 | u_int16_t *current) 399 | { 400 | u_int8_t i; 401 | u_int16_t j; 402 | u_int32_t temp; 403 | 404 | temp = 0x00000000; 405 | j = *current; 406 | 407 | for (i = 0; i < 4; i++, j++) { 408 | if (j >= databytes) 409 | j = 0; 410 | temp = (temp << 8) | data[j]; 411 | } 412 | 413 | *current = j; 414 | return temp; 415 | } 416 | 417 | void 418 | Blowfish_expand0state(blf_ctx *c, const u_int8_t *key, u_int16_t keybytes) 419 | { 420 | u_int16_t i; 421 | u_int16_t j; 422 | u_int16_t k; 423 | u_int32_t temp; 424 | u_int32_t datal; 425 | u_int32_t datar; 426 | 427 | j = 0; 428 | for (i = 0; i < BLF_N + 2; i++) { 429 | /* Extract 4 int8 to 1 int32 from keystream */ 430 | temp = Blowfish_stream2word(key, keybytes, &j); 431 | c->P[i] = c->P[i] ^ temp; 432 | } 433 | 434 | j = 0; 435 | datal = 0x00000000; 436 | datar = 0x00000000; 437 | for (i = 0; i < BLF_N + 2; i += 2) { 438 | Blowfish_encipher(c, &datal, &datar); 439 | 440 | c->P[i] = datal; 441 | c->P[i + 1] = datar; 442 | } 443 | 444 | for (i = 0; i < 4; i++) { 445 | for (k = 0; k < 256; k += 2) { 446 | Blowfish_encipher(c, &datal, &datar); 447 | 448 | c->S[i][k] = datal; 449 | c->S[i][k + 1] = datar; 450 | } 451 | } 452 | } 453 | 454 | 455 | void 456 | Blowfish_expandstate(blf_ctx *c, const u_int8_t *data, u_int16_t databytes, 457 | const u_int8_t *key, u_int16_t keybytes) 458 | { 459 | u_int16_t i; 460 | u_int16_t j; 461 | u_int16_t k; 462 | u_int32_t temp; 463 | u_int32_t datal; 464 | u_int32_t datar; 465 | 466 | j = 0; 467 | for (i = 0; i < BLF_N + 2; i++) { 468 | /* Extract 4 int8 to 1 int32 from keystream */ 469 | temp = Blowfish_stream2word(key, keybytes, &j); 470 | c->P[i] = c->P[i] ^ temp; 471 | } 472 | 473 | j = 0; 474 | datal = 0x00000000; 475 | datar = 0x00000000; 476 | for (i = 0; i < BLF_N + 2; i += 2) { 477 | datal ^= Blowfish_stream2word(data, databytes, &j); 478 | datar ^= Blowfish_stream2word(data, databytes, &j); 479 | Blowfish_encipher(c, &datal, &datar); 480 | 481 | c->P[i] = datal; 482 | c->P[i + 1] = datar; 483 | } 484 | 485 | for (i = 0; i < 4; i++) { 486 | for (k = 0; k < 256; k += 2) { 487 | datal ^= Blowfish_stream2word(data, databytes, &j); 488 | datar ^= Blowfish_stream2word(data, databytes, &j); 489 | Blowfish_encipher(c, &datal, &datar); 490 | 491 | c->S[i][k] = datal; 492 | c->S[i][k + 1] = datar; 493 | } 494 | } 495 | 496 | } 497 | 498 | void 499 | blf_key(blf_ctx *c, const u_int8_t *k, u_int16_t len) 500 | { 501 | /* Initalize S-boxes and subkeys with Pi */ 502 | Blowfish_initstate(c); 503 | 504 | /* Transform S-boxes and subkeys with key */ 505 | Blowfish_expand0state(c, k, len); 506 | } 507 | 508 | void 509 | blf_enc(blf_ctx *c, u_int32_t *data, u_int16_t blocks) 510 | { 511 | u_int32_t *d; 512 | u_int16_t i; 513 | 514 | d = data; 515 | for (i = 0; i < blocks; i++) { 516 | Blowfish_encipher(c, d, d + 1); 517 | d += 2; 518 | } 519 | } 520 | 521 | void 522 | blf_dec(blf_ctx *c, u_int32_t *data, u_int16_t blocks) 523 | { 524 | u_int32_t *d; 525 | u_int16_t i; 526 | 527 | d = data; 528 | for (i = 0; i < blocks; i++) { 529 | Blowfish_decipher(c, d, d + 1); 530 | d += 2; 531 | } 532 | } 533 | 534 | void 535 | blf_ecb_encrypt(blf_ctx *c, u_int8_t *data, u_int32_t len) 536 | { 537 | u_int32_t l, r; 538 | u_int32_t i; 539 | 540 | for (i = 0; i < len; i += 8) { 541 | l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]; 542 | r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]; 543 | Blowfish_encipher(c, &l, &r); 544 | data[0] = l >> 24 & 0xff; 545 | data[1] = l >> 16 & 0xff; 546 | data[2] = l >> 8 & 0xff; 547 | data[3] = l & 0xff; 548 | data[4] = r >> 24 & 0xff; 549 | data[5] = r >> 16 & 0xff; 550 | data[6] = r >> 8 & 0xff; 551 | data[7] = r & 0xff; 552 | data += 8; 553 | } 554 | } 555 | 556 | void 557 | blf_ecb_decrypt(blf_ctx *c, u_int8_t *data, u_int32_t len) 558 | { 559 | u_int32_t l, r; 560 | u_int32_t i; 561 | 562 | for (i = 0; i < len; i += 8) { 563 | l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]; 564 | r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]; 565 | Blowfish_decipher(c, &l, &r); 566 | data[0] = l >> 24 & 0xff; 567 | data[1] = l >> 16 & 0xff; 568 | data[2] = l >> 8 & 0xff; 569 | data[3] = l & 0xff; 570 | data[4] = r >> 24 & 0xff; 571 | data[5] = r >> 16 & 0xff; 572 | data[6] = r >> 8 & 0xff; 573 | data[7] = r & 0xff; 574 | data += 8; 575 | } 576 | } 577 | 578 | void 579 | blf_cbc_encrypt(blf_ctx *c, u_int8_t *iv, u_int8_t *data, u_int32_t len) 580 | { 581 | u_int32_t l, r; 582 | u_int32_t i, j; 583 | 584 | for (i = 0; i < len; i += 8) { 585 | for (j = 0; j < 8; j++) 586 | data[j] ^= iv[j]; 587 | l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]; 588 | r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]; 589 | Blowfish_encipher(c, &l, &r); 590 | data[0] = l >> 24 & 0xff; 591 | data[1] = l >> 16 & 0xff; 592 | data[2] = l >> 8 & 0xff; 593 | data[3] = l & 0xff; 594 | data[4] = r >> 24 & 0xff; 595 | data[5] = r >> 16 & 0xff; 596 | data[6] = r >> 8 & 0xff; 597 | data[7] = r & 0xff; 598 | iv = data; 599 | data += 8; 600 | } 601 | } 602 | 603 | void 604 | blf_cbc_decrypt(blf_ctx *c, u_int8_t *iva, u_int8_t *data, u_int32_t len) 605 | { 606 | u_int32_t l, r; 607 | u_int8_t *iv; 608 | u_int32_t i, j; 609 | 610 | iv = data + len - 16; 611 | data = data + len - 8; 612 | for (i = len - 8; i >= 8; i -= 8) { 613 | l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]; 614 | r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]; 615 | Blowfish_decipher(c, &l, &r); 616 | data[0] = l >> 24 & 0xff; 617 | data[1] = l >> 16 & 0xff; 618 | data[2] = l >> 8 & 0xff; 619 | data[3] = l & 0xff; 620 | data[4] = r >> 24 & 0xff; 621 | data[5] = r >> 16 & 0xff; 622 | data[6] = r >> 8 & 0xff; 623 | data[7] = r & 0xff; 624 | for (j = 0; j < 8; j++) 625 | data[j] ^= iv[j]; 626 | iv -= 8; 627 | data -= 8; 628 | } 629 | l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]; 630 | r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]; 631 | Blowfish_decipher(c, &l, &r); 632 | data[0] = l >> 24 & 0xff; 633 | data[1] = l >> 16 & 0xff; 634 | data[2] = l >> 8 & 0xff; 635 | data[3] = l & 0xff; 636 | data[4] = r >> 24 & 0xff; 637 | data[5] = r >> 16 & 0xff; 638 | data[6] = r >> 8 & 0xff; 639 | data[7] = r & 0xff; 640 | for (j = 0; j < 8; j++) 641 | data[j] ^= iva[j]; 642 | } 643 | 644 | #if 0 645 | void 646 | report(u_int32_t data[], u_int16_t len) 647 | { 648 | u_int16_t i; 649 | for (i = 0; i < len; i += 2) 650 | printf("Block %0hd: %08lx %08lx.\n", 651 | i / 2, data[i], data[i + 1]); 652 | } 653 | void 654 | main(void) 655 | { 656 | 657 | blf_ctx c; 658 | char key[] = "AAAAA"; 659 | char key2[] = "abcdefghijklmnopqrstuvwxyz"; 660 | 661 | u_int32_t data[10]; 662 | u_int32_t data2[] = 663 | {0x424c4f57L, 0x46495348L}; 664 | 665 | u_int16_t i; 666 | 667 | /* First test */ 668 | for (i = 0; i < 10; i++) 669 | data[i] = i; 670 | 671 | blf_key(&c, (u_int8_t *) key, 5); 672 | blf_enc(&c, data, 5); 673 | blf_dec(&c, data, 1); 674 | blf_dec(&c, data + 2, 4); 675 | printf("Should read as 0 - 9.\n"); 676 | report(data, 10); 677 | 678 | /* Second test */ 679 | blf_key(&c, (u_int8_t *) key2, strlen(key2)); 680 | blf_enc(&c, data2, 1); 681 | printf("\nShould read as: 0x324ed0fe 0xf413a203.\n"); 682 | report(data2, 2); 683 | blf_dec(&c, data2, 1); 684 | report(data2, 2); 685 | } 686 | #endif 687 | -------------------------------------------------------------------------------- /bcrypt/blowfish.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Blowfish - a fast block cipher designed by Bruce Schneier 3 | * 4 | * Copyright 1997 Niels Provos 5 | * All rights reserved. 6 | * 7 | * Redistribution and use in source and binary forms, with or without 8 | * modification, are permitted provided that the following conditions 9 | * are met: 10 | * 1. Redistributions of source code must retain the above copyright 11 | * notice, this list of conditions and the following disclaimer. 12 | * 2. Redistributions in binary form must reproduce the above copyright 13 | * notice, this list of conditions and the following disclaimer in the 14 | * documentation and/or other materials provided with the distribution. 15 | * 3. All advertising materials mentioning features or use of this software 16 | * must display the following acknowledgement: 17 | * This product includes software developed by Niels Provos. 18 | * 4. The name of the author may not be used to endorse or promote products 19 | * derived from this software without specific prior written permission. 20 | * 21 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 22 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 23 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 24 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 25 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 26 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 27 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 28 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 30 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 | * 32 | */ 33 | 34 | /* 35 | * FreeBSD implementation by Paul Herman 36 | */ 37 | 38 | #include 39 | #include 40 | 41 | #ifndef _BLF_H_ 42 | #define _BLF_H_ 43 | 44 | /* Schneier states the maximum key length to be 56 bytes. 45 | * The way how the subkeys are initalized by the key up 46 | * to (N+2)*4 i.e. 72 bytes are utilized. 47 | * Warning: For normal blowfish encryption only 56 bytes 48 | * of the key affect all cipherbits. 49 | */ 50 | 51 | #define BLF_N 16 /* Number of Subkeys */ 52 | #define BLF_MAXKEYLEN ((BLF_N-2)*4) /* 448 bits */ 53 | 54 | /* Blowfish context */ 55 | typedef struct BlowfishContext { 56 | u_int32_t S[4][256]; /* S-Boxes */ 57 | u_int32_t P[BLF_N + 2]; /* Subkeys */ 58 | } blf_ctx; 59 | 60 | /* Raw access to customized Blowfish 61 | * blf_key is just: 62 | * Blowfish_initstate( state ) 63 | * Blowfish_expand0state( state, key, keylen ) 64 | */ 65 | 66 | void Blowfish_encipher(blf_ctx *, u_int32_t *, u_int32_t *); 67 | void Blowfish_decipher(blf_ctx *, u_int32_t *, u_int32_t *); 68 | void Blowfish_initstate(blf_ctx *); 69 | void Blowfish_expand0state(blf_ctx *, const u_int8_t *, u_int16_t); 70 | void Blowfish_expandstate 71 | (blf_ctx *, const u_int8_t *, u_int16_t, const u_int8_t *, u_int16_t); 72 | 73 | /* Standard Blowfish */ 74 | 75 | void blf_key(blf_ctx *, const u_int8_t *, u_int16_t); 76 | void blf_enc(blf_ctx *, u_int32_t *, u_int16_t); 77 | void blf_dec(blf_ctx *, u_int32_t *, u_int16_t); 78 | 79 | void blf_ecb_encrypt(blf_ctx *, u_int8_t *, u_int32_t); 80 | void blf_ecb_decrypt(blf_ctx *, u_int8_t *, u_int32_t); 81 | 82 | void blf_cbc_encrypt(blf_ctx *, u_int8_t *, u_int8_t *, u_int32_t); 83 | void blf_cbc_decrypt(blf_ctx *, u_int8_t *, u_int8_t *, u_int32_t); 84 | 85 | /* Converts u_int8_t to u_int32_t */ 86 | u_int32_t Blowfish_stream2word(const u_int8_t *, u_int16_t , u_int16_t *); 87 | 88 | #endif 89 | -------------------------------------------------------------------------------- /bcrypt/build: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | gcc arc4random.c blowfish.h blowfish.c crypt-blowfish.c 3 | -------------------------------------------------------------------------------- /bcrypt/crypt-blowfish.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 1997 Niels Provos 3 | * All rights reserved. 4 | * 5 | * Redistribution and use in source and binary forms, with or without 6 | * modification, are permitted provided that the following conditions 7 | * are met: 8 | * 1. Redistributions of source code must retain the above copyright 9 | * notice, this list of conditions and the following disclaimer. 10 | * 2. Redistributions in binary form must reproduce the above copyright 11 | * notice, this list of conditions and the following disclaimer in the 12 | * documentation and/or other materials provided with the distribution. 13 | * 3. All advertising materials mentioning features or use of this software 14 | * must display the following acknowledgement: 15 | * This product includes software developed by Niels Provos. 16 | * 4. The name of the author may not be used to endorse or promote products 17 | * derived from this software without specific prior written permission. 18 | * 19 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 20 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 21 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 23 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 24 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 28 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 | */ 30 | 31 | #include 32 | #include 33 | #include 34 | 35 | /* This implementation is adaptable to current computing power. 36 | * You can have up to 2^31 rounds which should be enough for some 37 | * time to come. 38 | */ 39 | 40 | #define _PASSWORD_LEN 128 41 | 42 | #define BCRYPT_VERSION '2' 43 | #define BCRYPT_MAXSALT 16 /* Precomputation is just so nice */ 44 | #define BCRYPT_BLOCKS 6 /* Ciphertext blocks */ 45 | #define BCRYPT_MINROUNDS 16 /* we have log2(rounds) in salt */ 46 | 47 | #define false 0 48 | #define true 1 49 | #define bool int 50 | 51 | /* This password hashing algorithm was designed by David Mazieres 52 | * and works as follows: 53 | * 54 | * 1. state := InitState () 55 | * 2. state := ExpandKey (state, salt, password) 3. 56 | * REPEAT rounds: 57 | * state := ExpandKey (state, 0, salt) 58 | * state := ExpandKey(state, 0, password) 59 | * 4. ctext := "OrpheanBeholderScryDoubt" 60 | * 5. REPEAT 64: 61 | * ctext := Encrypt_ECB (state, ctext); 62 | * 6. RETURN Concatenate (salt, ctext); 63 | * 64 | */ 65 | 66 | /* 67 | * FreeBSD implementation by Paul Herman 68 | */ 69 | 70 | #include 71 | #include 72 | #include 73 | #include 74 | #include 75 | #include "blowfish.h" 76 | #ifdef __APPLE__ 77 | #include 78 | #else 79 | #include "crypt.h" 80 | #endif 81 | 82 | /* This implementation is adaptable to current computing power. 83 | * You can have up to 2^31 rounds which should be enough for some 84 | * time to come. 85 | */ 86 | 87 | #define BCRYPT_VERSION '2' 88 | #define BCRYPT_MAXSALT 16 /* Precomputation is just so nice */ 89 | #define BCRYPT_BLOCKS 6 /* Ciphertext blocks */ 90 | #define BCRYPT_MINROUNDS 16 /* we have log2(rounds) in salt */ 91 | 92 | char *bcrypt_gensalt(u_int8_t); 93 | 94 | static void encode_salt(char *, u_int8_t *, u_int16_t, u_int8_t); 95 | static void encode_base64(u_int8_t *, u_int8_t *, u_int16_t); 96 | static void decode_base64(u_int8_t *, u_int16_t, const u_int8_t *); 97 | 98 | //static char encrypted[_PASSWORD_LEN]; 99 | static char gsalt[BCRYPT_MAXSALT * 4 / 3 + 1]; 100 | static int error = -1; 101 | 102 | static const u_int8_t Base64Code[] = 103 | "./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; 104 | 105 | static const u_int8_t index_64[128] = 106 | { 107 | 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 108 | 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 109 | 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 110 | 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 111 | 255, 255, 255, 255, 255, 255, 0, 1, 54, 55, 112 | 56, 57, 58, 59, 60, 61, 62, 63, 255, 255, 113 | 255, 255, 255, 255, 255, 2, 3, 4, 5, 6, 114 | 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 115 | 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 116 | 255, 255, 255, 255, 255, 255, 28, 29, 30, 117 | 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 118 | 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 119 | 51, 52, 53, 255, 255, 255, 255, 255 120 | }; 121 | #define CHAR64(c) ( (c) > 127 ? 255 : index_64[(c)]) 122 | 123 | static void 124 | decode_base64(u_int8_t *buffer, u_int16_t len, const u_int8_t *data) 125 | { 126 | u_int8_t *bp = buffer; 127 | const u_int8_t *p = data; 128 | u_int8_t c1, c2, c3, c4; 129 | while (bp < buffer + len) { 130 | c1 = CHAR64(*p); 131 | c2 = CHAR64(*(p + 1)); 132 | 133 | /* Invalid data */ 134 | if (c1 == 255 || c2 == 255) 135 | break; 136 | 137 | *bp++ = (u_int8_t)((c1 << 2) | ((c2 & 0x30) >> 4)); 138 | if (bp >= buffer + len) 139 | break; 140 | 141 | c3 = CHAR64(*(p + 2)); 142 | if (c3 == 255) 143 | break; 144 | 145 | *bp++ = ((c2 & 0x0f) << 4) | ((c3 & 0x3c) >> 2); 146 | if (bp >= buffer + len) 147 | break; 148 | 149 | c4 = CHAR64(*(p + 3)); 150 | if (c4 == 255) 151 | break; 152 | *bp++ = ((c3 & 0x03) << 6) | c4; 153 | 154 | p += 4; 155 | } 156 | } 157 | 158 | static void 159 | encode_salt(char *salt, u_int8_t *csalt, u_int16_t clen, u_int8_t logr) 160 | { 161 | salt[0] = '$'; 162 | salt[1] = BCRYPT_VERSION; 163 | salt[2] = 'a'; 164 | salt[3] = '$'; 165 | 166 | snprintf(salt + 4, 4, "%2.2u$", logr); 167 | 168 | encode_base64((u_int8_t *) salt + 7, csalt, clen); 169 | } 170 | /* Generates a salt for this version of crypt. 171 | Since versions may change. Keeping this here 172 | seems sensible. 173 | */ 174 | 175 | char * 176 | bcrypt_gensalt(u_int8_t log_rounds) 177 | { 178 | u_int8_t csalt[BCRYPT_MAXSALT]; 179 | u_int16_t i; 180 | u_int32_t seed = 0; 181 | 182 | for (i = 0; i < BCRYPT_MAXSALT; i++) { 183 | if (i % 4 == 0) 184 | seed = arc4random(); 185 | csalt[i] = seed & 0xff; 186 | seed = seed >> 8; 187 | } 188 | 189 | if (log_rounds < 4) 190 | log_rounds = 4; 191 | 192 | encode_salt(gsalt, csalt, BCRYPT_MAXSALT, log_rounds); 193 | return gsalt; 194 | } 195 | /* We handle $Vers$log2(NumRounds)$salt+passwd$ 196 | i.e. $2$04$iwouldntknowwhattosayetKdJ6iFtacBqJdKe6aW7ou */ 197 | 198 | int 199 | crypt_blowfish(const char *key, const char *salt, char *encrypted) 200 | { 201 | blf_ctx state; 202 | u_int32_t rounds, i, k; 203 | u_int16_t j; 204 | u_int8_t key_len, salt_len, logr, minr; 205 | u_int8_t ciphertext[4 * BCRYPT_BLOCKS] = "OrpheanBeholderScryDoubt"; 206 | u_int8_t csalt[BCRYPT_MAXSALT]; 207 | u_int32_t cdata[BCRYPT_BLOCKS]; 208 | static const char *magic = "$2a$04$"; 209 | 210 | /* Defaults */ 211 | minr = 'a'; 212 | logr = 4; 213 | rounds = 1 << logr; 214 | 215 | /* If it starts with the magic string, then skip that */ 216 | if(!strncmp(salt, magic, strlen(magic))) { 217 | salt += strlen(magic); 218 | } 219 | else if (*salt == '$') { 220 | 221 | /* Discard "$" identifier */ 222 | salt++; 223 | 224 | if (*salt > BCRYPT_VERSION) { 225 | /* How do I handle errors ? Return ':' */ 226 | return error; 227 | } 228 | 229 | /* Check for minor versions */ 230 | if (salt[1] != '$') { 231 | switch (salt[1]) { 232 | case 'a': 233 | /* 'ab' should not yield the same as 'abab' */ 234 | minr = (u_int8_t)salt[1]; 235 | salt++; 236 | break; 237 | default: 238 | return error; 239 | } 240 | } else 241 | minr = 0; 242 | 243 | /* Discard version + "$" identifier */ 244 | salt += 2; 245 | 246 | if (salt[2] != '$') 247 | /* Out of sync with passwd entry */ 248 | return error; 249 | 250 | /* Computer power doesnt increase linear, 2^x should be fine */ 251 | logr = (u_int8_t)atoi(salt); 252 | rounds = 1 << logr; 253 | if (rounds < BCRYPT_MINROUNDS) 254 | return error; 255 | 256 | /* Discard num rounds + "$" identifier */ 257 | salt += 3; 258 | } 259 | 260 | 261 | /* We dont want the base64 salt but the raw data */ 262 | decode_base64(csalt, BCRYPT_MAXSALT, salt); 263 | salt_len = BCRYPT_MAXSALT; 264 | key_len = (u_int8_t)(strlen(key) + (minr >= 'a' ? 1 : 0)); 265 | 266 | /* Setting up S-Boxes and Subkeys */ 267 | Blowfish_initstate(&state); 268 | Blowfish_expandstate(&state, csalt, salt_len, 269 | (const u_int8_t *) key, key_len); 270 | for (k = 0; k < rounds; k++) { 271 | Blowfish_expand0state(&state, (const u_int8_t *) key, key_len); 272 | Blowfish_expand0state(&state, csalt, salt_len); 273 | } 274 | 275 | /* This can be precomputed later */ 276 | j = 0; 277 | for (i = 0; i < BCRYPT_BLOCKS; i++) 278 | cdata[i] = Blowfish_stream2word(ciphertext, 4 * BCRYPT_BLOCKS, &j); 279 | 280 | /* Now do the encryption */ 281 | for (k = 0; k < 64; k++) 282 | blf_enc(&state, cdata, BCRYPT_BLOCKS / 2); 283 | 284 | for (i = 0; i < BCRYPT_BLOCKS; i++) { 285 | ciphertext[4 * i + 3] = cdata[i] & 0xff; 286 | cdata[i] = cdata[i] >> 8; 287 | ciphertext[4 * i + 2] = cdata[i] & 0xff; 288 | cdata[i] = cdata[i] >> 8; 289 | ciphertext[4 * i + 1] = cdata[i] & 0xff; 290 | cdata[i] = cdata[i] >> 8; 291 | ciphertext[4 * i + 0] = cdata[i] & 0xff; 292 | } 293 | 294 | 295 | i = 0; 296 | encrypted[i++] = '$'; 297 | encrypted[i++] = BCRYPT_VERSION; 298 | if (minr) 299 | encrypted[i++] = (int8_t)minr; 300 | encrypted[i++] = '$'; 301 | 302 | snprintf(encrypted + i, 4, "%2.2u$", logr); 303 | 304 | encode_base64((u_int8_t *) encrypted + i + 3, csalt, BCRYPT_MAXSALT); 305 | encode_base64((u_int8_t *) encrypted + strlen(encrypted), ciphertext, 306 | 4 * BCRYPT_BLOCKS - 1); 307 | return 0; 308 | } 309 | 310 | static void 311 | encode_base64(u_int8_t *buffer, u_int8_t *data, u_int16_t len) 312 | { 313 | u_int8_t *bp = buffer; 314 | u_int8_t *p = data; 315 | u_int8_t c1, c2; 316 | while (p < data + len) { 317 | c1 = *p++; 318 | *bp++ = Base64Code[(c1 >> 2)]; 319 | c1 = (c1 & 0x03) << 4; 320 | if (p >= data + len) { 321 | *bp++ = Base64Code[c1]; 322 | break; 323 | } 324 | c2 = *p++; 325 | c1 |= (c2 >> 4) & 0x0f; 326 | *bp++ = Base64Code[c1]; 327 | c1 = (c2 & 0x0f) << 2; 328 | if (p >= data + len) { 329 | *bp++ = Base64Code[c1]; 330 | break; 331 | } 332 | c2 = *p++; 333 | c1 |= (c2 >> 6) & 0x03; 334 | *bp++ = Base64Code[c1]; 335 | *bp++ = Base64Code[c2 & 0x3f]; 336 | } 337 | *bp = '\0'; 338 | } 339 | 340 | int compare_string(const char* s1, const char* s2) { 341 | 342 | int eq = 1; 343 | int s1_len = strlen(s1); 344 | int s2_len = strlen(s2); 345 | 346 | if (s1_len != s2_len) { 347 | eq = 0; 348 | } 349 | 350 | const int max_len = (s2_len < s1_len) ? s1_len : s2_len; 351 | 352 | // to prevent timing attacks, should check entire string 353 | // don't exit after found to be false 354 | int i; 355 | for (i = 0; i < max_len; ++i) { 356 | if (s1_len >= i && s2_len >= i && s1[i] != s2[i]) { 357 | eq = 0; 358 | } 359 | } 360 | 361 | return eq; 362 | } 363 | 364 | #if 0 365 | void 366 | main() 367 | { 368 | char blubber[73]; 369 | char tocheck[73]; 370 | char p[_PASSWORD_LEN]; 371 | char check[_PASSWORD_LEN]; 372 | char *s; 373 | char salt[100]; 374 | //char *p, *s, *check; 375 | salt[0] = '$'; 376 | salt[1] = BCRYPT_VERSION; 377 | salt[2] = '$'; 378 | 379 | snprintf(salt + 3, 4, "%2.2u$", 5); 380 | 381 | salt[99] = 0; 382 | printf("72 bytes of password: "); 383 | fgets(blubber, 73, stdin); 384 | blubber[72] = 0; 385 | 386 | s = bcrypt_gensalt(5); 387 | printf("Generated salt: %s\n", s); 388 | crypt_blowfish(blubber, s, p); 389 | printf("Passwd entry: %s\n", p); 390 | fflush(stdin); 391 | 392 | printf("Enter password for check:"); 393 | fgets(tocheck, 73, stdin); 394 | tocheck[72] = 0; 395 | 396 | crypt_blowfish(tocheck, s, check); 397 | printf("blowfish generated (should match passwd entry): %s\n", check); 398 | 399 | if (compare_string(p, check)==1) { 400 | printf("Password matches.\n"); 401 | } else { 402 | printf("INVALID PASSWORD.\n"); 403 | } 404 | } 405 | #endif 406 | --------------------------------------------------------------------------------