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 31static 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 71static 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 80static 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 88static 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 96static 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 114static 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 167static 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 216static 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 274static 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 366static 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 */ 459static 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 */ 553static 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 */ 570static 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 */ 589static 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 */ 608static 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 */ 627static 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 */ 661static 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 */ 695static 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 */ 729static 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 */ 765static 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 */ 801static 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 */ 837static 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 */ 873static 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 */ 909static 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 */ 952static 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 */ 988static 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 */ 1033static 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 */ 1077static 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 */ 1115static 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 */ 1153static 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 */ 1196static 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 */ 1239static 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 */ 1282static 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 */ 1315static 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 */ 1348static 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 1378static 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 1404static 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 1453abts_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 */ 1540abts_suite *testcrypto(abts_suite *suite) 1541{ 1542 return ADD_SUITE(suite); 1543} 1544 1545#endif /* APU_HAVE_CRYPTO */ 1546