1 /* Licensed to the Apache Software Foundation (ASF) under one or more
2 * contributor license agreements. See the NOTICE file distributed with
3 * this work for additional information regarding copyright ownership.
4 * The ASF licenses this file to You under the Apache License, Version 2.0
5 * (the "License"); you may not use this file except in compliance with
6 * the License. You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "testutil.h"
18 #include "apr.h"
19 #include "apu.h"
20 #include "apu_errno.h"
21 #include "apr_pools.h"
22 #include "apr_dso.h"
23 #include "apr_crypto.h"
24 #include "apr_strings.h"
25
26 #if APU_HAVE_CRYPTO
27
28 #define TEST_STRING "12345"
29 #define ALIGNED_STRING "123456789012345"
30
get_driver(abts_case * tc,apr_pool_t * pool,const char * name,const char * params)31 static const apr_crypto_driver_t *get_driver(abts_case *tc, apr_pool_t *pool,
32 const char *name, const char *params)
33 {
34
35 const apr_crypto_driver_t *driver = NULL;
36 const apu_err_t *result = NULL;
37 apr_status_t rv;
38
39 rv = apr_crypto_init(pool);
40 ABTS_ASSERT(tc, "failed to init apr_crypto", rv == APR_SUCCESS);
41
42 rv = apr_crypto_get_driver(&driver, name, params, &result, pool);
43 if (APR_ENOTIMPL == rv) {
44 ABTS_NOT_IMPL(tc,
45 apr_psprintf(pool, "Crypto driver '%s' not implemented", (char *)name));
46 return NULL;
47 }
48 if (APR_EDSOOPEN == rv) {
49 ABTS_NOT_IMPL(tc,
50 apr_psprintf(pool, "Crypto driver '%s' DSO could not be opened", (char *)name));
51 return NULL;
52 }
53 if (APR_SUCCESS != rv && result) {
54 char err[1024];
55 apr_strerror(rv, err, sizeof(err) - 1);
56 fprintf(stderr, "get_driver error %d: %s: '%s' native error %d: %s (%s),",
57 rv, err, name, result->rc, result->reason ? result->reason : "",
58 result->msg ? result->msg : "");
59 }
60 ABTS_ASSERT(tc, apr_psprintf(pool, "failed to apr_crypto_get_driver for '%s' with %d",
61 name, rv), rv == APR_SUCCESS);
62 ABTS_ASSERT(tc, "apr_crypto_get_driver returned NULL", driver != NULL);
63 if (!driver || rv) {
64 return NULL;
65 }
66
67 return driver;
68
69 }
70
get_nss_driver(abts_case * tc,apr_pool_t * pool)71 static const apr_crypto_driver_t *get_nss_driver(abts_case *tc,
72 apr_pool_t *pool)
73 {
74
75 /* initialise NSS */
76 return get_driver(tc, pool, "nss", "");
77
78 }
79
get_openssl_driver(abts_case * tc,apr_pool_t * pool)80 static const apr_crypto_driver_t *get_openssl_driver(abts_case *tc,
81 apr_pool_t *pool)
82 {
83
84 return get_driver(tc, pool, "openssl", NULL);
85
86 }
87
get_commoncrypto_driver(abts_case * tc,apr_pool_t * pool)88 static const apr_crypto_driver_t *get_commoncrypto_driver(abts_case *tc,
89 apr_pool_t *pool)
90 {
91
92 return get_driver(tc, pool, "commoncrypto", NULL);
93
94 }
95
make(abts_case * tc,apr_pool_t * pool,const apr_crypto_driver_t * driver)96 static apr_crypto_t *make(abts_case *tc, apr_pool_t *pool,
97 const apr_crypto_driver_t *driver)
98 {
99
100 apr_crypto_t *f = NULL;
101
102 if (!driver) {
103 return NULL;
104 }
105
106 /* get the context */
107 apr_crypto_make(&f, driver, "engine=openssl", pool);
108 ABTS_ASSERT(tc, "apr_crypto_make returned NULL", f != NULL);
109
110 return f;
111
112 }
113
keysecret(abts_case * tc,apr_pool_t * pool,const apr_crypto_driver_t * driver,const apr_crypto_t * f,apr_crypto_block_key_type_e type,apr_crypto_block_key_mode_e mode,int doPad,apr_size_t secretLen,const char * description)114 static const apr_crypto_key_t *keysecret(abts_case *tc, apr_pool_t *pool,
115 const apr_crypto_driver_t *driver, const apr_crypto_t *f,
116 apr_crypto_block_key_type_e type, apr_crypto_block_key_mode_e mode,
117 int doPad, apr_size_t secretLen, const char *description)
118 {
119 apr_crypto_key_t *key = NULL;
120 const apu_err_t *result = NULL;
121 apr_crypto_key_rec_t *rec = apr_pcalloc(pool, sizeof(apr_crypto_key_rec_t));
122 apr_status_t rv;
123
124 if (!f) {
125 return NULL;
126 }
127
128 rec->ktype = APR_CRYPTO_KTYPE_SECRET;
129 rec->type = type;
130 rec->mode = mode;
131 rec->pad = doPad;
132 rec->k.secret.secret = apr_pcalloc(pool, secretLen);
133 rec->k.secret.secretLen = secretLen;
134
135 /* init the passphrase */
136 rv = apr_crypto_key(&key, rec, f, pool);
137 if (APR_ENOCIPHER == rv) {
138 apr_crypto_error(&result, f);
139 ABTS_NOT_IMPL(tc,
140 apr_psprintf(pool, "skipped: %s %s key return APR_ENOCIPHER: error %d: %s (%s)\n", description, apr_crypto_driver_name(driver), result->rc, result->reason ? result->reason : "", result->msg ? result->msg : ""));
141 return NULL;
142 }
143 else {
144 if (APR_SUCCESS != rv) {
145 apr_crypto_error(&result, f);
146 fprintf(stderr, "key: %s %s apr error %d / native error %d: %s (%s)\n",
147 description, apr_crypto_driver_name(driver), rv, result->rc,
148 result->reason ? result->reason : "",
149 result->msg ? result->msg : "");
150 }
151 ABTS_ASSERT(tc, "apr_crypto_key returned APR_EKEYLENGTH", rv != APR_EKEYLENGTH);
152 ABTS_ASSERT(tc, "apr_crypto_key returned APR_ENOKEY", rv != APR_ENOKEY);
153 ABTS_ASSERT(tc, "apr_crypto_key returned APR_EPADDING",
154 rv != APR_EPADDING);
155 ABTS_ASSERT(tc, "apr_crypto_key returned APR_EKEYTYPE",
156 rv != APR_EKEYTYPE);
157 ABTS_ASSERT(tc, "failed to apr_crypto_key", rv == APR_SUCCESS);
158 ABTS_ASSERT(tc, "apr_crypto_key returned NULL context", key != NULL);
159 }
160 if (rv) {
161 return NULL;
162 }
163 return key;
164
165 }
166
passphrase(abts_case * tc,apr_pool_t * pool,const apr_crypto_driver_t * driver,const apr_crypto_t * f,apr_crypto_block_key_type_e type,apr_crypto_block_key_mode_e mode,int doPad,const char * description)167 static const apr_crypto_key_t *passphrase(abts_case *tc, apr_pool_t *pool,
168 const apr_crypto_driver_t *driver, const apr_crypto_t *f,
169 apr_crypto_block_key_type_e type, apr_crypto_block_key_mode_e mode,
170 int doPad, const char *description)
171 {
172
173 apr_crypto_key_t *key = NULL;
174 const apu_err_t *result = NULL;
175 const char *pass = "secret";
176 const char *salt = "salt";
177 apr_status_t rv;
178
179 if (!f) {
180 return NULL;
181 }
182
183 /* init the passphrase */
184 rv = apr_crypto_passphrase(&key, NULL, pass, strlen(pass),
185 (unsigned char *) salt, strlen(salt), type, mode, doPad, 4096, f,
186 pool);
187 if (APR_ENOCIPHER == rv) {
188 apr_crypto_error(&result, f);
189 ABTS_NOT_IMPL(tc, apr_psprintf(pool,
190 "skipped: %s %s passphrase return APR_ENOCIPHER: error %d: %s (%s)\n",
191 description, apr_crypto_driver_name(driver), result->rc,
192 result->reason ? result->reason : "", result->msg ? result->msg : ""));
193 return NULL;
194 }
195 else {
196 if (APR_SUCCESS != rv) {
197 apr_crypto_error(&result, f);
198 fprintf(stderr, "passphrase: %s %s apr error %d / native error %d: %s (%s)\n",
199 description, apr_crypto_driver_name(driver), rv, result->rc,
200 result->reason ? result->reason : "",
201 result->msg ? result->msg : "");
202 }
203 ABTS_ASSERT(tc, "apr_crypto_passphrase returned APR_ENOKEY", rv != APR_ENOKEY);
204 ABTS_ASSERT(tc, "apr_crypto_passphrase returned APR_EPADDING", rv != APR_EPADDING);
205 ABTS_ASSERT(tc, "apr_crypto_passphrase returned APR_EKEYTYPE", rv != APR_EKEYTYPE);
206 ABTS_ASSERT(tc, "failed to apr_crypto_passphrase", rv == APR_SUCCESS);
207 ABTS_ASSERT(tc, "apr_crypto_passphrase returned NULL context", key != NULL);
208 }
209 if (rv) {
210 return NULL;
211 }
212 return key;
213
214 }
215
keypassphrase(abts_case * tc,apr_pool_t * pool,const apr_crypto_driver_t * driver,const apr_crypto_t * f,apr_crypto_block_key_type_e type,apr_crypto_block_key_mode_e mode,int doPad,const char * description)216 static const apr_crypto_key_t *keypassphrase(abts_case *tc, apr_pool_t *pool,
217 const apr_crypto_driver_t *driver, const apr_crypto_t *f,
218 apr_crypto_block_key_type_e type, apr_crypto_block_key_mode_e mode,
219 int doPad, const char *description)
220 {
221
222 apr_crypto_key_t *key = NULL;
223 const apu_err_t *result = NULL;
224 const char *pass = "secret";
225 const char *salt = "salt";
226 apr_crypto_key_rec_t *rec = apr_pcalloc(pool, sizeof(apr_crypto_key_rec_t));
227 apr_status_t rv;
228
229 if (!f) {
230 return NULL;
231 }
232
233 rec->ktype = APR_CRYPTO_KTYPE_PASSPHRASE;
234 rec->type = type;
235 rec->mode = mode;
236 rec->pad = doPad;
237 rec->k.passphrase.pass = pass;
238 rec->k.passphrase.passLen = strlen(pass);
239 rec->k.passphrase.salt = (unsigned char *)salt;
240 rec->k.passphrase.saltLen = strlen(salt);
241 rec->k.passphrase.iterations = 4096;
242
243 /* init the passphrase */
244 rv = apr_crypto_key(&key, rec, f, pool);
245 if (APR_ENOCIPHER == rv) {
246 apr_crypto_error(&result, f);
247 ABTS_NOT_IMPL(tc, apr_psprintf(pool,
248 "skipped: %s %s key passphrase return APR_ENOCIPHER: error %d: %s (%s)\n",
249 description, apr_crypto_driver_name(driver), result->rc,
250 result->reason ? result->reason : "", result->msg ? result->msg : ""));
251 return NULL;
252 }
253 else {
254 if (APR_SUCCESS != rv) {
255 apr_crypto_error(&result, f);
256 fprintf(stderr, "key passphrase: %s %s apr error %d / native error %d: %s (%s)\n",
257 description, apr_crypto_driver_name(driver), rv, result->rc,
258 result->reason ? result->reason : "",
259 result->msg ? result->msg : "");
260 }
261 ABTS_ASSERT(tc, "apr_crypto_key returned APR_ENOKEY", rv != APR_ENOKEY);
262 ABTS_ASSERT(tc, "apr_crypto_key returned APR_EPADDING", rv != APR_EPADDING);
263 ABTS_ASSERT(tc, "apr_crypto_key returned APR_EKEYTYPE", rv != APR_EKEYTYPE);
264 ABTS_ASSERT(tc, "failed to apr_crypto_key", rv == APR_SUCCESS);
265 ABTS_ASSERT(tc, "apr_crypto_key returned NULL context", key != NULL);
266 }
267 if (rv) {
268 return NULL;
269 }
270 return key;
271
272 }
273
encrypt_block(abts_case * tc,apr_pool_t * pool,const apr_crypto_driver_t * driver,const apr_crypto_t * f,const apr_crypto_key_t * key,const unsigned char * in,const apr_size_t inlen,unsigned char ** cipherText,apr_size_t * cipherTextLen,const unsigned char ** iv,apr_size_t * blockSize,const char * description)274 static unsigned char *encrypt_block(abts_case *tc, apr_pool_t *pool,
275 const apr_crypto_driver_t *driver, const apr_crypto_t *f,
276 const apr_crypto_key_t *key, const unsigned char *in,
277 const apr_size_t inlen, unsigned char **cipherText,
278 apr_size_t *cipherTextLen, const unsigned char **iv,
279 apr_size_t *blockSize, const char *description)
280 {
281
282 apr_crypto_block_t *block = NULL;
283 const apu_err_t *result = NULL;
284 apr_size_t len = 0;
285 apr_status_t rv;
286
287 if (!driver || !f || !key || !in) {
288 return NULL;
289 }
290
291 /* init the encryption */
292 rv = apr_crypto_block_encrypt_init(&block, iv, key, blockSize, pool);
293 if (APR_ENOTIMPL == rv) {
294 ABTS_NOT_IMPL(tc, "apr_crypto_block_encrypt_init returned APR_ENOTIMPL");
295 }
296 else {
297 if (APR_SUCCESS != rv) {
298 apr_crypto_error(&result, f);
299 fprintf(stderr,
300 "encrypt_init: %s %s (APR %d) native error %d: %s (%s)\n",
301 description, apr_crypto_driver_name(driver), rv, result->rc,
302 result->reason ? result->reason : "",
303 result->msg ? result->msg : "");
304 }
305 ABTS_ASSERT(tc, "apr_crypto_block_encrypt_init returned APR_ENOKEY",
306 rv != APR_ENOKEY);
307 ABTS_ASSERT(tc, "apr_crypto_block_encrypt_init returned APR_ENOIV",
308 rv != APR_ENOIV);
309 ABTS_ASSERT(tc, "apr_crypto_block_encrypt_init returned APR_EKEYTYPE",
310 rv != APR_EKEYTYPE);
311 ABTS_ASSERT(tc, "apr_crypto_block_encrypt_init returned APR_EKEYLENGTH",
312 rv != APR_EKEYLENGTH);
313 ABTS_ASSERT(tc,
314 "apr_crypto_block_encrypt_init returned APR_ENOTENOUGHENTROPY",
315 rv != APR_ENOTENOUGHENTROPY);
316 ABTS_ASSERT(tc, "failed to apr_crypto_block_encrypt_init",
317 rv == APR_SUCCESS);
318 ABTS_ASSERT(tc, "apr_crypto_block_encrypt_init returned NULL context",
319 block != NULL);
320 }
321 if (!block || rv) {
322 return NULL;
323 }
324
325 /* encrypt the block */
326 rv = apr_crypto_block_encrypt(cipherText, cipherTextLen, in, inlen, block);
327 if (APR_SUCCESS != rv) {
328 apr_crypto_error(&result, f);
329 fprintf(stderr, "encrypt: %s %s (APR %d) native error %d: %s (%s)\n",
330 description, apr_crypto_driver_name(driver), rv, result->rc,
331 result->reason ? result->reason : "",
332 result->msg ? result->msg : "");
333 }
334 ABTS_ASSERT(tc, "apr_crypto_block_encrypt returned APR_ECRYPT", rv != APR_ECRYPT);
335 ABTS_ASSERT(tc, "failed to apr_crypto_block_encrypt", rv == APR_SUCCESS);
336 ABTS_ASSERT(tc, "apr_crypto_block_encrypt failed to allocate buffer", *cipherText != NULL);
337 if (rv) {
338 return NULL;
339 }
340
341 /* finalise the encryption */
342 rv = apr_crypto_block_encrypt_finish(*cipherText + *cipherTextLen, &len,
343 block);
344 if (APR_SUCCESS != rv) {
345 apr_crypto_error(&result, f);
346 fprintf(stderr,
347 "encrypt_finish: %s %s (APR %d) native error %d: %s (%s)\n",
348 description, apr_crypto_driver_name(driver), rv, result->rc,
349 result->reason ? result->reason : "",
350 result->msg ? result->msg : "");
351 }
352 ABTS_ASSERT(tc, "apr_crypto_block_encrypt_finish returned APR_ECRYPT", rv != APR_ECRYPT);
353 ABTS_ASSERT(tc, "apr_crypto_block_encrypt_finish returned APR_EPADDING", rv != APR_EPADDING);
354 ABTS_ASSERT(tc, "apr_crypto_block_encrypt_finish returned APR_ENOSPACE", rv != APR_ENOSPACE);
355 ABTS_ASSERT(tc, "failed to apr_crypto_block_encrypt_finish", rv == APR_SUCCESS);
356 *cipherTextLen += len;
357 apr_crypto_block_cleanup(block);
358 if (rv) {
359 return NULL;
360 }
361
362 return *cipherText;
363
364 }
365
decrypt_block(abts_case * tc,apr_pool_t * pool,const apr_crypto_driver_t * driver,const apr_crypto_t * f,const apr_crypto_key_t * key,unsigned char * cipherText,apr_size_t cipherTextLen,unsigned char ** plainText,apr_size_t * plainTextLen,const unsigned char * iv,apr_size_t * blockSize,const char * description)366 static unsigned char *decrypt_block(abts_case *tc, apr_pool_t *pool,
367 const apr_crypto_driver_t *driver, const apr_crypto_t *f,
368 const apr_crypto_key_t *key, unsigned char *cipherText,
369 apr_size_t cipherTextLen, unsigned char **plainText,
370 apr_size_t *plainTextLen, const unsigned char *iv,
371 apr_size_t *blockSize, const char *description)
372 {
373
374 apr_crypto_block_t *block = NULL;
375 const apu_err_t *result = NULL;
376 apr_size_t len = 0;
377 apr_status_t rv;
378
379 if (!driver || !f || !key || !cipherText) {
380 return NULL;
381 }
382
383 /* init the decryption */
384 rv = apr_crypto_block_decrypt_init(&block, blockSize, iv, key, pool);
385 if (APR_ENOTIMPL == rv) {
386 ABTS_NOT_IMPL(tc, "apr_crypto_block_decrypt_init returned APR_ENOTIMPL");
387 }
388 else {
389 if (APR_SUCCESS != rv) {
390 apr_crypto_error(&result, f);
391 fprintf(stderr,
392 "decrypt_init: %s %s (APR %d) native error %d: %s (%s)\n",
393 description, apr_crypto_driver_name(driver), rv, result->rc,
394 result->reason ? result->reason : "",
395 result->msg ? result->msg : "");
396 }
397 ABTS_ASSERT(tc, "apr_crypto_block_decrypt_init returned APR_ENOKEY", rv != APR_ENOKEY);
398 ABTS_ASSERT(tc, "apr_crypto_block_decrypt_init returned APR_ENOIV", rv != APR_ENOIV);
399 ABTS_ASSERT(tc, "apr_crypto_block_decrypt_init returned APR_EKEYTYPE", rv != APR_EKEYTYPE);
400 ABTS_ASSERT(tc, "apr_crypto_block_decrypt_init returned APR_EKEYLENGTH", rv != APR_EKEYLENGTH);
401 ABTS_ASSERT(tc, "failed to apr_crypto_block_decrypt_init", rv == APR_SUCCESS);
402 ABTS_ASSERT(tc, "apr_crypto_block_decrypt_init returned NULL context", block != NULL);
403 }
404 if (!block || rv) {
405 return NULL;
406 }
407
408 /* decrypt the block */
409 rv = apr_crypto_block_decrypt(plainText, plainTextLen, cipherText,
410 cipherTextLen, block);
411 if (APR_SUCCESS != rv) {
412 apr_crypto_error(&result, f);
413 fprintf(stderr, "decrypt: %s %s (APR %d) native error %d: %s (%s)\n",
414 description, apr_crypto_driver_name(driver), rv, result->rc,
415 result->reason ? result->reason : "",
416 result->msg ? result->msg : "");
417 }
418 ABTS_ASSERT(tc, "apr_crypto_block_decrypt returned APR_ECRYPT", rv != APR_ECRYPT);
419 ABTS_ASSERT(tc, "failed to apr_crypto_block_decrypt", rv == APR_SUCCESS);
420 ABTS_ASSERT(tc, "apr_crypto_block_decrypt failed to allocate buffer", *plainText != NULL);
421 if (rv) {
422 return NULL;
423 }
424
425 /* finalise the decryption */
426 rv = apr_crypto_block_decrypt_finish(*plainText + *plainTextLen, &len,
427 block);
428 if (APR_SUCCESS != rv) {
429 apr_crypto_error(&result, f);
430 fprintf(stderr,
431 "decrypt_finish: %s %s (APR %d) native error %d: %s (%s)\n",
432 description, apr_crypto_driver_name(driver), rv, result->rc,
433 result->reason ? result->reason : "",
434 result->msg ? result->msg : "");
435 }
436 ABTS_ASSERT(tc, "apr_crypto_block_decrypt_finish returned APR_ECRYPT", rv != APR_ECRYPT);
437 ABTS_ASSERT(tc, "apr_crypto_block_decrypt_finish returned APR_EPADDING", rv != APR_EPADDING);
438 ABTS_ASSERT(tc, "apr_crypto_block_decrypt_finish returned APR_ENOSPACE", rv != APR_ENOSPACE);
439 ABTS_ASSERT(tc, "failed to apr_crypto_block_decrypt_finish", rv == APR_SUCCESS);
440 if (rv) {
441 return NULL;
442 }
443
444 *plainTextLen += len;
445 apr_crypto_block_cleanup(block);
446
447 return *plainText;
448
449 }
450
451 /**
452 * Interoperability test.
453 *
454 * data must point at an array of two driver structures. Data will be encrypted
455 * with the first driver, and decrypted with the second.
456 *
457 * If the two drivers interoperate, the test passes.
458 */
crypto_block_cross(abts_case * tc,apr_pool_t * pool,const apr_crypto_driver_t ** drivers,const apr_crypto_block_key_type_e type,const apr_crypto_block_key_mode_e mode,int doPad,const unsigned char * in,apr_size_t inlen,apr_size_t secretLen,const char * description)459 static void crypto_block_cross(abts_case *tc, apr_pool_t *pool,
460 const apr_crypto_driver_t **drivers,
461 const apr_crypto_block_key_type_e type,
462 const apr_crypto_block_key_mode_e mode, int doPad,
463 const unsigned char *in, apr_size_t inlen, apr_size_t secretLen,
464 const char *description)
465 {
466 const apr_crypto_driver_t *driver1 = drivers[0];
467 const apr_crypto_driver_t *driver2 = drivers[1];
468 apr_crypto_t *f1 = NULL;
469 apr_crypto_t *f2 = NULL;
470 const apr_crypto_key_t *key1 = NULL;
471 const apr_crypto_key_t *key2 = NULL;
472 const apr_crypto_key_t *key3 = NULL;
473 const apr_crypto_key_t *key4 = NULL;
474 const apr_crypto_key_t *key5 = NULL;
475 const apr_crypto_key_t *key6 = NULL;
476
477 unsigned char *cipherText = NULL;
478 apr_size_t cipherTextLen = 0;
479 unsigned char *plainText = NULL;
480 apr_size_t plainTextLen = 0;
481 const unsigned char *iv = NULL;
482 apr_size_t blockSize = 0;
483
484 f1 = make(tc, pool, driver1);
485 f2 = make(tc, pool, driver2);
486 key1 = passphrase(tc, pool, driver1, f1, type, mode, doPad, description);
487 key2 = passphrase(tc, pool, driver2, f2, type, mode, doPad, description);
488
489 cipherText = encrypt_block(tc, pool, driver1, f1, key1, in, inlen,
490 &cipherText, &cipherTextLen, &iv, &blockSize, description);
491 plainText = decrypt_block(tc, pool, driver2, f2, key2, cipherText,
492 cipherTextLen, &plainText, &plainTextLen, iv, &blockSize,
493 description);
494
495 if (cipherText && plainText) {
496 if (memcmp(in, plainText, inlen)) {
497 fprintf(stderr, "passphrase cross mismatch: %s %s/%s\n", description,
498 apr_crypto_driver_name(driver1), apr_crypto_driver_name(
499 driver2));
500 }
501 ABTS_STR_EQUAL(tc, (char *)in, (char *)plainText);
502 }
503
504 key3 = keysecret(tc, pool, driver1, f1, type, mode, doPad, secretLen, description);
505 key4 = keysecret(tc, pool, driver2, f2, type, mode, doPad, secretLen, description);
506
507 iv = NULL;
508 blockSize = 0;
509 cipherText = NULL;
510 plainText = NULL;
511 cipherText = encrypt_block(tc, pool, driver1, f1, key3, in, inlen,
512 &cipherText, &cipherTextLen, &iv, &blockSize, description);
513 plainText = decrypt_block(tc, pool, driver2, f2, key4, cipherText,
514 cipherTextLen, &plainText, &plainTextLen, iv, &blockSize,
515 description);
516
517 if (cipherText && plainText) {
518 if (memcmp(in, plainText, inlen)) {
519 fprintf(stderr, "key secret cross mismatch: %s %s/%s\n", description,
520 apr_crypto_driver_name(driver1), apr_crypto_driver_name(
521 driver2));
522 }
523 ABTS_STR_EQUAL(tc, (char *)in, (char *)plainText);
524 }
525
526 key5 = keypassphrase(tc, pool, driver1, f1, type, mode, doPad, description);
527 key6 = keypassphrase(tc, pool, driver2, f2, type, mode, doPad, description);
528
529 iv = NULL;
530 blockSize = 0;
531 cipherText = NULL;
532 plainText = NULL;
533 cipherText = encrypt_block(tc, pool, driver1, f1, key5, in, inlen,
534 &cipherText, &cipherTextLen, &iv, &blockSize, description);
535 plainText = decrypt_block(tc, pool, driver2, f2, key6, cipherText,
536 cipherTextLen, &plainText, &plainTextLen, iv, &blockSize,
537 description);
538
539 if (cipherText && plainText) {
540 if (memcmp(in, plainText, inlen)) {
541 fprintf(stderr, "key passphrase cross mismatch: %s %s/%s\n", description,
542 apr_crypto_driver_name(driver1), apr_crypto_driver_name(
543 driver2));
544 }
545 ABTS_STR_EQUAL(tc, (char *)in, (char *)plainText);
546 }
547
548 }
549
550 /**
551 * Test initialisation.
552 */
test_crypto_init(abts_case * tc,void * data)553 static void test_crypto_init(abts_case *tc, void *data)
554 {
555 apr_pool_t *pool = NULL;
556 apr_status_t rv;
557
558 apr_pool_create(&pool, NULL);
559
560 rv = apr_crypto_init(pool);
561 ABTS_ASSERT(tc, "failed to init apr_crypto", rv == APR_SUCCESS);
562
563 apr_pool_destroy(pool);
564
565 }
566
567 /**
568 * Simple test of OpenSSL key.
569 */
test_crypto_key_openssl(abts_case * tc,void * data)570 static void test_crypto_key_openssl(abts_case *tc, void *data)
571 {
572 apr_pool_t *pool = NULL;
573 const apr_crypto_driver_t *driver;
574 apr_crypto_t *f = NULL;
575
576 apr_pool_create(&pool, NULL);
577 driver = get_openssl_driver(tc, pool);
578
579 f = make(tc, pool, driver);
580 keysecret(tc, pool, driver, f, APR_KEY_AES_256, APR_MODE_CBC, 1, 32,
581 "KEY_AES_256/MODE_CBC");
582 apr_pool_destroy(pool);
583
584 }
585
586 /**
587 * Simple test of NSS key.
588 */
test_crypto_key_nss(abts_case * tc,void * data)589 static void test_crypto_key_nss(abts_case *tc, void *data)
590 {
591 apr_pool_t *pool = NULL;
592 const apr_crypto_driver_t *driver;
593 apr_crypto_t *f = NULL;
594
595 apr_pool_create(&pool, NULL);
596 driver = get_nss_driver(tc, pool);
597
598 f = make(tc, pool, driver);
599 keysecret(tc, pool, driver, f, APR_KEY_AES_256, APR_MODE_CBC, 1, 32,
600 "KEY_AES_256/MODE_CBC");
601 apr_pool_destroy(pool);
602
603 }
604
605 /**
606 * Simple test of CommonCrypto key.
607 */
test_crypto_key_commoncrypto(abts_case * tc,void * data)608 static void test_crypto_key_commoncrypto(abts_case *tc, void *data)
609 {
610 apr_pool_t *pool = NULL;
611 const apr_crypto_driver_t *driver;
612 apr_crypto_t *f = NULL;
613
614 apr_pool_create(&pool, NULL);
615 driver = get_commoncrypto_driver(tc, pool);
616
617 f = make(tc, pool, driver);
618 keysecret(tc, pool, driver, f, APR_KEY_AES_256, APR_MODE_CBC, 1, 32,
619 "KEY_AES_256/MODE_CBC");
620 apr_pool_destroy(pool);
621
622 }
623
624 /**
625 * Simple test of OpenSSL block crypt.
626 */
test_crypto_block_openssl(abts_case * tc,void * data)627 static void test_crypto_block_openssl(abts_case *tc, void *data)
628 {
629 apr_pool_t *pool = NULL;
630 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
631
632 const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
633 apr_size_t inlen = sizeof(ALIGNED_STRING);
634
635 apr_pool_create(&pool, NULL);
636 drivers[0] = get_openssl_driver(tc, pool);
637 drivers[1] = get_openssl_driver(tc, pool);
638 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 0,
639 in, inlen, 24, "KEY_3DES_192/MODE_CBC");
640 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_ECB, 0,
641 in, inlen, 24, "KEY_3DES_192/MODE_ECB");
642 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 0, in,
643 inlen, 32, "KEY_AES_256/MODE_CBC");
644 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 0, in,
645 inlen, 32, "KEY_AES_256/MODE_ECB");
646 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 0, in,
647 inlen, 24, "KEY_AES_192/MODE_CBC");
648 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 0, in,
649 inlen, 24, "KEY_AES_192/MODE_ECB");
650 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 0, in,
651 inlen, 16, "KEY_AES_128/MODE_CBC");
652 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 0, in,
653 inlen, 16, "KEY_AES_128/MODE_ECB");
654 apr_pool_destroy(pool);
655
656 }
657
658 /**
659 * Simple test of NSS block crypt.
660 */
test_crypto_block_nss(abts_case * tc,void * data)661 static void test_crypto_block_nss(abts_case *tc, void *data)
662 {
663 apr_pool_t *pool = NULL;
664 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
665
666 const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
667 apr_size_t inlen = sizeof(ALIGNED_STRING);
668
669 apr_pool_create(&pool, NULL);
670 drivers[0] = get_nss_driver(tc, pool);
671 drivers[1] = get_nss_driver(tc, pool);
672 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 0,
673 in, inlen, 24, "KEY_3DES_192/MODE_CBC");
674 /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */
675 /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 0, in, inlen, "KEY_3DES_192/MODE_ECB"); */
676 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 0, in,
677 inlen, 32, "KEY_AES_256/MODE_CBC");
678 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 0, in,
679 inlen, 32, "KEY_AES_256/MODE_ECB");
680 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 0, in,
681 inlen, 24, "KEY_AES_192/MODE_CBC");
682 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 0, in,
683 inlen, 24, "KEY_AES_192/MODE_ECB");
684 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 0, in,
685 inlen, 16, "KEY_AES_128/MODE_CBC");
686 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 0, in,
687 inlen, 16, "KEY_AES_128/MODE_ECB");
688 apr_pool_destroy(pool);
689
690 }
691
692 /**
693 * Simple test of Common Crypto block crypt.
694 */
test_crypto_block_commoncrypto(abts_case * tc,void * data)695 static void test_crypto_block_commoncrypto(abts_case *tc, void *data)
696 {
697 apr_pool_t *pool = NULL;
698 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
699
700 const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
701 apr_size_t inlen = sizeof(ALIGNED_STRING);
702
703 apr_pool_create(&pool, NULL);
704 drivers[0] = get_commoncrypto_driver(tc, pool);
705 drivers[1] = get_commoncrypto_driver(tc, pool);
706 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 0,
707 in, inlen, 24, "KEY_3DES_192/MODE_CBC");
708 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_ECB, 0,
709 in, inlen, 24, "KEY_3DES_192/MODE_ECB");
710 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 0, in,
711 inlen, 32, "KEY_AES_256/MODE_CBC");
712 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 0, in,
713 inlen, 32, "KEY_AES_256/MODE_ECB");
714 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 0, in,
715 inlen, 24, "KEY_AES_192/MODE_CBC");
716 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 0, in,
717 inlen, 24, "KEY_AES_192/MODE_ECB");
718 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 0, in,
719 inlen, 16, "KEY_AES_128/MODE_CBC");
720 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 0, in,
721 inlen, 16, "KEY_AES_128/MODE_ECB");
722 apr_pool_destroy(pool);
723
724 }
725
726 /**
727 * Encrypt NSS, decrypt OpenSSL.
728 */
test_crypto_block_nss_openssl(abts_case * tc,void * data)729 static void test_crypto_block_nss_openssl(abts_case *tc, void *data)
730 {
731 apr_pool_t *pool = NULL;
732 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
733
734 const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
735 apr_size_t inlen = sizeof(ALIGNED_STRING);
736
737 apr_pool_create(&pool, NULL);
738 drivers[0] = get_nss_driver(tc, pool);
739 drivers[1] = get_openssl_driver(tc, pool);
740
741 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 0,
742 in, inlen, 24, "KEY_3DES_192/MODE_CBC");
743
744 /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */
745 /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 0, in, inlen, 24, "KEY_3DES_192/MODE_ECB"); */
746 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 0, in,
747 inlen, 32, "KEY_AES_256/MODE_CBC");
748 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 0, in,
749 inlen, 32, "KEY_AES_256/MODE_ECB");
750 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 0, in,
751 inlen, 24, "KEY_AES_192/MODE_CBC");
752 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 0, in,
753 inlen, 24, "KEY_AES_192/MODE_ECB");
754 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 0, in,
755 inlen, 16, "KEY_AES_128/MODE_CBC");
756 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 0, in,
757 inlen, 16, "KEY_AES_128/MODE_ECB");
758 apr_pool_destroy(pool);
759
760 }
761
762 /**
763 * Encrypt OpenSSL, decrypt NSS.
764 */
test_crypto_block_openssl_nss(abts_case * tc,void * data)765 static void test_crypto_block_openssl_nss(abts_case *tc, void *data)
766 {
767 apr_pool_t *pool = NULL;
768 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
769
770 const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
771 apr_size_t inlen = sizeof(ALIGNED_STRING);
772
773 apr_pool_create(&pool, NULL);
774 drivers[0] = get_openssl_driver(tc, pool);
775 drivers[1] = get_nss_driver(tc, pool);
776 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 0,
777 in, inlen, 24, "KEY_3DES_192/MODE_CBC");
778
779 /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */
780 /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 0, in, inlen, 24, "KEY_3DES_192/MODE_ECB"); */
781
782 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 0, in,
783 inlen, 32, "KEY_AES_256/MODE_CBC");
784 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 0, in,
785 inlen, 32, "KEY_AES_256/MODE_ECB");
786 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 0, in,
787 inlen, 24, "KEY_AES_192/MODE_CBC");
788 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 0, in,
789 inlen, 24, "KEY_AES_192/MODE_ECB");
790 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 0, in,
791 inlen, 16, "KEY_AES_128/MODE_CBC");
792 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 0, in,
793 inlen, 16, "KEY_AES_128/MODE_ECB");
794 apr_pool_destroy(pool);
795
796 }
797
798 /**
799 * Encrypt OpenSSL, decrypt CommonCrypto.
800 */
test_crypto_block_openssl_commoncrypto(abts_case * tc,void * data)801 static void test_crypto_block_openssl_commoncrypto(abts_case *tc, void *data)
802 {
803 apr_pool_t *pool = NULL;
804 const apr_crypto_driver_t *drivers[] =
805 { NULL, NULL };
806
807 const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
808 apr_size_t inlen = sizeof(ALIGNED_STRING);
809
810 apr_pool_create(&pool, NULL);
811 drivers[0] = get_openssl_driver(tc, pool);
812 drivers[1] = get_commoncrypto_driver(tc, pool);
813
814 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 0, in,
815 inlen, 24, "KEY_3DES_192/MODE_CBC");
816 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_ECB, 0, in,
817 inlen, 24, "KEY_3DES_192/MODE_ECB");
818 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 0, in,
819 inlen, 32, "KEY_AES_256/MODE_CBC");
820 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 0, in,
821 inlen, 32, "KEY_AES_256/MODE_ECB");
822 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 0, in,
823 inlen, 24, "KEY_AES_192/MODE_CBC");
824 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 0, in,
825 inlen, 24, "KEY_AES_192/MODE_ECB");
826 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 0, in,
827 inlen, 16, "KEY_AES_128/MODE_CBC");
828 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 0, in,
829 inlen, 16, "KEY_AES_128/MODE_ECB");
830 apr_pool_destroy(pool);
831
832 }
833
834 /**
835 * Encrypt OpenSSL, decrypt CommonCrypto.
836 */
test_crypto_block_commoncrypto_openssl(abts_case * tc,void * data)837 static void test_crypto_block_commoncrypto_openssl(abts_case *tc, void *data)
838 {
839 apr_pool_t *pool = NULL;
840 const apr_crypto_driver_t *drivers[] =
841 { NULL, NULL };
842
843 const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
844 apr_size_t inlen = sizeof(ALIGNED_STRING);
845
846 apr_pool_create(&pool, NULL);
847 drivers[0] = get_commoncrypto_driver(tc, pool);
848 drivers[1] = get_openssl_driver(tc, pool);
849
850 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 0, in,
851 inlen, 24, "KEY_3DES_192/MODE_CBC");
852 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_ECB, 0, in,
853 inlen, 24, "KEY_3DES_192/MODE_ECB");
854 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 0, in,
855 inlen, 32, "KEY_AES_256/MODE_CBC");
856 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 0, in,
857 inlen, 32, "KEY_AES_256/MODE_ECB");
858 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 0, in,
859 inlen, 24, "KEY_AES_192/MODE_CBC");
860 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 0, in,
861 inlen, 24, "KEY_AES_192/MODE_ECB");
862 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 0, in,
863 inlen, 16, "KEY_AES_128/MODE_CBC");
864 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 0, in,
865 inlen, 16, "KEY_AES_128/MODE_ECB");
866 apr_pool_destroy(pool);
867
868 }
869
870 /**
871 * Simple test of OpenSSL block crypt.
872 */
test_crypto_block_openssl_pad(abts_case * tc,void * data)873 static void test_crypto_block_openssl_pad(abts_case *tc, void *data)
874 {
875 apr_pool_t *pool = NULL;
876 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
877
878 const unsigned char *in = (const unsigned char *) TEST_STRING;
879 apr_size_t inlen = sizeof(TEST_STRING);
880
881 apr_pool_create(&pool, NULL);
882 drivers[0] = get_openssl_driver(tc, pool);
883 drivers[1] = get_openssl_driver(tc, pool);
884
885 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 1,
886 in, inlen, 24, "KEY_3DES_192/MODE_CBC");
887 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_ECB, 1,
888 in, inlen, 24, "KEY_3DES_192/MODE_ECB");
889 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in,
890 inlen, 32, "KEY_AES_256/MODE_CBC");
891 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 1, in,
892 inlen, 32, "KEY_AES_256/MODE_ECB");
893 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 1, in,
894 inlen, 24, "KEY_AES_192/MODE_CBC");
895 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 1, in,
896 inlen, 24, "KEY_AES_192/MODE_ECB");
897 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 1, in,
898 inlen, 16, "KEY_AES_128/MODE_CBC");
899 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 1, in,
900 inlen, 16, "KEY_AES_128/MODE_ECB");
901
902 apr_pool_destroy(pool);
903
904 }
905
906 /**
907 * Simple test of NSS block crypt.
908 */
test_crypto_block_nss_pad(abts_case * tc,void * data)909 static void test_crypto_block_nss_pad(abts_case *tc, void *data)
910 {
911 apr_pool_t *pool = NULL;
912 const apr_crypto_driver_t *drivers[] =
913 { NULL, NULL };
914
915 const unsigned char *in = (const unsigned char *) TEST_STRING;
916 apr_size_t inlen = sizeof(TEST_STRING);
917
918 apr_pool_create(&pool, NULL);
919 drivers[0] = get_nss_driver(tc, pool);
920 drivers[1] = get_nss_driver(tc, pool);
921
922 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 1,
923 in, inlen, 24, "KEY_3DES_192/MODE_CBC");
924 /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */
925 /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 1, in, inlen, 24, "KEY_3DES_192/MODE_ECB"); */
926
927 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in,
928 inlen, 32, "KEY_AES_256/MODE_CBC");
929
930 /* KEY_AES_256 / MODE_ECB doesn't support padding on NSS */
931 /*crypto_block_cross(tc, pool, drivers, KEY_AES_256, MODE_ECB, 1, in, inlen, 32, "KEY_AES_256/MODE_ECB");*/
932
933 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 1, in,
934 inlen, 24, "KEY_AES_192/MODE_CBC");
935
936 /* KEY_AES_256 / MODE_ECB doesn't support padding on NSS */
937 /*crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_ECB, 1, in, inlen, 24, "KEY_AES_192/MODE_ECB");*/
938
939 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 1, in,
940 inlen, 16, "KEY_AES_128/MODE_CBC");
941
942 /* KEY_AES_256 / MODE_ECB doesn't support padding on NSS */
943 /*crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_ECB, 1, in, inlen, 16, "KEY_AES_128/MODE_ECB");*/
944
945 apr_pool_destroy(pool);
946
947 }
948
949 /**
950 * Simple test of Common Crypto block crypt.
951 */
test_crypto_block_commoncrypto_pad(abts_case * tc,void * data)952 static void test_crypto_block_commoncrypto_pad(abts_case *tc, void *data)
953 {
954 apr_pool_t *pool = NULL;
955 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
956
957 const unsigned char *in = (const unsigned char *) TEST_STRING;
958 apr_size_t inlen = sizeof(TEST_STRING);
959
960 apr_pool_create(&pool, NULL);
961 drivers[0] = get_commoncrypto_driver(tc, pool);
962 drivers[1] = get_commoncrypto_driver(tc, pool);
963
964 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 1,
965 in, inlen, 24, "KEY_3DES_192/MODE_CBC");
966 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_ECB, 1,
967 in, inlen, 24, "KEY_3DES_192/MODE_ECB");
968 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in,
969 inlen, 32, "KEY_AES_256/MODE_CBC");
970 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 1, in,
971 inlen, 32, "KEY_AES_256/MODE_ECB");
972 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 1, in,
973 inlen, 24, "KEY_AES_192/MODE_CBC");
974 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 1, in,
975 inlen, 24, "KEY_AES_192/MODE_ECB");
976 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 1, in,
977 inlen, 16, "KEY_AES_128/MODE_CBC");
978 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 1, in,
979 inlen, 16, "KEY_AES_128/MODE_ECB");
980
981 apr_pool_destroy(pool);
982
983 }
984
985 /**
986 * Encrypt NSS, decrypt OpenSSL.
987 */
test_crypto_block_nss_openssl_pad(abts_case * tc,void * data)988 static void test_crypto_block_nss_openssl_pad(abts_case *tc, void *data)
989 {
990 apr_pool_t *pool = NULL;
991 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
992
993 const unsigned char *in = (const unsigned char *) TEST_STRING;
994 apr_size_t inlen = sizeof(TEST_STRING);
995
996 apr_pool_create(&pool, NULL);
997 drivers[0] = get_nss_driver(tc, pool);
998 drivers[1] = get_openssl_driver(tc, pool);
999
1000 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 1,
1001 in, inlen, 24, "KEY_3DES_192/MODE_CBC");
1002
1003 /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */
1004 /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 1, in, inlen, 24, "KEY_3DES_192/MODE_ECB"); */
1005
1006 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in,
1007 inlen, 32, "KEY_AES_256/MODE_CBC");
1008
1009 /* KEY_AES_256 / MODE_ECB doesn't support padding on NSS */
1010 /*crypto_block_cross(tc, pool, drivers, KEY_AES_256, MODE_ECB, 1, in, inlen, 32, "KEY_AES_256/MODE_ECB");*/
1011
1012 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 1, in,
1013 inlen, 24, "KEY_AES_192/MODE_CBC");
1014
1015 /* KEY_AES_192 / MODE_ECB doesn't support padding on NSS */
1016 /*crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 1, in,
1017 inlen, 24, "KEY_AES_192/MODE_ECB");*/
1018
1019 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 1, in,
1020 inlen, 16, "KEY_AES_128/MODE_CBC");
1021
1022 /* KEY_AES_192 / MODE_ECB doesn't support padding on NSS */
1023 /*crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 1, in,
1024 inlen, 16, "KEY_AES_128/MODE_ECB");*/
1025
1026 apr_pool_destroy(pool);
1027
1028 }
1029
1030 /**
1031 * Encrypt OpenSSL, decrypt NSS.
1032 */
test_crypto_block_openssl_nss_pad(abts_case * tc,void * data)1033 static void test_crypto_block_openssl_nss_pad(abts_case *tc, void *data)
1034 {
1035 apr_pool_t *pool = NULL;
1036 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
1037
1038 const unsigned char *in = (const unsigned char *) TEST_STRING;
1039 apr_size_t inlen = sizeof(TEST_STRING);
1040
1041 apr_pool_create(&pool, NULL);
1042 drivers[0] = get_openssl_driver(tc, pool);
1043 drivers[1] = get_nss_driver(tc, pool);
1044 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 1,
1045 in, inlen, 24, "KEY_3DES_192/MODE_CBC");
1046
1047 /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */
1048 /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 1, in, inlen, 24, "KEY_3DES_192/MODE_ECB"); */
1049
1050 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in,
1051 inlen, 32, "KEY_AES_256/MODE_CBC");
1052
1053 /* KEY_AES_256 / MODE_ECB doesn't support padding on NSS */
1054 /*crypto_block_cross(tc, pool, drivers, KEY_AES_256, MODE_ECB, 1, in, inlen, 32, "KEY_AES_256/MODE_ECB");*/
1055
1056 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 1, in, inlen,
1057 24, "KEY_AES_192/MODE_CBC");
1058
1059 /* KEY_AES_192 / MODE_ECB doesn't support padding on NSS */
1060 /*crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 1, in, inlen,
1061 24, "KEY_AES_192/MODE_ECB");*/
1062
1063 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 1, in, inlen,
1064 16, "KEY_AES_128/MODE_CBC");
1065
1066 /* KEY_AES_128 / MODE_ECB doesn't support padding on NSS */
1067 /*crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 1, in, inlen,
1068 16, "KEY_AES_128/MODE_ECB");*/
1069
1070 apr_pool_destroy(pool);
1071
1072 }
1073
1074 /**
1075 * Encrypt CommonCrypto, decrypt OpenSSL.
1076 */
test_crypto_block_commoncrypto_openssl_pad(abts_case * tc,void * data)1077 static void test_crypto_block_commoncrypto_openssl_pad(abts_case *tc,
1078 void *data)
1079 {
1080 apr_pool_t *pool = NULL;
1081 const apr_crypto_driver_t *drivers[] =
1082 { NULL, NULL };
1083
1084 const unsigned char *in = (const unsigned char *) TEST_STRING;
1085 apr_size_t inlen = sizeof(TEST_STRING);
1086
1087 apr_pool_create(&pool, NULL);
1088 drivers[0] = get_commoncrypto_driver(tc, pool);
1089 drivers[1] = get_openssl_driver(tc, pool);
1090
1091 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 1, in,
1092 inlen, 24, "KEY_3DES_192/MODE_CBC");
1093 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_ECB, 1, in,
1094 inlen, 24, "KEY_3DES_192/MODE_ECB");
1095 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in,
1096 inlen, 32, "KEY_AES_256/MODE_CBC");
1097 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 1, in,
1098 inlen, 32, "KEY_AES_256/MODE_ECB");
1099 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 1, in,
1100 inlen, 24, "KEY_AES_192/MODE_CBC");
1101 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 1, in,
1102 inlen, 24, "KEY_AES_192/MODE_ECB");
1103 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 1, in,
1104 inlen, 16, "KEY_AES_128/MODE_CBC");
1105 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 1, in,
1106 inlen, 16, "KEY_AES_128/MODE_ECB");
1107
1108 apr_pool_destroy(pool);
1109
1110 }
1111
1112 /**
1113 * Encrypt OpenSSL, decrypt CommonCrypto.
1114 */
test_crypto_block_openssl_commoncrypto_pad(abts_case * tc,void * data)1115 static void test_crypto_block_openssl_commoncrypto_pad(abts_case *tc,
1116 void *data)
1117 {
1118 apr_pool_t *pool = NULL;
1119 const apr_crypto_driver_t *drivers[] =
1120 { NULL, NULL };
1121
1122 const unsigned char *in = (const unsigned char *) TEST_STRING;
1123 apr_size_t inlen = sizeof(TEST_STRING);
1124
1125 apr_pool_create(&pool, NULL);
1126 drivers[0] = get_openssl_driver(tc, pool);
1127 drivers[1] = get_commoncrypto_driver(tc, pool);
1128
1129 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 1, in,
1130 inlen, 24, "KEY_3DES_192/MODE_CBC");
1131 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_ECB, 1, in,
1132 inlen, 24, "KEY_3DES_192/MODE_ECB");
1133 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in,
1134 inlen, 32, "KEY_AES_256/MODE_CBC");
1135 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 1, in,
1136 inlen, 32, "KEY_AES_256/MODE_ECB");
1137 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 1, in,
1138 inlen, 24, "KEY_AES_192/MODE_CBC");
1139 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 1, in,
1140 inlen, 24, "KEY_AES_192/MODE_ECB");
1141 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 1, in,
1142 inlen, 16, "KEY_AES_128/MODE_CBC");
1143 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 1, in,
1144 inlen, 16, "KEY_AES_128/MODE_ECB");
1145
1146 apr_pool_destroy(pool);
1147
1148 }
1149
1150 /**
1151 * Get Types, OpenSSL.
1152 */
test_crypto_get_block_key_types_openssl(abts_case * tc,void * data)1153 static void test_crypto_get_block_key_types_openssl(abts_case *tc, void *data)
1154 {
1155 apr_pool_t *pool = NULL;
1156 const apr_crypto_driver_t *driver;
1157 apr_crypto_t *f;
1158 apr_hash_t *types;
1159 int *key_3des_192;
1160 int *key_aes_128;
1161 int *key_aes_192;
1162 int *key_aes_256;
1163
1164 apr_pool_create(&pool, NULL);
1165 driver = get_openssl_driver(tc, pool);
1166 if (driver) {
1167
1168 f = make(tc, pool, driver);
1169 apr_crypto_get_block_key_types(&types, f);
1170
1171 key_3des_192 = apr_hash_get(types, "3des192", APR_HASH_KEY_STRING);
1172 ABTS_PTR_NOTNULL(tc, key_3des_192);
1173 ABTS_INT_EQUAL(tc, *key_3des_192, APR_KEY_3DES_192);
1174
1175 key_aes_128 = apr_hash_get(types, "aes128", APR_HASH_KEY_STRING);
1176 ABTS_PTR_NOTNULL(tc, key_aes_128);
1177 ABTS_INT_EQUAL(tc, *key_aes_128, APR_KEY_AES_128);
1178
1179 key_aes_192 = apr_hash_get(types, "aes192", APR_HASH_KEY_STRING);
1180 ABTS_PTR_NOTNULL(tc, key_aes_192);
1181 ABTS_INT_EQUAL(tc, *key_aes_192, APR_KEY_AES_192);
1182
1183 key_aes_256 = apr_hash_get(types, "aes256", APR_HASH_KEY_STRING);
1184 ABTS_PTR_NOTNULL(tc, key_aes_256);
1185 ABTS_INT_EQUAL(tc, *key_aes_256, APR_KEY_AES_256);
1186
1187 }
1188
1189 apr_pool_destroy(pool);
1190
1191 }
1192
1193 /**
1194 * Get Types, NSS.
1195 */
test_crypto_get_block_key_types_nss(abts_case * tc,void * data)1196 static void test_crypto_get_block_key_types_nss(abts_case *tc, void *data)
1197 {
1198 apr_pool_t *pool = NULL;
1199 const apr_crypto_driver_t *driver;
1200 apr_crypto_t *f;
1201 apr_hash_t *types;
1202 int *key_3des_192;
1203 int *key_aes_128;
1204 int *key_aes_192;
1205 int *key_aes_256;
1206
1207 apr_pool_create(&pool, NULL);
1208 driver = get_nss_driver(tc, pool);
1209 if (driver) {
1210
1211 f = make(tc, pool, driver);
1212 apr_crypto_get_block_key_types(&types, f);
1213
1214 key_3des_192 = apr_hash_get(types, "3des192", APR_HASH_KEY_STRING);
1215 ABTS_PTR_NOTNULL(tc, key_3des_192);
1216 ABTS_INT_EQUAL(tc, *key_3des_192, APR_KEY_3DES_192);
1217
1218 key_aes_128 = apr_hash_get(types, "aes128", APR_HASH_KEY_STRING);
1219 ABTS_PTR_NOTNULL(tc, key_aes_128);
1220 ABTS_INT_EQUAL(tc, *key_aes_128, APR_KEY_AES_128);
1221
1222 key_aes_192 = apr_hash_get(types, "aes192", APR_HASH_KEY_STRING);
1223 ABTS_PTR_NOTNULL(tc, key_aes_192);
1224 ABTS_INT_EQUAL(tc, *key_aes_192, APR_KEY_AES_192);
1225
1226 key_aes_256 = apr_hash_get(types, "aes256", APR_HASH_KEY_STRING);
1227 ABTS_PTR_NOTNULL(tc, key_aes_256);
1228 ABTS_INT_EQUAL(tc, *key_aes_256, APR_KEY_AES_256);
1229
1230 }
1231
1232 apr_pool_destroy(pool);
1233
1234 }
1235
1236 /**
1237 * Get Types, Common Crypto.
1238 */
test_crypto_get_block_key_types_commoncrypto(abts_case * tc,void * data)1239 static void test_crypto_get_block_key_types_commoncrypto(abts_case *tc, void *data)
1240 {
1241 apr_pool_t *pool = NULL;
1242 const apr_crypto_driver_t *driver;
1243 apr_crypto_t *f;
1244 apr_hash_t *types;
1245 int *key_3des_192;
1246 int *key_aes_128;
1247 int *key_aes_192;
1248 int *key_aes_256;
1249
1250 apr_pool_create(&pool, NULL);
1251 driver = get_commoncrypto_driver(tc, pool);
1252 if (driver) {
1253
1254 f = make(tc, pool, driver);
1255 apr_crypto_get_block_key_types(&types, f);
1256
1257 key_3des_192 = apr_hash_get(types, "3des192", APR_HASH_KEY_STRING);
1258 ABTS_PTR_NOTNULL(tc, key_3des_192);
1259 ABTS_INT_EQUAL(tc, *key_3des_192, APR_KEY_3DES_192);
1260
1261 key_aes_128 = apr_hash_get(types, "aes128", APR_HASH_KEY_STRING);
1262 ABTS_PTR_NOTNULL(tc, key_aes_128);
1263 ABTS_INT_EQUAL(tc, *key_aes_128, APR_KEY_AES_128);
1264
1265 key_aes_192 = apr_hash_get(types, "aes192", APR_HASH_KEY_STRING);
1266 ABTS_PTR_NOTNULL(tc, key_aes_192);
1267 ABTS_INT_EQUAL(tc, *key_aes_192, APR_KEY_AES_192);
1268
1269 key_aes_256 = apr_hash_get(types, "aes256", APR_HASH_KEY_STRING);
1270 ABTS_PTR_NOTNULL(tc, key_aes_256);
1271 ABTS_INT_EQUAL(tc, *key_aes_256, APR_KEY_AES_256);
1272
1273 }
1274
1275 apr_pool_destroy(pool);
1276
1277 }
1278
1279 /**
1280 * Get Modes, OpenSSL.
1281 */
test_crypto_get_block_key_modes_openssl(abts_case * tc,void * data)1282 static void test_crypto_get_block_key_modes_openssl(abts_case *tc, void *data)
1283 {
1284 apr_pool_t *pool = NULL;
1285 const apr_crypto_driver_t *driver;
1286 apr_crypto_t *f;
1287 apr_hash_t *modes;
1288 int *mode_ecb;
1289 int *mode_cbc;
1290
1291 apr_pool_create(&pool, NULL);
1292 driver = get_openssl_driver(tc, pool);
1293 if (driver) {
1294
1295 f = make(tc, pool, driver);
1296 apr_crypto_get_block_key_modes(&modes, f);
1297
1298 mode_ecb = apr_hash_get(modes, "ecb", APR_HASH_KEY_STRING);
1299 ABTS_PTR_NOTNULL(tc, mode_ecb);
1300 ABTS_INT_EQUAL(tc, *mode_ecb, APR_MODE_ECB);
1301
1302 mode_cbc = apr_hash_get(modes, "cbc", APR_HASH_KEY_STRING);
1303 ABTS_PTR_NOTNULL(tc, mode_cbc);
1304 ABTS_INT_EQUAL(tc, *mode_cbc, APR_MODE_CBC);
1305
1306 }
1307
1308 apr_pool_destroy(pool);
1309
1310 }
1311
1312 /**
1313 * Get Modes, NSS.
1314 */
test_crypto_get_block_key_modes_nss(abts_case * tc,void * data)1315 static void test_crypto_get_block_key_modes_nss(abts_case *tc, void *data)
1316 {
1317 apr_pool_t *pool = NULL;
1318 const apr_crypto_driver_t *driver;
1319 apr_crypto_t *f;
1320 apr_hash_t *modes;
1321 int *mode_ecb;
1322 int *mode_cbc;
1323
1324 apr_pool_create(&pool, NULL);
1325 driver = get_nss_driver(tc, pool);
1326 if (driver) {
1327
1328 f = make(tc, pool, driver);
1329 apr_crypto_get_block_key_modes(&modes, f);
1330
1331 mode_ecb = apr_hash_get(modes, "ecb", APR_HASH_KEY_STRING);
1332 ABTS_PTR_NOTNULL(tc, mode_ecb);
1333 ABTS_INT_EQUAL(tc, *mode_ecb, APR_MODE_ECB);
1334
1335 mode_cbc = apr_hash_get(modes, "cbc", APR_HASH_KEY_STRING);
1336 ABTS_PTR_NOTNULL(tc, mode_cbc);
1337 ABTS_INT_EQUAL(tc, *mode_cbc, APR_MODE_CBC);
1338
1339 }
1340
1341 apr_pool_destroy(pool);
1342
1343 }
1344
1345 /**
1346 * Get Modes, Common Crypto.
1347 */
test_crypto_get_block_key_modes_commoncrypto(abts_case * tc,void * data)1348 static void test_crypto_get_block_key_modes_commoncrypto(abts_case *tc, void *data)
1349 {
1350 apr_pool_t *pool = NULL;
1351 const apr_crypto_driver_t *driver;
1352 apr_crypto_t *f;
1353 apr_hash_t *modes;
1354 int *mode_ecb;
1355 int *mode_cbc;
1356
1357 apr_pool_create(&pool, NULL);
1358 driver = get_commoncrypto_driver(tc, pool);
1359 if (driver) {
1360
1361 f = make(tc, pool, driver);
1362 apr_crypto_get_block_key_modes(&modes, f);
1363
1364 mode_ecb = apr_hash_get(modes, "ecb", APR_HASH_KEY_STRING);
1365 ABTS_PTR_NOTNULL(tc, mode_ecb);
1366 ABTS_INT_EQUAL(tc, *mode_ecb, APR_MODE_ECB);
1367
1368 mode_cbc = apr_hash_get(modes, "cbc", APR_HASH_KEY_STRING);
1369 ABTS_PTR_NOTNULL(tc, mode_cbc);
1370 ABTS_INT_EQUAL(tc, *mode_cbc, APR_MODE_CBC);
1371
1372 }
1373
1374 apr_pool_destroy(pool);
1375
1376 }
1377
test_crypto_memzero(abts_case * tc,void * data)1378 static void test_crypto_memzero(abts_case *tc, void *data)
1379 {
1380 /* Aligned message */
1381 struct {
1382 char buf[7 * sizeof(int)];
1383 int untouched;
1384 } msg;
1385 /* A bit of type punning such that 'msg' might look unused
1386 * after the call to apr_crypto_memzero().
1387 */
1388 int *ptr = (int *)&msg;
1389 int i;
1390
1391 /* Fill buf with non-zeros (odds) */
1392 for (i = 1; i < 2 * sizeof(msg.buf); i += 2) {
1393 msg.buf[i / 2] = (char)i;
1394 ABTS_ASSERT(tc, "test_crypto_memzero() barrier", msg.buf[i / 2] != 0);
1395 }
1396
1397 /* Zero out the whole, and check it */
1398 apr_crypto_memzero(&msg, sizeof msg);
1399 for (i = 0; i < sizeof(msg) / sizeof(*ptr); ++i) {
1400 ABTS_ASSERT(tc, "test_crypto_memzero() optimized out", ptr[i] == 0);
1401 }
1402 }
1403
test_crypto_equals(abts_case * tc,void * data)1404 static void test_crypto_equals(abts_case *tc, void *data)
1405 {
1406 /* Buffers of each type of scalar */
1407 union {
1408 char c;
1409 short s;
1410 int i;
1411 long l;
1412 float f;
1413 double d;
1414 void *p;
1415 } buf0[7], buf1[7], buf[7];
1416 char *ptr = (char *)buf;
1417 int i;
1418
1419 #define TEST_SCALAR_MATCH(i, x, r) \
1420 ABTS_ASSERT(tc, "test_crypto_equals(" APR_STRINGIFY(x) ")" \
1421 " != " APR_STRINGIFY(r), \
1422 apr_crypto_equals(&buf##r[i].x, &buf[i].x, \
1423 sizeof(buf[i].x)) == r)
1424
1425 /* Fill buf with non-zeros (odds) */
1426 for (i = 1; i < 2 * sizeof(buf); i += 2) {
1427 ptr[i / 2] = (char)i;
1428 }
1429 /* Set buf1 = buf */
1430 memcpy(buf1, buf, sizeof buf);
1431 /* Set buf0 = {0} */
1432 memset(buf0, 0, sizeof buf0);
1433
1434 /* Check that buf1 == buf for each scalar */
1435 TEST_SCALAR_MATCH(0, c, 1);
1436 TEST_SCALAR_MATCH(1, s, 1);
1437 TEST_SCALAR_MATCH(2, i, 1);
1438 TEST_SCALAR_MATCH(3, l, 1);
1439 TEST_SCALAR_MATCH(4, f, 1);
1440 TEST_SCALAR_MATCH(5, d, 1);
1441 TEST_SCALAR_MATCH(6, p, 1);
1442
1443 /* Check that buf0 != buf for each scalar */
1444 TEST_SCALAR_MATCH(0, c, 0);
1445 TEST_SCALAR_MATCH(1, s, 0);
1446 TEST_SCALAR_MATCH(2, i, 0);
1447 TEST_SCALAR_MATCH(3, l, 0);
1448 TEST_SCALAR_MATCH(4, f, 0);
1449 TEST_SCALAR_MATCH(5, d, 0);
1450 TEST_SCALAR_MATCH(6, p, 0);
1451 }
1452
testcrypto(abts_suite * suite)1453 abts_suite *testcrypto(abts_suite *suite)
1454 {
1455 suite = ADD_SUITE(suite);
1456
1457 /* test simple init and shutdown */
1458 abts_run_test(suite, test_crypto_init, NULL);
1459
1460 /* test key parsing - openssl */
1461 abts_run_test(suite, test_crypto_key_openssl, NULL);
1462
1463 /* test key parsing - nss */
1464 abts_run_test(suite, test_crypto_key_nss, NULL);
1465
1466 /* test key parsing - commoncrypto */
1467 abts_run_test(suite, test_crypto_key_commoncrypto, NULL);
1468
1469 /* test a simple encrypt / decrypt operation - openssl */
1470 abts_run_test(suite, test_crypto_block_openssl, NULL);
1471
1472 /* test a padded encrypt / decrypt operation - openssl */
1473 abts_run_test(suite, test_crypto_block_openssl_pad, NULL);
1474
1475 /* test a simple encrypt / decrypt operation - nss */
1476 abts_run_test(suite, test_crypto_block_nss, NULL);
1477
1478 /* test a padded encrypt / decrypt operation - nss */
1479 abts_run_test(suite, test_crypto_block_nss_pad, NULL);
1480
1481 /* test a simple encrypt / decrypt operation - commoncrypto */
1482 abts_run_test(suite, test_crypto_block_commoncrypto, NULL);
1483
1484 /* test a padded encrypt / decrypt operation - commoncrypto */
1485 abts_run_test(suite, test_crypto_block_commoncrypto_pad, NULL);
1486
1487 /* test encrypt nss / decrypt openssl */
1488 abts_run_test(suite, test_crypto_block_nss_openssl, NULL);
1489
1490 /* test padded encrypt nss / decrypt openssl */
1491 abts_run_test(suite, test_crypto_block_nss_openssl_pad, NULL);
1492
1493 /* test encrypt openssl / decrypt nss */
1494 abts_run_test(suite, test_crypto_block_openssl_nss, NULL);
1495
1496 /* test padded encrypt openssl / decrypt nss */
1497 abts_run_test(suite, test_crypto_block_openssl_nss_pad, NULL);
1498
1499 /* test encrypt openssl / decrypt commoncrypto */
1500 abts_run_test(suite, test_crypto_block_openssl_commoncrypto, NULL);
1501
1502 /* test padded encrypt openssl / decrypt commoncrypto */
1503 abts_run_test(suite, test_crypto_block_openssl_commoncrypto_pad, NULL);
1504
1505 /* test encrypt commoncrypto / decrypt openssl */
1506 abts_run_test(suite, test_crypto_block_commoncrypto_openssl, NULL);
1507
1508 /* test padded encrypt commoncrypto / decrypt openssl */
1509 abts_run_test(suite, test_crypto_block_commoncrypto_openssl_pad, NULL);
1510
1511 /* test block key types openssl */
1512 abts_run_test(suite, test_crypto_get_block_key_types_openssl, NULL);
1513
1514 /* test block key types nss */
1515 abts_run_test(suite, test_crypto_get_block_key_types_nss, NULL);
1516
1517 /* test block key types commoncrypto */
1518 abts_run_test(suite, test_crypto_get_block_key_types_commoncrypto, NULL);
1519
1520 /* test block key modes openssl */
1521 abts_run_test(suite, test_crypto_get_block_key_modes_openssl, NULL);
1522
1523 /* test block key modes nss */
1524 abts_run_test(suite, test_crypto_get_block_key_modes_nss, NULL);
1525
1526 /* test block key modes commoncrypto */
1527 abts_run_test(suite, test_crypto_get_block_key_modes_commoncrypto, NULL);
1528
1529 abts_run_test(suite, test_crypto_memzero, NULL);
1530 abts_run_test(suite, test_crypto_equals, NULL);
1531
1532 return suite;
1533 }
1534
1535 #else
1536
1537 /**
1538 * Dummy test suite when crypto is turned off.
1539 */
testcrypto(abts_suite * suite)1540 abts_suite *testcrypto(abts_suite *suite)
1541 {
1542 return ADD_SUITE(suite);
1543 }
1544
1545 #endif /* APU_HAVE_CRYPTO */
1546