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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
20 #include "apu_errno.h"
21 #include "apr_pools.h"
23 #include "apr_crypto.h"
24 #include "apr_strings.h"
28 #define TEST_STRING "12345"
29 #define ALIGNED_STRING "123456789012345"
31 static const apr_crypto_driver_t *get_driver(abts_case *tc, apr_pool_t *pool,
32 const char *name, const char *params)
35 const apr_crypto_driver_t *driver = NULL;
36 const apu_err_t *result = NULL;
39 rv = apr_crypto_init(pool);
40 ABTS_ASSERT(tc, "failed to init apr_crypto", rv == APR_SUCCESS);
42 rv = apr_crypto_get_driver(&driver, name, params, &result, pool);
43 if (APR_ENOTIMPL == rv) {
45 apr_psprintf(pool, "Crypto driver '%s' not implemented", (char *)name));
48 if (APR_EDSOOPEN == rv) {
50 apr_psprintf(pool, "Crypto driver '%s' DSO could not be opened", (char *)name));
53 if (APR_SUCCESS != rv && result) {
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 : "");
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);
71 static const apr_crypto_driver_t *get_nss_driver(abts_case *tc,
76 return get_driver(tc, pool, "nss", "");
80 static const apr_crypto_driver_t *get_openssl_driver(abts_case *tc,
84 return get_driver(tc, pool, "openssl", NULL);
88 static const apr_crypto_driver_t *get_commoncrypto_driver(abts_case *tc,
92 return get_driver(tc, pool, "commoncrypto", NULL);
96 static apr_crypto_t *make(abts_case *tc, apr_pool_t *pool,
97 const apr_crypto_driver_t *driver)
100 apr_crypto_t *f = NULL;
106 /* get the context */
107 apr_crypto_make(&f, driver, "engine=openssl", pool);
108 ABTS_ASSERT(tc, "apr_crypto_make returned NULL", f != NULL);
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)
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));
128 rec->ktype = APR_CRYPTO_KTYPE_SECRET;
132 rec->k.secret.secret = apr_pcalloc(pool, secretLen);
133 rec->k.secret.secretLen = secretLen;
135 /* init the passphrase */
136 rv = apr_crypto_key(&key, rec, f, pool);
137 if (APR_ENOCIPHER == rv) {
138 apr_crypto_error(&result, f);
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 : ""));
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 : "");
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",
155 ABTS_ASSERT(tc, "apr_crypto_key returned 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);
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)
173 apr_crypto_key_t *key = NULL;
174 const apu_err_t *result = NULL;
175 const char *pass = "secret";
176 const char *salt = "salt";
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,
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 : ""));
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 : "");
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);
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)
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));
233 rec->ktype = APR_CRYPTO_KTYPE_PASSPHRASE;
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;
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 : ""));
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 : "");
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);
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)
282 apr_crypto_block_t *block = NULL;
283 const apu_err_t *result = NULL;
287 if (!driver || !f || !key || !in) {
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");
297 if (APR_SUCCESS != rv) {
298 apr_crypto_error(&result, f);
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 : "");
305 ABTS_ASSERT(tc, "apr_crypto_block_encrypt_init returned APR_ENOKEY",
307 ABTS_ASSERT(tc, "apr_crypto_block_encrypt_init returned APR_ENOIV",
309 ABTS_ASSERT(tc, "apr_crypto_block_encrypt_init returned APR_EKEYTYPE",
311 ABTS_ASSERT(tc, "apr_crypto_block_encrypt_init returned APR_EKEYLENGTH",
312 rv != APR_EKEYLENGTH);
314 "apr_crypto_block_encrypt_init returned APR_ENOTENOUGHENTROPY",
315 rv != APR_ENOTENOUGHENTROPY);
316 ABTS_ASSERT(tc, "failed to apr_crypto_block_encrypt_init",
318 ABTS_ASSERT(tc, "apr_crypto_block_encrypt_init returned NULL context",
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 : "");
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);
341 /* finalise the encryption */
342 rv = apr_crypto_block_encrypt_finish(*cipherText + *cipherTextLen, &len,
344 if (APR_SUCCESS != rv) {
345 apr_crypto_error(&result, f);
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 : "");
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);
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)
374 apr_crypto_block_t *block = NULL;
375 const apu_err_t *result = NULL;
379 if (!driver || !f || !key || !cipherText) {
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");
389 if (APR_SUCCESS != rv) {
390 apr_crypto_error(&result, f);
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 : "");
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);
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 : "");
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);
425 /* finalise the decryption */
426 rv = apr_crypto_block_decrypt_finish(*plainText + *plainTextLen, &len,
428 if (APR_SUCCESS != rv) {
429 apr_crypto_error(&result, f);
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 : "");
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);
444 *plainTextLen += len;
445 apr_crypto_block_cleanup(block);
452 * Interoperability test.
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.
457 * If the two drivers interoperate, the test passes.
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)
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;
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;
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);
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,
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(
501 ABTS_STR_EQUAL(tc, (char *)in, (char *)plainText);
504 key3 = keysecret(tc, pool, driver1, f1, type, mode, doPad, secretLen, description);
505 key4 = keysecret(tc, pool, driver2, f2, type, mode, doPad, secretLen, description);
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,
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(
523 ABTS_STR_EQUAL(tc, (char *)in, (char *)plainText);
526 key5 = keypassphrase(tc, pool, driver1, f1, type, mode, doPad, description);
527 key6 = keypassphrase(tc, pool, driver2, f2, type, mode, doPad, description);
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,
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(
545 ABTS_STR_EQUAL(tc, (char *)in, (char *)plainText);
551 * Test initialisation.
553 static void test_crypto_init(abts_case *tc, void *data)
555 apr_pool_t *pool = NULL;
558 apr_pool_create(&pool, NULL);
560 rv = apr_crypto_init(pool);
561 ABTS_ASSERT(tc, "failed to init apr_crypto", rv == APR_SUCCESS);
563 apr_pool_destroy(pool);
568 * Simple test of OpenSSL key.
570 static void test_crypto_key_openssl(abts_case *tc, void *data)
572 apr_pool_t *pool = NULL;
573 const apr_crypto_driver_t *driver;
574 apr_crypto_t *f = NULL;
576 apr_pool_create(&pool, NULL);
577 driver = get_openssl_driver(tc, pool);
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);
587 * Simple test of NSS key.
589 static void test_crypto_key_nss(abts_case *tc, void *data)
591 apr_pool_t *pool = NULL;
592 const apr_crypto_driver_t *driver;
593 apr_crypto_t *f = NULL;
595 apr_pool_create(&pool, NULL);
596 driver = get_nss_driver(tc, pool);
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);
606 * Simple test of CommonCrypto key.
608 static void test_crypto_key_commoncrypto(abts_case *tc, void *data)
610 apr_pool_t *pool = NULL;
611 const apr_crypto_driver_t *driver;
612 apr_crypto_t *f = NULL;
614 apr_pool_create(&pool, NULL);
615 driver = get_commoncrypto_driver(tc, pool);
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);
625 * Simple test of OpenSSL block crypt.
627 static void test_crypto_block_openssl(abts_case *tc, void *data)
629 apr_pool_t *pool = NULL;
630 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
632 const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
633 apr_size_t inlen = sizeof(ALIGNED_STRING);
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);
659 * Simple test of NSS block crypt.
661 static void test_crypto_block_nss(abts_case *tc, void *data)
663 apr_pool_t *pool = NULL;
664 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
666 const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
667 apr_size_t inlen = sizeof(ALIGNED_STRING);
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);
693 * Simple test of Common Crypto block crypt.
695 static void test_crypto_block_commoncrypto(abts_case *tc, void *data)
697 apr_pool_t *pool = NULL;
698 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
700 const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
701 apr_size_t inlen = sizeof(ALIGNED_STRING);
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);
727 * Encrypt NSS, decrypt OpenSSL.
729 static void test_crypto_block_nss_openssl(abts_case *tc, void *data)
731 apr_pool_t *pool = NULL;
732 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
734 const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
735 apr_size_t inlen = sizeof(ALIGNED_STRING);
737 apr_pool_create(&pool, NULL);
738 drivers[0] = get_nss_driver(tc, pool);
739 drivers[1] = get_openssl_driver(tc, pool);
741 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 0,
742 in, inlen, 24, "KEY_3DES_192/MODE_CBC");
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);
763 * Encrypt OpenSSL, decrypt NSS.
765 static void test_crypto_block_openssl_nss(abts_case *tc, void *data)
767 apr_pool_t *pool = NULL;
768 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
770 const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
771 apr_size_t inlen = sizeof(ALIGNED_STRING);
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");
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"); */
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);
799 * Encrypt OpenSSL, decrypt CommonCrypto.
801 static void test_crypto_block_openssl_commoncrypto(abts_case *tc, void *data)
803 apr_pool_t *pool = NULL;
804 const apr_crypto_driver_t *drivers[] =
807 const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
808 apr_size_t inlen = sizeof(ALIGNED_STRING);
810 apr_pool_create(&pool, NULL);
811 drivers[0] = get_openssl_driver(tc, pool);
812 drivers[1] = get_commoncrypto_driver(tc, pool);
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);
835 * Encrypt OpenSSL, decrypt CommonCrypto.
837 static void test_crypto_block_commoncrypto_openssl(abts_case *tc, void *data)
839 apr_pool_t *pool = NULL;
840 const apr_crypto_driver_t *drivers[] =
843 const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
844 apr_size_t inlen = sizeof(ALIGNED_STRING);
846 apr_pool_create(&pool, NULL);
847 drivers[0] = get_commoncrypto_driver(tc, pool);
848 drivers[1] = get_openssl_driver(tc, pool);
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);
871 * Simple test of OpenSSL block crypt.
873 static void test_crypto_block_openssl_pad(abts_case *tc, void *data)
875 apr_pool_t *pool = NULL;
876 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
878 const unsigned char *in = (const unsigned char *) TEST_STRING;
879 apr_size_t inlen = sizeof(TEST_STRING);
881 apr_pool_create(&pool, NULL);
882 drivers[0] = get_openssl_driver(tc, pool);
883 drivers[1] = get_openssl_driver(tc, pool);
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");
902 apr_pool_destroy(pool);
907 * Simple test of NSS block crypt.
909 static void test_crypto_block_nss_pad(abts_case *tc, void *data)
911 apr_pool_t *pool = NULL;
912 const apr_crypto_driver_t *drivers[] =
915 const unsigned char *in = (const unsigned char *) TEST_STRING;
916 apr_size_t inlen = sizeof(TEST_STRING);
918 apr_pool_create(&pool, NULL);
919 drivers[0] = get_nss_driver(tc, pool);
920 drivers[1] = get_nss_driver(tc, pool);
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"); */
927 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in,
928 inlen, 32, "KEY_AES_256/MODE_CBC");
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");*/
933 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 1, in,
934 inlen, 24, "KEY_AES_192/MODE_CBC");
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");*/
939 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 1, in,
940 inlen, 16, "KEY_AES_128/MODE_CBC");
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");*/
945 apr_pool_destroy(pool);
950 * Simple test of Common Crypto block crypt.
952 static void test_crypto_block_commoncrypto_pad(abts_case *tc, void *data)
954 apr_pool_t *pool = NULL;
955 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
957 const unsigned char *in = (const unsigned char *) TEST_STRING;
958 apr_size_t inlen = sizeof(TEST_STRING);
960 apr_pool_create(&pool, NULL);
961 drivers[0] = get_commoncrypto_driver(tc, pool);
962 drivers[1] = get_commoncrypto_driver(tc, pool);
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");
981 apr_pool_destroy(pool);
986 * Encrypt NSS, decrypt OpenSSL.
988 static void test_crypto_block_nss_openssl_pad(abts_case *tc, void *data)
990 apr_pool_t *pool = NULL;
991 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
993 const unsigned char *in = (const unsigned char *) TEST_STRING;
994 apr_size_t inlen = sizeof(TEST_STRING);
996 apr_pool_create(&pool, NULL);
997 drivers[0] = get_nss_driver(tc, pool);
998 drivers[1] = get_openssl_driver(tc, pool);
1000 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 1,
1001 in, inlen, 24, "KEY_3DES_192/MODE_CBC");
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"); */
1006 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in,
1007 inlen, 32, "KEY_AES_256/MODE_CBC");
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");*/
1012 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 1, in,
1013 inlen, 24, "KEY_AES_192/MODE_CBC");
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");*/
1019 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 1, in,
1020 inlen, 16, "KEY_AES_128/MODE_CBC");
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");*/
1026 apr_pool_destroy(pool);
1031 * Encrypt OpenSSL, decrypt NSS.
1033 static void test_crypto_block_openssl_nss_pad(abts_case *tc, void *data)
1035 apr_pool_t *pool = NULL;
1036 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
1038 const unsigned char *in = (const unsigned char *) TEST_STRING;
1039 apr_size_t inlen = sizeof(TEST_STRING);
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");
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"); */
1050 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in,
1051 inlen, 32, "KEY_AES_256/MODE_CBC");
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");*/
1056 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 1, in, inlen,
1057 24, "KEY_AES_192/MODE_CBC");
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");*/
1063 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 1, in, inlen,
1064 16, "KEY_AES_128/MODE_CBC");
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");*/
1070 apr_pool_destroy(pool);
1075 * Encrypt CommonCrypto, decrypt OpenSSL.
1077 static void test_crypto_block_commoncrypto_openssl_pad(abts_case *tc,
1080 apr_pool_t *pool = NULL;
1081 const apr_crypto_driver_t *drivers[] =
1084 const unsigned char *in = (const unsigned char *) TEST_STRING;
1085 apr_size_t inlen = sizeof(TEST_STRING);
1087 apr_pool_create(&pool, NULL);
1088 drivers[0] = get_commoncrypto_driver(tc, pool);
1089 drivers[1] = get_openssl_driver(tc, pool);
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");
1108 apr_pool_destroy(pool);
1113 * Encrypt OpenSSL, decrypt CommonCrypto.
1115 static void test_crypto_block_openssl_commoncrypto_pad(abts_case *tc,
1118 apr_pool_t *pool = NULL;
1119 const apr_crypto_driver_t *drivers[] =
1122 const unsigned char *in = (const unsigned char *) TEST_STRING;
1123 apr_size_t inlen = sizeof(TEST_STRING);
1125 apr_pool_create(&pool, NULL);
1126 drivers[0] = get_openssl_driver(tc, pool);
1127 drivers[1] = get_commoncrypto_driver(tc, pool);
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");
1146 apr_pool_destroy(pool);
1151 * Get Types, OpenSSL.
1153 static void test_crypto_get_block_key_types_openssl(abts_case *tc, void *data)
1155 apr_pool_t *pool = NULL;
1156 const apr_crypto_driver_t *driver;
1164 apr_pool_create(&pool, NULL);
1165 driver = get_openssl_driver(tc, pool);
1168 f = make(tc, pool, driver);
1169 apr_crypto_get_block_key_types(&types, f);
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);
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);
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);
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);
1189 apr_pool_destroy(pool);
1196 static void test_crypto_get_block_key_types_nss(abts_case *tc, void *data)
1198 apr_pool_t *pool = NULL;
1199 const apr_crypto_driver_t *driver;
1207 apr_pool_create(&pool, NULL);
1208 driver = get_nss_driver(tc, pool);
1211 f = make(tc, pool, driver);
1212 apr_crypto_get_block_key_types(&types, f);
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);
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);
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);
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);
1232 apr_pool_destroy(pool);
1237 * Get Types, Common Crypto.
1239 static void test_crypto_get_block_key_types_commoncrypto(abts_case *tc, void *data)
1241 apr_pool_t *pool = NULL;
1242 const apr_crypto_driver_t *driver;
1250 apr_pool_create(&pool, NULL);
1251 driver = get_commoncrypto_driver(tc, pool);
1254 f = make(tc, pool, driver);
1255 apr_crypto_get_block_key_types(&types, f);
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);
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);
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);
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);
1275 apr_pool_destroy(pool);
1280 * Get Modes, OpenSSL.
1282 static void test_crypto_get_block_key_modes_openssl(abts_case *tc, void *data)
1284 apr_pool_t *pool = NULL;
1285 const apr_crypto_driver_t *driver;
1291 apr_pool_create(&pool, NULL);
1292 driver = get_openssl_driver(tc, pool);
1295 f = make(tc, pool, driver);
1296 apr_crypto_get_block_key_modes(&modes, f);
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);
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);
1308 apr_pool_destroy(pool);
1315 static void test_crypto_get_block_key_modes_nss(abts_case *tc, void *data)
1317 apr_pool_t *pool = NULL;
1318 const apr_crypto_driver_t *driver;
1324 apr_pool_create(&pool, NULL);
1325 driver = get_nss_driver(tc, pool);
1328 f = make(tc, pool, driver);
1329 apr_crypto_get_block_key_modes(&modes, f);
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);
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);
1341 apr_pool_destroy(pool);
1346 * Get Modes, Common Crypto.
1348 static void test_crypto_get_block_key_modes_commoncrypto(abts_case *tc, void *data)
1350 apr_pool_t *pool = NULL;
1351 const apr_crypto_driver_t *driver;
1357 apr_pool_create(&pool, NULL);
1358 driver = get_commoncrypto_driver(tc, pool);
1361 f = make(tc, pool, driver);
1362 apr_crypto_get_block_key_modes(&modes, f);
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);
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);
1374 apr_pool_destroy(pool);
1378 static void test_crypto_memzero(abts_case *tc, void *data)
1380 /* Aligned message */
1382 char buf[7 * sizeof(int)];
1385 /* A bit of type punning such that 'msg' might look unused
1386 * after the call to apr_crypto_memzero().
1388 int *ptr = (int *)&msg;
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);
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);
1404 static void test_crypto_equals(abts_case *tc, void *data)
1406 /* Buffers of each type of scalar */
1415 } buf0[7], buf1[7], buf[7];
1416 char *ptr = (char *)buf;
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)
1425 /* Fill buf with non-zeros (odds) */
1426 for (i = 1; i < 2 * sizeof(buf); i += 2) {
1427 ptr[i / 2] = (char)i;
1429 /* Set buf1 = buf */
1430 memcpy(buf1, buf, sizeof buf);
1431 /* Set buf0 = {0} */
1432 memset(buf0, 0, sizeof buf0);
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);
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);
1453 abts_suite *testcrypto(abts_suite *suite)
1455 suite = ADD_SUITE(suite);
1457 /* test simple init and shutdown */
1458 abts_run_test(suite, test_crypto_init, NULL);
1460 /* test key parsing - openssl */
1461 abts_run_test(suite, test_crypto_key_openssl, NULL);
1463 /* test key parsing - nss */
1464 abts_run_test(suite, test_crypto_key_nss, NULL);
1466 /* test key parsing - commoncrypto */
1467 abts_run_test(suite, test_crypto_key_commoncrypto, NULL);
1469 /* test a simple encrypt / decrypt operation - openssl */
1470 abts_run_test(suite, test_crypto_block_openssl, NULL);
1472 /* test a padded encrypt / decrypt operation - openssl */
1473 abts_run_test(suite, test_crypto_block_openssl_pad, NULL);
1475 /* test a simple encrypt / decrypt operation - nss */
1476 abts_run_test(suite, test_crypto_block_nss, NULL);
1478 /* test a padded encrypt / decrypt operation - nss */
1479 abts_run_test(suite, test_crypto_block_nss_pad, NULL);
1481 /* test a simple encrypt / decrypt operation - commoncrypto */
1482 abts_run_test(suite, test_crypto_block_commoncrypto, NULL);
1484 /* test a padded encrypt / decrypt operation - commoncrypto */
1485 abts_run_test(suite, test_crypto_block_commoncrypto_pad, NULL);
1487 /* test encrypt nss / decrypt openssl */
1488 abts_run_test(suite, test_crypto_block_nss_openssl, NULL);
1490 /* test padded encrypt nss / decrypt openssl */
1491 abts_run_test(suite, test_crypto_block_nss_openssl_pad, NULL);
1493 /* test encrypt openssl / decrypt nss */
1494 abts_run_test(suite, test_crypto_block_openssl_nss, NULL);
1496 /* test padded encrypt openssl / decrypt nss */
1497 abts_run_test(suite, test_crypto_block_openssl_nss_pad, NULL);
1499 /* test encrypt openssl / decrypt commoncrypto */
1500 abts_run_test(suite, test_crypto_block_openssl_commoncrypto, NULL);
1502 /* test padded encrypt openssl / decrypt commoncrypto */
1503 abts_run_test(suite, test_crypto_block_openssl_commoncrypto_pad, NULL);
1505 /* test encrypt commoncrypto / decrypt openssl */
1506 abts_run_test(suite, test_crypto_block_commoncrypto_openssl, NULL);
1508 /* test padded encrypt commoncrypto / decrypt openssl */
1509 abts_run_test(suite, test_crypto_block_commoncrypto_openssl_pad, NULL);
1511 /* test block key types openssl */
1512 abts_run_test(suite, test_crypto_get_block_key_types_openssl, NULL);
1514 /* test block key types nss */
1515 abts_run_test(suite, test_crypto_get_block_key_types_nss, NULL);
1517 /* test block key types commoncrypto */
1518 abts_run_test(suite, test_crypto_get_block_key_types_commoncrypto, NULL);
1520 /* test block key modes openssl */
1521 abts_run_test(suite, test_crypto_get_block_key_modes_openssl, NULL);
1523 /* test block key modes nss */
1524 abts_run_test(suite, test_crypto_get_block_key_modes_nss, NULL);
1526 /* test block key modes commoncrypto */
1527 abts_run_test(suite, test_crypto_get_block_key_modes_commoncrypto, NULL);
1529 abts_run_test(suite, test_crypto_memzero, NULL);
1530 abts_run_test(suite, test_crypto_equals, NULL);
1538 * Dummy test suite when crypto is turned off.
1540 abts_suite *testcrypto(abts_suite *suite)
1542 return ADD_SUITE(suite);
1545 #endif /* APU_HAVE_CRYPTO */