summaryrefslogtreecommitdiffabout
path: root/pwmanager
Unidiff
Diffstat (limited to 'pwmanager') (more/less context) (ignore whitespace changes)
-rw-r--r--pwmanager/libcrypt/cipher/serpent.c4
-rw-r--r--pwmanager/pwmanager/binentrygen.cpp5
-rw-r--r--pwmanager/pwmanager/binentrygen.h2
-rw-r--r--pwmanager/pwmanager/blowfish.cpp2
-rw-r--r--pwmanager/pwmanager/blowfish.h4
-rw-r--r--pwmanager/pwmanager/genpasswd.cpp1
-rw-r--r--pwmanager/pwmanager/libgcryptif.h4
-rw-r--r--pwmanager/pwmanager/pwmexception.h3
-rw-r--r--pwmanager/pwmanager/randomizer.h1
9 files changed, 17 insertions, 9 deletions
diff --git a/pwmanager/libcrypt/cipher/serpent.c b/pwmanager/libcrypt/cipher/serpent.c
index d606d9f..fb5df20 100644
--- a/pwmanager/libcrypt/cipher/serpent.c
+++ b/pwmanager/libcrypt/cipher/serpent.c
@@ -1,979 +1,979 @@
1/* serpent.c - Implementation of the Serpent encryption algorithm. 1/* serpent.c - Implementation of the Serpent encryption algorithm.
2 *Copyright (C) 2003 Free Software Foundation, Inc. 2 *Copyright (C) 2003 Free Software Foundation, Inc.
3 * 3 *
4 * This file is part of Libgcrypt. 4 * This file is part of Libgcrypt.
5 * 5 *
6 * Libgcrypt is free software; you can redistribute it and/or modify 6 * Libgcrypt is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU Lesser general Public License as 7 * it under the terms of the GNU Lesser general Public License as
8 * published by the Free Software Foundation; either version 2.1 of 8 * published by the Free Software Foundation; either version 2.1 of
9 * the License, or (at your option) any later version. 9 * the License, or (at your option) any later version.
10 * 10 *
11 * Libgcrypt is distributed in the hope that it will be useful, 11 * Libgcrypt is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU Lesser General Public License for more details. 14 * GNU Lesser General Public License for more details.
15 * 15 *
16 * You should have received a copy of the GNU Lesser General Public 16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this program; if not, write to the Free Software 17 * License along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 18 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
19 * 02111-1307, USA. 19 * 02111-1307, USA.
20 */ 20 */
21 21
22#include <config.h> 22#include <config.h>
23 23
24#include <string.h> 24#include <string.h>
25#include <stdio.h> 25#include <stdio.h>
26 26
27#include "types.h" 27#include "types.h"
28#include "g10lib.h" 28#include "g10lib.h"
29#include "cipher.h" 29#include "cipher.h"
30#include "bithelp.h" 30#include "bithelp.h"
31 31
32/* Number of rounds per Serpent encrypt/decrypt operation. */ 32/* Number of rounds per Serpent encrypt/decrypt operation. */
33#define ROUNDS 32 33#define ROUNDS 32
34 34
35/* Magic number, used during generating of the subkeys. */ 35/* Magic number, used during generating of the subkeys. */
36#define PHI 0x9E3779B9 36#define PHI 0x9E3779B9
37 37
38/* Internal types. */ 38/* Internal types. */
39typedef byte byte_t; 39typedef byte byte_t;
40typedef u32 u32_t; 40typedef u32 u32_t;
41 41
42/* Serpent works on 128 bit blocks. */ 42/* Serpent works on 128 bit blocks. */
43typedef u32_t serpent_block_t[4]; 43typedef u32_t serpent_block_t[4];
44 44
45/* Serpent key, provided by the user. If the original key is shorter 45/* Serpent key, provided by the user. If the original key is shorter
46 than 256 bits, it is padded. */ 46 than 256 bits, it is padded. */
47typedef u32_t serpent_key_t[8]; 47typedef u32_t serpent_key_t[8];
48 48
49/* The key schedule consists of 33 128 bit subkeys. */ 49/* The key schedule consists of 33 128 bit subkeys. */
50typedef u32_t serpent_subkeys_t[ROUNDS + 1][4]; 50typedef u32_t serpent_subkeys_t[ROUNDS + 1][4];
51 51
52/* A Serpent context. */ 52/* A Serpent context. */
53typedef struct serpent_context 53typedef struct serpent_context
54{ 54{
55 serpent_subkeys_t keys;/* Generated subkeys. */ 55 serpent_subkeys_t keys;/* Generated subkeys. */
56} serpent_context_t; 56} serpent_context_t;
57 57
58#define byte_swap_32(x) \ 58#define byte_swap_32(x) \
59 (0 \ 59 (0 \
60 | (((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >> 8) \ 60 | (((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >> 8) \
61 | (((x) & 0x0000ff00) << 8) | (((x) & 0x000000ff) << 24)); 61 | (((x) & 0x0000ff00) << 8) | (((x) & 0x000000ff) << 24));
62 62
63/* These are the S-Boxes of Serpent. They are copied from Serpents 63/* These are the S-Boxes of Serpent. They are copied from Serpents
64 reference implementation (the optimized one, contained in 64 reference implementation (the optimized one, contained in
65 `floppy2') and are therefore: 65 `floppy2') and are therefore:
66 66
67 Copyright (C) 1998 Ross Anderson, Eli Biham, Lars Knudsen. 67 Copyright (C) 1998 Ross Anderson, Eli Biham, Lars Knudsen.
68 68
69 To quote the Serpent homepage 69 To quote the Serpent homepage
70 (http://www.cl.cam.ac.uk/~rja14/serpent.html): 70 (http://www.cl.cam.ac.uk/~rja14/serpent.html):
71 71
72 "Serpent is now completely in the public domain, and we impose no 72 "Serpent is now completely in the public domain, and we impose no
73 restrictions on its use. This was announced on the 21st August at 73 restrictions on its use. This was announced on the 21st August at
74 the First AES Candidate Conference. The optimised implementations 74 the First AES Candidate Conference. The optimised implementations
75 in the submission package are now under the GNU PUBLIC LICENSE 75 in the submission package are now under the GNU PUBLIC LICENSE
76 (GPL), although some comments in the code still say otherwise. You 76 (GPL), although some comments in the code still say otherwise. You
77 are welcome to use Serpent for any application." */ 77 are welcome to use Serpent for any application." */
78 78
79#define SBOX0(a, b, c, d, w, x, y, z) \ 79#define SBOX0(a, b, c, d, w, x, y, z) \
80 { \ 80 { \
81 register unsigned long t02, t03, t05, t06, t07, t08, t09; \ 81 register unsigned long t02, t03, t05, t06, t07, t08, t09; \
82 register unsigned long t11, t12, t13, t14, t15, t17, t01; \ 82 register unsigned long t11, t12, t13, t14, t15, t17, t01; \
83 t01 = b ^ c ; \ 83 t01 = b ^ c ; \
84 t02 = a | d ; \ 84 t02 = a | d ; \
85 t03 = a ^ b ; \ 85 t03 = a ^ b ; \
86 z = t02 ^ t01; \ 86 z = t02 ^ t01; \
87 t05 = c | z ; \ 87 t05 = c | z ; \
88 t06 = a ^ d ; \ 88 t06 = a ^ d ; \
89 t07 = b | c ; \ 89 t07 = b | c ; \
90 t08 = d & t05; \ 90 t08 = d & t05; \
91 t09 = t03 & t07; \ 91 t09 = t03 & t07; \
92 y = t09 ^ t08; \ 92 y = t09 ^ t08; \
93 t11 = t09 & y ; \ 93 t11 = t09 & y ; \
94 t12 = c ^ d ; \ 94 t12 = c ^ d ; \
95 t13 = t07 ^ t11; \ 95 t13 = t07 ^ t11; \
96 t14 = b & t06; \ 96 t14 = b & t06; \
97 t15 = t06 ^ t13; \ 97 t15 = t06 ^ t13; \
98 w = ~ t15; \ 98 w = ~ t15; \
99 t17 = w ^ t14; \ 99 t17 = w ^ t14; \
100 x = t12 ^ t17; \ 100 x = t12 ^ t17; \
101 } 101 }
102 102
103#define SBOX0_INVERSE(a, b, c, d, w, x, y, z) \ 103#define SBOX0_INVERSE(a, b, c, d, w, x, y, z) \
104 { \ 104 { \
105 register unsigned long t02, t03, t04, t05, t06, t08, t09, t10; \ 105 register unsigned long t02, t03, t04, t05, t06, t08, t09, t10; \
106 register unsigned long t12, t13, t14, t15, t17, t18, t01; \ 106 register unsigned long t12, t13, t14, t15, t17, t18, t01; \
107 t01 = c ^ d ; \ 107 t01 = c ^ d ; \
108 t02 = a | b ; \ 108 t02 = a | b ; \
109 t03 = b | c ; \ 109 t03 = b | c ; \
110 t04 = c & t01; \ 110 t04 = c & t01; \
111 t05 = t02 ^ t01; \ 111 t05 = t02 ^ t01; \
112 t06 = a | t04; \ 112 t06 = a | t04; \
113 y = ~ t05; \ 113 y = ~ t05; \
114 t08 = b ^ d ; \ 114 t08 = b ^ d ; \
115 t09 = t03 & t08; \ 115 t09 = t03 & t08; \
116 t10 = d | y ; \ 116 t10 = d | y ; \
117 x = t09 ^ t06; \ 117 x = t09 ^ t06; \
118 t12 = a | t05; \ 118 t12 = a | t05; \
119 t13 = x ^ t12; \ 119 t13 = x ^ t12; \
120 t14 = t03 ^ t10; \ 120 t14 = t03 ^ t10; \
121 t15 = a ^ c ; \ 121 t15 = a ^ c ; \
122 z = t14 ^ t13; \ 122 z = t14 ^ t13; \
123 t17 = t05 & t13; \ 123 t17 = t05 & t13; \
124 t18 = t14 | t17; \ 124 t18 = t14 | t17; \
125 w = t15 ^ t18; \ 125 w = t15 ^ t18; \
126 } 126 }
127 127
128#define SBOX1(a, b, c, d, w, x, y, z) \ 128#define SBOX1(a, b, c, d, w, x, y, z) \
129 { \ 129 { \
130 register unsigned long t02, t03, t04, t05, t06, t07, t08; \ 130 register unsigned long t02, t03, t04, t05, t06, t07, t08; \
131 register unsigned long t10, t11, t12, t13, t16, t17, t01; \ 131 register unsigned long t10, t11, t12, t13, t16, t17, t01; \
132 t01 = a | d ; \ 132 t01 = a | d ; \
133 t02 = c ^ d ; \ 133 t02 = c ^ d ; \
134 t03 = ~ b ; \ 134 t03 = ~ b ; \
135 t04 = a ^ c ; \ 135 t04 = a ^ c ; \
136 t05 = a | t03; \ 136 t05 = a | t03; \
137 t06 = d & t04; \ 137 t06 = d & t04; \
138 t07 = t01 & t02; \ 138 t07 = t01 & t02; \
139 t08 = b | t06; \ 139 t08 = b | t06; \
140 y = t02 ^ t05; \ 140 y = t02 ^ t05; \
141 t10 = t07 ^ t08; \ 141 t10 = t07 ^ t08; \
142 t11 = t01 ^ t10; \ 142 t11 = t01 ^ t10; \
143 t12 = y ^ t11; \ 143 t12 = y ^ t11; \
144 t13 = b & d ; \ 144 t13 = b & d ; \
145 z = ~ t10; \ 145 z = ~ t10; \
146 x = t13 ^ t12; \ 146 x = t13 ^ t12; \
147 t16 = t10 | x ; \ 147 t16 = t10 | x ; \
148 t17 = t05 & t16; \ 148 t17 = t05 & t16; \
149 w = c ^ t17; \ 149 w = c ^ t17; \
150 } 150 }
151 151
152#define SBOX1_INVERSE(a, b, c, d, w, x, y, z) \ 152#define SBOX1_INVERSE(a, b, c, d, w, x, y, z) \
153 { \ 153 { \
154 register unsigned long t02, t03, t04, t05, t06, t07, t08; \ 154 register unsigned long t02, t03, t04, t05, t06, t07, t08; \
155 register unsigned long t09, t10, t11, t14, t15, t17, t01; \ 155 register unsigned long t09, t10, t11, t14, t15, t17, t01; \
156 t01 = a ^ b ; \ 156 t01 = a ^ b ; \
157 t02 = b | d ; \ 157 t02 = b | d ; \
158 t03 = a & c ; \ 158 t03 = a & c ; \
159 t04 = c ^ t02; \ 159 t04 = c ^ t02; \
160 t05 = a | t04; \ 160 t05 = a | t04; \
161 t06 = t01 & t05; \ 161 t06 = t01 & t05; \
162 t07 = d | t03; \ 162 t07 = d | t03; \
163 t08 = b ^ t06; \ 163 t08 = b ^ t06; \
164 t09 = t07 ^ t06; \ 164 t09 = t07 ^ t06; \
165 t10 = t04 | t03; \ 165 t10 = t04 | t03; \
166 t11 = d & t08; \ 166 t11 = d & t08; \
167 y = ~ t09; \ 167 y = ~ t09; \
168 x = t10 ^ t11; \ 168 x = t10 ^ t11; \
169 t14 = a | y ; \ 169 t14 = a | y ; \
170 t15 = t06 ^ x ; \ 170 t15 = t06 ^ x ; \
171 z = t01 ^ t04; \ 171 z = t01 ^ t04; \
172 t17 = c ^ t15; \ 172 t17 = c ^ t15; \
173 w = t14 ^ t17; \ 173 w = t14 ^ t17; \
174 } 174 }
175 175
176#define SBOX2(a, b, c, d, w, x, y, z) \ 176#define SBOX2(a, b, c, d, w, x, y, z) \
177 { \ 177 { \
178 register unsigned long t02, t03, t05, t06, t07, t08; \ 178 register unsigned long t02, t03, t05, t06, t07, t08; \
179 register unsigned long t09, t10, t12, t13, t14, t01; \ 179 register unsigned long t09, t10, t12, t13, t14, t01; \
180 t01 = a | c ; \ 180 t01 = a | c ; \
181 t02 = a ^ b ; \ 181 t02 = a ^ b ; \
182 t03 = d ^ t01; \ 182 t03 = d ^ t01; \
183 w = t02 ^ t03; \ 183 w = t02 ^ t03; \
184 t05 = c ^ w ; \ 184 t05 = c ^ w ; \
185 t06 = b ^ t05; \ 185 t06 = b ^ t05; \
186 t07 = b | t05; \ 186 t07 = b | t05; \
187 t08 = t01 & t06; \ 187 t08 = t01 & t06; \
188 t09 = t03 ^ t07; \ 188 t09 = t03 ^ t07; \
189 t10 = t02 | t09; \ 189 t10 = t02 | t09; \
190 x = t10 ^ t08; \ 190 x = t10 ^ t08; \
191 t12 = a | d ; \ 191 t12 = a | d ; \
192 t13 = t09 ^ x ; \ 192 t13 = t09 ^ x ; \
193 t14 = b ^ t13; \ 193 t14 = b ^ t13; \
194 z = ~ t09; \ 194 z = ~ t09; \
195 y = t12 ^ t14; \ 195 y = t12 ^ t14; \
196 } 196 }
197 197
198#define SBOX2_INVERSE(a, b, c, d, w, x, y, z) \ 198#define SBOX2_INVERSE(a, b, c, d, w, x, y, z) \
199 { \ 199 { \
200 register unsigned long t02, t03, t04, t06, t07, t08, t09; \ 200 register unsigned long t02, t03, t04, t06, t07, t08, t09; \
201 register unsigned long t10, t11, t12, t15, t16, t17, t01; \ 201 register unsigned long t10, t11, t12, t15, t16, t17, t01; \
202 t01 = a ^ d ; \ 202 t01 = a ^ d ; \
203 t02 = c ^ d ; \ 203 t02 = c ^ d ; \
204 t03 = a & c ; \ 204 t03 = a & c ; \
205 t04 = b | t02; \ 205 t04 = b | t02; \
206 w = t01 ^ t04; \ 206 w = t01 ^ t04; \
207 t06 = a | c ; \ 207 t06 = a | c ; \
208 t07 = d | w ; \ 208 t07 = d | w ; \
209 t08 = ~ d ; \ 209 t08 = ~ d ; \
210 t09 = b & t06; \ 210 t09 = b & t06; \
211 t10 = t08 | t03; \ 211 t10 = t08 | t03; \
212 t11 = b & t07; \ 212 t11 = b & t07; \
213 t12 = t06 & t02; \ 213 t12 = t06 & t02; \
214 z = t09 ^ t10; \ 214 z = t09 ^ t10; \
215 x = t12 ^ t11; \ 215 x = t12 ^ t11; \
216 t15 = c & z ; \ 216 t15 = c & z ; \
217 t16 = w ^ x ; \ 217 t16 = w ^ x ; \
218 t17 = t10 ^ t15; \ 218 t17 = t10 ^ t15; \
219 y = t16 ^ t17; \ 219 y = t16 ^ t17; \
220 } 220 }
221 221
222#define SBOX3(a, b, c, d, w, x, y, z) \ 222#define SBOX3(a, b, c, d, w, x, y, z) \
223 { \ 223 { \
224 register unsigned long t02, t03, t04, t05, t06, t07, t08; \ 224 register unsigned long t02, t03, t04, t05, t06, t07, t08; \
225 register unsigned long t09, t10, t11, t13, t14, t15, t01; \ 225 register unsigned long t09, t10, t11, t13, t14, t15, t01; \
226 t01 = a ^ c ; \ 226 t01 = a ^ c ; \
227 t02 = a | d ; \ 227 t02 = a | d ; \
228 t03 = a & d ; \ 228 t03 = a & d ; \
229 t04 = t01 & t02; \ 229 t04 = t01 & t02; \
230 t05 = b | t03; \ 230 t05 = b | t03; \
231 t06 = a & b ; \ 231 t06 = a & b ; \
232 t07 = d ^ t04; \ 232 t07 = d ^ t04; \
233 t08 = c | t06; \ 233 t08 = c | t06; \
234 t09 = b ^ t07; \ 234 t09 = b ^ t07; \
235 t10 = d & t05; \ 235 t10 = d & t05; \
236 t11 = t02 ^ t10; \ 236 t11 = t02 ^ t10; \
237 z = t08 ^ t09; \ 237 z = t08 ^ t09; \
238 t13 = d | z ; \ 238 t13 = d | z ; \
239 t14 = a | t07; \ 239 t14 = a | t07; \
240 t15 = b & t13; \ 240 t15 = b & t13; \
241 y = t08 ^ t11; \ 241 y = t08 ^ t11; \
242 w = t14 ^ t15; \ 242 w = t14 ^ t15; \
243 x = t05 ^ t04; \ 243 x = t05 ^ t04; \
244 } 244 }
245 245
246#define SBOX3_INVERSE(a, b, c, d, w, x, y, z) \ 246#define SBOX3_INVERSE(a, b, c, d, w, x, y, z) \
247 { \ 247 { \
248 register unsigned long t02, t03, t04, t05, t06, t07, t09; \ 248 register unsigned long t02, t03, t04, t05, t06, t07, t09; \
249 register unsigned long t11, t12, t13, t14, t16, t01; \ 249 register unsigned long t11, t12, t13, t14, t16, t01; \
250 t01 = c | d ; \ 250 t01 = c | d ; \
251 t02 = a | d ; \ 251 t02 = a | d ; \
252 t03 = c ^ t02; \ 252 t03 = c ^ t02; \
253 t04 = b ^ t02; \ 253 t04 = b ^ t02; \
254 t05 = a ^ d ; \ 254 t05 = a ^ d ; \
255 t06 = t04 & t03; \ 255 t06 = t04 & t03; \
256 t07 = b & t01; \ 256 t07 = b & t01; \
257 y = t05 ^ t06; \ 257 y = t05 ^ t06; \
258 t09 = a ^ t03; \ 258 t09 = a ^ t03; \
259 w = t07 ^ t03; \ 259 w = t07 ^ t03; \
260 t11 = w | t05; \ 260 t11 = w | t05; \
261 t12 = t09 & t11; \ 261 t12 = t09 & t11; \
262 t13 = a & y ; \ 262 t13 = a & y ; \
263 t14 = t01 ^ t05; \ 263 t14 = t01 ^ t05; \
264 x = b ^ t12; \ 264 x = b ^ t12; \
265 t16 = b | t13; \ 265 t16 = b | t13; \
266 z = t14 ^ t16; \ 266 z = t14 ^ t16; \
267 } 267 }
268 268
269#define SBOX4(a, b, c, d, w, x, y, z) \ 269#define SBOX4(a, b, c, d, w, x, y, z) \
270 { \ 270 { \
271 register unsigned long t02, t03, t04, t05, t06, t08, t09; \ 271 register unsigned long t02, t03, t04, t05, t06, t08, t09; \
272 register unsigned long t10, t11, t12, t13, t14, t15, t16, t01; \ 272 register unsigned long t10, t11, t12, t13, t14, t15, t16, t01; \
273 t01 = a | b ; \ 273 t01 = a | b ; \
274 t02 = b | c ; \ 274 t02 = b | c ; \
275 t03 = a ^ t02; \ 275 t03 = a ^ t02; \
276 t04 = b ^ d ; \ 276 t04 = b ^ d ; \
277 t05 = d | t03; \ 277 t05 = d | t03; \
278 t06 = d & t01; \ 278 t06 = d & t01; \
279 z = t03 ^ t06; \ 279 z = t03 ^ t06; \
280 t08 = z & t04; \ 280 t08 = z & t04; \
281 t09 = t04 & t05; \ 281 t09 = t04 & t05; \
282 t10 = c ^ t06; \ 282 t10 = c ^ t06; \
283 t11 = b & c ; \ 283 t11 = b & c ; \
284 t12 = t04 ^ t08; \ 284 t12 = t04 ^ t08; \
285 t13 = t11 | t03; \ 285 t13 = t11 | t03; \
286 t14 = t10 ^ t09; \ 286 t14 = t10 ^ t09; \
287 t15 = a & t05; \ 287 t15 = a & t05; \
288 t16 = t11 | t12; \ 288 t16 = t11 | t12; \
289 y = t13 ^ t08; \ 289 y = t13 ^ t08; \
290 x = t15 ^ t16; \ 290 x = t15 ^ t16; \
291 w = ~ t14; \ 291 w = ~ t14; \
292 } 292 }
293 293
294#define SBOX4_INVERSE(a, b, c, d, w, x, y, z) \ 294#define SBOX4_INVERSE(a, b, c, d, w, x, y, z) \
295 { \ 295 { \
296 register unsigned long t02, t03, t04, t05, t06, t07, t09; \ 296 register unsigned long t02, t03, t04, t05, t06, t07, t09; \
297 register unsigned long t10, t11, t12, t13, t15, t01; \ 297 register unsigned long t10, t11, t12, t13, t15, t01; \
298 t01 = b | d ; \ 298 t01 = b | d ; \
299 t02 = c | d ; \ 299 t02 = c | d ; \
300 t03 = a & t01; \ 300 t03 = a & t01; \
301 t04 = b ^ t02; \ 301 t04 = b ^ t02; \
302 t05 = c ^ d ; \ 302 t05 = c ^ d ; \
303 t06 = ~ t03; \ 303 t06 = ~ t03; \
304 t07 = a & t04; \ 304 t07 = a & t04; \
305 x = t05 ^ t07; \ 305 x = t05 ^ t07; \
306 t09 = x | t06; \ 306 t09 = x | t06; \
307 t10 = a ^ t07; \ 307 t10 = a ^ t07; \
308 t11 = t01 ^ t09; \ 308 t11 = t01 ^ t09; \
309 t12 = d ^ t04; \ 309 t12 = d ^ t04; \
310 t13 = c | t10; \ 310 t13 = c | t10; \
311 z = t03 ^ t12; \ 311 z = t03 ^ t12; \
312 t15 = a ^ t04; \ 312 t15 = a ^ t04; \
313 y = t11 ^ t13; \ 313 y = t11 ^ t13; \
314 w = t15 ^ t09; \ 314 w = t15 ^ t09; \
315 } 315 }
316 316
317#define SBOX5(a, b, c, d, w, x, y, z) \ 317#define SBOX5(a, b, c, d, w, x, y, z) \
318 { \ 318 { \
319 register unsigned long t02, t03, t04, t05, t07, t08, t09; \ 319 register unsigned long t02, t03, t04, t05, t07, t08, t09; \
320 register unsigned long t10, t11, t12, t13, t14, t01; \ 320 register unsigned long t10, t11, t12, t13, t14, t01; \
321 t01 = b ^ d ; \ 321 t01 = b ^ d ; \
322 t02 = b | d ; \ 322 t02 = b | d ; \
323 t03 = a & t01; \ 323 t03 = a & t01; \
324 t04 = c ^ t02; \ 324 t04 = c ^ t02; \
325 t05 = t03 ^ t04; \ 325 t05 = t03 ^ t04; \
326 w = ~ t05; \ 326 w = ~ t05; \
327 t07 = a ^ t01; \ 327 t07 = a ^ t01; \
328 t08 = d | w ; \ 328 t08 = d | w ; \
329 t09 = b | t05; \ 329 t09 = b | t05; \
330 t10 = d ^ t08; \ 330 t10 = d ^ t08; \
331 t11 = b | t07; \ 331 t11 = b | t07; \
332 t12 = t03 | w ; \ 332 t12 = t03 | w ; \
333 t13 = t07 | t10; \ 333 t13 = t07 | t10; \
334 t14 = t01 ^ t11; \ 334 t14 = t01 ^ t11; \
335 y = t09 ^ t13; \ 335 y = t09 ^ t13; \
336 x = t07 ^ t08; \ 336 x = t07 ^ t08; \
337 z = t12 ^ t14; \ 337 z = t12 ^ t14; \
338 } 338 }
339 339
340#define SBOX5_INVERSE(a, b, c, d, w, x, y, z) \ 340#define SBOX5_INVERSE(a, b, c, d, w, x, y, z) \
341 { \ 341 { \
342 register unsigned long t02, t03, t04, t05, t07, t08, t09; \ 342 register unsigned long t02, t03, t04, t05, t07, t08, t09; \
343 register unsigned long t10, t12, t13, t15, t16, t01; \ 343 register unsigned long t10, t12, t13, t15, t16, t01; \
344 t01 = a & d ; \ 344 t01 = a & d ; \
345 t02 = c ^ t01; \ 345 t02 = c ^ t01; \
346 t03 = a ^ d ; \ 346 t03 = a ^ d ; \
347 t04 = b & t02; \ 347 t04 = b & t02; \
348 t05 = a & c ; \ 348 t05 = a & c ; \
349 w = t03 ^ t04; \ 349 w = t03 ^ t04; \
350 t07 = a & w ; \ 350 t07 = a & w ; \
351 t08 = t01 ^ w ; \ 351 t08 = t01 ^ w ; \
352 t09 = b | t05; \ 352 t09 = b | t05; \
353 t10 = ~ b ; \ 353 t10 = ~ b ; \
354 x = t08 ^ t09; \ 354 x = t08 ^ t09; \
355 t12 = t10 | t07; \ 355 t12 = t10 | t07; \
356 t13 = w | x ; \ 356 t13 = w | x ; \
357 z = t02 ^ t12; \ 357 z = t02 ^ t12; \
358 t15 = t02 ^ t13; \ 358 t15 = t02 ^ t13; \
359 t16 = b ^ d ; \ 359 t16 = b ^ d ; \
360 y = t16 ^ t15; \ 360 y = t16 ^ t15; \
361 } 361 }
362 362
363#define SBOX6(a, b, c, d, w, x, y, z) \ 363#define SBOX6(a, b, c, d, w, x, y, z) \
364 { \ 364 { \
365 register unsigned long t02, t03, t04, t05, t07, t08, t09, t10; \ 365 register unsigned long t02, t03, t04, t05, t07, t08, t09, t10; \
366 register unsigned long t11, t12, t13, t15, t17, t18, t01; \ 366 register unsigned long t11, t12, t13, t15, t17, t18, t01; \
367 t01 = a & d ; \ 367 t01 = a & d ; \
368 t02 = b ^ c ; \ 368 t02 = b ^ c ; \
369 t03 = a ^ d ; \ 369 t03 = a ^ d ; \
370 t04 = t01 ^ t02; \ 370 t04 = t01 ^ t02; \
371 t05 = b | c ; \ 371 t05 = b | c ; \
372 x = ~ t04; \ 372 x = ~ t04; \
373 t07 = t03 & t05; \ 373 t07 = t03 & t05; \
374 t08 = b & x ; \ 374 t08 = b & x ; \
375 t09 = a | c ; \ 375 t09 = a | c ; \
376 t10 = t07 ^ t08; \ 376 t10 = t07 ^ t08; \
377 t11 = b | d ; \ 377 t11 = b | d ; \
378 t12 = c ^ t11; \ 378 t12 = c ^ t11; \
379 t13 = t09 ^ t10; \ 379 t13 = t09 ^ t10; \
380 y = ~ t13; \ 380 y = ~ t13; \
381 t15 = x & t03; \ 381 t15 = x & t03; \
382 z = t12 ^ t07; \ 382 z = t12 ^ t07; \
383 t17 = a ^ b ; \ 383 t17 = a ^ b ; \
384 t18 = y ^ t15; \ 384 t18 = y ^ t15; \
385 w = t17 ^ t18; \ 385 w = t17 ^ t18; \
386 } 386 }
387 387
388#define SBOX6_INVERSE(a, b, c, d, w, x, y, z) \ 388#define SBOX6_INVERSE(a, b, c, d, w, x, y, z) \
389 { \ 389 { \
390 register unsigned long t02, t03, t04, t05, t06, t07, t08, t09; \ 390 register unsigned long t02, t03, t04, t05, t06, t07, t08, t09; \
391 register unsigned long t12, t13, t14, t15, t16, t17, t01; \ 391 register unsigned long t12, t13, t14, t15, t16, t17, t01; \
392 t01 = a ^ c ; \ 392 t01 = a ^ c ; \
393 t02 = ~ c ; \ 393 t02 = ~ c ; \
394 t03 = b & t01; \ 394 t03 = b & t01; \
395 t04 = b | t02; \ 395 t04 = b | t02; \
396 t05 = d | t03; \ 396 t05 = d | t03; \
397 t06 = b ^ d ; \ 397 t06 = b ^ d ; \
398 t07 = a & t04; \ 398 t07 = a & t04; \
399 t08 = a | t02; \ 399 t08 = a | t02; \
400 t09 = t07 ^ t05; \ 400 t09 = t07 ^ t05; \
401 x = t06 ^ t08; \ 401 x = t06 ^ t08; \
402 w = ~ t09; \ 402 w = ~ t09; \
403 t12 = b & w ; \ 403 t12 = b & w ; \
404 t13 = t01 & t05; \ 404 t13 = t01 & t05; \
405 t14 = t01 ^ t12; \ 405 t14 = t01 ^ t12; \
406 t15 = t07 ^ t13; \ 406 t15 = t07 ^ t13; \
407 t16 = d | t02; \ 407 t16 = d | t02; \
408 t17 = a ^ x ; \ 408 t17 = a ^ x ; \
409 z = t17 ^ t15; \ 409 z = t17 ^ t15; \
410 y = t16 ^ t14; \ 410 y = t16 ^ t14; \
411 } 411 }
412 412
413#define SBOX7(a, b, c, d, w, x, y, z) \ 413#define SBOX7(a, b, c, d, w, x, y, z) \
414 { \ 414 { \
415 register unsigned long t02, t03, t04, t05, t06, t08, t09, t10; \ 415 register unsigned long t02, t03, t04, t05, t06, t08, t09, t10; \
416 register unsigned long t11, t13, t14, t15, t16, t17, t01; \ 416 register unsigned long t11, t13, t14, t15, t16, t17, t01; \
417 t01 = a & c ; \ 417 t01 = a & c ; \
418 t02 = ~ d ; \ 418 t02 = ~ d ; \
419 t03 = a & t02; \ 419 t03 = a & t02; \
420 t04 = b | t01; \ 420 t04 = b | t01; \
421 t05 = a & b ; \ 421 t05 = a & b ; \
422 t06 = c ^ t04; \ 422 t06 = c ^ t04; \
423 z = t03 ^ t06; \ 423 z = t03 ^ t06; \
424 t08 = c | z ; \ 424 t08 = c | z ; \
425 t09 = d | t05; \ 425 t09 = d | t05; \
426 t10 = a ^ t08; \ 426 t10 = a ^ t08; \
427 t11 = t04 & z ; \ 427 t11 = t04 & z ; \
428 x = t09 ^ t10; \ 428 x = t09 ^ t10; \
429 t13 = b ^ x ; \ 429 t13 = b ^ x ; \
430 t14 = t01 ^ x ; \ 430 t14 = t01 ^ x ; \
431 t15 = c ^ t05; \ 431 t15 = c ^ t05; \
432 t16 = t11 | t13; \ 432 t16 = t11 | t13; \
433 t17 = t02 | t14; \ 433 t17 = t02 | t14; \
434 w = t15 ^ t17; \ 434 w = t15 ^ t17; \
435 y = a ^ t16; \ 435 y = a ^ t16; \
436 } 436 }
437 437
438#define SBOX7_INVERSE(a, b, c, d, w, x, y, z) \ 438#define SBOX7_INVERSE(a, b, c, d, w, x, y, z) \
439 { \ 439 { \
440 register unsigned long t02, t03, t04, t06, t07, t08, t09; \ 440 register unsigned long t02, t03, t04, t06, t07, t08, t09; \
441 register unsigned long t10, t11, t13, t14, t15, t16, t01; \ 441 register unsigned long t10, t11, t13, t14, t15, t16, t01; \
442 t01 = a & b ; \ 442 t01 = a & b ; \
443 t02 = a | b ; \ 443 t02 = a | b ; \
444 t03 = c | t01; \ 444 t03 = c | t01; \
445 t04 = d & t02; \ 445 t04 = d & t02; \
446 z = t03 ^ t04; \ 446 z = t03 ^ t04; \
447 t06 = b ^ t04; \ 447 t06 = b ^ t04; \
448 t07 = d ^ z ; \ 448 t07 = d ^ z ; \
449 t08 = ~ t07; \ 449 t08 = ~ t07; \
450 t09 = t06 | t08; \ 450 t09 = t06 | t08; \
451 t10 = b ^ d ; \ 451 t10 = b ^ d ; \
452 t11 = a | d ; \ 452 t11 = a | d ; \
453 x = a ^ t09; \ 453 x = a ^ t09; \
454 t13 = c ^ t06; \ 454 t13 = c ^ t06; \
455 t14 = c & t11; \ 455 t14 = c & t11; \
456 t15 = d | x ; \ 456 t15 = d | x ; \
457 t16 = t01 | t10; \ 457 t16 = t01 | t10; \
458 w = t13 ^ t15; \ 458 w = t13 ^ t15; \
459 y = t14 ^ t16; \ 459 y = t14 ^ t16; \
460 } 460 }
461 461
462/* XOR BLOCK1 into BLOCK0. */ 462/* XOR BLOCK1 into BLOCK0. */
463#define BLOCK_XOR(block0, block1) \ 463#define BLOCK_XOR(block0, block1) \
464 { \ 464 { \
465 block0[0] ^= block1[0]; \ 465 block0[0] ^= block1[0]; \
466 block0[1] ^= block1[1]; \ 466 block0[1] ^= block1[1]; \
467 block0[2] ^= block1[2]; \ 467 block0[2] ^= block1[2]; \
468 block0[3] ^= block1[3]; \ 468 block0[3] ^= block1[3]; \
469 } 469 }
470 470
471/* Copy BLOCK_SRC to BLOCK_DST. */ 471/* Copy BLOCK_SRC to BLOCK_DST. */
472#define BLOCK_COPY(block_dst, block_src) \ 472#define BLOCK_COPY(block_dst, block_src) \
473 { \ 473 { \
474 block_dst[0] = block_src[0]; \ 474 block_dst[0] = block_src[0]; \
475 block_dst[1] = block_src[1]; \ 475 block_dst[1] = block_src[1]; \
476 block_dst[2] = block_src[2]; \ 476 block_dst[2] = block_src[2]; \
477 block_dst[3] = block_src[3]; \ 477 block_dst[3] = block_src[3]; \
478 } 478 }
479 479
480/* Apply SBOX number WHICH to to the block found in ARRAY0 at index 480/* Apply SBOX number WHICH to to the block found in ARRAY0 at index
481 INDEX, writing the output to the block found in ARRAY1 at index 481 INDEX, writing the output to the block found in ARRAY1 at index
482 INDEX. */ 482 INDEX. */
483#define SBOX(which, array0, array1, index) \ 483#define SBOX(which, array0, array1, index) \
484 SBOX##which (array0[index + 0], array0[index + 1], \ 484 SBOX##which (array0[index + 0], array0[index + 1], \
485 array0[index + 2], array0[index + 3], \ 485 array0[index + 2], array0[index + 3], \
486 array1[index + 0], array1[index + 1], \ 486 array1[index + 0], array1[index + 1], \
487 array1[index + 2], array1[index + 3]); 487 array1[index + 2], array1[index + 3]);
488 488
489/* Apply inverse SBOX number WHICH to to the block found in ARRAY0 at 489/* Apply inverse SBOX number WHICH to to the block found in ARRAY0 at
490 index INDEX, writing the output to the block found in ARRAY1 at 490 index INDEX, writing the output to the block found in ARRAY1 at
491 index INDEX. */ 491 index INDEX. */
492#define SBOX_INVERSE(which, array0, array1, index) \ 492#define SBOX_INVERSE(which, array0, array1, index) \
493 SBOX##which##_INVERSE (array0[index + 0], array0[index + 1], \ 493 SBOX##which##_INVERSE (array0[index + 0], array0[index + 1], \
494 array0[index + 2], array0[index + 3], \ 494 array0[index + 2], array0[index + 3], \
495 array1[index + 0], array1[index + 1], \ 495 array1[index + 0], array1[index + 1], \
496 array1[index + 2], array1[index + 3]); 496 array1[index + 2], array1[index + 3]);
497 497
498/* Apply the linear transformation to BLOCK. */ 498/* Apply the linear transformation to BLOCK. */
499#define LINEAR_TRANSFORMATION(block) \ 499#define LINEAR_TRANSFORMATION(block) \
500 { \ 500 { \
501 block[0] = rol (block[0], 13); \ 501 block[0] = rol (block[0], 13); \
502 block[2] = rol (block[2], 3); \ 502 block[2] = rol (block[2], 3); \
503 block[1] = block[1] ^ block[0] ^ block[2]; \ 503 block[1] = block[1] ^ block[0] ^ block[2]; \
504 block[3] = block[3] ^ block[2] ^ (block[0] << 3); \ 504 block[3] = block[3] ^ block[2] ^ (block[0] << 3); \
505 block[1] = rol (block[1], 1); \ 505 block[1] = rol (block[1], 1); \
506 block[3] = rol (block[3], 7); \ 506 block[3] = rol (block[3], 7); \
507 block[0] = block[0] ^ block[1] ^ block[3]; \ 507 block[0] = block[0] ^ block[1] ^ block[3]; \
508 block[2] = block[2] ^ block[3] ^ (block[1] << 7); \ 508 block[2] = block[2] ^ block[3] ^ (block[1] << 7); \
509 block[0] = rol (block[0], 5); \ 509 block[0] = rol (block[0], 5); \
510 block[2] = rol (block[2], 22); \ 510 block[2] = rol (block[2], 22); \
511 } 511 }
512 512
513/* Apply the inverse linear transformation to BLOCK. */ 513/* Apply the inverse linear transformation to BLOCK. */
514#define LINEAR_TRANSFORMATION_INVERSE(block) \ 514#define LINEAR_TRANSFORMATION_INVERSE(block) \
515 { \ 515 { \
516 block[2] = ror (block[2], 22); \ 516 block[2] = ror (block[2], 22); \
517 block[0] = ror (block[0] , 5); \ 517 block[0] = ror (block[0] , 5); \
518 block[2] = block[2] ^ block[3] ^ (block[1] << 7); \ 518 block[2] = block[2] ^ block[3] ^ (block[1] << 7); \
519 block[0] = block[0] ^ block[1] ^ block[3]; \ 519 block[0] = block[0] ^ block[1] ^ block[3]; \
520 block[3] = ror (block[3], 7); \ 520 block[3] = ror (block[3], 7); \
521 block[1] = ror (block[1], 1); \ 521 block[1] = ror (block[1], 1); \
522 block[3] = block[3] ^ block[2] ^ (block[0] << 3); \ 522 block[3] = block[3] ^ block[2] ^ (block[0] << 3); \
523 block[1] = block[1] ^ block[0] ^ block[2]; \ 523 block[1] = block[1] ^ block[0] ^ block[2]; \
524 block[2] = ror (block[2], 3); \ 524 block[2] = ror (block[2], 3); \
525 block[0] = ror (block[0], 13); \ 525 block[0] = ror (block[0], 13); \
526 } 526 }
527 527
528/* Apply a Serpent round to BLOCK, using the SBOX number WHICH and the 528/* Apply a Serpent round to BLOCK, using the SBOX number WHICH and the
529 subkeys contained in SUBKEYS. Use BLOCK_TMP as temporary storage. 529 subkeys contained in SUBKEYS. Use BLOCK_TMP as temporary storage.
530 This macro increments `round'. */ 530 This macro increments `round'. */
531#define ROUND(which, subkeys, block, block_tmp) \ 531#define ROUND(which, subkeys, block, block_tmp) \
532 { \ 532 { \
533 BLOCK_XOR (block, subkeys[round]); \ 533 BLOCK_XOR (block, subkeys[round]); \
534 round++; \ 534 round++; \
535 SBOX (which, block, block_tmp, 0); \ 535 SBOX (which, block, block_tmp, 0); \
536 LINEAR_TRANSFORMATION (block_tmp); \ 536 LINEAR_TRANSFORMATION (block_tmp); \
537 BLOCK_COPY (block, block_tmp); \ 537 BLOCK_COPY (block, block_tmp); \
538 } 538 }
539 539
540/* Apply the last Serpent round to BLOCK, using the SBOX number WHICH 540/* Apply the last Serpent round to BLOCK, using the SBOX number WHICH
541 and the subkeys contained in SUBKEYS. Use BLOCK_TMP as temporary 541 and the subkeys contained in SUBKEYS. Use BLOCK_TMP as temporary
542 storage. The result will be stored in BLOCK_TMP. This macro 542 storage. The result will be stored in BLOCK_TMP. This macro
543 increments `round'. */ 543 increments `round'. */
544#define ROUND_LAST(which, subkeys, block, block_tmp) \ 544#define ROUND_LAST(which, subkeys, block, block_tmp) \
545 { \ 545 { \
546 BLOCK_XOR (block, subkeys[round]); \ 546 BLOCK_XOR (block, subkeys[round]); \
547 round++; \ 547 round++; \
548 SBOX (which, block, block_tmp, 0); \ 548 SBOX (which, block, block_tmp, 0); \
549 BLOCK_XOR (block_tmp, subkeys[round]); \ 549 BLOCK_XOR (block_tmp, subkeys[round]); \
550 round++; \ 550 round++; \
551 } 551 }
552 552
553/* Apply an inverse Serpent round to BLOCK, using the SBOX number 553/* Apply an inverse Serpent round to BLOCK, using the SBOX number
554 WHICH and the subkeys contained in SUBKEYS. Use BLOCK_TMP as 554 WHICH and the subkeys contained in SUBKEYS. Use BLOCK_TMP as
555 temporary storage. This macro increments `round'. */ 555 temporary storage. This macro increments `round'. */
556#define ROUND_INVERSE(which, subkey, block, block_tmp) \ 556#define ROUND_INVERSE(which, subkey, block, block_tmp) \
557 { \ 557 { \
558 LINEAR_TRANSFORMATION_INVERSE (block); \ 558 LINEAR_TRANSFORMATION_INVERSE (block); \
559 SBOX_INVERSE (which, block, block_tmp, 0); \ 559 SBOX_INVERSE (which, block, block_tmp, 0); \
560 BLOCK_XOR (block_tmp, subkey[round]); \ 560 BLOCK_XOR (block_tmp, subkey[round]); \
561 round--; \ 561 round--; \
562 BLOCK_COPY (block, block_tmp); \ 562 BLOCK_COPY (block, block_tmp); \
563 } 563 }
564 564
565/* Apply the first Serpent round to BLOCK, using the SBOX number WHICH 565/* Apply the first Serpent round to BLOCK, using the SBOX number WHICH
566 and the subkeys contained in SUBKEYS. Use BLOCK_TMP as temporary 566 and the subkeys contained in SUBKEYS. Use BLOCK_TMP as temporary
567 storage. The result will be stored in BLOCK_TMP. This macro 567 storage. The result will be stored in BLOCK_TMP. This macro
568 increments `round'. */ 568 increments `round'. */
569#define ROUND_FIRST_INVERSE(which, subkeys, block, block_tmp) \ 569#define ROUND_FIRST_INVERSE(which, subkeys, block, block_tmp) \
570 { \ 570 { \
571 BLOCK_XOR (block, subkeys[round]); \ 571 BLOCK_XOR (block, subkeys[round]); \
572 round--; \ 572 round--; \
573 SBOX_INVERSE (which, block, block_tmp, 0); \ 573 SBOX_INVERSE (which, block, block_tmp, 0); \
574 BLOCK_XOR (block_tmp, subkeys[round]); \ 574 BLOCK_XOR (block_tmp, subkeys[round]); \
575 round--; \ 575 round--; \
576 } 576 }
577 577
578/* Convert the user provided key KEY of KEY_LENGTH bytes into the 578/* Convert the user provided key KEY of KEY_LENGTH bytes into the
579 internally used format. */ 579 internally used format. */
580static void 580static void
581serpent_key_prepare (const byte_t *key, unsigned int key_length, 581serpent_key_prepare (const byte_t *key, unsigned int key_length,
582 serpent_key_t key_prepared) 582 serpent_key_t key_prepared)
583{ 583{
584 int i; 584 int i;
585 585
586 /* Copy key. */ 586 /* Copy key. */
587 for (i = 0; i < key_length / 4; i++) 587 for (i = 0; i < key_length / 4; i++)
588 { 588 {
589#ifdef WORDS_BIGENDIAN 589#ifdef WORDS_BIGENDIAN
590 key_prepared[i] = byte_swap_32 (((u32_t *) key)[i]); 590 key_prepared[i] = byte_swap_32 (((u32_t *) key)[i]);
591#else 591#else
592 key_prepared[i] = ((u32_t *) key)[i]; 592 key_prepared[i] = ((u32_t *) key)[i];
593#endif 593#endif
594 } 594 }
595 595
596 if (i < 8) 596 if (i < 8)
597 { 597 {
598 /* Key must be padded according to the Serpent 598 /* Key must be padded according to the Serpent
599 specification. */ 599 specification. */
600 key_prepared[i] = 0x00000001; 600 key_prepared[i] = 0x00000001;
601 601
602 for (i++; i < 8; i++) 602 for (i++; i < 8; i++)
603 key_prepared[i] = 0; 603 key_prepared[i] = 0;
604 } 604 }
605} 605}
606 606
607/* Derive the 33 subkeys from KEY and store them in SUBKEYS. */ 607/* Derive the 33 subkeys from KEY and store them in SUBKEYS. */
608static void 608static void
609serpent_subkeys_generate (serpent_key_t key, serpent_subkeys_t subkeys) 609serpent_subkeys_generate (serpent_key_t key, serpent_subkeys_t subkeys)
610{ 610{
611 u32_t w_real[140]; /* The `prekey'. */ 611 u32_t w_real[140]; /* The `prekey'. */
612 u32_t k[132]; 612 u32_t k[132];
613 u32_t *w = &w_real[8]; 613 u32_t *w = &w_real[8];
614 int i, j; 614 int i, j;
615 615
616 /* Initialize with key values. */ 616 /* Initialize with key values. */
617 for (i = 0; i < 8; i++) 617 for (i = 0; i < 8; i++)
618 w[i - 8] = key[i]; 618 w[i - 8] = key[i];
619 619
620 /* Expand to intermediate key using the affine recurrence. */ 620 /* Expand to intermediate key using the affine recurrence. */
621 for (i = 0; i < 132; i++) 621 for (i = 0; i < 132; i++)
622 w[i] = rol (w[i - 8] ^ w[i - 5] ^ w[i - 3] ^ w[i - 1] ^ PHI ^ i, 11); 622 w[i] = rol (w[i - 8] ^ w[i - 5] ^ w[i - 3] ^ w[i - 1] ^ PHI ^ i, 11);
623 623
624 /* Calculate subkeys via S-Boxes, in bitslice mode. */ 624 /* Calculate subkeys via S-Boxes, in bitslice mode. */
625 SBOX (3, w, k, 0); 625 SBOX (3, w, k, 0);
626 SBOX (2, w, k, 4); 626 SBOX (2, w, k, 4);
627 SBOX (1, w, k, 8); 627 SBOX (1, w, k, 8);
628 SBOX (0, w, k, 12); 628 SBOX (0, w, k, 12);
629 SBOX (7, w, k, 16); 629 SBOX (7, w, k, 16);
630 SBOX (6, w, k, 20); 630 SBOX (6, w, k, 20);
631 SBOX (5, w, k, 24); 631 SBOX (5, w, k, 24);
632 SBOX (4, w, k, 28); 632 SBOX (4, w, k, 28);
633 SBOX (3, w, k, 32); 633 SBOX (3, w, k, 32);
634 SBOX (2, w, k, 36); 634 SBOX (2, w, k, 36);
635 SBOX (1, w, k, 40); 635 SBOX (1, w, k, 40);
636 SBOX (0, w, k, 44); 636 SBOX (0, w, k, 44);
637 SBOX (7, w, k, 48); 637 SBOX (7, w, k, 48);
638 SBOX (6, w, k, 52); 638 SBOX (6, w, k, 52);
639 SBOX (5, w, k, 56); 639 SBOX (5, w, k, 56);
640 SBOX (4, w, k, 60); 640 SBOX (4, w, k, 60);
641 SBOX (3, w, k, 64); 641 SBOX (3, w, k, 64);
642 SBOX (2, w, k, 68); 642 SBOX (2, w, k, 68);
643 SBOX (1, w, k, 72); 643 SBOX (1, w, k, 72);
644 SBOX (0, w, k, 76); 644 SBOX (0, w, k, 76);
645 SBOX (7, w, k, 80); 645 SBOX (7, w, k, 80);
646 SBOX (6, w, k, 84); 646 SBOX (6, w, k, 84);
647 SBOX (5, w, k, 88); 647 SBOX (5, w, k, 88);
648 SBOX (4, w, k, 92); 648 SBOX (4, w, k, 92);
649 SBOX (3, w, k, 96); 649 SBOX (3, w, k, 96);
650 SBOX (2, w, k, 100); 650 SBOX (2, w, k, 100);
651 SBOX (1, w, k, 104); 651 SBOX (1, w, k, 104);
652 SBOX (0, w, k, 108); 652 SBOX (0, w, k, 108);
653 SBOX (7, w, k, 112); 653 SBOX (7, w, k, 112);
654 SBOX (6, w, k, 116); 654 SBOX (6, w, k, 116);
655 SBOX (5, w, k, 120); 655 SBOX (5, w, k, 120);
656 SBOX (4, w, k, 124); 656 SBOX (4, w, k, 124);
657 SBOX (3, w, k, 128); 657 SBOX (3, w, k, 128);
658 658
659 /* Renumber subkeys. */ 659 /* Renumber subkeys. */
660 for (i = 0; i < ROUNDS + 1; i++) 660 for (i = 0; i < ROUNDS + 1; i++)
661 for (j = 0; j < 4; j++) 661 for (j = 0; j < 4; j++)
662 subkeys[i][j] = k[4 * i + j]; 662 subkeys[i][j] = k[4 * i + j];
663} 663}
664 664
665/* Initialize CONTEXT with the key KEY of KEY_LENGTH bits. */ 665/* Initialize CONTEXT with the key KEY of KEY_LENGTH bits. */
666static void 666static void
667serpent_setkey_internal (serpent_context_t *context, 667serpent_setkey_internal (serpent_context_t *context,
668 const byte_t *key, unsigned int key_length) 668 const byte_t *key, unsigned int key_length)
669{ 669{
670 serpent_key_t key_prepared; 670 serpent_key_t key_prepared;
671 671
672 serpent_key_prepare (key, key_length, key_prepared); 672 serpent_key_prepare (key, key_length, key_prepared);
673 serpent_subkeys_generate (key_prepared, context->keys); 673 serpent_subkeys_generate (key_prepared, context->keys);
674 _gcry_burn_stack (272 * sizeof (u32_t)); 674 _gcry_burn_stack (272 * sizeof (u32_t));
675} 675}
676 676 static const char *serpent_test (void);
677/* Initialize CTX with the key KEY of KEY_LENGTH bytes. */ 677/* Initialize CTX with the key KEY of KEY_LENGTH bytes. */
678static gcry_err_code_t 678static gcry_err_code_t
679serpent_setkey (void *ctx, 679serpent_setkey (void *ctx,
680 const byte_t *key, unsigned int key_length) 680 const byte_t *key, unsigned int key_length)
681{ 681{
682 serpent_context_t *context = ctx; 682 serpent_context_t *context = ctx;
683 static const char *serpent_test_ret; 683 static const char *serpent_test_ret;
684 static int serpent_init_done; 684 static int serpent_init_done;
685 gcry_err_code_t ret = GPG_ERR_NO_ERROR; 685 gcry_err_code_t ret = GPG_ERR_NO_ERROR;
686 686
687 if (! serpent_init_done) 687 if (! serpent_init_done)
688 { 688 {
689 /* Execute a self-test the first time, Serpent is used. */ 689 /* Execute a self-test the first time, Serpent is used. */
690 static const char *serpent_test (void); 690
691 691
692 serpent_test_ret = serpent_test (); 692 serpent_test_ret = serpent_test ();
693 if (serpent_test_ret) 693 if (serpent_test_ret)
694 log_error ("Serpent test failure: %s\n", serpent_test_ret); 694 log_error ("Serpent test failure: %s\n", serpent_test_ret);
695 serpent_init_done = 1; 695 serpent_init_done = 1;
696 } 696 }
697 697
698 if (serpent_test_ret) 698 if (serpent_test_ret)
699 ret = GPG_ERR_SELFTEST_FAILED; 699 ret = GPG_ERR_SELFTEST_FAILED;
700 else 700 else
701 { 701 {
702 serpent_setkey_internal (context, key, key_length); 702 serpent_setkey_internal (context, key, key_length);
703 _gcry_burn_stack (sizeof (serpent_key_t)); 703 _gcry_burn_stack (sizeof (serpent_key_t));
704 } 704 }
705 705
706 return ret; 706 return ret;
707} 707}
708 708
709static void 709static void
710serpent_encrypt_internal (serpent_context_t *context, 710serpent_encrypt_internal (serpent_context_t *context,
711 const serpent_block_t input, serpent_block_t output) 711 const serpent_block_t input, serpent_block_t output)
712{ 712{
713 serpent_block_t b, b_next; 713 serpent_block_t b, b_next;
714 int round = 0; 714 int round = 0;
715 715
716#ifdef WORDS_BIGENDIAN 716#ifdef WORDS_BIGENDIAN
717 b[0] = byte_swap_32 (input[0]); 717 b[0] = byte_swap_32 (input[0]);
718 b[1] = byte_swap_32 (input[1]); 718 b[1] = byte_swap_32 (input[1]);
719 b[2] = byte_swap_32 (input[2]); 719 b[2] = byte_swap_32 (input[2]);
720 b[3] = byte_swap_32 (input[3]); 720 b[3] = byte_swap_32 (input[3]);
721#else 721#else
722 b[0] = input[0]; 722 b[0] = input[0];
723 b[1] = input[1]; 723 b[1] = input[1];
724 b[2] = input[2]; 724 b[2] = input[2];
725 b[3] = input[3]; 725 b[3] = input[3];
726#endif 726#endif
727 727
728 ROUND (0, context->keys, b, b_next); 728 ROUND (0, context->keys, b, b_next);
729 ROUND (1, context->keys, b, b_next); 729 ROUND (1, context->keys, b, b_next);
730 ROUND (2, context->keys, b, b_next); 730 ROUND (2, context->keys, b, b_next);
731 ROUND (3, context->keys, b, b_next); 731 ROUND (3, context->keys, b, b_next);
732 ROUND (4, context->keys, b, b_next); 732 ROUND (4, context->keys, b, b_next);
733 ROUND (5, context->keys, b, b_next); 733 ROUND (5, context->keys, b, b_next);
734 ROUND (6, context->keys, b, b_next); 734 ROUND (6, context->keys, b, b_next);
735 ROUND (7, context->keys, b, b_next); 735 ROUND (7, context->keys, b, b_next);
736 ROUND (0, context->keys, b, b_next); 736 ROUND (0, context->keys, b, b_next);
737 ROUND (1, context->keys, b, b_next); 737 ROUND (1, context->keys, b, b_next);
738 ROUND (2, context->keys, b, b_next); 738 ROUND (2, context->keys, b, b_next);
739 ROUND (3, context->keys, b, b_next); 739 ROUND (3, context->keys, b, b_next);
740 ROUND (4, context->keys, b, b_next); 740 ROUND (4, context->keys, b, b_next);
741 ROUND (5, context->keys, b, b_next); 741 ROUND (5, context->keys, b, b_next);
742 ROUND (6, context->keys, b, b_next); 742 ROUND (6, context->keys, b, b_next);
743 ROUND (7, context->keys, b, b_next); 743 ROUND (7, context->keys, b, b_next);
744 ROUND (0, context->keys, b, b_next); 744 ROUND (0, context->keys, b, b_next);
745 ROUND (1, context->keys, b, b_next); 745 ROUND (1, context->keys, b, b_next);
746 ROUND (2, context->keys, b, b_next); 746 ROUND (2, context->keys, b, b_next);
747 ROUND (3, context->keys, b, b_next); 747 ROUND (3, context->keys, b, b_next);
748 ROUND (4, context->keys, b, b_next); 748 ROUND (4, context->keys, b, b_next);
749 ROUND (5, context->keys, b, b_next); 749 ROUND (5, context->keys, b, b_next);
750 ROUND (6, context->keys, b, b_next); 750 ROUND (6, context->keys, b, b_next);
751 ROUND (7, context->keys, b, b_next); 751 ROUND (7, context->keys, b, b_next);
752 ROUND (0, context->keys, b, b_next); 752 ROUND (0, context->keys, b, b_next);
753 ROUND (1, context->keys, b, b_next); 753 ROUND (1, context->keys, b, b_next);
754 ROUND (2, context->keys, b, b_next); 754 ROUND (2, context->keys, b, b_next);
755 ROUND (3, context->keys, b, b_next); 755 ROUND (3, context->keys, b, b_next);
756 ROUND (4, context->keys, b, b_next); 756 ROUND (4, context->keys, b, b_next);
757 ROUND (5, context->keys, b, b_next); 757 ROUND (5, context->keys, b, b_next);
758 ROUND (6, context->keys, b, b_next); 758 ROUND (6, context->keys, b, b_next);
759 759
760 ROUND_LAST (7, context->keys, b, b_next); 760 ROUND_LAST (7, context->keys, b, b_next);
761 761
762#ifdef WORDS_BIGENDIAN 762#ifdef WORDS_BIGENDIAN
763 output[0] = byte_swap_32 (b_next[0]); 763 output[0] = byte_swap_32 (b_next[0]);
764 output[1] = byte_swap_32 (b_next[1]); 764 output[1] = byte_swap_32 (b_next[1]);
765 output[2] = byte_swap_32 (b_next[2]); 765 output[2] = byte_swap_32 (b_next[2]);
766 output[3] = byte_swap_32 (b_next[3]); 766 output[3] = byte_swap_32 (b_next[3]);
767#else 767#else
768 output[0] = b_next[0]; 768 output[0] = b_next[0];
769 output[1] = b_next[1]; 769 output[1] = b_next[1];
770 output[2] = b_next[2]; 770 output[2] = b_next[2];
771 output[3] = b_next[3]; 771 output[3] = b_next[3];
772#endif 772#endif
773} 773}
774 774
775static void 775static void
776serpent_decrypt_internal (serpent_context_t *context, 776serpent_decrypt_internal (serpent_context_t *context,
777 const serpent_block_t input, serpent_block_t output) 777 const serpent_block_t input, serpent_block_t output)
778{ 778{
779 serpent_block_t b, b_next; 779 serpent_block_t b, b_next;
780 int round = ROUNDS; 780 int round = ROUNDS;
781 781
782#ifdef WORDS_BIGENDIAN 782#ifdef WORDS_BIGENDIAN
783 b_next[0] = byte_swap_32 (input[0]); 783 b_next[0] = byte_swap_32 (input[0]);
784 b_next[1] = byte_swap_32 (input[1]); 784 b_next[1] = byte_swap_32 (input[1]);
785 b_next[2] = byte_swap_32 (input[2]); 785 b_next[2] = byte_swap_32 (input[2]);
786 b_next[3] = byte_swap_32 (input[3]); 786 b_next[3] = byte_swap_32 (input[3]);
787#else 787#else
788 b_next[0] = input[0]; 788 b_next[0] = input[0];
789 b_next[1] = input[1]; 789 b_next[1] = input[1];
790 b_next[2] = input[2]; 790 b_next[2] = input[2];
791 b_next[3] = input[3]; 791 b_next[3] = input[3];
792#endif 792#endif
793 793
794 ROUND_FIRST_INVERSE (7, context->keys, b_next, b); 794 ROUND_FIRST_INVERSE (7, context->keys, b_next, b);
795 795
796 ROUND_INVERSE (6, context->keys, b, b_next); 796 ROUND_INVERSE (6, context->keys, b, b_next);
797 ROUND_INVERSE (5, context->keys, b, b_next); 797 ROUND_INVERSE (5, context->keys, b, b_next);
798 ROUND_INVERSE (4, context->keys, b, b_next); 798 ROUND_INVERSE (4, context->keys, b, b_next);
799 ROUND_INVERSE (3, context->keys, b, b_next); 799 ROUND_INVERSE (3, context->keys, b, b_next);
800 ROUND_INVERSE (2, context->keys, b, b_next); 800 ROUND_INVERSE (2, context->keys, b, b_next);
801 ROUND_INVERSE (1, context->keys, b, b_next); 801 ROUND_INVERSE (1, context->keys, b, b_next);
802 ROUND_INVERSE (0, context->keys, b, b_next); 802 ROUND_INVERSE (0, context->keys, b, b_next);
803 ROUND_INVERSE (7, context->keys, b, b_next); 803 ROUND_INVERSE (7, context->keys, b, b_next);
804 ROUND_INVERSE (6, context->keys, b, b_next); 804 ROUND_INVERSE (6, context->keys, b, b_next);
805 ROUND_INVERSE (5, context->keys, b, b_next); 805 ROUND_INVERSE (5, context->keys, b, b_next);
806 ROUND_INVERSE (4, context->keys, b, b_next); 806 ROUND_INVERSE (4, context->keys, b, b_next);
807 ROUND_INVERSE (3, context->keys, b, b_next); 807 ROUND_INVERSE (3, context->keys, b, b_next);
808 ROUND_INVERSE (2, context->keys, b, b_next); 808 ROUND_INVERSE (2, context->keys, b, b_next);
809 ROUND_INVERSE (1, context->keys, b, b_next); 809 ROUND_INVERSE (1, context->keys, b, b_next);
810 ROUND_INVERSE (0, context->keys, b, b_next); 810 ROUND_INVERSE (0, context->keys, b, b_next);
811 ROUND_INVERSE (7, context->keys, b, b_next); 811 ROUND_INVERSE (7, context->keys, b, b_next);
812 ROUND_INVERSE (6, context->keys, b, b_next); 812 ROUND_INVERSE (6, context->keys, b, b_next);
813 ROUND_INVERSE (5, context->keys, b, b_next); 813 ROUND_INVERSE (5, context->keys, b, b_next);
814 ROUND_INVERSE (4, context->keys, b, b_next); 814 ROUND_INVERSE (4, context->keys, b, b_next);
815 ROUND_INVERSE (3, context->keys, b, b_next); 815 ROUND_INVERSE (3, context->keys, b, b_next);
816 ROUND_INVERSE (2, context->keys, b, b_next); 816 ROUND_INVERSE (2, context->keys, b, b_next);
817 ROUND_INVERSE (1, context->keys, b, b_next); 817 ROUND_INVERSE (1, context->keys, b, b_next);
818 ROUND_INVERSE (0, context->keys, b, b_next); 818 ROUND_INVERSE (0, context->keys, b, b_next);
819 ROUND_INVERSE (7, context->keys, b, b_next); 819 ROUND_INVERSE (7, context->keys, b, b_next);
820 ROUND_INVERSE (6, context->keys, b, b_next); 820 ROUND_INVERSE (6, context->keys, b, b_next);
821 ROUND_INVERSE (5, context->keys, b, b_next); 821 ROUND_INVERSE (5, context->keys, b, b_next);
822 ROUND_INVERSE (4, context->keys, b, b_next); 822 ROUND_INVERSE (4, context->keys, b, b_next);
823 ROUND_INVERSE (3, context->keys, b, b_next); 823 ROUND_INVERSE (3, context->keys, b, b_next);
824 ROUND_INVERSE (2, context->keys, b, b_next); 824 ROUND_INVERSE (2, context->keys, b, b_next);
825 ROUND_INVERSE (1, context->keys, b, b_next); 825 ROUND_INVERSE (1, context->keys, b, b_next);
826 ROUND_INVERSE (0, context->keys, b, b_next); 826 ROUND_INVERSE (0, context->keys, b, b_next);
827 827
828 828
829#ifdef WORDS_BIGENDIAN 829#ifdef WORDS_BIGENDIAN
830 output[0] = byte_swap_32 (b_next[0]); 830 output[0] = byte_swap_32 (b_next[0]);
831 output[1] = byte_swap_32 (b_next[1]); 831 output[1] = byte_swap_32 (b_next[1]);
832 output[2] = byte_swap_32 (b_next[2]); 832 output[2] = byte_swap_32 (b_next[2]);
833 output[3] = byte_swap_32 (b_next[3]); 833 output[3] = byte_swap_32 (b_next[3]);
834#else 834#else
835 output[0] = b_next[0]; 835 output[0] = b_next[0];
836 output[1] = b_next[1]; 836 output[1] = b_next[1];
837 output[2] = b_next[2]; 837 output[2] = b_next[2];
838 output[3] = b_next[3]; 838 output[3] = b_next[3];
839#endif 839#endif
840} 840}
841 841
842static void 842static void
843serpent_encrypt (void *ctx, byte_t *buffer_out, const byte_t *buffer_in) 843serpent_encrypt (void *ctx, byte_t *buffer_out, const byte_t *buffer_in)
844{ 844{
845 serpent_context_t *context = ctx; 845 serpent_context_t *context = ctx;
846 846
847 serpent_encrypt_internal (context, 847 serpent_encrypt_internal (context,
848 (const u32_t *) buffer_in, (u32_t *) buffer_out); 848 (const u32_t *) buffer_in, (u32_t *) buffer_out);
849 _gcry_burn_stack (2 * sizeof (serpent_block_t)); 849 _gcry_burn_stack (2 * sizeof (serpent_block_t));
850} 850}
851 851
852static void 852static void
853serpent_decrypt (void *ctx, byte *buffer_out, const byte *buffer_in) 853serpent_decrypt (void *ctx, byte *buffer_out, const byte *buffer_in)
854{ 854{
855 serpent_context_t *context = ctx; 855 serpent_context_t *context = ctx;
856 856
857 serpent_decrypt_internal (context, 857 serpent_decrypt_internal (context,
858 (const u32_t *) buffer_in, 858 (const u32_t *) buffer_in,
859 (u32_t *) buffer_out); 859 (u32_t *) buffer_out);
860 _gcry_burn_stack (2 * sizeof (serpent_block_t)); 860 _gcry_burn_stack (2 * sizeof (serpent_block_t));
861} 861}
862 862
863 863
864 864
865/* Serpent test. */ 865/* Serpent test. */
866 866
867static const char * 867static const char *
868serpent_test (void) 868serpent_test (void)
869{ 869{
870 serpent_context_t context; 870 serpent_context_t context;
871 unsigned char scratch[16]; 871 unsigned char scratch[16];
872 unsigned int i; 872 unsigned int i;
873 873
874 static struct test 874 static struct test
875 { 875 {
876 int key_length; 876 int key_length;
877 unsigned char key[32]; 877 unsigned char key[32];
878 unsigned char text_plain[16]; 878 unsigned char text_plain[16];
879 unsigned char text_cipher[16]; 879 unsigned char text_cipher[16];
880 } test_data[] = 880 } test_data[] =
881 { 881 {
882 { 882 {
883 16, 883 16,
884 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 884 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
885 "\xD2\x9D\x57\x6F\xCE\xA3\xA3\xA7\xED\x90\x99\xF2\x92\x73\xD7\x8E", 885 "\xD2\x9D\x57\x6F\xCE\xA3\xA3\xA7\xED\x90\x99\xF2\x92\x73\xD7\x8E",
886 "\xB2\x28\x8B\x96\x8A\xE8\xB0\x86\x48\xD1\xCE\x96\x06\xFD\x99\x2D" 886 "\xB2\x28\x8B\x96\x8A\xE8\xB0\x86\x48\xD1\xCE\x96\x06\xFD\x99\x2D"
887 }, 887 },
888 { 888 {
889 24, 889 24,
890 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 890 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
891 "\x00\x00\x00\x00\x00\x00\x00\x00", 891 "\x00\x00\x00\x00\x00\x00\x00\x00",
892 "\xD2\x9D\x57\x6F\xCE\xAB\xA3\xA7\xED\x98\x99\xF2\x92\x7B\xD7\x8E", 892 "\xD2\x9D\x57\x6F\xCE\xAB\xA3\xA7\xED\x98\x99\xF2\x92\x7B\xD7\x8E",
893 "\x13\x0E\x35\x3E\x10\x37\xC2\x24\x05\xE8\xFA\xEF\xB2\xC3\xC3\xE9" 893 "\x13\x0E\x35\x3E\x10\x37\xC2\x24\x05\xE8\xFA\xEF\xB2\xC3\xC3\xE9"
894 }, 894 },
895 { 895 {
896 32, 896 32,
897 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 897 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
898 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 898 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
899 "\xD0\x95\x57\x6F\xCE\xA3\xE3\xA7\xED\x98\xD9\xF2\x90\x73\xD7\x8E", 899 "\xD0\x95\x57\x6F\xCE\xA3\xE3\xA7\xED\x98\xD9\xF2\x90\x73\xD7\x8E",
900 "\xB9\x0E\xE5\x86\x2D\xE6\x91\x68\xF2\xBD\xD5\x12\x5B\x45\x47\x2B" 900 "\xB9\x0E\xE5\x86\x2D\xE6\x91\x68\xF2\xBD\xD5\x12\x5B\x45\x47\x2B"
901 }, 901 },
902 { 902 {
903 32, 903 32,
904 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" 904 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
905 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 905 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
906 "\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00", 906 "\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00",
907 "\x20\x61\xA4\x27\x82\xBD\x52\xEC\x69\x1E\xC3\x83\xB0\x3B\xA7\x7C" 907 "\x20\x61\xA4\x27\x82\xBD\x52\xEC\x69\x1E\xC3\x83\xB0\x3B\xA7\x7C"
908 }, 908 },
909 { 909 {
910 0 910 0
911 }, 911 },
912 }; 912 };
913 913
914 for (i = 0; test_data[i].key_length; i++) 914 for (i = 0; test_data[i].key_length; i++)
915 { 915 {
916 serpent_setkey_internal (&context, test_data[i].key, 916 serpent_setkey_internal (&context, test_data[i].key,
917 test_data[i].key_length); 917 test_data[i].key_length);
918 serpent_encrypt_internal (&context, 918 serpent_encrypt_internal (&context,
919 (const u32_t *) test_data[i].text_plain, 919 (const u32_t *) test_data[i].text_plain,
920 (u32_t *) scratch); 920 (u32_t *) scratch);
921 921
922 if (memcmp (scratch, test_data[i].text_cipher, sizeof (serpent_block_t))) 922 if (memcmp (scratch, test_data[i].text_cipher, sizeof (serpent_block_t)))
923 switch (test_data[i].key_length) 923 switch (test_data[i].key_length)
924 { 924 {
925 case 16: 925 case 16:
926 return "Serpent-128 test encryption failed."; 926 return "Serpent-128 test encryption failed.";
927 case 24: 927 case 24:
928 return "Serpent-192 test encryption failed."; 928 return "Serpent-192 test encryption failed.";
929 case 32: 929 case 32:
930 return "Serpent-256 test encryption failed."; 930 return "Serpent-256 test encryption failed.";
931 } 931 }
932 932
933 serpent_decrypt_internal (&context, 933 serpent_decrypt_internal (&context,
934 (const u32_t *) test_data[i].text_cipher, 934 (const u32_t *) test_data[i].text_cipher,
935 (u32_t *) scratch); 935 (u32_t *) scratch);
936 if (memcmp (scratch, test_data[i].text_plain, sizeof (serpent_block_t))) 936 if (memcmp (scratch, test_data[i].text_plain, sizeof (serpent_block_t)))
937 switch (test_data[i].key_length) 937 switch (test_data[i].key_length)
938 { 938 {
939 case 16: 939 case 16:
940 return "Serpent-128 test decryption failed."; 940 return "Serpent-128 test decryption failed.";
941 case 24: 941 case 24:
942 return "Serpent-192 test decryption failed."; 942 return "Serpent-192 test decryption failed.";
943 case 32: 943 case 32:
944 return "Serpent-256 test decryption failed."; 944 return "Serpent-256 test decryption failed.";
945 } 945 }
946 } 946 }
947 947
948 return NULL; 948 return NULL;
949} 949}
950 950
951 951
952 952
953/* "SERPENT" is an alias for "SERPENT128". */ 953/* "SERPENT" is an alias for "SERPENT128". */
954static const char *cipher_spec_serpent128_aliases[] = 954static const char *cipher_spec_serpent128_aliases[] =
955 { 955 {
956 "SERPENT", 956 "SERPENT",
957 NULL, 957 NULL,
958 }; 958 };
959 959
960gcry_cipher_spec_t _gcry_cipher_spec_serpent128 = 960gcry_cipher_spec_t _gcry_cipher_spec_serpent128 =
961 { 961 {
962 "SERPENT128", cipher_spec_serpent128_aliases, NULL, 16, 128, 962 "SERPENT128", cipher_spec_serpent128_aliases, NULL, 16, 128,
963 sizeof (serpent_context_t), 963 sizeof (serpent_context_t),
964 serpent_setkey, serpent_encrypt, serpent_decrypt, 964 serpent_setkey, serpent_encrypt, serpent_decrypt,
965 }; 965 };
966 966
967gcry_cipher_spec_t _gcry_cipher_spec_serpent192 = 967gcry_cipher_spec_t _gcry_cipher_spec_serpent192 =
968 { 968 {
969 "SERPENT192", NULL, NULL, 16, 192, 969 "SERPENT192", NULL, NULL, 16, 192,
970 sizeof (serpent_context_t), 970 sizeof (serpent_context_t),
971 serpent_setkey, serpent_encrypt, serpent_decrypt, 971 serpent_setkey, serpent_encrypt, serpent_decrypt,
972 }; 972 };
973 973
974gcry_cipher_spec_t _gcry_cipher_spec_serpent256 = 974gcry_cipher_spec_t _gcry_cipher_spec_serpent256 =
975 { 975 {
976 "SERPENT256", NULL, NULL, 16, 256, 976 "SERPENT256", NULL, NULL, 16, 256,
977 sizeof (serpent_context_t), 977 sizeof (serpent_context_t),
978 serpent_setkey, serpent_encrypt, serpent_decrypt, 978 serpent_setkey, serpent_encrypt, serpent_decrypt,
979 }; 979 };
diff --git a/pwmanager/pwmanager/binentrygen.cpp b/pwmanager/pwmanager/binentrygen.cpp
index 7d5ae45..f156a5e 100644
--- a/pwmanager/pwmanager/binentrygen.cpp
+++ b/pwmanager/pwmanager/binentrygen.cpp
@@ -1,71 +1,72 @@
1/*************************************************************************** 1/***************************************************************************
2 * * 2 * *
3 * copyright (C) 2004 by Michael Buesch * 3 * copyright (C) 2004 by Michael Buesch *
4 * email: mbuesch@freenet.de * 4 * email: mbuesch@freenet.de *
5 * * 5 * *
6 * This program is free software; you can redistribute it and/or modify * 6 * This program is free software; you can redistribute it and/or modify *
7 * it under the terms of the GNU General Public License version 2 * 7 * it under the terms of the GNU General Public License version 2 *
8 * as published by the Free Software Foundation. * 8 * as published by the Free Software Foundation. *
9 * * 9 * *
10 ***************************************************************************/ 10 ***************************************************************************/
11 11
12/*************************************************************************** 12/***************************************************************************
13 * copyright (C) 2004 by Ulf Schenk 13 * copyright (C) 2004 by Ulf Schenk
14 * This file is originaly based on version 1.0.1 of pwmanager 14 * This file is originaly based on version 1.0.1 of pwmanager
15 * and was modified to run on embedded devices that run microkde 15 * and was modified to run on embedded devices that run microkde
16 * 16 *
17 * $Id$ 17 * $Id$
18 **************************************************************************/ 18 **************************************************************************/
19 19
20
21#include "binentrygen.h" 20#include "binentrygen.h"
22#include "base64.h" 21#include "base64.h"
23#include "pwmexception.h"
24 22
23#include "pwmexception.h"
24#include "globalstuff.h"
25 25
26void BinEntryGen::encode(const QByteArray &data, 26void BinEntryGen::encode(const QByteArray &data,
27 PwMDataItem *ret, 27 PwMDataItem *ret,
28 DataType type) 28 DataType type)
29{ 29{
30 ret->clear(); 30 ret->clear();
31 ret->name = tostr(static_cast<int>(type)); 31 ret->name = tostr(static_cast<int>(type));
32 ret->binary = true; 32 ret->binary = true;
33 if (data.size() == 0) 33 if (data.size() == 0)
34 return; 34 return;
35 Base64 b64; 35 Base64 b64;
36 string d(data.data(), data.size()); 36 string d(data.data(), data.size());
37 ret->pw = b64.encode(d); 37 ret->pw = b64.encode(d);
38} 38}
39 39
40void BinEntryGen::decode(const PwMDataItem &data, 40void BinEntryGen::decode(const PwMDataItem &data,
41 QByteArray *ret, 41 QByteArray *ret,
42 DataType *type) 42 DataType *type)
43{ 43{
44 BUG_ON(!data.binary); 44 BUG_ON(!data.binary);
45 int t = strtol(data.name.c_str(), 0, 10); 45 int t = strtol(data.name.c_str(), 0, 10);
46 *type = static_cast<DataType>(t); 46 *type = static_cast<DataType>(t);
47 switch (*type) { 47 switch (*type) {
48 case None: 48 case None:
49 case KWalletMap: 49 case KWalletMap:
50 case KWalletStream: 50 case KWalletStream:
51 break; 51 break;
52 default: 52 default:
53 *type = None; 53 *type = None;
54 } 54 }
55 if (data.pw == "") { 55 if (data.pw == "") {
56 ret->fill(0); 56 ret->fill(0);
57 ret->resize(0); 57 ret->resize(0);
58 return; 58 return;
59 } 59 }
60 Base64 b64; 60 Base64 b64;
61 string d(b64.decode(data.pw)); 61 string d(b64.decode(data.pw));
62 ret->duplicate(d.c_str(), d.length()); 62 ret->duplicate(d.c_str(), d.length());
63} 63}
64 64
65BinEntryGen::DataType BinEntryGen::binType(const PwMDataItem &data) 65BinEntryGen::DataType BinEntryGen::binType(const PwMDataItem &data)
66{ 66{
67 if (!data.binary) 67 if (!data.binary)
68 return None; 68 return None;
69 int type = strtol(data.name.c_str(), 0, 10); 69 int type = strtol(data.name.c_str(), 0, 10);
70 return (static_cast<DataType>(type)); 70 return (static_cast<DataType>(type));
71} 71}
72
diff --git a/pwmanager/pwmanager/binentrygen.h b/pwmanager/pwmanager/binentrygen.h
index a58cd42..49288aa 100644
--- a/pwmanager/pwmanager/binentrygen.h
+++ b/pwmanager/pwmanager/binentrygen.h
@@ -1,65 +1,65 @@
1/*************************************************************************** 1/***************************************************************************
2 * * 2 * *
3 * copyright (C) 2004 by Michael Buesch * 3 * copyright (C) 2004 by Michael Buesch *
4 * email: mbuesch@freenet.de * 4 * email: mbuesch@freenet.de *
5 * * 5 * *
6 * This program is free software; you can redistribute it and/or modify * 6 * This program is free software; you can redistribute it and/or modify *
7 * it under the terms of the GNU General Public License version 2 * 7 * it under the terms of the GNU General Public License version 2 *
8 * as published by the Free Software Foundation. * 8 * as published by the Free Software Foundation. *
9 * * 9 * *
10 ***************************************************************************/ 10 ***************************************************************************/
11 11
12/*************************************************************************** 12/***************************************************************************
13 * copyright (C) 2004 by Ulf Schenk 13 * copyright (C) 2004 by Ulf Schenk
14 * This file is originaly based on version 1.0.1 of pwmanager 14 * This file is originaly based on version 1.0.1 of pwmanager
15 * and was modified to run on embedded devices that run microkde 15 * and was modified to run on embedded devices that run microkde
16 * 16 *
17 * $Id$ 17 * $Id$
18 **************************************************************************/ 18 **************************************************************************/
19 19
20#ifndef __BINENTRYGEN_H 20#ifndef __BINENTRYGEN_H
21#define __BINENTRYGEN_H 21#define __BINENTRYGEN_H
22 22
23#include "pwmdoc.h"
24 23
25#include <qcstring.h> 24#include <qcstring.h>
26 25
26#include "pwmdoc.h"
27 27
28/** Binary entry generator. 28/** Binary entry generator.
29 * This generator generates a normal struct PwMDataItem 29 * This generator generates a normal struct PwMDataItem
30 * from binary data (using base64 encoding). 30 * from binary data (using base64 encoding).
31 * This mechanism is used to support the binary interface functions 31 * This mechanism is used to support the binary interface functions
32 * of the KWallet emulation, for example. 32 * of the KWallet emulation, for example.
33 * 33 *
34 * The format of the encoded binary data as a PwMDataItem is as follows: 34 * The format of the encoded binary data as a PwMDataItem is as follows:
35 * 35 *
36 * PwMDataItem::desc contains the normal description string for 36 * PwMDataItem::desc contains the normal description string for
37 * this entry. Nothing surprising. 37 * this entry. Nothing surprising.
38 * PwMDataItem::name contains the "DataType" number in ascii format. 38 * PwMDataItem::name contains the "DataType" number in ascii format.
39 * PwMDataItem::pw contains the base64 encoded data stream. 39 * PwMDataItem::pw contains the base64 encoded data stream.
40 * PwMDataItem::binary is always true for binary entries. 40 * PwMDataItem::binary is always true for binary entries.
41 * All other PwMDataItems are currently unused by BinEntryGen. 41 * All other PwMDataItems are currently unused by BinEntryGen.
42 */ 42 */
43class BinEntryGen 43class BinEntryGen
44{ 44{
45public: 45public:
46 enum DataType 46 enum DataType
47 { 47 {
48 None = 0, 48 None = 0,
49 KWalletMap, 49 KWalletMap,
50 KWalletStream 50 KWalletStream
51 }; 51 };
52 52
53public: 53public:
54 BinEntryGen() { } 54 BinEntryGen() { }
55 55
56 /** Encode the binary "data" and return it in "ret" */ 56 /** Encode the binary "data" and return it in "ret" */
57 void encode(const QByteArray &data, PwMDataItem *ret, DataType type); 57 void encode(const QByteArray &data, PwMDataItem *ret, DataType type);
58 /** Decode the "data" and return it as binary "ret" */ 58 /** Decode the "data" and return it as binary "ret" */
59 void decode(const PwMDataItem &data, QByteArray *ret, DataType *type); 59 void decode(const PwMDataItem &data, QByteArray *ret, DataType *type);
60 60
61 /** Return the data type for this binary data item */ 61 /** Return the data type for this binary data item */
62 DataType binType(const PwMDataItem &data); 62 DataType binType(const PwMDataItem &data);
63}; 63};
64 64
65#endif // __BINENTRYGEN_H 65#endif // __BINENTRYGEN_H
diff --git a/pwmanager/pwmanager/blowfish.cpp b/pwmanager/pwmanager/blowfish.cpp
index 2ca58ce..ee29756 100644
--- a/pwmanager/pwmanager/blowfish.cpp
+++ b/pwmanager/pwmanager/blowfish.cpp
@@ -1,579 +1,579 @@
1/* 2003.05.02: Derived from libgcrypt-1.1.12 by Michael Buesch */ 1/* 2003.05.02: Derived from libgcrypt-1.1.12 by Michael Buesch */
2 2
3/* blowfish.c - Blowfish encryption 3/* blowfish.c - Blowfish encryption
4 *Copyright (C) 1998, 2001, 2002 Free Software Foundation, Inc. 4 *Copyright (C) 1998, 2001, 2002 Free Software Foundation, Inc.
5 * 5 *
6 * This file is part of Libgcrypt. 6 * This file is part of Libgcrypt.
7 * 7 *
8 * Libgcrypt is free software; you can redistribute it and/or modify 8 * Libgcrypt is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser general Public License as 9 * it under the terms of the GNU Lesser general Public License as
10 * published by the Free Software Foundation; either version 2.1 of 10 * published by the Free Software Foundation; either version 2.1 of
11 * the License, or (at your option) any later version. 11 * the License, or (at your option) any later version.
12 * 12 *
13 * Libgcrypt is distributed in the hope that it will be useful, 13 * Libgcrypt is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Lesser General Public License for more details. 16 * GNU Lesser General Public License for more details.
17 * 17 *
18 * You should have received a copy of the GNU Lesser General Public 18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this program; if not, write to the Free Software 19 * License along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA 20 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
21 * 21 *
22 * For a description of the algorithm, see: 22 * For a description of the algorithm, see:
23 * Bruce Schneier: Applied Cryptography. John Wiley & Sons, 1996. 23 * Bruce Schneier: Applied Cryptography. John Wiley & Sons, 1996.
24 * ISBN 0-471-11709-9. Pages 336 ff. 24 * ISBN 0-471-11709-9. Pages 336 ff.
25 */ 25 */
26 26
27/* Test values: 27/* Test values:
28 * key "abcdefghijklmnopqrstuvwxyz"; 28 * key "abcdefghijklmnopqrstuvwxyz";
29 * plain "BLOWFISH" 29 * plain "BLOWFISH"
30 * cipher 32 4E D0 FE F4 13 A2 03 30 * cipher 32 4E D0 FE F4 13 A2 03
31 * 31 *
32 */ 32 */
33 33
34/*************************************************************************** 34/***************************************************************************
35 * copyright (C) 2004 by Ulf Schenk 35 * copyright (C) 2004 by Ulf Schenk
36 * This file is originaly based on version 1.0.1 of pwmanager 36 * This file is originaly based on version 1.0.1 of pwmanager
37 * and was modified to run on embedded devices that run microkde 37 * and was modified to run on embedded devices that run microkde
38 * 38 *
39 * $Id$ 39 * $Id$
40 **************************************************************************/ 40 **************************************************************************/
41 41
42 42
43#include <string.h> 43#include <string.h>
44#include <stdlib.h> 44#include <stdlib.h>
45 45
46#include "blowfish.h"
47#include "globalstuff.h" 46#include "globalstuff.h"
48 47
48#include "blowfish.h"
49 49
50/* precomputed S boxes */ 50/* precomputed S boxes */
51static const uint32_t ks0[256] = { 51static const uint32_t ks0[256] = {
52 0xD1310BA6, 0x98DFB5AC, 0x2FFD72DB, 0xD01ADFB7, 0xB8E1AFED, 0x6A267E96, 52 0xD1310BA6, 0x98DFB5AC, 0x2FFD72DB, 0xD01ADFB7, 0xB8E1AFED, 0x6A267E96,
53 0xBA7C9045, 0xF12C7F99, 0x24A19947, 0xB3916CF7, 0x0801F2E2, 0x858EFC16, 53 0xBA7C9045, 0xF12C7F99, 0x24A19947, 0xB3916CF7, 0x0801F2E2, 0x858EFC16,
54 0x636920D8, 0x71574E69, 0xA458FEA3, 0xF4933D7E, 0x0D95748F, 0x728EB658, 54 0x636920D8, 0x71574E69, 0xA458FEA3, 0xF4933D7E, 0x0D95748F, 0x728EB658,
55 0x718BCD58, 0x82154AEE, 0x7B54A41D, 0xC25A59B5, 0x9C30D539, 0x2AF26013, 55 0x718BCD58, 0x82154AEE, 0x7B54A41D, 0xC25A59B5, 0x9C30D539, 0x2AF26013,
56 0xC5D1B023, 0x286085F0, 0xCA417918, 0xB8DB38EF, 0x8E79DCB0, 0x603A180E, 56 0xC5D1B023, 0x286085F0, 0xCA417918, 0xB8DB38EF, 0x8E79DCB0, 0x603A180E,
57 0x6C9E0E8B, 0xB01E8A3E, 0xD71577C1, 0xBD314B27, 0x78AF2FDA, 0x55605C60, 57 0x6C9E0E8B, 0xB01E8A3E, 0xD71577C1, 0xBD314B27, 0x78AF2FDA, 0x55605C60,
58 0xE65525F3, 0xAA55AB94, 0x57489862, 0x63E81440, 0x55CA396A, 0x2AAB10B6, 58 0xE65525F3, 0xAA55AB94, 0x57489862, 0x63E81440, 0x55CA396A, 0x2AAB10B6,
59 0xB4CC5C34, 0x1141E8CE, 0xA15486AF, 0x7C72E993, 0xB3EE1411, 0x636FBC2A, 59 0xB4CC5C34, 0x1141E8CE, 0xA15486AF, 0x7C72E993, 0xB3EE1411, 0x636FBC2A,
60 0x2BA9C55D, 0x741831F6, 0xCE5C3E16, 0x9B87931E, 0xAFD6BA33, 0x6C24CF5C, 60 0x2BA9C55D, 0x741831F6, 0xCE5C3E16, 0x9B87931E, 0xAFD6BA33, 0x6C24CF5C,
61 0x7A325381, 0x28958677, 0x3B8F4898, 0x6B4BB9AF, 0xC4BFE81B, 0x66282193, 61 0x7A325381, 0x28958677, 0x3B8F4898, 0x6B4BB9AF, 0xC4BFE81B, 0x66282193,
62 0x61D809CC, 0xFB21A991, 0x487CAC60, 0x5DEC8032, 0xEF845D5D, 0xE98575B1, 62 0x61D809CC, 0xFB21A991, 0x487CAC60, 0x5DEC8032, 0xEF845D5D, 0xE98575B1,
63 0xDC262302, 0xEB651B88, 0x23893E81, 0xD396ACC5, 0x0F6D6FF3, 0x83F44239, 63 0xDC262302, 0xEB651B88, 0x23893E81, 0xD396ACC5, 0x0F6D6FF3, 0x83F44239,
64 0x2E0B4482, 0xA4842004, 0x69C8F04A, 0x9E1F9B5E, 0x21C66842, 0xF6E96C9A, 64 0x2E0B4482, 0xA4842004, 0x69C8F04A, 0x9E1F9B5E, 0x21C66842, 0xF6E96C9A,
65 0x670C9C61, 0xABD388F0, 0x6A51A0D2, 0xD8542F68, 0x960FA728, 0xAB5133A3, 65 0x670C9C61, 0xABD388F0, 0x6A51A0D2, 0xD8542F68, 0x960FA728, 0xAB5133A3,
66 0x6EEF0B6C, 0x137A3BE4, 0xBA3BF050, 0x7EFB2A98, 0xA1F1651D, 0x39AF0176, 66 0x6EEF0B6C, 0x137A3BE4, 0xBA3BF050, 0x7EFB2A98, 0xA1F1651D, 0x39AF0176,
67 0x66CA593E, 0x82430E88, 0x8CEE8619, 0x456F9FB4, 0x7D84A5C3, 0x3B8B5EBE, 67 0x66CA593E, 0x82430E88, 0x8CEE8619, 0x456F9FB4, 0x7D84A5C3, 0x3B8B5EBE,
68 0xE06F75D8, 0x85C12073, 0x401A449F, 0x56C16AA6, 0x4ED3AA62, 0x363F7706, 68 0xE06F75D8, 0x85C12073, 0x401A449F, 0x56C16AA6, 0x4ED3AA62, 0x363F7706,
69 0x1BFEDF72, 0x429B023D, 0x37D0D724, 0xD00A1248, 0xDB0FEAD3, 0x49F1C09B, 69 0x1BFEDF72, 0x429B023D, 0x37D0D724, 0xD00A1248, 0xDB0FEAD3, 0x49F1C09B,
70 0x075372C9, 0x80991B7B, 0x25D479D8, 0xF6E8DEF7, 0xE3FE501A, 0xB6794C3B, 70 0x075372C9, 0x80991B7B, 0x25D479D8, 0xF6E8DEF7, 0xE3FE501A, 0xB6794C3B,
71 0x976CE0BD, 0x04C006BA, 0xC1A94FB6, 0x409F60C4, 0x5E5C9EC2, 0x196A2463, 71 0x976CE0BD, 0x04C006BA, 0xC1A94FB6, 0x409F60C4, 0x5E5C9EC2, 0x196A2463,
72 0x68FB6FAF, 0x3E6C53B5, 0x1339B2EB, 0x3B52EC6F, 0x6DFC511F, 0x9B30952C, 72 0x68FB6FAF, 0x3E6C53B5, 0x1339B2EB, 0x3B52EC6F, 0x6DFC511F, 0x9B30952C,
73 0xCC814544, 0xAF5EBD09, 0xBEE3D004, 0xDE334AFD, 0x660F2807, 0x192E4BB3, 73 0xCC814544, 0xAF5EBD09, 0xBEE3D004, 0xDE334AFD, 0x660F2807, 0x192E4BB3,
74 0xC0CBA857, 0x45C8740F, 0xD20B5F39, 0xB9D3FBDB, 0x5579C0BD, 0x1A60320A, 74 0xC0CBA857, 0x45C8740F, 0xD20B5F39, 0xB9D3FBDB, 0x5579C0BD, 0x1A60320A,
75 0xD6A100C6, 0x402C7279, 0x679F25FE, 0xFB1FA3CC, 0x8EA5E9F8, 0xDB3222F8, 75 0xD6A100C6, 0x402C7279, 0x679F25FE, 0xFB1FA3CC, 0x8EA5E9F8, 0xDB3222F8,
76 0x3C7516DF, 0xFD616B15, 0x2F501EC8, 0xAD0552AB, 0x323DB5FA, 0xFD238760, 76 0x3C7516DF, 0xFD616B15, 0x2F501EC8, 0xAD0552AB, 0x323DB5FA, 0xFD238760,
77 0x53317B48, 0x3E00DF82, 0x9E5C57BB, 0xCA6F8CA0, 0x1A87562E, 0xDF1769DB, 77 0x53317B48, 0x3E00DF82, 0x9E5C57BB, 0xCA6F8CA0, 0x1A87562E, 0xDF1769DB,
78 0xD542A8F6, 0x287EFFC3, 0xAC6732C6, 0x8C4F5573, 0x695B27B0, 0xBBCA58C8, 78 0xD542A8F6, 0x287EFFC3, 0xAC6732C6, 0x8C4F5573, 0x695B27B0, 0xBBCA58C8,
79 0xE1FFA35D, 0xB8F011A0, 0x10FA3D98, 0xFD2183B8, 0x4AFCB56C, 0x2DD1D35B, 79 0xE1FFA35D, 0xB8F011A0, 0x10FA3D98, 0xFD2183B8, 0x4AFCB56C, 0x2DD1D35B,
80 0x9A53E479, 0xB6F84565, 0xD28E49BC, 0x4BFB9790, 0xE1DDF2DA, 0xA4CB7E33, 80 0x9A53E479, 0xB6F84565, 0xD28E49BC, 0x4BFB9790, 0xE1DDF2DA, 0xA4CB7E33,
81 0x62FB1341, 0xCEE4C6E8, 0xEF20CADA, 0x36774C01, 0xD07E9EFE, 0x2BF11FB4, 81 0x62FB1341, 0xCEE4C6E8, 0xEF20CADA, 0x36774C01, 0xD07E9EFE, 0x2BF11FB4,
82 0x95DBDA4D, 0xAE909198, 0xEAAD8E71, 0x6B93D5A0, 0xD08ED1D0, 0xAFC725E0, 82 0x95DBDA4D, 0xAE909198, 0xEAAD8E71, 0x6B93D5A0, 0xD08ED1D0, 0xAFC725E0,
83 0x8E3C5B2F, 0x8E7594B7, 0x8FF6E2FB, 0xF2122B64, 0x8888B812, 0x900DF01C, 83 0x8E3C5B2F, 0x8E7594B7, 0x8FF6E2FB, 0xF2122B64, 0x8888B812, 0x900DF01C,
84 0x4FAD5EA0, 0x688FC31C, 0xD1CFF191, 0xB3A8C1AD, 0x2F2F2218, 0xBE0E1777, 84 0x4FAD5EA0, 0x688FC31C, 0xD1CFF191, 0xB3A8C1AD, 0x2F2F2218, 0xBE0E1777,
85 0xEA752DFE, 0x8B021FA1, 0xE5A0CC0F, 0xB56F74E8, 0x18ACF3D6, 0xCE89E299, 85 0xEA752DFE, 0x8B021FA1, 0xE5A0CC0F, 0xB56F74E8, 0x18ACF3D6, 0xCE89E299,
86 0xB4A84FE0, 0xFD13E0B7, 0x7CC43B81, 0xD2ADA8D9, 0x165FA266, 0x80957705, 86 0xB4A84FE0, 0xFD13E0B7, 0x7CC43B81, 0xD2ADA8D9, 0x165FA266, 0x80957705,
87 0x93CC7314, 0x211A1477, 0xE6AD2065, 0x77B5FA86, 0xC75442F5, 0xFB9D35CF, 87 0x93CC7314, 0x211A1477, 0xE6AD2065, 0x77B5FA86, 0xC75442F5, 0xFB9D35CF,
88 0xEBCDAF0C, 0x7B3E89A0, 0xD6411BD3, 0xAE1E7E49, 0x00250E2D, 0x2071B35E, 88 0xEBCDAF0C, 0x7B3E89A0, 0xD6411BD3, 0xAE1E7E49, 0x00250E2D, 0x2071B35E,
89 0x226800BB, 0x57B8E0AF, 0x2464369B, 0xF009B91E, 0x5563911D, 0x59DFA6AA, 89 0x226800BB, 0x57B8E0AF, 0x2464369B, 0xF009B91E, 0x5563911D, 0x59DFA6AA,
90 0x78C14389, 0xD95A537F, 0x207D5BA2, 0x02E5B9C5, 0x83260376, 0x6295CFA9, 90 0x78C14389, 0xD95A537F, 0x207D5BA2, 0x02E5B9C5, 0x83260376, 0x6295CFA9,
91 0x11C81968, 0x4E734A41, 0xB3472DCA, 0x7B14A94A, 0x1B510052, 0x9A532915, 91 0x11C81968, 0x4E734A41, 0xB3472DCA, 0x7B14A94A, 0x1B510052, 0x9A532915,
92 0xD60F573F, 0xBC9BC6E4, 0x2B60A476, 0x81E67400, 0x08BA6FB5, 0x571BE91F, 92 0xD60F573F, 0xBC9BC6E4, 0x2B60A476, 0x81E67400, 0x08BA6FB5, 0x571BE91F,
93 0xF296EC6B, 0x2A0DD915, 0xB6636521, 0xE7B9F9B6, 0xFF34052E, 0xC5855664, 93 0xF296EC6B, 0x2A0DD915, 0xB6636521, 0xE7B9F9B6, 0xFF34052E, 0xC5855664,
94 0x53B02D5D, 0xA99F8FA1, 0x08BA4799, 0x6E85076A 94 0x53B02D5D, 0xA99F8FA1, 0x08BA4799, 0x6E85076A
95}; 95};
96 96
97static const uint32_t ks1[256] = { 97static const uint32_t ks1[256] = {
98 0x4B7A70E9, 0xB5B32944, 0xDB75092E, 0xC4192623, 0xAD6EA6B0, 0x49A7DF7D, 98 0x4B7A70E9, 0xB5B32944, 0xDB75092E, 0xC4192623, 0xAD6EA6B0, 0x49A7DF7D,
99 0x9CEE60B8, 0x8FEDB266, 0xECAA8C71, 0x699A17FF, 0x5664526C, 0xC2B19EE1, 99 0x9CEE60B8, 0x8FEDB266, 0xECAA8C71, 0x699A17FF, 0x5664526C, 0xC2B19EE1,
100 0x193602A5, 0x75094C29, 0xA0591340, 0xE4183A3E, 0x3F54989A, 0x5B429D65, 100 0x193602A5, 0x75094C29, 0xA0591340, 0xE4183A3E, 0x3F54989A, 0x5B429D65,
101 0x6B8FE4D6, 0x99F73FD6, 0xA1D29C07, 0xEFE830F5, 0x4D2D38E6, 0xF0255DC1, 101 0x6B8FE4D6, 0x99F73FD6, 0xA1D29C07, 0xEFE830F5, 0x4D2D38E6, 0xF0255DC1,
102 0x4CDD2086, 0x8470EB26, 0x6382E9C6, 0x021ECC5E, 0x09686B3F, 0x3EBAEFC9, 102 0x4CDD2086, 0x8470EB26, 0x6382E9C6, 0x021ECC5E, 0x09686B3F, 0x3EBAEFC9,
103 0x3C971814, 0x6B6A70A1, 0x687F3584, 0x52A0E286, 0xB79C5305, 0xAA500737, 103 0x3C971814, 0x6B6A70A1, 0x687F3584, 0x52A0E286, 0xB79C5305, 0xAA500737,
104 0x3E07841C, 0x7FDEAE5C, 0x8E7D44EC, 0x5716F2B8, 0xB03ADA37, 0xF0500C0D, 104 0x3E07841C, 0x7FDEAE5C, 0x8E7D44EC, 0x5716F2B8, 0xB03ADA37, 0xF0500C0D,
105 0xF01C1F04, 0x0200B3FF, 0xAE0CF51A, 0x3CB574B2, 0x25837A58, 0xDC0921BD, 105 0xF01C1F04, 0x0200B3FF, 0xAE0CF51A, 0x3CB574B2, 0x25837A58, 0xDC0921BD,
106 0xD19113F9, 0x7CA92FF6, 0x94324773, 0x22F54701, 0x3AE5E581, 0x37C2DADC, 106 0xD19113F9, 0x7CA92FF6, 0x94324773, 0x22F54701, 0x3AE5E581, 0x37C2DADC,
107 0xC8B57634, 0x9AF3DDA7, 0xA9446146, 0x0FD0030E, 0xECC8C73E, 0xA4751E41, 107 0xC8B57634, 0x9AF3DDA7, 0xA9446146, 0x0FD0030E, 0xECC8C73E, 0xA4751E41,
108 0xE238CD99, 0x3BEA0E2F, 0x3280BBA1, 0x183EB331, 0x4E548B38, 0x4F6DB908, 108 0xE238CD99, 0x3BEA0E2F, 0x3280BBA1, 0x183EB331, 0x4E548B38, 0x4F6DB908,
109 0x6F420D03, 0xF60A04BF, 0x2CB81290, 0x24977C79, 0x5679B072, 0xBCAF89AF, 109 0x6F420D03, 0xF60A04BF, 0x2CB81290, 0x24977C79, 0x5679B072, 0xBCAF89AF,
110 0xDE9A771F, 0xD9930810, 0xB38BAE12, 0xDCCF3F2E, 0x5512721F, 0x2E6B7124, 110 0xDE9A771F, 0xD9930810, 0xB38BAE12, 0xDCCF3F2E, 0x5512721F, 0x2E6B7124,
111 0x501ADDE6, 0x9F84CD87, 0x7A584718, 0x7408DA17, 0xBC9F9ABC, 0xE94B7D8C, 111 0x501ADDE6, 0x9F84CD87, 0x7A584718, 0x7408DA17, 0xBC9F9ABC, 0xE94B7D8C,
112 0xEC7AEC3A, 0xDB851DFA, 0x63094366, 0xC464C3D2, 0xEF1C1847, 0x3215D908, 112 0xEC7AEC3A, 0xDB851DFA, 0x63094366, 0xC464C3D2, 0xEF1C1847, 0x3215D908,
113 0xDD433B37, 0x24C2BA16, 0x12A14D43, 0x2A65C451, 0x50940002, 0x133AE4DD, 113 0xDD433B37, 0x24C2BA16, 0x12A14D43, 0x2A65C451, 0x50940002, 0x133AE4DD,
114 0x71DFF89E, 0x10314E55, 0x81AC77D6, 0x5F11199B, 0x043556F1, 0xD7A3C76B, 114 0x71DFF89E, 0x10314E55, 0x81AC77D6, 0x5F11199B, 0x043556F1, 0xD7A3C76B,
115 0x3C11183B, 0x5924A509, 0xF28FE6ED, 0x97F1FBFA, 0x9EBABF2C, 0x1E153C6E, 115 0x3C11183B, 0x5924A509, 0xF28FE6ED, 0x97F1FBFA, 0x9EBABF2C, 0x1E153C6E,
116 0x86E34570, 0xEAE96FB1, 0x860E5E0A, 0x5A3E2AB3, 0x771FE71C, 0x4E3D06FA, 116 0x86E34570, 0xEAE96FB1, 0x860E5E0A, 0x5A3E2AB3, 0x771FE71C, 0x4E3D06FA,
117 0x2965DCB9, 0x99E71D0F, 0x803E89D6, 0x5266C825, 0x2E4CC978, 0x9C10B36A, 117 0x2965DCB9, 0x99E71D0F, 0x803E89D6, 0x5266C825, 0x2E4CC978, 0x9C10B36A,
118 0xC6150EBA, 0x94E2EA78, 0xA5FC3C53, 0x1E0A2DF4, 0xF2F74EA7, 0x361D2B3D, 118 0xC6150EBA, 0x94E2EA78, 0xA5FC3C53, 0x1E0A2DF4, 0xF2F74EA7, 0x361D2B3D,
119 0x1939260F, 0x19C27960, 0x5223A708, 0xF71312B6, 0xEBADFE6E, 0xEAC31F66, 119 0x1939260F, 0x19C27960, 0x5223A708, 0xF71312B6, 0xEBADFE6E, 0xEAC31F66,
120 0xE3BC4595, 0xA67BC883, 0xB17F37D1, 0x018CFF28, 0xC332DDEF, 0xBE6C5AA5, 120 0xE3BC4595, 0xA67BC883, 0xB17F37D1, 0x018CFF28, 0xC332DDEF, 0xBE6C5AA5,
121 0x65582185, 0x68AB9802, 0xEECEA50F, 0xDB2F953B, 0x2AEF7DAD, 0x5B6E2F84, 121 0x65582185, 0x68AB9802, 0xEECEA50F, 0xDB2F953B, 0x2AEF7DAD, 0x5B6E2F84,
122 0x1521B628, 0x29076170, 0xECDD4775, 0x619F1510, 0x13CCA830, 0xEB61BD96, 122 0x1521B628, 0x29076170, 0xECDD4775, 0x619F1510, 0x13CCA830, 0xEB61BD96,
123 0x0334FE1E, 0xAA0363CF, 0xB5735C90, 0x4C70A239, 0xD59E9E0B, 0xCBAADE14, 123 0x0334FE1E, 0xAA0363CF, 0xB5735C90, 0x4C70A239, 0xD59E9E0B, 0xCBAADE14,
124 0xEECC86BC, 0x60622CA7, 0x9CAB5CAB, 0xB2F3846E, 0x648B1EAF, 0x19BDF0CA, 124 0xEECC86BC, 0x60622CA7, 0x9CAB5CAB, 0xB2F3846E, 0x648B1EAF, 0x19BDF0CA,
125 0xA02369B9, 0x655ABB50, 0x40685A32, 0x3C2AB4B3, 0x319EE9D5, 0xC021B8F7, 125 0xA02369B9, 0x655ABB50, 0x40685A32, 0x3C2AB4B3, 0x319EE9D5, 0xC021B8F7,
126 0x9B540B19, 0x875FA099, 0x95F7997E, 0x623D7DA8, 0xF837889A, 0x97E32D77, 126 0x9B540B19, 0x875FA099, 0x95F7997E, 0x623D7DA8, 0xF837889A, 0x97E32D77,
127 0x11ED935F, 0x16681281, 0x0E358829, 0xC7E61FD6, 0x96DEDFA1, 0x7858BA99, 127 0x11ED935F, 0x16681281, 0x0E358829, 0xC7E61FD6, 0x96DEDFA1, 0x7858BA99,
128 0x57F584A5, 0x1B227263, 0x9B83C3FF, 0x1AC24696, 0xCDB30AEB, 0x532E3054, 128 0x57F584A5, 0x1B227263, 0x9B83C3FF, 0x1AC24696, 0xCDB30AEB, 0x532E3054,
129 0x8FD948E4, 0x6DBC3128, 0x58EBF2EF, 0x34C6FFEA, 0xFE28ED61, 0xEE7C3C73, 129 0x8FD948E4, 0x6DBC3128, 0x58EBF2EF, 0x34C6FFEA, 0xFE28ED61, 0xEE7C3C73,
130 0x5D4A14D9, 0xE864B7E3, 0x42105D14, 0x203E13E0, 0x45EEE2B6, 0xA3AAABEA, 130 0x5D4A14D9, 0xE864B7E3, 0x42105D14, 0x203E13E0, 0x45EEE2B6, 0xA3AAABEA,
131 0xDB6C4F15, 0xFACB4FD0, 0xC742F442, 0xEF6ABBB5, 0x654F3B1D, 0x41CD2105, 131 0xDB6C4F15, 0xFACB4FD0, 0xC742F442, 0xEF6ABBB5, 0x654F3B1D, 0x41CD2105,
132 0xD81E799E, 0x86854DC7, 0xE44B476A, 0x3D816250, 0xCF62A1F2, 0x5B8D2646, 132 0xD81E799E, 0x86854DC7, 0xE44B476A, 0x3D816250, 0xCF62A1F2, 0x5B8D2646,
133 0xFC8883A0, 0xC1C7B6A3, 0x7F1524C3, 0x69CB7492, 0x47848A0B, 0x5692B285, 133 0xFC8883A0, 0xC1C7B6A3, 0x7F1524C3, 0x69CB7492, 0x47848A0B, 0x5692B285,
134 0x095BBF00, 0xAD19489D, 0x1462B174, 0x23820E00, 0x58428D2A, 0x0C55F5EA, 134 0x095BBF00, 0xAD19489D, 0x1462B174, 0x23820E00, 0x58428D2A, 0x0C55F5EA,
135 0x1DADF43E, 0x233F7061, 0x3372F092, 0x8D937E41, 0xD65FECF1, 0x6C223BDB, 135 0x1DADF43E, 0x233F7061, 0x3372F092, 0x8D937E41, 0xD65FECF1, 0x6C223BDB,
136 0x7CDE3759, 0xCBEE7460, 0x4085F2A7, 0xCE77326E, 0xA6078084, 0x19F8509E, 136 0x7CDE3759, 0xCBEE7460, 0x4085F2A7, 0xCE77326E, 0xA6078084, 0x19F8509E,
137 0xE8EFD855, 0x61D99735, 0xA969A7AA, 0xC50C06C2, 0x5A04ABFC, 0x800BCADC, 137 0xE8EFD855, 0x61D99735, 0xA969A7AA, 0xC50C06C2, 0x5A04ABFC, 0x800BCADC,
138 0x9E447A2E, 0xC3453484, 0xFDD56705, 0x0E1E9EC9, 0xDB73DBD3, 0x105588CD, 138 0x9E447A2E, 0xC3453484, 0xFDD56705, 0x0E1E9EC9, 0xDB73DBD3, 0x105588CD,
139 0x675FDA79, 0xE3674340, 0xC5C43465, 0x713E38D8, 0x3D28F89E, 0xF16DFF20, 139 0x675FDA79, 0xE3674340, 0xC5C43465, 0x713E38D8, 0x3D28F89E, 0xF16DFF20,
140 0x153E21E7, 0x8FB03D4A, 0xE6E39F2B, 0xDB83ADF7 140 0x153E21E7, 0x8FB03D4A, 0xE6E39F2B, 0xDB83ADF7
141}; 141};
142 142
143static const uint32_t ks2[256] = { 143static const uint32_t ks2[256] = {
144 0xE93D5A68, 0x948140F7, 0xF64C261C, 0x94692934, 0x411520F7, 0x7602D4F7, 144 0xE93D5A68, 0x948140F7, 0xF64C261C, 0x94692934, 0x411520F7, 0x7602D4F7,
145 0xBCF46B2E, 0xD4A20068, 0xD4082471, 0x3320F46A, 0x43B7D4B7, 0x500061AF, 145 0xBCF46B2E, 0xD4A20068, 0xD4082471, 0x3320F46A, 0x43B7D4B7, 0x500061AF,
146 0x1E39F62E, 0x97244546, 0x14214F74, 0xBF8B8840, 0x4D95FC1D, 0x96B591AF, 146 0x1E39F62E, 0x97244546, 0x14214F74, 0xBF8B8840, 0x4D95FC1D, 0x96B591AF,
147 0x70F4DDD3, 0x66A02F45, 0xBFBC09EC, 0x03BD9785, 0x7FAC6DD0, 0x31CB8504, 147 0x70F4DDD3, 0x66A02F45, 0xBFBC09EC, 0x03BD9785, 0x7FAC6DD0, 0x31CB8504,
148 0x96EB27B3, 0x55FD3941, 0xDA2547E6, 0xABCA0A9A, 0x28507825, 0x530429F4, 148 0x96EB27B3, 0x55FD3941, 0xDA2547E6, 0xABCA0A9A, 0x28507825, 0x530429F4,
149 0x0A2C86DA, 0xE9B66DFB, 0x68DC1462, 0xD7486900, 0x680EC0A4, 0x27A18DEE, 149 0x0A2C86DA, 0xE9B66DFB, 0x68DC1462, 0xD7486900, 0x680EC0A4, 0x27A18DEE,
150 0x4F3FFEA2, 0xE887AD8C, 0xB58CE006, 0x7AF4D6B6, 0xAACE1E7C, 0xD3375FEC, 150 0x4F3FFEA2, 0xE887AD8C, 0xB58CE006, 0x7AF4D6B6, 0xAACE1E7C, 0xD3375FEC,
151 0xCE78A399, 0x406B2A42, 0x20FE9E35, 0xD9F385B9, 0xEE39D7AB, 0x3B124E8B, 151 0xCE78A399, 0x406B2A42, 0x20FE9E35, 0xD9F385B9, 0xEE39D7AB, 0x3B124E8B,
152 0x1DC9FAF7, 0x4B6D1856, 0x26A36631, 0xEAE397B2, 0x3A6EFA74, 0xDD5B4332, 152 0x1DC9FAF7, 0x4B6D1856, 0x26A36631, 0xEAE397B2, 0x3A6EFA74, 0xDD5B4332,
153 0x6841E7F7, 0xCA7820FB, 0xFB0AF54E, 0xD8FEB397, 0x454056AC, 0xBA489527, 153 0x6841E7F7, 0xCA7820FB, 0xFB0AF54E, 0xD8FEB397, 0x454056AC, 0xBA489527,
154 0x55533A3A, 0x20838D87, 0xFE6BA9B7, 0xD096954B, 0x55A867BC, 0xA1159A58, 154 0x55533A3A, 0x20838D87, 0xFE6BA9B7, 0xD096954B, 0x55A867BC, 0xA1159A58,
155 0xCCA92963, 0x99E1DB33, 0xA62A4A56, 0x3F3125F9, 0x5EF47E1C, 0x9029317C, 155 0xCCA92963, 0x99E1DB33, 0xA62A4A56, 0x3F3125F9, 0x5EF47E1C, 0x9029317C,
156 0xFDF8E802, 0x04272F70, 0x80BB155C, 0x05282CE3, 0x95C11548, 0xE4C66D22, 156 0xFDF8E802, 0x04272F70, 0x80BB155C, 0x05282CE3, 0x95C11548, 0xE4C66D22,
157 0x48C1133F, 0xC70F86DC, 0x07F9C9EE, 0x41041F0F, 0x404779A4, 0x5D886E17, 157 0x48C1133F, 0xC70F86DC, 0x07F9C9EE, 0x41041F0F, 0x404779A4, 0x5D886E17,
158 0x325F51EB, 0xD59BC0D1, 0xF2BCC18F, 0x41113564, 0x257B7834, 0x602A9C60, 158 0x325F51EB, 0xD59BC0D1, 0xF2BCC18F, 0x41113564, 0x257B7834, 0x602A9C60,
159 0xDFF8E8A3, 0x1F636C1B, 0x0E12B4C2, 0x02E1329E, 0xAF664FD1, 0xCAD18115, 159 0xDFF8E8A3, 0x1F636C1B, 0x0E12B4C2, 0x02E1329E, 0xAF664FD1, 0xCAD18115,
160 0x6B2395E0, 0x333E92E1, 0x3B240B62, 0xEEBEB922, 0x85B2A20E, 0xE6BA0D99, 160 0x6B2395E0, 0x333E92E1, 0x3B240B62, 0xEEBEB922, 0x85B2A20E, 0xE6BA0D99,
161 0xDE720C8C, 0x2DA2F728, 0xD0127845, 0x95B794FD, 0x647D0862, 0xE7CCF5F0, 161 0xDE720C8C, 0x2DA2F728, 0xD0127845, 0x95B794FD, 0x647D0862, 0xE7CCF5F0,
162 0x5449A36F, 0x877D48FA, 0xC39DFD27, 0xF33E8D1E, 0x0A476341, 0x992EFF74, 162 0x5449A36F, 0x877D48FA, 0xC39DFD27, 0xF33E8D1E, 0x0A476341, 0x992EFF74,
163 0x3A6F6EAB, 0xF4F8FD37, 0xA812DC60, 0xA1EBDDF8, 0x991BE14C, 0xDB6E6B0D, 163 0x3A6F6EAB, 0xF4F8FD37, 0xA812DC60, 0xA1EBDDF8, 0x991BE14C, 0xDB6E6B0D,
164 0xC67B5510, 0x6D672C37, 0x2765D43B, 0xDCD0E804, 0xF1290DC7, 0xCC00FFA3, 164 0xC67B5510, 0x6D672C37, 0x2765D43B, 0xDCD0E804, 0xF1290DC7, 0xCC00FFA3,
165 0xB5390F92, 0x690FED0B, 0x667B9FFB, 0xCEDB7D9C, 0xA091CF0B, 0xD9155EA3, 165 0xB5390F92, 0x690FED0B, 0x667B9FFB, 0xCEDB7D9C, 0xA091CF0B, 0xD9155EA3,
166 0xBB132F88, 0x515BAD24, 0x7B9479BF, 0x763BD6EB, 0x37392EB3, 0xCC115979, 166 0xBB132F88, 0x515BAD24, 0x7B9479BF, 0x763BD6EB, 0x37392EB3, 0xCC115979,
167 0x8026E297, 0xF42E312D, 0x6842ADA7, 0xC66A2B3B, 0x12754CCC, 0x782EF11C, 167 0x8026E297, 0xF42E312D, 0x6842ADA7, 0xC66A2B3B, 0x12754CCC, 0x782EF11C,
168 0x6A124237, 0xB79251E7, 0x06A1BBE6, 0x4BFB6350, 0x1A6B1018, 0x11CAEDFA, 168 0x6A124237, 0xB79251E7, 0x06A1BBE6, 0x4BFB6350, 0x1A6B1018, 0x11CAEDFA,
169 0x3D25BDD8, 0xE2E1C3C9, 0x44421659, 0x0A121386, 0xD90CEC6E, 0xD5ABEA2A, 169 0x3D25BDD8, 0xE2E1C3C9, 0x44421659, 0x0A121386, 0xD90CEC6E, 0xD5ABEA2A,
170 0x64AF674E, 0xDA86A85F, 0xBEBFE988, 0x64E4C3FE, 0x9DBC8057, 0xF0F7C086, 170 0x64AF674E, 0xDA86A85F, 0xBEBFE988, 0x64E4C3FE, 0x9DBC8057, 0xF0F7C086,
171 0x60787BF8, 0x6003604D, 0xD1FD8346, 0xF6381FB0, 0x7745AE04, 0xD736FCCC, 171 0x60787BF8, 0x6003604D, 0xD1FD8346, 0xF6381FB0, 0x7745AE04, 0xD736FCCC,
172 0x83426B33, 0xF01EAB71, 0xB0804187, 0x3C005E5F, 0x77A057BE, 0xBDE8AE24, 172 0x83426B33, 0xF01EAB71, 0xB0804187, 0x3C005E5F, 0x77A057BE, 0xBDE8AE24,
173 0x55464299, 0xBF582E61, 0x4E58F48F, 0xF2DDFDA2, 0xF474EF38, 0x8789BDC2, 173 0x55464299, 0xBF582E61, 0x4E58F48F, 0xF2DDFDA2, 0xF474EF38, 0x8789BDC2,
174 0x5366F9C3, 0xC8B38E74, 0xB475F255, 0x46FCD9B9, 0x7AEB2661, 0x8B1DDF84, 174 0x5366F9C3, 0xC8B38E74, 0xB475F255, 0x46FCD9B9, 0x7AEB2661, 0x8B1DDF84,
175 0x846A0E79, 0x915F95E2, 0x466E598E, 0x20B45770, 0x8CD55591, 0xC902DE4C, 175 0x846A0E79, 0x915F95E2, 0x466E598E, 0x20B45770, 0x8CD55591, 0xC902DE4C,
176 0xB90BACE1, 0xBB8205D0, 0x11A86248, 0x7574A99E, 0xB77F19B6, 0xE0A9DC09, 176 0xB90BACE1, 0xBB8205D0, 0x11A86248, 0x7574A99E, 0xB77F19B6, 0xE0A9DC09,
177 0x662D09A1, 0xC4324633, 0xE85A1F02, 0x09F0BE8C, 0x4A99A025, 0x1D6EFE10, 177 0x662D09A1, 0xC4324633, 0xE85A1F02, 0x09F0BE8C, 0x4A99A025, 0x1D6EFE10,
178 0x1AB93D1D, 0x0BA5A4DF, 0xA186F20F, 0x2868F169, 0xDCB7DA83, 0x573906FE, 178 0x1AB93D1D, 0x0BA5A4DF, 0xA186F20F, 0x2868F169, 0xDCB7DA83, 0x573906FE,
179 0xA1E2CE9B, 0x4FCD7F52, 0x50115E01, 0xA70683FA, 0xA002B5C4, 0x0DE6D027, 179 0xA1E2CE9B, 0x4FCD7F52, 0x50115E01, 0xA70683FA, 0xA002B5C4, 0x0DE6D027,
180 0x9AF88C27, 0x773F8641, 0xC3604C06, 0x61A806B5, 0xF0177A28, 0xC0F586E0, 180 0x9AF88C27, 0x773F8641, 0xC3604C06, 0x61A806B5, 0xF0177A28, 0xC0F586E0,
181 0x006058AA, 0x30DC7D62, 0x11E69ED7, 0x2338EA63, 0x53C2DD94, 0xC2C21634, 181 0x006058AA, 0x30DC7D62, 0x11E69ED7, 0x2338EA63, 0x53C2DD94, 0xC2C21634,
182 0xBBCBEE56, 0x90BCB6DE, 0xEBFC7DA1, 0xCE591D76, 0x6F05E409, 0x4B7C0188, 182 0xBBCBEE56, 0x90BCB6DE, 0xEBFC7DA1, 0xCE591D76, 0x6F05E409, 0x4B7C0188,
183 0x39720A3D, 0x7C927C24, 0x86E3725F, 0x724D9DB9, 0x1AC15BB4, 0xD39EB8FC, 183 0x39720A3D, 0x7C927C24, 0x86E3725F, 0x724D9DB9, 0x1AC15BB4, 0xD39EB8FC,
184 0xED545578, 0x08FCA5B5, 0xD83D7CD3, 0x4DAD0FC4, 0x1E50EF5E, 0xB161E6F8, 184 0xED545578, 0x08FCA5B5, 0xD83D7CD3, 0x4DAD0FC4, 0x1E50EF5E, 0xB161E6F8,
185 0xA28514D9, 0x6C51133C, 0x6FD5C7E7, 0x56E14EC4, 0x362ABFCE, 0xDDC6C837, 185 0xA28514D9, 0x6C51133C, 0x6FD5C7E7, 0x56E14EC4, 0x362ABFCE, 0xDDC6C837,
186 0xD79A3234, 0x92638212, 0x670EFA8E, 0x406000E0 186 0xD79A3234, 0x92638212, 0x670EFA8E, 0x406000E0
187}; 187};
188 188
189static const uint32_t ks3[256] = { 189static const uint32_t ks3[256] = {
190 0x3A39CE37, 0xD3FAF5CF, 0xABC27737, 0x5AC52D1B, 0x5CB0679E, 0x4FA33742, 190 0x3A39CE37, 0xD3FAF5CF, 0xABC27737, 0x5AC52D1B, 0x5CB0679E, 0x4FA33742,
191 0xD3822740, 0x99BC9BBE, 0xD5118E9D, 0xBF0F7315, 0xD62D1C7E, 0xC700C47B, 191 0xD3822740, 0x99BC9BBE, 0xD5118E9D, 0xBF0F7315, 0xD62D1C7E, 0xC700C47B,
192 0xB78C1B6B, 0x21A19045, 0xB26EB1BE, 0x6A366EB4, 0x5748AB2F, 0xBC946E79, 192 0xB78C1B6B, 0x21A19045, 0xB26EB1BE, 0x6A366EB4, 0x5748AB2F, 0xBC946E79,
193 0xC6A376D2, 0x6549C2C8, 0x530FF8EE, 0x468DDE7D, 0xD5730A1D, 0x4CD04DC6, 193 0xC6A376D2, 0x6549C2C8, 0x530FF8EE, 0x468DDE7D, 0xD5730A1D, 0x4CD04DC6,
194 0x2939BBDB, 0xA9BA4650, 0xAC9526E8, 0xBE5EE304, 0xA1FAD5F0, 0x6A2D519A, 194 0x2939BBDB, 0xA9BA4650, 0xAC9526E8, 0xBE5EE304, 0xA1FAD5F0, 0x6A2D519A,
195 0x63EF8CE2, 0x9A86EE22, 0xC089C2B8, 0x43242EF6, 0xA51E03AA, 0x9CF2D0A4, 195 0x63EF8CE2, 0x9A86EE22, 0xC089C2B8, 0x43242EF6, 0xA51E03AA, 0x9CF2D0A4,
196 0x83C061BA, 0x9BE96A4D, 0x8FE51550, 0xBA645BD6, 0x2826A2F9, 0xA73A3AE1, 196 0x83C061BA, 0x9BE96A4D, 0x8FE51550, 0xBA645BD6, 0x2826A2F9, 0xA73A3AE1,
197 0x4BA99586, 0xEF5562E9, 0xC72FEFD3, 0xF752F7DA, 0x3F046F69, 0x77FA0A59, 197 0x4BA99586, 0xEF5562E9, 0xC72FEFD3, 0xF752F7DA, 0x3F046F69, 0x77FA0A59,
198 0x80E4A915, 0x87B08601, 0x9B09E6AD, 0x3B3EE593, 0xE990FD5A, 0x9E34D797, 198 0x80E4A915, 0x87B08601, 0x9B09E6AD, 0x3B3EE593, 0xE990FD5A, 0x9E34D797,
199 0x2CF0B7D9, 0x022B8B51, 0x96D5AC3A, 0x017DA67D, 0xD1CF3ED6, 0x7C7D2D28, 199 0x2CF0B7D9, 0x022B8B51, 0x96D5AC3A, 0x017DA67D, 0xD1CF3ED6, 0x7C7D2D28,
200 0x1F9F25CF, 0xADF2B89B, 0x5AD6B472, 0x5A88F54C, 0xE029AC71, 0xE019A5E6, 200 0x1F9F25CF, 0xADF2B89B, 0x5AD6B472, 0x5A88F54C, 0xE029AC71, 0xE019A5E6,
201 0x47B0ACFD, 0xED93FA9B, 0xE8D3C48D, 0x283B57CC, 0xF8D56629, 0x79132E28, 201 0x47B0ACFD, 0xED93FA9B, 0xE8D3C48D, 0x283B57CC, 0xF8D56629, 0x79132E28,
202 0x785F0191, 0xED756055, 0xF7960E44, 0xE3D35E8C, 0x15056DD4, 0x88F46DBA, 202 0x785F0191, 0xED756055, 0xF7960E44, 0xE3D35E8C, 0x15056DD4, 0x88F46DBA,
203 0x03A16125, 0x0564F0BD, 0xC3EB9E15, 0x3C9057A2, 0x97271AEC, 0xA93A072A, 203 0x03A16125, 0x0564F0BD, 0xC3EB9E15, 0x3C9057A2, 0x97271AEC, 0xA93A072A,
204 0x1B3F6D9B, 0x1E6321F5, 0xF59C66FB, 0x26DCF319, 0x7533D928, 0xB155FDF5, 204 0x1B3F6D9B, 0x1E6321F5, 0xF59C66FB, 0x26DCF319, 0x7533D928, 0xB155FDF5,
205 0x03563482, 0x8ABA3CBB, 0x28517711, 0xC20AD9F8, 0xABCC5167, 0xCCAD925F, 205 0x03563482, 0x8ABA3CBB, 0x28517711, 0xC20AD9F8, 0xABCC5167, 0xCCAD925F,
206 0x4DE81751, 0x3830DC8E, 0x379D5862, 0x9320F991, 0xEA7A90C2, 0xFB3E7BCE, 206 0x4DE81751, 0x3830DC8E, 0x379D5862, 0x9320F991, 0xEA7A90C2, 0xFB3E7BCE,
207 0x5121CE64, 0x774FBE32, 0xA8B6E37E, 0xC3293D46, 0x48DE5369, 0x6413E680, 207 0x5121CE64, 0x774FBE32, 0xA8B6E37E, 0xC3293D46, 0x48DE5369, 0x6413E680,
208 0xA2AE0810, 0xDD6DB224, 0x69852DFD, 0x09072166, 0xB39A460A, 0x6445C0DD, 208 0xA2AE0810, 0xDD6DB224, 0x69852DFD, 0x09072166, 0xB39A460A, 0x6445C0DD,
209 0x586CDECF, 0x1C20C8AE, 0x5BBEF7DD, 0x1B588D40, 0xCCD2017F, 0x6BB4E3BB, 209 0x586CDECF, 0x1C20C8AE, 0x5BBEF7DD, 0x1B588D40, 0xCCD2017F, 0x6BB4E3BB,
210 0xDDA26A7E, 0x3A59FF45, 0x3E350A44, 0xBCB4CDD5, 0x72EACEA8, 0xFA6484BB, 210 0xDDA26A7E, 0x3A59FF45, 0x3E350A44, 0xBCB4CDD5, 0x72EACEA8, 0xFA6484BB,
211 0x8D6612AE, 0xBF3C6F47, 0xD29BE463, 0x542F5D9E, 0xAEC2771B, 0xF64E6370, 211 0x8D6612AE, 0xBF3C6F47, 0xD29BE463, 0x542F5D9E, 0xAEC2771B, 0xF64E6370,
212 0x740E0D8D, 0xE75B1357, 0xF8721671, 0xAF537D5D, 0x4040CB08, 0x4EB4E2CC, 212 0x740E0D8D, 0xE75B1357, 0xF8721671, 0xAF537D5D, 0x4040CB08, 0x4EB4E2CC,
213 0x34D2466A, 0x0115AF84, 0xE1B00428, 0x95983A1D, 0x06B89FB4, 0xCE6EA048, 213 0x34D2466A, 0x0115AF84, 0xE1B00428, 0x95983A1D, 0x06B89FB4, 0xCE6EA048,
214 0x6F3F3B82, 0x3520AB82, 0x011A1D4B, 0x277227F8, 0x611560B1, 0xE7933FDC, 214 0x6F3F3B82, 0x3520AB82, 0x011A1D4B, 0x277227F8, 0x611560B1, 0xE7933FDC,
215 0xBB3A792B, 0x344525BD, 0xA08839E1, 0x51CE794B, 0x2F32C9B7, 0xA01FBAC9, 215 0xBB3A792B, 0x344525BD, 0xA08839E1, 0x51CE794B, 0x2F32C9B7, 0xA01FBAC9,
216 0xE01CC87E, 0xBCC7D1F6, 0xCF0111C3, 0xA1E8AAC7, 0x1A908749, 0xD44FBD9A, 216 0xE01CC87E, 0xBCC7D1F6, 0xCF0111C3, 0xA1E8AAC7, 0x1A908749, 0xD44FBD9A,
217 0xD0DADECB, 0xD50ADA38, 0x0339C32A, 0xC6913667, 0x8DF9317C, 0xE0B12B4F, 217 0xD0DADECB, 0xD50ADA38, 0x0339C32A, 0xC6913667, 0x8DF9317C, 0xE0B12B4F,
218 0xF79E59B7, 0x43F5BB3A, 0xF2D519FF, 0x27D9459C, 0xBF97222C, 0x15E6FC2A, 218 0xF79E59B7, 0x43F5BB3A, 0xF2D519FF, 0x27D9459C, 0xBF97222C, 0x15E6FC2A,
219 0x0F91FC71, 0x9B941525, 0xFAE59361, 0xCEB69CEB, 0xC2A86459, 0x12BAA8D1, 219 0x0F91FC71, 0x9B941525, 0xFAE59361, 0xCEB69CEB, 0xC2A86459, 0x12BAA8D1,
220 0xB6C1075E, 0xE3056A0C, 0x10D25065, 0xCB03A442, 0xE0EC6E0E, 0x1698DB3B, 220 0xB6C1075E, 0xE3056A0C, 0x10D25065, 0xCB03A442, 0xE0EC6E0E, 0x1698DB3B,
221 0x4C98A0BE, 0x3278E964, 0x9F1F9532, 0xE0D392DF, 0xD3A0342B, 0x8971F21E, 221 0x4C98A0BE, 0x3278E964, 0x9F1F9532, 0xE0D392DF, 0xD3A0342B, 0x8971F21E,
222 0x1B0A7441, 0x4BA3348C, 0xC5BE7120, 0xC37632D8, 0xDF359F8D, 0x9B992F2E, 222 0x1B0A7441, 0x4BA3348C, 0xC5BE7120, 0xC37632D8, 0xDF359F8D, 0x9B992F2E,
223 0xE60B6F47, 0x0FE3F11D, 0xE54CDA54, 0x1EDAD891, 0xCE6279CF, 0xCD3E7E6F, 223 0xE60B6F47, 0x0FE3F11D, 0xE54CDA54, 0x1EDAD891, 0xCE6279CF, 0xCD3E7E6F,
224 0x1618B166, 0xFD2C1D05, 0x848FD2C5, 0xF6FB2299, 0xF523F357, 0xA6327623, 224 0x1618B166, 0xFD2C1D05, 0x848FD2C5, 0xF6FB2299, 0xF523F357, 0xA6327623,
225 0x93A83531, 0x56CCCD02, 0xACF08162, 0x5A75EBB5, 0x6E163697, 0x88D273CC, 225 0x93A83531, 0x56CCCD02, 0xACF08162, 0x5A75EBB5, 0x6E163697, 0x88D273CC,
226 0xDE966292, 0x81B949D0, 0x4C50901B, 0x71C65614, 0xE6C6C7BD, 0x327A140A, 226 0xDE966292, 0x81B949D0, 0x4C50901B, 0x71C65614, 0xE6C6C7BD, 0x327A140A,
227 0x45E1D006, 0xC3F27B9A, 0xC9AA53FD, 0x62A80F00, 0xBB25BFE2, 0x35BDD2F6, 227 0x45E1D006, 0xC3F27B9A, 0xC9AA53FD, 0x62A80F00, 0xBB25BFE2, 0x35BDD2F6,
228 0x71126905, 0xB2040222, 0xB6CBCF7C, 0xCD769C2B, 0x53113EC0, 0x1640E3D3, 228 0x71126905, 0xB2040222, 0xB6CBCF7C, 0xCD769C2B, 0x53113EC0, 0x1640E3D3,
229 0x38ABBD60, 0x2547ADF0, 0xBA38209C, 0xF746CE76, 0x77AFA1C5, 0x20756060, 229 0x38ABBD60, 0x2547ADF0, 0xBA38209C, 0xF746CE76, 0x77AFA1C5, 0x20756060,
230 0x85CBFE4E, 0x8AE88DD8, 0x7AAAF9B0, 0x4CF9AA7E, 0x1948C25C, 0x02FB8A8C, 230 0x85CBFE4E, 0x8AE88DD8, 0x7AAAF9B0, 0x4CF9AA7E, 0x1948C25C, 0x02FB8A8C,
231 0x01C36AE4, 0xD6EBE1F9, 0x90D4F869, 0xA65CDEA0, 0x3F09252D, 0xC208E69F, 231 0x01C36AE4, 0xD6EBE1F9, 0x90D4F869, 0xA65CDEA0, 0x3F09252D, 0xC208E69F,
232 0xB74E6132, 0xCE77E25B, 0x578FDFE3, 0x3AC372E6 232 0xB74E6132, 0xCE77E25B, 0x578FDFE3, 0x3AC372E6
233}; 233};
234 234
235static const uint32_t ps[BLOWFISH_ROUNDS + 2] = { 235static const uint32_t ps[BLOWFISH_ROUNDS + 2] = {
236 0x243F6A88, 0x85A308D3, 0x13198A2E, 0x03707344, 0xA4093822, 0x299F31D0, 236 0x243F6A88, 0x85A308D3, 0x13198A2E, 0x03707344, 0xA4093822, 0x299F31D0,
237 0x082EFA98, 0xEC4E6C89, 0x452821E6, 0x38D01377, 0xBE5466CF, 0x34E90C6C, 237 0x082EFA98, 0xEC4E6C89, 0x452821E6, 0x38D01377, 0xBE5466CF, 0x34E90C6C,
238 0xC0AC29B7, 0xC97C50DD, 0x3F84D5B5, 0xB5470917, 0x9216D5D9, 0x8979FB1B 238 0xC0AC29B7, 0xC97C50DD, 0x3F84D5B5, 0xB5470917, 0x9216D5D9, 0x8979FB1B
239}; 239};
240 240
241void Blowfish::burn_stack(int bytes) 241void Blowfish::burn_stack(int bytes)
242{ 242{
243 char buf[64]; 243 char buf[64];
244 244
245 memset(buf, 0, sizeof buf); 245 memset(buf, 0, sizeof buf);
246 bytes -= sizeof buf; 246 bytes -= sizeof buf;
247 if (bytes > 0) 247 if (bytes > 0)
248 burn_stack(bytes); 248 burn_stack(bytes);
249} 249}
250 250
251void Blowfish::do_encrypt(uint32_t * ret_xl, uint32_t * ret_xr) 251void Blowfish::do_encrypt(uint32_t * ret_xl, uint32_t * ret_xr)
252{ 252{
253#if BLOWFISH_ROUNDS == 16 253#if BLOWFISH_ROUNDS == 16
254 uint32_t xl, xr, *s0, *s1, *s2, *s3, *p; 254 uint32_t xl, xr, *s0, *s1, *s2, *s3, *p;
255 255
256 xl = *ret_xl; 256 xl = *ret_xl;
257 xr = *ret_xr; 257 xr = *ret_xr;
258 p = bc.p; 258 p = bc.p;
259 s0 = bc.s0; 259 s0 = bc.s0;
260 s1 = bc.s1; 260 s1 = bc.s1;
261 s2 = bc.s2; 261 s2 = bc.s2;
262 s3 = bc.s3; 262 s3 = bc.s3;
263 263
264 R(xl, xr, 0, p, s0, s1, s2, s3); 264 R(xl, xr, 0, p, s0, s1, s2, s3);
265 R(xr, xl, 1, p, s0, s1, s2, s3); 265 R(xr, xl, 1, p, s0, s1, s2, s3);
266 R(xl, xr, 2, p, s0, s1, s2, s3); 266 R(xl, xr, 2, p, s0, s1, s2, s3);
267 R(xr, xl, 3, p, s0, s1, s2, s3); 267 R(xr, xl, 3, p, s0, s1, s2, s3);
268 R(xl, xr, 4, p, s0, s1, s2, s3); 268 R(xl, xr, 4, p, s0, s1, s2, s3);
269 R(xr, xl, 5, p, s0, s1, s2, s3); 269 R(xr, xl, 5, p, s0, s1, s2, s3);
270 R(xl, xr, 6, p, s0, s1, s2, s3); 270 R(xl, xr, 6, p, s0, s1, s2, s3);
271 R(xr, xl, 7, p, s0, s1, s2, s3); 271 R(xr, xl, 7, p, s0, s1, s2, s3);
272 R(xl, xr, 8, p, s0, s1, s2, s3); 272 R(xl, xr, 8, p, s0, s1, s2, s3);
273 R(xr, xl, 9, p, s0, s1, s2, s3); 273 R(xr, xl, 9, p, s0, s1, s2, s3);
274 R(xl, xr, 10, p, s0, s1, s2, s3); 274 R(xl, xr, 10, p, s0, s1, s2, s3);
275 R(xr, xl, 11, p, s0, s1, s2, s3); 275 R(xr, xl, 11, p, s0, s1, s2, s3);
276 R(xl, xr, 12, p, s0, s1, s2, s3); 276 R(xl, xr, 12, p, s0, s1, s2, s3);
277 R(xr, xl, 13, p, s0, s1, s2, s3); 277 R(xr, xl, 13, p, s0, s1, s2, s3);
278 R(xl, xr, 14, p, s0, s1, s2, s3); 278 R(xl, xr, 14, p, s0, s1, s2, s3);
279 R(xr, xl, 15, p, s0, s1, s2, s3); 279 R(xr, xl, 15, p, s0, s1, s2, s3);
280 280
281 xl ^= p[BLOWFISH_ROUNDS]; 281 xl ^= p[BLOWFISH_ROUNDS];
282 xr ^= p[BLOWFISH_ROUNDS + 1]; 282 xr ^= p[BLOWFISH_ROUNDS + 1];
283 283
284 *ret_xl = xr; 284 *ret_xl = xr;
285 *ret_xr = xl; 285 *ret_xr = xl;
286 286
287#else 287#else
288 uint32_t xl, xr, temp, *p; 288 uint32_t xl, xr, temp, *p;
289 int i; 289 int i;
290 290
291 xl = *ret_xl; 291 xl = *ret_xl;
292 xr = *ret_xr; 292 xr = *ret_xr;
293 p = bc.p; 293 p = bc.p;
294 294
295 for (i = 0; i < BLOWFISH_ROUNDS; i++) { 295 for (i = 0; i < BLOWFISH_ROUNDS; i++) {
296 xl ^= p[i]; 296 xl ^= p[i];
297 xr ^= function_F(xl); 297 xr ^= function_F(xl);
298 temp = xl; 298 temp = xl;
299 xl = xr; 299 xl = xr;
300 xr = temp; 300 xr = temp;
301 } 301 }
302 temp = xl; 302 temp = xl;
303 xl = xr; 303 xl = xr;
304 xr = temp; 304 xr = temp;
305 305
306 xr ^= p[BLOWFISH_ROUNDS]; 306 xr ^= p[BLOWFISH_ROUNDS];
307 xl ^= p[BLOWFISH_ROUNDS + 1]; 307 xl ^= p[BLOWFISH_ROUNDS + 1];
308 308
309 *ret_xl = xl; 309 *ret_xl = xl;
310 *ret_xr = xr; 310 *ret_xr = xr;
311#endif 311#endif
312} 312}
313 313
314void Blowfish::do_decrypt(uint32_t * ret_xl, uint32_t * ret_xr) 314void Blowfish::do_decrypt(uint32_t * ret_xl, uint32_t * ret_xr)
315{ 315{
316#if BLOWFISH_ROUNDS == 16 316#if BLOWFISH_ROUNDS == 16
317 uint32_t xl, xr, *s0, *s1, *s2, *s3, *p; 317 uint32_t xl, xr, *s0, *s1, *s2, *s3, *p;
318 318
319 xl = *ret_xl; 319 xl = *ret_xl;
320 xr = *ret_xr; 320 xr = *ret_xr;
321 p = bc.p; 321 p = bc.p;
322 s0 = bc.s0; 322 s0 = bc.s0;
323 s1 = bc.s1; 323 s1 = bc.s1;
324 s2 = bc.s2; 324 s2 = bc.s2;
325 s3 = bc.s3; 325 s3 = bc.s3;
326 326
327 R(xl, xr, 17, p, s0, s1, s2, s3); 327 R(xl, xr, 17, p, s0, s1, s2, s3);
328 R(xr, xl, 16, p, s0, s1, s2, s3); 328 R(xr, xl, 16, p, s0, s1, s2, s3);
329 R(xl, xr, 15, p, s0, s1, s2, s3); 329 R(xl, xr, 15, p, s0, s1, s2, s3);
330 R(xr, xl, 14, p, s0, s1, s2, s3); 330 R(xr, xl, 14, p, s0, s1, s2, s3);
331 R(xl, xr, 13, p, s0, s1, s2, s3); 331 R(xl, xr, 13, p, s0, s1, s2, s3);
332 R(xr, xl, 12, p, s0, s1, s2, s3); 332 R(xr, xl, 12, p, s0, s1, s2, s3);
333 R(xl, xr, 11, p, s0, s1, s2, s3); 333 R(xl, xr, 11, p, s0, s1, s2, s3);
334 R(xr, xl, 10, p, s0, s1, s2, s3); 334 R(xr, xl, 10, p, s0, s1, s2, s3);
335 R(xl, xr, 9, p, s0, s1, s2, s3); 335 R(xl, xr, 9, p, s0, s1, s2, s3);
336 R(xr, xl, 8, p, s0, s1, s2, s3); 336 R(xr, xl, 8, p, s0, s1, s2, s3);
337 R(xl, xr, 7, p, s0, s1, s2, s3); 337 R(xl, xr, 7, p, s0, s1, s2, s3);
338 R(xr, xl, 6, p, s0, s1, s2, s3); 338 R(xr, xl, 6, p, s0, s1, s2, s3);
339 R(xl, xr, 5, p, s0, s1, s2, s3); 339 R(xl, xr, 5, p, s0, s1, s2, s3);
340 R(xr, xl, 4, p, s0, s1, s2, s3); 340 R(xr, xl, 4, p, s0, s1, s2, s3);
341 R(xl, xr, 3, p, s0, s1, s2, s3); 341 R(xl, xr, 3, p, s0, s1, s2, s3);
342 R(xr, xl, 2, p, s0, s1, s2, s3); 342 R(xr, xl, 2, p, s0, s1, s2, s3);
343 343
344 xl ^= p[1]; 344 xl ^= p[1];
345 xr ^= p[0]; 345 xr ^= p[0];
346 346
347 *ret_xl = xr; 347 *ret_xl = xr;
348 *ret_xr = xl; 348 *ret_xr = xl;
349 349
350#else 350#else
351 uint32_t xl, xr, temp, *p; 351 uint32_t xl, xr, temp, *p;
352 int i; 352 int i;
353 353
354 xl = *ret_xl; 354 xl = *ret_xl;
355 xr = *ret_xr; 355 xr = *ret_xr;
356 p = bc.p; 356 p = bc.p;
357 357
358 for (i = BLOWFISH_ROUNDS + 1; i > 1; i--) { 358 for (i = BLOWFISH_ROUNDS + 1; i > 1; i--) {
359 xl ^= p[i]; 359 xl ^= p[i];
360 xr ^= function_F(xl); 360 xr ^= function_F(xl);
361 temp = xl; 361 temp = xl;
362 xl = xr; 362 xl = xr;
363 xr = temp; 363 xr = temp;
364 } 364 }
365 365
366 temp = xl; 366 temp = xl;
367 xl = xr; 367 xl = xr;
368 xr = temp; 368 xr = temp;
369 369
370 xr ^= p[1]; 370 xr ^= p[1];
371 xl ^= p[0]; 371 xl ^= p[0];
372 372
373 *ret_xl = xl; 373 *ret_xl = xl;
374 *ret_xr = xr; 374 *ret_xr = xr;
375#endif 375#endif
376} 376}
377 377
378void Blowfish::do_encrypt_block(byte * outbuf, byte * inbuf) 378void Blowfish::do_encrypt_block(byte * outbuf, byte * inbuf)
379{ 379{
380 uint32_t d1, d2; 380 uint32_t d1, d2;
381 381
382 d1 = inbuf[0] << 24 | inbuf[1] << 16 | inbuf[2] << 8 | inbuf[3]; 382 d1 = inbuf[0] << 24 | inbuf[1] << 16 | inbuf[2] << 8 | inbuf[3];
383 d2 = inbuf[4] << 24 | inbuf[5] << 16 | inbuf[6] << 8 | inbuf[7]; 383 d2 = inbuf[4] << 24 | inbuf[5] << 16 | inbuf[6] << 8 | inbuf[7];
384 do_encrypt(&d1, &d2); 384 do_encrypt(&d1, &d2);
385 outbuf[0] = (d1 >> 24) & 0xff; 385 outbuf[0] = (d1 >> 24) & 0xff;
386 outbuf[1] = (d1 >> 16) & 0xff; 386 outbuf[1] = (d1 >> 16) & 0xff;
387 outbuf[2] = (d1 >> 8) & 0xff; 387 outbuf[2] = (d1 >> 8) & 0xff;
388 outbuf[3] = d1 & 0xff; 388 outbuf[3] = d1 & 0xff;
389 outbuf[4] = (d2 >> 24) & 0xff; 389 outbuf[4] = (d2 >> 24) & 0xff;
390 outbuf[5] = (d2 >> 16) & 0xff; 390 outbuf[5] = (d2 >> 16) & 0xff;
391 outbuf[6] = (d2 >> 8) & 0xff; 391 outbuf[6] = (d2 >> 8) & 0xff;
392 outbuf[7] = d2 & 0xff; 392 outbuf[7] = d2 & 0xff;
393} 393}
394 394
395void Blowfish::encrypt_block(byte * outbuf, byte * inbuf) 395void Blowfish::encrypt_block(byte * outbuf, byte * inbuf)
396{ 396{
397 do_encrypt_block(outbuf, inbuf); 397 do_encrypt_block(outbuf, inbuf);
398 burn_stack(64); 398 burn_stack(64);
399} 399}
400 400
401void Blowfish::do_decrypt_block(byte * outbuf, byte * inbuf) 401void Blowfish::do_decrypt_block(byte * outbuf, byte * inbuf)
402{ 402{
403 uint32_t d1, d2; 403 uint32_t d1, d2;
404 404
405 d1 = inbuf[0] << 24 | inbuf[1] << 16 | inbuf[2] << 8 | inbuf[3]; 405 d1 = inbuf[0] << 24 | inbuf[1] << 16 | inbuf[2] << 8 | inbuf[3];
406 d2 = inbuf[4] << 24 | inbuf[5] << 16 | inbuf[6] << 8 | inbuf[7]; 406 d2 = inbuf[4] << 24 | inbuf[5] << 16 | inbuf[6] << 8 | inbuf[7];
407 do_decrypt(&d1, &d2); 407 do_decrypt(&d1, &d2);
408 outbuf[0] = (d1 >> 24) & 0xff; 408 outbuf[0] = (d1 >> 24) & 0xff;
409 outbuf[1] = (d1 >> 16) & 0xff; 409 outbuf[1] = (d1 >> 16) & 0xff;
410 outbuf[2] = (d1 >> 8) & 0xff; 410 outbuf[2] = (d1 >> 8) & 0xff;
411 outbuf[3] = d1 & 0xff; 411 outbuf[3] = d1 & 0xff;
412 outbuf[4] = (d2 >> 24) & 0xff; 412 outbuf[4] = (d2 >> 24) & 0xff;
413 outbuf[5] = (d2 >> 16) & 0xff; 413 outbuf[5] = (d2 >> 16) & 0xff;
414 outbuf[6] = (d2 >> 8) & 0xff; 414 outbuf[6] = (d2 >> 8) & 0xff;
415 outbuf[7] = d2 & 0xff; 415 outbuf[7] = d2 & 0xff;
416} 416}
417 417
418void Blowfish::decrypt_block(byte * outbuf, byte * inbuf) 418void Blowfish::decrypt_block(byte * outbuf, byte * inbuf)
419{ 419{
420 do_decrypt_block(outbuf, inbuf); 420 do_decrypt_block(outbuf, inbuf);
421 burn_stack(64); 421 burn_stack(64);
422} 422}
423 423
424bool Blowfish::selfTest() 424bool Blowfish::selfTest()
425{ 425{
426 byte plain1[] = "BLOWFISH"; 426 byte plain1[] = "BLOWFISH";
427 byte key1[] = "abcdefghijklmnopqrstuvwxyz"; 427 byte key1[] = "abcdefghijklmnopqrstuvwxyz";
428 byte cipher1[] = "\x32\x4E\xD0\xFE\xF4\x13\xA2\x03"; 428 byte cipher1[] = "\x32\x4E\xD0\xFE\xF4\x13\xA2\x03";
429 byte plain2[] = "\xFE\xDC\xBA\x98\x76\x54\x32\x10"; 429 byte plain2[] = "\xFE\xDC\xBA\x98\x76\x54\x32\x10";
430 byte key2[] = "\x41\x79\x6E\xA0\x52\x61\x6E\xE4"; 430 byte key2[] = "\x41\x79\x6E\xA0\x52\x61\x6E\xE4";
431 byte cipher2[] = "\xE1\x13\xF4\x10\x2C\xFC\xCE\x43"; 431 byte cipher2[] = "\xE1\x13\xF4\x10\x2C\xFC\xCE\x43";
432 byte buffer[8]; 432 byte buffer[8];
433 433
434 Blowfish blowfish; 434 Blowfish blowfish;
435 435
436 blowfish.bf_setkey(key1, array_size(key1) - 1); 436 blowfish.bf_setkey(key1, array_size(key1) - 1);
437 blowfish.bf_encrypt(buffer, plain1, array_size(plain1) - 1); 437 blowfish.bf_encrypt(buffer, plain1, array_size(plain1) - 1);
438 if (unlikely(memcmp(buffer, cipher1, array_size(cipher1) - 1))) 438 if (unlikely(memcmp(buffer, cipher1, array_size(cipher1) - 1)))
439 return false; 439 return false;
440 440
441 blowfish.bf_decrypt(buffer, buffer, array_size(buffer)); 441 blowfish.bf_decrypt(buffer, buffer, array_size(buffer));
442 if (unlikely(memcmp(buffer, plain1, array_size(plain1) - 1))) 442 if (unlikely(memcmp(buffer, plain1, array_size(plain1) - 1)))
443 return false; 443 return false;
444 444
445 blowfish.bf_setkey(key2, array_size(key2) - 1); 445 blowfish.bf_setkey(key2, array_size(key2) - 1);
446 blowfish.bf_encrypt(buffer, plain2, array_size(plain2) - 1); 446 blowfish.bf_encrypt(buffer, plain2, array_size(plain2) - 1);
447 if (unlikely(memcmp(buffer, cipher2, array_size(cipher2) - 1))) 447 if (unlikely(memcmp(buffer, cipher2, array_size(cipher2) - 1)))
448 return false; 448 return false;
449 449
450 blowfish.bf_decrypt(buffer, buffer, array_size(buffer)); 450 blowfish.bf_decrypt(buffer, buffer, array_size(buffer));
451 if (unlikely(memcmp(buffer, plain2, array_size(plain2) - 1))) 451 if (unlikely(memcmp(buffer, plain2, array_size(plain2) - 1)))
452 return false; 452 return false;
453 453
454 return true; 454 return true;
455} 455}
456 456
457int Blowfish::do_bf_setkey(byte * key, unsigned int keylen) 457int Blowfish::do_bf_setkey(byte * key, unsigned int keylen)
458{ 458{
459 int i, j; 459 int i, j;
460 uint32_t data, datal, datar; 460 uint32_t data, datal, datar;
461 461
462 for (i = 0; i < BLOWFISH_ROUNDS + 2; ++i) 462 for (i = 0; i < BLOWFISH_ROUNDS + 2; ++i)
463 bc.p[i] = ps[i]; 463 bc.p[i] = ps[i];
464 for (i = 0; i < 256; ++i) { 464 for (i = 0; i < 256; ++i) {
465 bc.s0[i] = ks0[i]; 465 bc.s0[i] = ks0[i];
466 bc.s1[i] = ks1[i]; 466 bc.s1[i] = ks1[i];
467 bc.s2[i] = ks2[i]; 467 bc.s2[i] = ks2[i];
468 bc.s3[i] = ks3[i]; 468 bc.s3[i] = ks3[i];
469 } 469 }
470 470
471 for (i = j = 0; i < BLOWFISH_ROUNDS + 2; ++i) { 471 for (i = j = 0; i < BLOWFISH_ROUNDS + 2; ++i) {
472#ifdef BIG_ENDIAN_HOST 472#ifdef BIG_ENDIAN_HOST
473 ((byte *) & data)[0] = key[j]; 473 ((byte *) & data)[0] = key[j];
474 ((byte *) & data)[1] = key[(j + 1) % keylen]; 474 ((byte *) & data)[1] = key[(j + 1) % keylen];
475 ((byte *) & data)[2] = key[(j + 2) % keylen]; 475 ((byte *) & data)[2] = key[(j + 2) % keylen];
476 ((byte *) & data)[3] = key[(j + 3) % keylen]; 476 ((byte *) & data)[3] = key[(j + 3) % keylen];
477#else 477#else
478 ((byte *) & data)[3] = key[j]; 478 ((byte *) & data)[3] = key[j];
479 ((byte *) & data)[2] = key[(j + 1) % keylen]; 479 ((byte *) & data)[2] = key[(j + 1) % keylen];
480 ((byte *) & data)[1] = key[(j + 2) % keylen]; 480 ((byte *) & data)[1] = key[(j + 2) % keylen];
481 ((byte *) & data)[0] = key[(j + 3) % keylen]; 481 ((byte *) & data)[0] = key[(j + 3) % keylen];
482#endif 482#endif
483 bc.p[i] ^= data; 483 bc.p[i] ^= data;
484 j = (j + 4) % keylen; 484 j = (j + 4) % keylen;
485 } 485 }
486 486
487 datal = datar = 0; 487 datal = datar = 0;
488 for (i = 0; i < BLOWFISH_ROUNDS + 2; i += 2) { 488 for (i = 0; i < BLOWFISH_ROUNDS + 2; i += 2) {
489 do_encrypt(&datal, &datar); 489 do_encrypt(&datal, &datar);
490 bc.p[i] = datal; 490 bc.p[i] = datal;
491 bc.p[i + 1] = datar; 491 bc.p[i + 1] = datar;
492 } 492 }
493 for (i = 0; i < 256; i += 2) { 493 for (i = 0; i < 256; i += 2) {
494 do_encrypt(&datal, &datar); 494 do_encrypt(&datal, &datar);
495 bc.s0[i] = datal; 495 bc.s0[i] = datal;
496 bc.s0[i + 1] = datar; 496 bc.s0[i + 1] = datar;
497 } 497 }
498 for (i = 0; i < 256; i += 2) { 498 for (i = 0; i < 256; i += 2) {
499 do_encrypt(&datal, &datar); 499 do_encrypt(&datal, &datar);
500 bc.s1[i] = datal; 500 bc.s1[i] = datal;
501 bc.s1[i + 1] = datar; 501 bc.s1[i + 1] = datar;
502 } 502 }
503 for (i = 0; i < 256; i += 2) { 503 for (i = 0; i < 256; i += 2) {
504 do_encrypt(&datal, &datar); 504 do_encrypt(&datal, &datar);
505 bc.s2[i] = datal; 505 bc.s2[i] = datal;
506 bc.s2[i + 1] = datar; 506 bc.s2[i + 1] = datar;
507 } 507 }
508 for (i = 0; i < 256; i += 2) { 508 for (i = 0; i < 256; i += 2) {
509 do_encrypt(&datal, &datar); 509 do_encrypt(&datal, &datar);
510 bc.s3[i] = datal; 510 bc.s3[i] = datal;
511 bc.s3[i + 1] = datar; 511 bc.s3[i + 1] = datar;
512 } 512 }
513 513
514 /* Check for weak key. A weak key is a key in which a value in */ 514 /* Check for weak key. A weak key is a key in which a value in */
515 /* the P-array (here c) occurs more than once per table. */ 515 /* the P-array (here c) occurs more than once per table. */
516 for (i = 0; i < 255; ++i) { 516 for (i = 0; i < 255; ++i) {
517 for (j = i + 1; j < 256; ++j) { 517 for (j = i + 1; j < 256; ++j) {
518 if ((bc.s0[i] == bc.s0[j]) || (bc.s1[i] == bc.s1[j]) || 518 if ((bc.s0[i] == bc.s0[j]) || (bc.s1[i] == bc.s1[j]) ||
519 (bc.s2[i] == bc.s2[j]) || (bc.s3[i] == bc.s3[j])) 519 (bc.s2[i] == bc.s2[j]) || (bc.s3[i] == bc.s3[j]))
520 return 1; 520 return 1;
521 } 521 }
522 } 522 }
523 523
524 return 0; 524 return 0;
525} 525}
526 526
527int Blowfish::bf_setkey(byte * key, unsigned int keylen) 527int Blowfish::bf_setkey(byte * key, unsigned int keylen)
528{ 528{
529 int rc = do_bf_setkey(key, keylen); 529 int rc = do_bf_setkey(key, keylen);
530 burn_stack(64); 530 burn_stack(64);
531 return rc; 531 return rc;
532} 532}
533 533
534int Blowfish::bf_encrypt(byte * outbuf, byte * inbuf, unsigned int inbuf_len) 534int Blowfish::bf_encrypt(byte * outbuf, byte * inbuf, unsigned int inbuf_len)
535{ 535{
536 if (unlikely(inbuf_len % 8)) 536 if (unlikely(inbuf_len % 8))
537 return 1; 537 return 1;
538 538
539 unsigned int i = 0; 539 unsigned int i = 0;
540 while (i < inbuf_len) { 540 while (i < inbuf_len) {
541 encrypt_block(outbuf + i, inbuf + i); 541 encrypt_block(outbuf + i, inbuf + i);
542 i += 8; 542 i += 8;
543 } 543 }
544 return 0; 544 return 0;
545} 545}
546 546
547int Blowfish::bf_decrypt(byte * outbuf, byte * inbuf, unsigned int inbuf_len) 547int Blowfish::bf_decrypt(byte * outbuf, byte * inbuf, unsigned int inbuf_len)
548{ 548{
549 if (unlikely(inbuf_len % 8)) 549 if (unlikely(inbuf_len % 8))
550 return 1; 550 return 1;
551 551
552 unsigned int i = 0; 552 unsigned int i = 0;
553 while (i < inbuf_len) { 553 while (i < inbuf_len) {
554 decrypt_block(outbuf + i, inbuf + i); 554 decrypt_block(outbuf + i, inbuf + i);
555 i += 8; 555 i += 8;
556 } 556 }
557 return 0; 557 return 0;
558} 558}
559 559
560void Blowfish::padNull(string *buf) 560void Blowfish::padNull(string *buf)
561{ 561{
562 buf->append(1, (char)0x01); 562 buf->append(1, (char)0x01);
563 string::size_type append_null = 8 - (buf->length() % 8); 563 string::size_type append_null = 8 - (buf->length() % 8);
564 buf->append(append_null, (char)0x00); 564 buf->append(append_null, (char)0x00);
565} 565}
566 566
567bool Blowfish::unpadNull(string *buf) 567bool Blowfish::unpadNull(string *buf)
568{ 568{
569 if (unlikely(buf->size() % 8)) 569 if (unlikely(buf->size() % 8))
570 return false; 570 return false;
571 string::size_type pos = buf->length() - 1; 571 string::size_type pos = buf->length() - 1;
572 while ((*buf)[pos] != (char)0x01) { 572 while ((*buf)[pos] != (char)0x01) {
573 if (unlikely(pos == 0)) 573 if (unlikely(pos == 0))
574 return false; 574 return false;
575 --pos; 575 --pos;
576 } 576 }
577 buf->erase(pos, buf->length() - pos); 577 buf->erase(pos, buf->length() - pos);
578 return true; 578 return true;
579} 579}
diff --git a/pwmanager/pwmanager/blowfish.h b/pwmanager/pwmanager/blowfish.h
index 5129eab..862cccb 100644
--- a/pwmanager/pwmanager/blowfish.h
+++ b/pwmanager/pwmanager/blowfish.h
@@ -1,129 +1,131 @@
1/*************************************************************************** 1/***************************************************************************
2 * * 2 * *
3 * copyright (C) 2003, 2004 by Michael Buesch * 3 * copyright (C) 2003, 2004 by Michael Buesch *
4 * email: mbuesch@freenet.de * 4 * email: mbuesch@freenet.de *
5 * * 5 * *
6 * blowfish.c - Blowfish encryption * 6 * blowfish.c - Blowfish encryption *
7 * Copyright (C) 1998, 2001, 2002 Free Software Foundation, Inc. * 7 * Copyright (C) 1998, 2001, 2002 Free Software Foundation, Inc. *
8 * * 8 * *
9 * This program is free software; you can redistribute it and/or modify * 9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License version 2 * 10 * it under the terms of the GNU General Public License version 2 *
11 * as published by the Free Software Foundation. * 11 * as published by the Free Software Foundation. *
12 * * 12 * *
13 ***************************************************************************/ 13 ***************************************************************************/
14 14
15/*************************************************************************** 15/***************************************************************************
16 * copyright (C) 2004 by Ulf Schenk 16 * copyright (C) 2004 by Ulf Schenk
17 * This file is originaly based on version 1.0.1 of pwmanager 17 * This file is originaly based on version 1.0.1 of pwmanager
18 * and was modified to run on embedded devices that run microkde 18 * and was modified to run on embedded devices that run microkde
19 * 19 *
20 * $Id$ 20 * $Id$
21 **************************************************************************/ 21 **************************************************************************/
22 22
23#ifndef BLOWFISH_H 23#ifndef BLOWFISH_H
24#define BLOWFISH_H 24#define BLOWFISH_H
25 25
26#include "pwmexception.h" 26//#include "pwmexception.h"
27#ifndef _WIN32_ 27#ifndef _WIN32_
28#include <stdint.h> 28#include <stdint.h>
29#else 29#else
30 30
31#endif 31#endif
32#include <string> 32#include <string>
33using std::string; 33using std::string;
34 34
35 #define BLOWFISH_BLOCKSIZE8 35 #define BLOWFISH_BLOCKSIZE8
36 #define BLOWFISH_ROUNDS 16 36 #define BLOWFISH_ROUNDS 16
37 #define CIPHER_ALGO_BLOWFISH 4/* blowfish 128 bit key */ 37 #define CIPHER_ALGO_BLOWFISH 4/* blowfish 128 bit key */
38 38
39#ifndef _WIN32_ 39#ifndef _WIN32_
40 typedef uint8_t byte; 40 typedef uint8_t byte;
41#else 41#else
42#define uint8_t Q_UINT8 42#define uint8_t Q_UINT8
43#define byte Q_UINT8 43#define byte Q_UINT8
44#define uint32_t Q_UINT32 44#define uint32_t Q_UINT32
45#endif 45#endif
46 46
47//#include "pwmexception.h"
48
47/** blowfish encryption algorithm. 49/** blowfish encryption algorithm.
48 * Derived from libgcrypt-1.1.12 50 * Derived from libgcrypt-1.1.12
49 */ 51 */
50class Blowfish 52class Blowfish
51{ 53{
52 struct BLOWFISH_context 54 struct BLOWFISH_context
53 { 55 {
54 uint32_t s0[256]; 56 uint32_t s0[256];
55 uint32_t s1[256]; 57 uint32_t s1[256];
56 uint32_t s2[256]; 58 uint32_t s2[256];
57 uint32_t s3[256]; 59 uint32_t s3[256];
58 uint32_t p[BLOWFISH_ROUNDS+2]; 60 uint32_t p[BLOWFISH_ROUNDS+2];
59 }; 61 };
60 62
61public: 63public:
62 Blowfish() {} 64 Blowfish() {}
63 static bool selfTest(); 65 static bool selfTest();
64 66
65 /** set key to encrypt. if return == 1, it is a weak key. */ 67 /** set key to encrypt. if return == 1, it is a weak key. */
66 int bf_setkey( byte *key, unsigned int keylen ); 68 int bf_setkey( byte *key, unsigned int keylen );
67 /** encrypt inbuf and return it in outbuf. 69 /** encrypt inbuf and return it in outbuf.
68 * inbuf and outbuf have to be: buf % 8 == 0 70 * inbuf and outbuf have to be: buf % 8 == 0
69 * You may check this with getPaddedLen() and pad with NULL. 71 * You may check this with getPaddedLen() and pad with NULL.
70 */ 72 */
71 int bf_encrypt( byte *outbuf, byte *inbuf, unsigned int inbuf_len ); 73 int bf_encrypt( byte *outbuf, byte *inbuf, unsigned int inbuf_len );
72 /** decrypt inbuf and return it in outbuf. 74 /** decrypt inbuf and return it in outbuf.
73 * inbuf and outbuf have to be: buf % 8 == 0 75 * inbuf and outbuf have to be: buf % 8 == 0
74 * You may check this with getPaddedLen() and pad with NULL. 76 * You may check this with getPaddedLen() and pad with NULL.
75 */ 77 */
76 int bf_decrypt( byte *outbuf, byte *inbuf, unsigned int inbuf_len ); 78 int bf_decrypt( byte *outbuf, byte *inbuf, unsigned int inbuf_len );
77 /** returns the length, the sting has to be padded to */ 79 /** returns the length, the sting has to be padded to */
78 static unsigned int getPaddedLen(unsigned int inLen) 80 static unsigned int getPaddedLen(unsigned int inLen)
79 { return ((8 - (inLen % 8)) + inLen); } 81 { return ((8 - (inLen % 8)) + inLen); }
80 /** pad up to 8 bytes. */ 82 /** pad up to 8 bytes. */
81 static void padNull(string *buf); 83 static void padNull(string *buf);
82 /** remove padded data */ 84 /** remove padded data */
83 static bool unpadNull(string *buf); 85 static bool unpadNull(string *buf);
84 86
85protected: 87protected:
86#if BLOWFISH_ROUNDS != 16 88#if BLOWFISH_ROUNDS != 16
87 uint32_t function_F( uint32_t x) 89 uint32_t function_F( uint32_t x)
88 { 90 {
89 uint16_t a, b, c, d; 91 uint16_t a, b, c, d;
90 #ifdef BIG_ENDIAN_HOST 92 #ifdef BIG_ENDIAN_HOST
91 a = ((byte *) & x)[0]; 93 a = ((byte *) & x)[0];
92 b = ((byte *) & x)[1]; 94 b = ((byte *) & x)[1];
93 c = ((byte *) & x)[2]; 95 c = ((byte *) & x)[2];
94 d = ((byte *) & x)[3]; 96 d = ((byte *) & x)[3];
95 #else 97 #else
96 a = ((byte *) & x)[3]; 98 a = ((byte *) & x)[3];
97 b = ((byte *) & x)[2]; 99 b = ((byte *) & x)[2];
98 c = ((byte *) & x)[1]; 100 c = ((byte *) & x)[1];
99 d = ((byte *) & x)[0]; 101 d = ((byte *) & x)[0];
100 #endif 102 #endif
101 return ((bc.s0[a] + bc.s1[b]) ^ bc.s2[c]) + bc.s3[d]; 103 return ((bc.s0[a] + bc.s1[b]) ^ bc.s2[c]) + bc.s3[d];
102 } 104 }
103#endif 105#endif
104 void R(uint32_t &l, uint32_t &r, uint32_t i, uint32_t *p, 106 void R(uint32_t &l, uint32_t &r, uint32_t i, uint32_t *p,
105 uint32_t *s0, uint32_t *s1, uint32_t *s2, uint32_t *s3) 107 uint32_t *s0, uint32_t *s1, uint32_t *s2, uint32_t *s3)
106 { 108 {
107 l ^= p[i]; 109 l ^= p[i];
108 #ifdef BIG_ENDIAN_HOST 110 #ifdef BIG_ENDIAN_HOST
109 r ^= (( s0[((byte*)&l)[0]] + s1[((byte*)&l)[1]]) 111 r ^= (( s0[((byte*)&l)[0]] + s1[((byte*)&l)[1]])
110 ^ s2[((byte*)&l)[2]]) + s3[((byte*)&l)[3]]; 112 ^ s2[((byte*)&l)[2]]) + s3[((byte*)&l)[3]];
111 #else 113 #else
112 r ^= (( s0[((byte*)&l)[3]] + s1[((byte*)&l)[2]]) 114 r ^= (( s0[((byte*)&l)[3]] + s1[((byte*)&l)[2]])
113 ^ s2[((byte*)&l)[1]]) + s3[((byte*)&l)[0]]; 115 ^ s2[((byte*)&l)[1]]) + s3[((byte*)&l)[0]];
114 #endif 116 #endif
115 } 117 }
116 void encrypt_block(byte *outbuf, byte *inbuf); 118 void encrypt_block(byte *outbuf, byte *inbuf);
117 void decrypt_block(byte *outbuf, byte *inbuf); 119 void decrypt_block(byte *outbuf, byte *inbuf);
118 void burn_stack(int bytes); 120 void burn_stack(int bytes);
119 void do_encrypt(uint32_t *ret_xl, uint32_t *ret_xr); 121 void do_encrypt(uint32_t *ret_xl, uint32_t *ret_xr);
120 void do_decrypt(uint32_t *ret_xl, uint32_t *ret_xr); 122 void do_decrypt(uint32_t *ret_xl, uint32_t *ret_xr);
121 void do_encrypt_block(byte *outbuf, byte *inbuf); 123 void do_encrypt_block(byte *outbuf, byte *inbuf);
122 void do_decrypt_block(byte *outbuf, byte *inbuf); 124 void do_decrypt_block(byte *outbuf, byte *inbuf);
123 int do_bf_setkey(byte *key, unsigned int keylen); 125 int do_bf_setkey(byte *key, unsigned int keylen);
124 126
125protected: 127protected:
126 struct BLOWFISH_context bc; 128 struct BLOWFISH_context bc;
127}; 129};
128 130
129#endif 131#endif
diff --git a/pwmanager/pwmanager/genpasswd.cpp b/pwmanager/pwmanager/genpasswd.cpp
index b0cceff..41078b3 100644
--- a/pwmanager/pwmanager/genpasswd.cpp
+++ b/pwmanager/pwmanager/genpasswd.cpp
@@ -1,192 +1,193 @@
1/*************************************************************************** 1/***************************************************************************
2 * * 2 * *
3 * copyright (C) 2004 by Michael Buesch * 3 * copyright (C) 2004 by Michael Buesch *
4 * email: mbuesch@freenet.de * 4 * email: mbuesch@freenet.de *
5 * * 5 * *
6 * This program is free software; you can redistribute it and/or modify * 6 * This program is free software; you can redistribute it and/or modify *
7 * it under the terms of the GNU General Public License version 2 * 7 * it under the terms of the GNU General Public License version 2 *
8 * as published by the Free Software Foundation. * 8 * as published by the Free Software Foundation. *
9 * * 9 * *
10 ***************************************************************************/ 10 ***************************************************************************/
11 11
12/*************************************************************************** 12/***************************************************************************
13 * copyright (C) 2004 by Ulf Schenk 13 * copyright (C) 2004 by Ulf Schenk
14 * This file is originaly based on version 1.0.1 of pwmanager 14 * This file is originaly based on version 1.0.1 of pwmanager
15 * and was modified to run on embedded devices that run microkde 15 * and was modified to run on embedded devices that run microkde
16 * 16 *
17 * $Id$ 17 * $Id$
18 **************************************************************************/ 18 **************************************************************************/
19 19
20#include "genpasswd.h" 20#include "genpasswd.h"
21#include "pwmexception.h" 21#include "pwmexception.h"
22#include "randomizer.h" 22#include "randomizer.h"
23#include "globalstuff.h"
23 24
24 25
25/* how often can a char of the same charset be reused in order */ 26/* how often can a char of the same charset be reused in order */
26 #define FILTER_MAX_CHARSET_REUSE3 27 #define FILTER_MAX_CHARSET_REUSE3
27/* re-randomize all charsets on every iteration (0/1) */ 28/* re-randomize all charsets on every iteration (0/1) */
28 #define RERAND_CHARSET 0 29 #define RERAND_CHARSET 0
29 30
30 31
31struct staticCharsetStruct 32struct staticCharsetStruct
32{ 33{
33 const char *lower; 34 const char *lower;
34 const char *upper; 35 const char *upper;
35 const char *num; 36 const char *num;
36 const char *special; 37 const char *special;
37 const char *blank; 38 const char *blank;
38}; 39};
39 40
40static struct staticCharsetStruct staticCharset = { 41static struct staticCharsetStruct staticCharset = {
41 "abcdefghijklmnopqrstuvwxyz", 42 "abcdefghijklmnopqrstuvwxyz",
42 "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 43 "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
43 "0123456789", 44 "0123456789",
44 "!\"§$%&/()=?,.-;:_+", 45 "!\"§$%&/()=?,.-;:_+",
45 " " 46 " "
46}; 47};
47 48
48 49
49GenPasswd::GenPasswd() 50GenPasswd::GenPasswd()
50 : length (8) 51 : length (8)
51 , useFilter (true) 52 , useFilter (true)
52{ 53{
53 dynCharset.setAutoDelete(true); 54 dynCharset.setAutoDelete(true);
54} 55}
55 56
56void GenPasswd::setCharset(bool lower, 57void GenPasswd::setCharset(bool lower,
57 bool upper, 58 bool upper,
58 bool num, 59 bool num,
59 bool special, 60 bool special,
60 bool blank, 61 bool blank,
61 QString user) 62 QString user)
62{ 63{
63 unsigned int sanityCheck = 0; 64 unsigned int sanityCheck = 0;
64 dynCharset_element *tmpElement; 65 dynCharset_element *tmpElement;
65 dynCharset.clear(); 66 dynCharset.clear();
66 if (lower) { 67 if (lower) {
67 tmpElement = new dynCharset_element; 68 tmpElement = new dynCharset_element;
68 tmpElement->refCnt = 0; 69 tmpElement->refCnt = 0;
69 tmpElement->data = staticCharset.lower; 70 tmpElement->data = staticCharset.lower;
70 dynCharset.append(tmpElement); 71 dynCharset.append(tmpElement);
71 ++sanityCheck; 72 ++sanityCheck;
72 } 73 }
73 if (upper) { 74 if (upper) {
74 tmpElement = new dynCharset_element; 75 tmpElement = new dynCharset_element;
75 tmpElement->refCnt = 0; 76 tmpElement->refCnt = 0;
76 tmpElement->data = staticCharset.upper; 77 tmpElement->data = staticCharset.upper;
77 dynCharset.append(tmpElement); 78 dynCharset.append(tmpElement);
78 ++sanityCheck; 79 ++sanityCheck;
79 } 80 }
80 if (num) { 81 if (num) {
81 tmpElement = new dynCharset_element; 82 tmpElement = new dynCharset_element;
82 tmpElement->refCnt = 0; 83 tmpElement->refCnt = 0;
83 tmpElement->data = staticCharset.num; 84 tmpElement->data = staticCharset.num;
84 dynCharset.append(tmpElement); 85 dynCharset.append(tmpElement);
85 ++sanityCheck; 86 ++sanityCheck;
86 } 87 }
87 if (special) { 88 if (special) {
88 tmpElement = new dynCharset_element; 89 tmpElement = new dynCharset_element;
89 tmpElement->refCnt = 0; 90 tmpElement->refCnt = 0;
90 tmpElement->data = staticCharset.special; 91 tmpElement->data = staticCharset.special;
91 dynCharset.append(tmpElement); 92 dynCharset.append(tmpElement);
92 ++sanityCheck; 93 ++sanityCheck;
93 } 94 }
94 if (blank) { 95 if (blank) {
95 tmpElement = new dynCharset_element; 96 tmpElement = new dynCharset_element;
96 tmpElement->refCnt = 0; 97 tmpElement->refCnt = 0;
97 tmpElement->data = staticCharset.blank; 98 tmpElement->data = staticCharset.blank;
98 dynCharset.append(tmpElement); 99 dynCharset.append(tmpElement);
99 } 100 }
100 if (!user.isEmpty()) { 101 if (!user.isEmpty()) {
101 tmpElement = new dynCharset_element; 102 tmpElement = new dynCharset_element;
102 tmpElement->refCnt = 0; 103 tmpElement->refCnt = 0;
103 tmpElement->data = user; 104 tmpElement->data = user;
104 dynCharset.append(tmpElement); 105 dynCharset.append(tmpElement);
105 if (likely(user.length() >= 2)) 106 if (likely(user.length() >= 2))
106 ++sanityCheck; 107 ++sanityCheck;
107 } 108 }
108 BUG_ON(!sanityCheck); 109 BUG_ON(!sanityCheck);
109 rndDynCharset(); 110 rndDynCharset();
110} 111}
111 112
112void GenPasswd::rndDynCharset() 113void GenPasswd::rndDynCharset()
113{ 114{
114 QString tmpData; 115 QString tmpData;
115 int pos; 116 int pos;
116 Randomizer *rnd = Randomizer::obj(); 117 Randomizer *rnd = Randomizer::obj();
117 // QPtrList<dynCharset_element>::iterator is not available in QT-3.1 118 // QPtrList<dynCharset_element>::iterator is not available in QT-3.1
118 unsigned int i, cnt = dynCharset.count(); 119 unsigned int i, cnt = dynCharset.count();
119 dynCharset_element *p; 120 dynCharset_element *p;
120 for (i = 0; i < cnt; ++i) { 121 for (i = 0; i < cnt; ++i) {
121 p = dynCharset.at(i); 122 p = dynCharset.at(i);
122 PWM_ASSERT(p); 123 PWM_ASSERT(p);
123 tmpData = QString::null; 124 tmpData = QString::null;
124 while (p->data.length()) { 125 while (p->data.length()) {
125 pos = rnd->genRndInt() % p->data.length(); 126 pos = rnd->genRndInt() % p->data.length();
126 tmpData.append(p->data.at(pos)); 127 tmpData.append(p->data.at(pos));
127 p->data.remove(pos, 1); 128 p->data.remove(pos, 1);
128 } 129 }
129 p->data = tmpData; 130 p->data = tmpData;
130 } 131 }
131} 132}
132 133
133QString GenPasswd::gen() 134QString GenPasswd::gen()
134{ 135{
135 BUG_ON(dynCharset.count() <= 0); 136 BUG_ON(dynCharset.count() <= 0);
136 BUG_ON(length < 1); 137 BUG_ON(length < 1);
137 dynCharset_element *curCharset; 138 dynCharset_element *curCharset;
138 QString ret; 139 QString ret;
139 int i; 140 int i;
140 for (i = 0; i < length; ++i) { 141 for (i = 0; i < length; ++i) {
141 curCharset = selectNextCharset(); 142 curCharset = selectNextCharset();
142#if RERAND_CHARSET != 0 143#if RERAND_CHARSET != 0
143 rndDynCharset(); 144 rndDynCharset();
144#endif // RERAND_CHARSET 145#endif // RERAND_CHARSET
145 ret += genNewRandom(curCharset); 146 ret += genNewRandom(curCharset);
146 } 147 }
147 return ret; 148 return ret;
148} 149}
149 150
150GenPasswd::dynCharset_element * GenPasswd::selectNextCharset() 151GenPasswd::dynCharset_element * GenPasswd::selectNextCharset()
151{ 152{
152 dynCharset_element *ret; 153 dynCharset_element *ret;
153 int numCharsets = dynCharset.count(); 154 int numCharsets = dynCharset.count();
154 BUG_ON(numCharsets <= 0); 155 BUG_ON(numCharsets <= 0);
155 if (numCharsets == 1) 156 if (numCharsets == 1)
156 return dynCharset.at(0); 157 return dynCharset.at(0);
157 Randomizer *rnd = Randomizer::obj(); 158 Randomizer *rnd = Randomizer::obj();
158 if (useFilter) { 159 if (useFilter) {
159 // find out which charsets are allowed (filtering) 160 // find out which charsets are allowed (filtering)
160 QPtrList<dynCharset_element> allowedCharsets; 161 QPtrList<dynCharset_element> allowedCharsets;
161 // QPtrList<dynCharset_element>::iterator is not available in QT-3.1 162 // QPtrList<dynCharset_element>::iterator is not available in QT-3.1
162 unsigned int i, cnt = dynCharset.count(); 163 unsigned int i, cnt = dynCharset.count();
163 dynCharset_element *p; 164 dynCharset_element *p;
164 for (i = 0; i < cnt; ++i) { 165 for (i = 0; i < cnt; ++i) {
165 p = dynCharset.at(i); 166 p = dynCharset.at(i);
166 PWM_ASSERT(p); 167 PWM_ASSERT(p);
167 if (p->refCnt < FILTER_MAX_CHARSET_REUSE) { 168 if (p->refCnt < FILTER_MAX_CHARSET_REUSE) {
168 allowedCharsets.append(p); 169 allowedCharsets.append(p);
169 } else { 170 } else {
170 p->refCnt = 0; 171 p->refCnt = 0;
171 } 172 }
172 } 173 }
173 int numAllowedCharsets = allowedCharsets.count(); 174 int numAllowedCharsets = allowedCharsets.count();
174 BUG_ON(numAllowedCharsets <= 0); 175 BUG_ON(numAllowedCharsets <= 0);
175 // now get a random charset out of the allowed 176 // now get a random charset out of the allowed
176 unsigned int randomPos = rnd->genRndUInt() % numAllowedCharsets; 177 unsigned int randomPos = rnd->genRndUInt() % numAllowedCharsets;
177 ret = allowedCharsets.at(randomPos); 178 ret = allowedCharsets.at(randomPos);
178 ret->refCnt++; 179 ret->refCnt++;
179 return ret; 180 return ret;
180 } 181 }
181 // all charsets are allowed here (no filtering). Get a random. 182 // all charsets are allowed here (no filtering). Get a random.
182 unsigned int randomPos = rnd->genRndUInt() % numCharsets; 183 unsigned int randomPos = rnd->genRndUInt() % numCharsets;
183 ret = dynCharset.at(randomPos); 184 ret = dynCharset.at(randomPos);
184 return ret; 185 return ret;
185} 186}
186 187
187QChar GenPasswd::genNewRandom(const dynCharset_element *charset) 188QChar GenPasswd::genNewRandom(const dynCharset_element *charset)
188{ 189{
189 Randomizer *rnd = Randomizer::obj(); 190 Randomizer *rnd = Randomizer::obj();
190 int pos = rnd->genRndInt() % charset->data.length(); 191 int pos = rnd->genRndInt() % charset->data.length();
191 return charset->data.at(pos); 192 return charset->data.at(pos);
192} 193}
diff --git a/pwmanager/pwmanager/libgcryptif.h b/pwmanager/pwmanager/libgcryptif.h
index 9a987a2..a08d678 100644
--- a/pwmanager/pwmanager/libgcryptif.h
+++ b/pwmanager/pwmanager/libgcryptif.h
@@ -1,177 +1,179 @@
1/*************************************************************************** 1/***************************************************************************
2 * * 2 * *
3 * copyright (C) 2004 by Michael Buesch * 3 * copyright (C) 2004 by Michael Buesch *
4 * email: mbuesch@freenet.de * 4 * email: mbuesch@freenet.de *
5 * * 5 * *
6 * hashPassphrase() is derived from GnuPG and is * 6 * hashPassphrase() is derived from GnuPG and is *
7 * Copyright (C) 1998, 1999, 2000, 2001, 2003 * 7 * Copyright (C) 1998, 1999, 2000, 2001, 2003 *
8 * Free Software Foundation, Inc. * 8 * Free Software Foundation, Inc. *
9 * * 9 * *
10 * This program is free software; you can redistribute it and/or modify * 10 * This program is free software; you can redistribute it and/or modify *
11 * it under the terms of the GNU General Public License version 2 * 11 * it under the terms of the GNU General Public License version 2 *
12 * as published by the Free Software Foundation. * 12 * as published by the Free Software Foundation. *
13 * * 13 * *
14 ***************************************************************************/ 14 ***************************************************************************/
15 15
16/*************************************************************************** 16/***************************************************************************
17 * copyright (C) 2004 by Ulf Schenk 17 * copyright (C) 2004 by Ulf Schenk
18 * This file is originaly based on version 1.1 of pwmanager 18 * This file is originaly based on version 1.1 of pwmanager
19 * and was modified to run on embedded devices that run microkde 19 * and was modified to run on embedded devices that run microkde
20 * 20 *
21 * $Id$ 21 * $Id$
22 **************************************************************************/ 22 **************************************************************************/
23 23
24#ifndef __LIBGCRYPTIF_H 24#ifndef __LIBGCRYPTIF_H
25#define __LIBGCRYPTIF_H 25#define __LIBGCRYPTIF_H
26 26
27#include "pwmexception.h"
28 27
29//#undef CONFIG_PWMANAGER_GCRY // for debugging only. 28//#undef CONFIG_PWMANAGER_GCRY // for debugging only.
30#ifdef CONFIG_PWMANAGER_GCRY 29#ifdef CONFIG_PWMANAGER_GCRY
31 30
32#include <stddef.h> 31#include <stddef.h>
33#include <sys/types.h> 32#include <sys/types.h>
34#ifndef _WIN32_ 33#ifndef _WIN32_
35#include <stdint.h> 34#include <stdint.h>
36#else 35#else
37#define uint8_t Q_UINT8 36#define uint8_t Q_UINT8
38#define byte Q_UINT8 37#define byte Q_UINT8
39#define uint32_t Q_UINT32 38#define uint32_t Q_UINT32
40#endif 39#endif
41 #define STRING2KEY_SALTLEN8 40 #define STRING2KEY_SALTLEN8
42 41
42#include "pwmexception.h"
43
44
43/** interface class for the libgcrypt cipher and hash algorithms 45/** interface class for the libgcrypt cipher and hash algorithms
44 * NOTE: Always allocate 1024 extra bytes for the inBuf (for padding) 46 * NOTE: Always allocate 1024 extra bytes for the inBuf (for padding)
45 */ 47 */
46class LibGCryptIf 48class LibGCryptIf
47{ 49{
48protected: 50protected:
49 struct STRING2KEY 51 struct STRING2KEY
50 { 52 {
51 int mode; 53 int mode;
52 int hash_algo; 54 int hash_algo;
53 uint8_t salt[STRING2KEY_SALTLEN]; 55 uint8_t salt[STRING2KEY_SALTLEN];
54 uint32_t count; 56 uint32_t count;
55 }; 57 };
56 struct DEK 58 struct DEK
57 { 59 {
58 size_t keylen; 60 size_t keylen;
59 uint8_t key[32]; // this is the largest used keylen (256 bit) 61 uint8_t key[32]; // this is the largest used keylen (256 bit)
60 }; 62 };
61 63
62public: 64public:
63 LibGCryptIf() { } 65 LibGCryptIf() { }
64 /** is libgcrypt available? */ 66 /** is libgcrypt available? */
65 static bool available() 67 static bool available()
66 { return true; } 68 { return true; }
67 /** encrypt data. _algo is the PWM_CRYPT_* ID 69 /** encrypt data. _algo is the PWM_CRYPT_* ID
68 * of the algorithm. 70 * of the algorithm.
69 */ 71 */
70 PwMerror encrypt(unsigned char **outBuf, 72 PwMerror encrypt(unsigned char **outBuf,
71 size_t *outBufLen, 73 size_t *outBufLen,
72 unsigned char *inBuf, 74 unsigned char *inBuf,
73 size_t inBufLen, 75 size_t inBufLen,
74 const unsigned char *key, 76 const unsigned char *key,
75 size_t keylen, 77 size_t keylen,
76 char _algo, 78 char _algo,
77 char _hashalgo //US BUG: pass _hashalgo because we need it in hashPassphrase 79 char _hashalgo //US BUG: pass _hashalgo because we need it in hashPassphrase
78); 80);
79 /** decrypt data. _algo is the PWM_CRYPT_* ID 81 /** decrypt data. _algo is the PWM_CRYPT_* ID
80 * of the algorithm. 82 * of the algorithm.
81 */ 83 */
82 PwMerror decrypt(unsigned char **outBuf, 84 PwMerror decrypt(unsigned char **outBuf,
83 size_t *outBufLen, 85 size_t *outBufLen,
84 const unsigned char *inBuf, 86 const unsigned char *inBuf,
85 size_t inBufLen, 87 size_t inBufLen,
86 const unsigned char *key, 88 const unsigned char *key,
87 size_t keylen, 89 size_t keylen,
88 char _algo, 90 char _algo,
89 char _hashalgo //US BUG: pass _hashalgo because we need it in hashPassphrase 91 char _hashalgo //US BUG: pass _hashalgo because we need it in hashPassphrase
90); 92);
91 /** hash data. _algo is the PWM_HASH_* ID of the hash */ 93 /** hash data. _algo is the PWM_HASH_* ID of the hash */
92 PwMerror hash(unsigned char **outBuf, 94 PwMerror hash(unsigned char **outBuf,
93 size_t *outBufLen, 95 size_t *outBufLen,
94 const unsigned char *inBuf, 96 const unsigned char *inBuf,
95 size_t inBufLen, 97 size_t inBufLen,
96 char _algo); 98 char _algo);
97 /** returns the length of the hash. _algo is the PWM_HASH_* 99 /** returns the length of the hash. _algo is the PWM_HASH_*
98 * id of the hash. returns 0 on error. 100 * id of the hash. returns 0 on error.
99 */ 101 */
100 unsigned int hashLength(char _algo); 102 unsigned int hashLength(char _algo);
101 103
102protected: 104protected:
103 /** returns the total buffer length */ 105 /** returns the total buffer length */
104 size_t getBufLen(size_t inBufLen, size_t boundary) 106 size_t getBufLen(size_t inBufLen, size_t boundary)
105 { 107 {
106 return ((boundary - (inBufLen % boundary)) + inBufLen); 108 return ((boundary - (inBufLen % boundary)) + inBufLen);
107 } 109 }
108 /** pad the data up to the given boundary. 110 /** pad the data up to the given boundary.
109 * "buf" has to be big enough! 111 * "buf" has to be big enough!
110 */ 112 */
111 void padData(unsigned char *buf, 113 void padData(unsigned char *buf,
112 size_t bufLen, 114 size_t bufLen,
113 size_t boundary); 115 size_t boundary);
114 /** unpad the data */ 116 /** unpad the data */
115 void unpadData(const unsigned char *buf, 117 void unpadData(const unsigned char *buf,
116 size_t *bufLen); 118 size_t *bufLen);
117 /** maps the PWM_CRYPT_* ID of an algorithm 119 /** maps the PWM_CRYPT_* ID of an algorithm
118 * to the libgcrypt GCRY_CIPHER_* ID 120 * to the libgcrypt GCRY_CIPHER_* ID
119 */ 121 */
120 int mapCipherId(char algo); 122 int mapCipherId(char algo);
121 /** maps the PWM_HASH_* ID of an algorithm 123 /** maps the PWM_HASH_* ID of an algorithm
122 * to the libgcrypt GCRY_MD_* ID 124 * to the libgcrypt GCRY_MD_* ID
123 */ 125 */
124 int mapHashId(char algo); 126 int mapHashId(char algo);
125 /** hash a passphrase to a cipher key */ 127 /** hash a passphrase to a cipher key */
126 bool hashPassphrase(const unsigned char *pw, 128 bool hashPassphrase(const unsigned char *pw,
127 size_t pwlen, 129 size_t pwlen,
128 unsigned char *salt, 130 unsigned char *salt,
129 unsigned char *key, 131 unsigned char *key,
130 size_t keylen, 132 size_t keylen,
131 bool create, 133 bool create,
132 char _hashalgo //US BUG: pass _hashalgo because we need it in hashPassphrase 134 char _hashalgo //US BUG: pass _hashalgo because we need it in hashPassphrase
133); 135);
134 /** hash a passphrase to a cipher key */ 136 /** hash a passphrase to a cipher key */
135 bool doHashPassphrase(DEK *dek, 137 bool doHashPassphrase(DEK *dek,
136 const unsigned char *pw, 138 const unsigned char *pw,
137 size_t pwlen, 139 size_t pwlen,
138 STRING2KEY *s2k, 140 STRING2KEY *s2k,
139 bool create); 141 bool create);
140}; 142};
141 143
142 144
143#else // CONFIG_PWMANAGER_GCRY 145#else // CONFIG_PWMANAGER_GCRY
144/** libgcrypt is not installed. This is a NOP wrapper. */ 146/** libgcrypt is not installed. This is a NOP wrapper. */
145class LibGCryptIf 147class LibGCryptIf
146{ 148{
147public: 149public:
148 LibGCryptIf() { } 150 LibGCryptIf() { }
149 static bool available() 151 static bool available()
150 { return false; } 152 { return false; }
151 PwMerror encrypt(unsigned char **, 153 PwMerror encrypt(unsigned char **,
152 size_t *, 154 size_t *,
153 unsigned char *, 155 unsigned char *,
154 size_t, 156 size_t,
155 const unsigned char *, 157 const unsigned char *,
156 size_t, 158 size_t,
157 char) 159 char)
158 { return e_cryptNotImpl; } 160 { return e_cryptNotImpl; }
159 PwMerror decrypt(unsigned char **, 161 PwMerror decrypt(unsigned char **,
160 size_t *, 162 size_t *,
161 const unsigned char *, 163 const unsigned char *,
162 size_t, 164 size_t,
163 const unsigned char *, 165 const unsigned char *,
164 size_t, 166 size_t,
165 char) 167 char)
166 { return e_cryptNotImpl; } 168 { return e_cryptNotImpl; }
167 PwMerror hash(unsigned char **, 169 PwMerror hash(unsigned char **,
168 size_t *, 170 size_t *,
169 const unsigned char *, 171 const unsigned char *,
170 size_t, 172 size_t,
171 char) 173 char)
172 { return e_hashNotImpl; } 174 { return e_hashNotImpl; }
173 unsigned int hashLength(char) 175 unsigned int hashLength(char)
174 { return 0; } 176 { return 0; }
175}; 177};
176#endif // CONFIG_PWMANAGER_GCRY 178#endif // CONFIG_PWMANAGER_GCRY
177#endif // __LIBGCRYPTIF_H 179#endif // __LIBGCRYPTIF_H
diff --git a/pwmanager/pwmanager/pwmexception.h b/pwmanager/pwmanager/pwmexception.h
index 301ebd7..7f5a3a6 100644
--- a/pwmanager/pwmanager/pwmexception.h
+++ b/pwmanager/pwmanager/pwmexception.h
@@ -1,217 +1,218 @@
1/*************************************************************************** 1/***************************************************************************
2 * * 2 * *
3 * copyright (C) 2003, 2004 by Michael Buesch * 3 * copyright (C) 2003, 2004 by Michael Buesch *
4 * email: mbuesch@freenet.de * 4 * email: mbuesch@freenet.de *
5 * * 5 * *
6 * This program is free software; you can redistribute it and/or modify * 6 * This program is free software; you can redistribute it and/or modify *
7 * it under the terms of the GNU General Public License version 2 * 7 * it under the terms of the GNU General Public License version 2 *
8 * as published by the Free Software Foundation. * 8 * as published by the Free Software Foundation. *
9 * * 9 * *
10 ***************************************************************************/ 10 ***************************************************************************/
11 11
12/*************************************************************************** 12/***************************************************************************
13 * copyright (C) 2004 by Ulf Schenk 13 * copyright (C) 2004 by Ulf Schenk
14 * This file is originaly based on version 1.0.1 of pwmanager 14 * This file is originaly based on version 1.0.1 of pwmanager
15 * and was modified to run on embedded devices that run microkde 15 * and was modified to run on embedded devices that run microkde
16 * 16 *
17 * $Id$ 17 * $Id$
18 **************************************************************************/ 18 **************************************************************************/
19 19
20#ifndef __PWMEXCEPTION_H 20#ifndef __PWMEXCEPTION_H
21#define __PWMEXCEPTION_H 21#define __PWMEXCEPTION_H
22 22
23#include "globalstuff.h" 23//#include "globalstuff.h"
24 24
25#include <iostream> 25#include <iostream>
26#include <string> 26#include <string>
27using std::string; 27using std::string;
28using std::cerr; 28using std::cerr;
29using std::cout; 29using std::cout;
30using std::endl; 30using std::endl;
31 31
32/* This is an internal function to reduce code-overhead 32/* This is an internal function to reduce code-overhead
33 * of the BUG(), WARN(), TOD0() and FiXME() macros. Please use 33 * of the BUG(), WARN(), TOD0() and FiXME() macros. Please use
34 * these macros instead of calling this function directly. 34 * these macros instead of calling this function directly.
35 */ 35 */
36void pwmFatal(const char *id, 36void pwmFatal(const char *id,
37 const char *file, 37 const char *file,
38 int line); 38 int line);
39 39
40/** Use PWM_ASSERT(condition) for debugging assertions. 40/** Use PWM_ASSERT(condition) for debugging assertions.
41 * "condition" is eaten up and replaced with a NOP 41 * "condition" is eaten up and replaced with a NOP
42 * when debugging is disabled. 42 * when debugging is disabled.
43 * 43 *
44 * PWM_ASSERT_NOEAT(condition) is the same as PWM_ASSERT(condition), 44 * PWM_ASSERT_NOEAT(condition) is the same as PWM_ASSERT(condition),
45 * but it does _not_ eat up "condition" and ensures that 45 * but it does _not_ eat up "condition" and ensures that
46 * condition is always evaluated. 46 * condition is always evaluated.
47 */ 47 */
48#ifdef PWM_ASSERT 48#ifdef PWM_ASSERT
49# undef PWM_ASSERT 49# undef PWM_ASSERT
50#endif 50#endif
51#ifdef PWM_ASSERT_NOEAT 51#ifdef PWM_ASSERT_NOEAT
52# undef PWM_ASSERT_NOEAT 52# undef PWM_ASSERT_NOEAT
53#endif 53#endif
54#ifdef PWM_DEBUG 54#ifdef PWM_DEBUG
55 # define PWM_ASSERT(x) do { \ 55 # define PWM_ASSERT(x) do { \
56 if (unlikely(!(x))) { \ 56 if (unlikely(!(x))) { \
57 cerr << "PWM_ASSERT failed: (" << #x\ 57 cerr << "PWM_ASSERT failed: (" << #x\
58 << ") in " << __FILE__ \ 58 << ") in " << __FILE__ \
59 << ":" << __LINE__ \ 59 << ":" << __LINE__ \
60 << endl; \ 60 << endl; \
61 } \ 61 } \
62 } while (0) 62 } while (0)
63 # define PWM_ASSERT_NOEAT(x)do { PWM_ASSERT(x); } while (0) 63 # define PWM_ASSERT_NOEAT(x)do { PWM_ASSERT(x); } while (0)
64#else // PWM_DEBUG 64#else // PWM_DEBUG
65 # define PWM_ASSERT(x) do { } while (0) 65 # define PWM_ASSERT(x) do { } while (0)
66 # define PWM_ASSERT_NOEAT(x)do { if (x) ; } while (0) 66 # define PWM_ASSERT_NOEAT(x)do { if (x) ; } while (0)
67#endif // PWM_DEBUG 67#endif // PWM_DEBUG
68 68
69/** Insert a BUG() into code paths which clearly show 69/** Insert a BUG() into code paths which clearly show
70 * a bug in the code and which should, under normal 70 * a bug in the code and which should, under normal
71 * circumstances, never execute. 71 * circumstances, never execute.
72 */ 72 */
73#ifdef BUG 73#ifdef BUG
74# undef BUG 74# undef BUG
75#endif 75#endif
76 #define BUG()do { pwmFatal("BUG", __FILE__, __LINE__); } while (0) 76 #define BUG()do { pwmFatal("BUG", __FILE__, __LINE__); } while (0)
77 77
78/** Use BUG_ON(condition) to print a bug-message if "condition" 78/** Use BUG_ON(condition) to print a bug-message if "condition"
79 * is true. This is also enabled in non-debugging code. 79 * is true. This is also enabled in non-debugging code.
80 */ 80 */
81#ifdef BUG_ON 81#ifdef BUG_ON
82# undef BUG_ON 82# undef BUG_ON
83#endif 83#endif
84 #define BUG_ON(x) do { if (unlikely(x))BUG(); } while (0) 84 #define BUG_ON(x) do { if (unlikely(x))BUG(); } while (0)
85 85
86/** Insert a WARN() into code-paths which should not 86/** Insert a WARN() into code-paths which should not
87 * execute normally, but if they do it's non-fatal. 87 * execute normally, but if they do it's non-fatal.
88 */ 88 */
89#ifdef WARN 89#ifdef WARN
90# undef WARN 90# undef WARN
91#endif 91#endif
92 #define WARN()do { pwmFatal("badness", __FILE__, __LINE__); } while (0) 92 #define WARN()do { pwmFatal("badness", __FILE__, __LINE__); } while (0)
93 93
94/** Same as BUG_ON() but prints a warning-message */ 94/** Same as BUG_ON() but prints a warning-message */
95#ifdef WARN_ON 95#ifdef WARN_ON
96# undef WARN_ON 96# undef WARN_ON
97#endif 97#endif
98 #define WARN_ON(x) do { if (unlikely(x))WARN(); } while (0) 98 #define WARN_ON(x) do { if (unlikely(x))WARN(); } while (0)
99 99
100/** Insert this into code which is incomplete */ 100/** Insert this into code which is incomplete */
101#ifdef TODO 101#ifdef TODO
102# undef TODO 102# undef TODO
103#endif 103#endif
104 #define TODO()do { pwmFatal("TODO", __FILE__, __LINE__); } while (0) 104 #define TODO()do { pwmFatal("TODO", __FILE__, __LINE__); } while (0)
105 105
106/** Insert this into code which likely contains bugs */ 106/** Insert this into code which likely contains bugs */
107#ifdef FIXME 107#ifdef FIXME
108# undef FIXME 108# undef FIXME
109#endif 109#endif
110 #define FIXME()do { pwmFatal("FIXME", __FILE__, __LINE__); } while (0) 110 #define FIXME()do { pwmFatal("FIXME", __FILE__, __LINE__); } while (0)
111 111
112 112
113/** PwM error codes */ 113/** PwM error codes */
114enum PwMerror { 114enum PwMerror {
115 e_success = 0, 115 e_success = 0,
116 116
117 // file access errors 117 // file access errors
118 e_filename, 118 e_filename,
119 e_readFile, 119 e_readFile,
120 e_writeFile, 120 e_writeFile,
121 e_openFile, 121 e_openFile,
122 e_accessFile, // permission error, etc... 122 e_accessFile, // permission error, etc...
123 e_fileGeneric, 123 e_fileGeneric,
124 e_alreadyOpen, 124 e_alreadyOpen,
125 125
126 // other file errors 126 // other file errors
127 e_fileVer, 127 e_fileVer,
128 e_fileFormat, // format error 128 e_fileFormat, // format error
129 e_unsupportedFormat,// completely unsupported format 129 e_unsupportedFormat,// completely unsupported format
130 e_setFilePointer, 130 e_setFilePointer,
131 e_fileBackup, 131 e_fileBackup,
132 e_fileCorrupt, // file data has correct format, 132 e_fileCorrupt, // file data has correct format,
133 // but is corrupt (checksum error, etc) 133 // but is corrupt (checksum error, etc)
134 134
135 // password errors 135 // password errors
136 e_wrongPw, 136 e_wrongPw,
137 e_getPw, 137 e_getPw,
138 e_weakPw, 138 e_weakPw,
139 e_noPw, 139 e_noPw,
140 140
141 // action not implemented errors 141 // action not implemented errors
142 e_hashNotImpl, 142 e_hashNotImpl,
143 e_cryptNotImpl, 143 e_cryptNotImpl,
144 144
145 // argument/parameter errors 145 // argument/parameter errors
146 e_incompleteArg, 146 e_incompleteArg,
147 e_invalidArg, 147 e_invalidArg,
148 148
149 // misc 149 // misc
150 e_writeHeader, 150 e_writeHeader,
151 e_serializeDta, 151 e_serializeDta,
152 e_enc, 152 e_enc,
153 e_entryExists, 153 e_entryExists,
154 e_categoryExists, 154 e_categoryExists,
155 e_maxAllowedEntr,// no more entries can be added. 155 e_maxAllowedEntr,// no more entries can be added.
156 e_outOfMem, 156 e_outOfMem,
157 e_lock, // error while (un)locking 157 e_lock, // error while (un)locking
158 e_docNotSaved, // doc wasn't saved to a file, yet. 158 e_docNotSaved, // doc wasn't saved to a file, yet.
159 e_docIsEmpty, 159 e_docIsEmpty,
160 e_binEntry, 160 e_binEntry,
161 e_normalEntry, 161 e_normalEntry,
162 e_syncError, 162 e_syncError,
163 163
164 e_generic 164 e_generic
165}; 165};
166 166
167/** can be used for general exception faults */ 167/** can be used for general exception faults */
168class PwMException 168class PwMException
169{ 169{
170public: 170public:
171 enum exceptionId 171 enum exceptionId
172 { 172 {
173 EX_GENERIC = 0, 173 EX_GENERIC = 0,
174 EX_OPEN, 174 EX_OPEN,
175 EX_CLOSE, 175 EX_CLOSE,
176 EX_READ, 176 EX_READ,
177 EX_WRITE, 177 EX_WRITE,
178 EX_LOAD_MODULE, 178 EX_LOAD_MODULE,
179 EX_PARSE 179 EX_PARSE
180 }; 180 };
181 181
182public: 182public:
183 PwMException(exceptionId id = EX_GENERIC, 183 PwMException(exceptionId id = EX_GENERIC,
184 const char *message = "") 184 const char *message = "")
185 { 185 {
186 exId = id; 186 exId = id;
187 exMsg = message; 187 exMsg = message;
188 } 188 }
189 189
190 exceptionId getId() 190 exceptionId getId()
191 { return exId; } 191 { return exId; }
192 const char* getMessage() 192 const char* getMessage()
193 { return exMsg; } 193 { return exMsg; }
194 194
195protected: 195protected:
196 /** ID of this exception */ 196 /** ID of this exception */
197 exceptionId exId; 197 exceptionId exId;
198 /** additional error-message for this exception */ 198 /** additional error-message for this exception */
199 const char *exMsg; 199 const char *exMsg;
200}; 200};
201 201
202void __printInfo(const string &msg); 202void __printInfo(const string &msg);
203void __printWarn(const string &msg); 203void __printWarn(const string &msg);
204void __printError(const string &msg); 204void __printError(const string &msg);
205 205
206#ifdef PWM_DEBUG 206#ifdef PWM_DEBUG
207 void __printDebug(const string &msg); 207 void __printDebug(const string &msg);
208 # define printDebug(x)__printDebug(x) 208 # define printDebug(x)__printDebug(x)
209#else 209#else
210 # define printDebug(x)do { } while (0) 210 # define printDebug(x)do { } while (0)
211#endif 211#endif
212 212
213 #define printInfo(x)__printInfo(x) 213 #define printInfo(x)__printInfo(x)
214 #define printWarn(x)__printWarn(x) 214 #define printWarn(x)__printWarn(x)
215 #define printError(x)__printError(x) 215 #define printError(x)__printError(x)
216 216
217#include "globalstuff.h"
217#endif // __PWMEXCEPTION_H 218#endif // __PWMEXCEPTION_H
diff --git a/pwmanager/pwmanager/randomizer.h b/pwmanager/pwmanager/randomizer.h
index f2a6015..44cc28e 100644
--- a/pwmanager/pwmanager/randomizer.h
+++ b/pwmanager/pwmanager/randomizer.h
@@ -1,86 +1,87 @@
1/*************************************************************************** 1/***************************************************************************
2 * * 2 * *
3 * copyright (C) 2003, 2004 by Michael Buesch * 3 * copyright (C) 2003, 2004 by Michael Buesch *
4 * email: mbuesch@freenet.de * 4 * email: mbuesch@freenet.de *
5 * * 5 * *
6 * This program is free software; you can redistribute it and/or modify * 6 * This program is free software; you can redistribute it and/or modify *
7 * it under the terms of the GNU General Public License version 2 * 7 * it under the terms of the GNU General Public License version 2 *
8 * as published by the Free Software Foundation. * 8 * as published by the Free Software Foundation. *
9 * * 9 * *
10 ***************************************************************************/ 10 ***************************************************************************/
11 11
12/*************************************************************************** 12/***************************************************************************
13 * copyright (C) 2004 by Ulf Schenk 13 * copyright (C) 2004 by Ulf Schenk
14 * This file is originaly based on version 1.1 of pwmanager 14 * This file is originaly based on version 1.1 of pwmanager
15 * and was modified to run on embedded devices that run microkde 15 * and was modified to run on embedded devices that run microkde
16 * 16 *
17 * $Id$ 17 * $Id$
18 **************************************************************************/ 18 **************************************************************************/
19 19
20#ifndef __RANDOMIZER_H 20#ifndef __RANDOMIZER_H
21#define __RANDOMIZER_H 21#define __RANDOMIZER_H
22 22
23#include "pwmexception.h" 23#include "pwmexception.h"
24#include "globalstuff.h"
24 25
25#ifndef PWM_EMBEDDED 26#ifndef PWM_EMBEDDED
26#include <qmutex.h> 27#include <qmutex.h>
27#endif 28#endif
28 29
29#include <string> 30#include <string>
30 31
31using std::string; 32using std::string;
32 33
33class QFile; 34class QFile;
34 35
35/** Randomizer to get random values. 36/** Randomizer to get random values.
36 * This class is thread-safe. 37 * This class is thread-safe.
37 * You should always use the instance returned by 38 * You should always use the instance returned by
38 * obj() to use it. 39 * obj() to use it.
39 */ 40 */
40class Randomizer 41class Randomizer
41{ 42{
42public: 43public:
43 Randomizer(); 44 Randomizer();
44 ~Randomizer(); 45 ~Randomizer();
45 46
46 static Randomizer * obj() 47 static Randomizer * obj()
47 { 48 {
48 PWM_ASSERT(rndObj); 49 PWM_ASSERT(rndObj);
49 return rndObj; 50 return rndObj;
50 } 51 }
51 static void init() 52 static void init()
52 { 53 {
53 PWM_ASSERT(!rndObj); 54 PWM_ASSERT(!rndObj);
54 rndObj = new Randomizer; 55 rndObj = new Randomizer;
55 } 56 }
56 static void cleanup() 57 static void cleanup()
57 { 58 {
58 delete_ifnot_null(rndObj); 59 delete_ifnot_null(rndObj);
59 } 60 }
60 61
61 /** generate random char */ 62 /** generate random char */
62 char genRndChar(); 63 char genRndChar();
63 /** generate random int */ 64 /** generate random int */
64 int genRndInt(); 65 int genRndInt();
65 /** generate a random unsigned int */ 66 /** generate a random unsigned int */
66 unsigned int genRndUInt(); 67 unsigned int genRndUInt();
67 68
68 /** returns a buffer with random data */ 69 /** returns a buffer with random data */
69 string genRndBuf(size_t len); 70 string genRndBuf(size_t len);
70 /** returns a buffer with random data */ 71 /** returns a buffer with random data */
71 void genRndBuf(unsigned char *buf, size_t len); 72 void genRndBuf(unsigned char *buf, size_t len);
72 73
73protected: 74protected:
74 /** random-device-node (if available. Otherwise NULL) */ 75 /** random-device-node (if available. Otherwise NULL) */
75 QFile *rndDev; 76 QFile *rndDev;
76#ifndef PWM_EMBEDDED 77#ifndef PWM_EMBEDDED
77 /** mutex for accessing the public functions thread-save */ 78 /** mutex for accessing the public functions thread-save */
78 QMutex mutex; 79 QMutex mutex;
79#endif 80#endif
80 /** seed value for fallback - rand_r() */ 81 /** seed value for fallback - rand_r() */
81 unsigned int seed; 82 unsigned int seed;
82 /** static Randomizer object returned by obj() */ 83 /** static Randomizer object returned by obj() */
83 static Randomizer *rndObj; 84 static Randomizer *rndObj;
84}; 85};
85 86
86#endif // __RANDOMIZER_H 87#endif // __RANDOMIZER_H