1251876Speter/* Licensed to the Apache Software Foundation (ASF) under one or more 2251876Speter * contributor license agreements. See the NOTICE file distributed with 3251876Speter * this work for additional information regarding copyright ownership. 4251876Speter * The ASF licenses this file to You under the Apache License, Version 2.0 5251876Speter * (the "License"); you may not use this file except in compliance with 6251876Speter * the License. You may obtain a copy of the License at 7251876Speter * 8251876Speter * http://www.apache.org/licenses/LICENSE-2.0 9251876Speter * 10251876Speter * Unless required by applicable law or agreed to in writing, software 11251876Speter * distributed under the License is distributed on an "AS IS" BASIS, 12251876Speter * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13251876Speter * See the License for the specific language governing permissions and 14251876Speter * limitations under the License. 15251876Speter */ 16251876Speter 17251876Speter#include "testutil.h" 18251876Speter#include "apr.h" 19251876Speter#include "apu.h" 20251876Speter#include "apu_errno.h" 21251876Speter#include "apr_pools.h" 22251876Speter#include "apr_dso.h" 23251876Speter#include "apr_crypto.h" 24251876Speter#include "apr_strings.h" 25251876Speter 26251876Speter#if APU_HAVE_CRYPTO 27251876Speter 28251876Speter#define TEST_STRING "12345" 29251876Speter#define ALIGNED_STRING "123456789012345" 30251876Speter 31251876Speterstatic const apr_crypto_driver_t *get_driver(abts_case *tc, apr_pool_t *pool, 32251876Speter const char *name, const char *params) 33251876Speter{ 34251876Speter 35251876Speter const apr_crypto_driver_t *driver = NULL; 36251876Speter const apu_err_t *err = NULL; 37251876Speter apr_status_t rv; 38251876Speter 39251876Speter rv = apr_crypto_init(pool); 40251876Speter ABTS_ASSERT(tc, "failed to init apr_crypto", rv == APR_SUCCESS); 41251876Speter 42251876Speter rv = apr_crypto_get_driver(&driver, name, params, &err, pool); 43251876Speter if (APR_SUCCESS != rv && err) { 44251876Speter ABTS_NOT_IMPL(tc, err->msg); 45251876Speter return NULL; 46251876Speter } 47251876Speter if (APR_ENOTIMPL == rv) { 48251876Speter ABTS_NOT_IMPL(tc, (char *)driver); 49251876Speter return NULL; 50251876Speter } 51251876Speter ABTS_ASSERT(tc, "failed to apr_crypto_get_driver", rv == APR_SUCCESS); 52251876Speter ABTS_ASSERT(tc, "apr_crypto_get_driver returned NULL", driver != NULL); 53251876Speter if (!driver || rv) { 54251876Speter return NULL; 55251876Speter } 56251876Speter 57251876Speter return driver; 58251876Speter 59251876Speter} 60251876Speter 61251876Speterstatic const apr_crypto_driver_t *get_nss_driver(abts_case *tc, 62251876Speter apr_pool_t *pool) 63251876Speter{ 64251876Speter 65251876Speter /* initialise NSS */ 66251876Speter return get_driver(tc, pool, "nss", "dir=data"); 67251876Speter 68251876Speter} 69251876Speter 70251876Speterstatic const apr_crypto_driver_t *get_openssl_driver(abts_case *tc, 71251876Speter apr_pool_t *pool) 72251876Speter{ 73251876Speter 74251876Speter return get_driver(tc, pool, "openssl", NULL); 75251876Speter 76251876Speter} 77251876Speter 78251876Speterstatic apr_crypto_t *make(abts_case *tc, apr_pool_t *pool, 79251876Speter const apr_crypto_driver_t *driver) 80251876Speter{ 81251876Speter 82251876Speter apr_crypto_t *f = NULL; 83251876Speter 84251876Speter if (!driver) { 85251876Speter return NULL; 86251876Speter } 87251876Speter 88251876Speter /* get the context */ 89251876Speter apr_crypto_make(&f, driver, "engine=openssl", pool); 90251876Speter ABTS_ASSERT(tc, "apr_crypto_make returned NULL", f != NULL); 91251876Speter 92251876Speter return f; 93251876Speter 94251876Speter} 95251876Speter 96251876Speterstatic const apr_crypto_key_t *passphrase(abts_case *tc, apr_pool_t *pool, 97251876Speter const apr_crypto_driver_t *driver, const apr_crypto_t *f, 98251876Speter apr_crypto_block_key_type_e type, apr_crypto_block_key_mode_e mode, 99251876Speter int doPad, const char *description) 100251876Speter{ 101251876Speter 102251876Speter apr_crypto_key_t *key = NULL; 103251876Speter const apu_err_t *result = NULL; 104251876Speter const char *pass = "secret"; 105251876Speter const char *salt = "salt"; 106251876Speter apr_status_t rv; 107251876Speter 108251876Speter if (!f) { 109251876Speter return NULL; 110251876Speter } 111251876Speter 112251876Speter /* init the passphrase */ 113251876Speter rv = apr_crypto_passphrase(&key, NULL, pass, strlen(pass), 114251876Speter (unsigned char *) salt, strlen(salt), type, mode, doPad, 4096, f, 115251876Speter pool); 116251876Speter if (APR_ENOCIPHER == rv) { 117251876Speter apr_crypto_error(&result, f); 118251876Speter ABTS_NOT_IMPL(tc, apr_psprintf(pool, 119251876Speter "skipped: %s %s passphrase return APR_ENOCIPHER: error %d: %s (%s)\n", 120251876Speter description, apr_crypto_driver_name(driver), result->rc, 121251876Speter result->reason ? result->reason : "", result->msg ? result->msg : "")); 122251876Speter return NULL; 123251876Speter } 124251876Speter else { 125251876Speter if (APR_SUCCESS != rv) { 126251876Speter apr_crypto_error(&result, f); 127251876Speter fprintf(stderr, "passphrase: %s %s native error %d: %s (%s)\n", 128251876Speter description, apr_crypto_driver_name(driver), result->rc, 129251876Speter result->reason ? result->reason : "", 130251876Speter result->msg ? result->msg : ""); 131251876Speter } 132251876Speter ABTS_ASSERT(tc, "apr_crypto_passphrase returned APR_ENOKEY", rv != APR_ENOKEY); 133251876Speter ABTS_ASSERT(tc, "apr_crypto_passphrase returned APR_EPADDING", rv != APR_EPADDING); 134251876Speter ABTS_ASSERT(tc, "apr_crypto_passphrase returned APR_EKEYTYPE", rv != APR_EKEYTYPE); 135251876Speter ABTS_ASSERT(tc, "failed to apr_crypto_passphrase", rv == APR_SUCCESS); 136251876Speter ABTS_ASSERT(tc, "apr_crypto_passphrase returned NULL context", key != NULL); 137251876Speter } 138251876Speter if (rv) { 139251876Speter return NULL; 140251876Speter } 141251876Speter return key; 142251876Speter 143251876Speter} 144251876Speter 145251876Speterstatic unsigned char *encrypt_block(abts_case *tc, apr_pool_t *pool, 146251876Speter const apr_crypto_driver_t *driver, const apr_crypto_t *f, 147251876Speter const apr_crypto_key_t *key, const unsigned char *in, 148251876Speter const apr_size_t inlen, unsigned char **cipherText, 149251876Speter apr_size_t *cipherTextLen, const unsigned char **iv, 150251876Speter apr_size_t *blockSize, const char *description) 151251876Speter{ 152251876Speter 153251876Speter apr_crypto_block_t *block = NULL; 154251876Speter const apu_err_t *result = NULL; 155251876Speter apr_size_t len = 0; 156251876Speter apr_status_t rv; 157251876Speter 158251876Speter if (!driver || !f || !key || !in) { 159251876Speter return NULL; 160251876Speter } 161251876Speter 162251876Speter /* init the encryption */ 163251876Speter rv = apr_crypto_block_encrypt_init(&block, iv, key, blockSize, pool); 164251876Speter if (APR_ENOTIMPL == rv) { 165251876Speter ABTS_NOT_IMPL(tc, "apr_crypto_block_encrypt_init returned APR_ENOTIMPL"); 166251876Speter } 167251876Speter else { 168251876Speter if (APR_SUCCESS != rv) { 169251876Speter apr_crypto_error(&result, f); 170251876Speter fprintf(stderr, "encrypt_init: %s %s native error %d: %s (%s)\n", 171251876Speter description, apr_crypto_driver_name(driver), result->rc, 172251876Speter result->reason ? result->reason : "", 173251876Speter result->msg ? result->msg : ""); 174251876Speter } 175251876Speter ABTS_ASSERT(tc, "apr_crypto_block_encrypt_init returned APR_ENOKEY", rv != APR_ENOKEY); 176251876Speter ABTS_ASSERT(tc, "apr_crypto_block_encrypt_init returned APR_ENOIV", rv != APR_ENOIV); 177251876Speter ABTS_ASSERT(tc, "apr_crypto_block_encrypt_init returned APR_EKEYTYPE", rv != APR_EKEYTYPE); 178251876Speter ABTS_ASSERT(tc, "apr_crypto_block_encrypt_init returned APR_EKEYLENGTH", rv != APR_EKEYLENGTH); 179251876Speter ABTS_ASSERT(tc, "failed to apr_crypto_block_encrypt_init", rv == APR_SUCCESS); 180251876Speter ABTS_ASSERT(tc, "apr_crypto_block_encrypt_init returned NULL context", block != NULL); 181251876Speter } 182251876Speter if (!block || rv) { 183251876Speter return NULL; 184251876Speter } 185251876Speter 186251876Speter /* encrypt the block */ 187251876Speter rv = apr_crypto_block_encrypt(cipherText, cipherTextLen, in, inlen, block); 188251876Speter if (APR_SUCCESS != rv) { 189251876Speter apr_crypto_error(&result, f); 190251876Speter fprintf(stderr, "encrypt: %s %s native error %d: %s (%s)\n", 191251876Speter description, apr_crypto_driver_name(driver), result->rc, 192251876Speter result->reason ? result->reason : "", result->msg ? result->msg 193251876Speter : ""); 194251876Speter } 195251876Speter ABTS_ASSERT(tc, "apr_crypto_block_encrypt returned APR_ECRYPT", rv != APR_ECRYPT); 196251876Speter ABTS_ASSERT(tc, "failed to apr_crypto_block_encrypt", rv == APR_SUCCESS); 197251876Speter ABTS_ASSERT(tc, "apr_crypto_block_encrypt failed to allocate buffer", *cipherText != NULL); 198251876Speter if (rv) { 199251876Speter return NULL; 200251876Speter } 201251876Speter 202251876Speter /* finalise the encryption */ 203251876Speter rv = apr_crypto_block_encrypt_finish(*cipherText + *cipherTextLen, &len, 204251876Speter block); 205251876Speter if (APR_SUCCESS != rv) { 206251876Speter apr_crypto_error(&result, f); 207251876Speter fprintf(stderr, "encrypt_finish: %s %s native error %d: %s (%s)\n", 208251876Speter description, apr_crypto_driver_name(driver), result->rc, 209251876Speter result->reason ? result->reason : "", result->msg ? result->msg 210251876Speter : ""); 211251876Speter } 212251876Speter ABTS_ASSERT(tc, "apr_crypto_block_encrypt_finish returned APR_ECRYPT", rv != APR_ECRYPT); 213251876Speter ABTS_ASSERT(tc, "apr_crypto_block_encrypt_finish returned APR_EPADDING", rv != APR_EPADDING); 214251876Speter ABTS_ASSERT(tc, "failed to apr_crypto_block_encrypt_finish", rv == APR_SUCCESS); 215251876Speter *cipherTextLen += len; 216251876Speter apr_crypto_block_cleanup(block); 217251876Speter if (rv) { 218251876Speter return NULL; 219251876Speter } 220251876Speter 221251876Speter return *cipherText; 222251876Speter 223251876Speter} 224251876Speter 225251876Speterstatic unsigned char *decrypt_block(abts_case *tc, apr_pool_t *pool, 226251876Speter const apr_crypto_driver_t *driver, const apr_crypto_t *f, 227251876Speter const apr_crypto_key_t *key, unsigned char *cipherText, 228251876Speter apr_size_t cipherTextLen, unsigned char **plainText, 229251876Speter apr_size_t *plainTextLen, const unsigned char *iv, 230251876Speter apr_size_t *blockSize, const char *description) 231251876Speter{ 232251876Speter 233251876Speter apr_crypto_block_t *block = NULL; 234251876Speter const apu_err_t *result = NULL; 235251876Speter apr_size_t len = 0; 236251876Speter apr_status_t rv; 237251876Speter 238251876Speter if (!driver || !f || !key || !cipherText) { 239251876Speter return NULL; 240251876Speter } 241251876Speter 242251876Speter /* init the decryption */ 243251876Speter rv = apr_crypto_block_decrypt_init(&block, blockSize, iv, key, pool); 244251876Speter if (APR_ENOTIMPL == rv) { 245251876Speter ABTS_NOT_IMPL(tc, "apr_crypto_block_decrypt_init returned APR_ENOTIMPL"); 246251876Speter } 247251876Speter else { 248251876Speter if (APR_SUCCESS != rv) { 249251876Speter apr_crypto_error(&result, f); 250251876Speter fprintf(stderr, "decrypt_init: %s %s native error %d: %s (%s)\n", 251251876Speter description, apr_crypto_driver_name(driver), result->rc, 252251876Speter result->reason ? result->reason : "", 253251876Speter result->msg ? result->msg : ""); 254251876Speter } 255251876Speter ABTS_ASSERT(tc, "apr_crypto_block_decrypt_init returned APR_ENOKEY", rv != APR_ENOKEY); 256251876Speter ABTS_ASSERT(tc, "apr_crypto_block_decrypt_init returned APR_ENOIV", rv != APR_ENOIV); 257251876Speter ABTS_ASSERT(tc, "apr_crypto_block_decrypt_init returned APR_EKEYTYPE", rv != APR_EKEYTYPE); 258251876Speter ABTS_ASSERT(tc, "apr_crypto_block_decrypt_init returned APR_EKEYLENGTH", rv != APR_EKEYLENGTH); 259251876Speter ABTS_ASSERT(tc, "failed to apr_crypto_block_decrypt_init", rv == APR_SUCCESS); 260251876Speter ABTS_ASSERT(tc, "apr_crypto_block_decrypt_init returned NULL context", block != NULL); 261251876Speter } 262251876Speter if (!block || rv) { 263251876Speter return NULL; 264251876Speter } 265251876Speter 266251876Speter /* decrypt the block */ 267251876Speter rv = apr_crypto_block_decrypt(plainText, plainTextLen, cipherText, 268251876Speter cipherTextLen, block); 269251876Speter if (APR_SUCCESS != rv) { 270251876Speter apr_crypto_error(&result, f); 271251876Speter fprintf(stderr, "decrypt: %s %s native error %d: %s (%s)\n", 272251876Speter description, apr_crypto_driver_name(driver), result->rc, 273251876Speter result->reason ? result->reason : "", result->msg ? result->msg 274251876Speter : ""); 275251876Speter } 276251876Speter ABTS_ASSERT(tc, "apr_crypto_block_decrypt returned APR_ECRYPT", rv != APR_ECRYPT); 277251876Speter ABTS_ASSERT(tc, "failed to apr_crypto_block_decrypt", rv == APR_SUCCESS); 278251876Speter ABTS_ASSERT(tc, "apr_crypto_block_decrypt failed to allocate buffer", *plainText != NULL); 279251876Speter if (rv) { 280251876Speter return NULL; 281251876Speter } 282251876Speter 283251876Speter /* finalise the decryption */ 284251876Speter rv = apr_crypto_block_decrypt_finish(*plainText + *plainTextLen, &len, 285251876Speter block); 286251876Speter if (APR_SUCCESS != rv) { 287251876Speter apr_crypto_error(&result, f); 288251876Speter fprintf(stderr, "decrypt_finish: %s %s native error %d: %s (%s)\n", 289251876Speter description, apr_crypto_driver_name(driver), result->rc, 290251876Speter result->reason ? result->reason : "", result->msg ? result->msg 291251876Speter : ""); 292251876Speter } 293251876Speter ABTS_ASSERT(tc, "apr_crypto_block_decrypt_finish returned APR_ECRYPT", rv != APR_ECRYPT); 294251876Speter ABTS_ASSERT(tc, "apr_crypto_block_decrypt_finish returned APR_EPADDING", rv != APR_EPADDING); 295251876Speter ABTS_ASSERT(tc, "failed to apr_crypto_block_decrypt_finish", rv == APR_SUCCESS); 296251876Speter if (rv) { 297251876Speter return NULL; 298251876Speter } 299251876Speter 300251876Speter *plainTextLen += len; 301251876Speter apr_crypto_block_cleanup(block); 302251876Speter 303251876Speter return *plainText; 304251876Speter 305251876Speter} 306251876Speter 307251876Speter/** 308251876Speter * Interoperability test. 309251876Speter * 310251876Speter * data must point at an array of two driver structures. Data will be encrypted 311251876Speter * with the first driver, and decrypted with the second. 312251876Speter * 313251876Speter * If the two drivers interoperate, the test passes. 314251876Speter */ 315251876Speterstatic void crypto_block_cross(abts_case *tc, apr_pool_t *pool, 316251876Speter const apr_crypto_driver_t **drivers, 317251876Speter const apr_crypto_block_key_type_e type, 318251876Speter const apr_crypto_block_key_mode_e mode, int doPad, 319251876Speter const unsigned char *in, apr_size_t inlen, const char *description) 320251876Speter{ 321251876Speter const apr_crypto_driver_t *driver1 = drivers[0]; 322251876Speter const apr_crypto_driver_t *driver2 = drivers[1]; 323251876Speter apr_crypto_t *f1 = NULL; 324251876Speter apr_crypto_t *f2 = NULL; 325251876Speter const apr_crypto_key_t *key1 = NULL; 326251876Speter const apr_crypto_key_t *key2 = NULL; 327251876Speter 328251876Speter unsigned char *cipherText = NULL; 329251876Speter apr_size_t cipherTextLen = 0; 330251876Speter unsigned char *plainText = NULL; 331251876Speter apr_size_t plainTextLen = 0; 332251876Speter const unsigned char *iv = NULL; 333251876Speter apr_size_t blockSize = 0; 334251876Speter 335251876Speter f1 = make(tc, pool, driver1); 336251876Speter f2 = make(tc, pool, driver2); 337251876Speter key1 = passphrase(tc, pool, driver1, f1, type, mode, doPad, description); 338251876Speter key2 = passphrase(tc, pool, driver2, f2, type, mode, doPad, description); 339251876Speter 340251876Speter cipherText = encrypt_block(tc, pool, driver1, f1, key1, in, inlen, 341251876Speter &cipherText, &cipherTextLen, &iv, &blockSize, description); 342251876Speter plainText = decrypt_block(tc, pool, driver2, f2, key2, cipherText, 343251876Speter cipherTextLen, &plainText, &plainTextLen, iv, &blockSize, 344251876Speter description); 345251876Speter 346251876Speter if (cipherText && plainText) { 347251876Speter if (memcmp(in, plainText, inlen)) { 348251876Speter fprintf(stderr, "cross mismatch: %s %s/%s\n", description, 349251876Speter apr_crypto_driver_name(driver1), apr_crypto_driver_name( 350251876Speter driver2)); 351251876Speter } 352251876Speter ABTS_STR_EQUAL(tc, (char *)in, (char *)plainText); 353251876Speter } 354251876Speter 355251876Speter} 356251876Speter 357251876Speter/** 358251876Speter * Test initialisation. 359251876Speter */ 360251876Speterstatic void test_crypto_init(abts_case *tc, void *data) 361251876Speter{ 362251876Speter apr_pool_t *pool = NULL; 363251876Speter apr_status_t rv; 364251876Speter 365251876Speter apr_pool_create(&pool, NULL); 366251876Speter 367251876Speter rv = apr_crypto_init(pool); 368251876Speter ABTS_ASSERT(tc, "failed to init apr_crypto", rv == APR_SUCCESS); 369251876Speter 370251876Speter apr_pool_destroy(pool); 371251876Speter 372251876Speter} 373251876Speter 374251876Speter/** 375251876Speter * Simple test of OpenSSL block crypt. 376251876Speter */ 377251876Speterstatic void test_crypto_block_openssl(abts_case *tc, void *data) 378251876Speter{ 379251876Speter apr_pool_t *pool = NULL; 380251876Speter const apr_crypto_driver_t *drivers[] = { NULL, NULL }; 381251876Speter 382251876Speter const unsigned char *in = (const unsigned char *) ALIGNED_STRING; 383251876Speter apr_size_t inlen = sizeof(ALIGNED_STRING); 384251876Speter 385251876Speter apr_pool_create(&pool, NULL); 386251876Speter drivers[0] = get_openssl_driver(tc, pool); 387251876Speter drivers[1] = get_openssl_driver(tc, pool); 388251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 0, 389251876Speter in, inlen, "KEY_3DES_192/MODE_CBC"); 390251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_ECB, 0, 391251876Speter in, inlen, "KEY_3DES_192/MODE_ECB"); 392251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 0, in, 393251876Speter inlen, "KEY_AES_256/MODE_CBC"); 394251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 0, in, 395251876Speter inlen, "KEY_AES_256/MODE_ECB"); 396251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 0, in, 397251876Speter inlen, "KEY_AES_192/MODE_CBC"); 398251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 0, in, 399251876Speter inlen, "KEY_AES_192/MODE_ECB"); 400251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 0, in, 401251876Speter inlen, "KEY_AES_128/MODE_CBC"); 402251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 0, in, 403251876Speter inlen, "KEY_AES_128/MODE_ECB"); 404251876Speter apr_pool_destroy(pool); 405251876Speter 406251876Speter} 407251876Speter 408251876Speter/** 409251876Speter * Simple test of NSS block crypt. 410251876Speter */ 411251876Speterstatic void test_crypto_block_nss(abts_case *tc, void *data) 412251876Speter{ 413251876Speter apr_pool_t *pool = NULL; 414251876Speter const apr_crypto_driver_t *drivers[] = { NULL, NULL }; 415251876Speter 416251876Speter const unsigned char *in = (const unsigned char *) ALIGNED_STRING; 417251876Speter apr_size_t inlen = sizeof(ALIGNED_STRING); 418251876Speter 419251876Speter apr_pool_create(&pool, NULL); 420251876Speter drivers[0] = get_nss_driver(tc, pool); 421251876Speter drivers[1] = get_nss_driver(tc, pool); 422251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 0, 423251876Speter in, inlen, "KEY_3DES_192/MODE_CBC"); 424251876Speter /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */ 425251876Speter /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 0, in, inlen, "KEY_3DES_192/MODE_ECB"); */ 426251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 0, in, 427251876Speter inlen, "KEY_AES_256/MODE_CBC"); 428251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 0, in, 429251876Speter inlen, "KEY_AES_256/MODE_ECB"); 430251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 0, in, 431251876Speter inlen, "KEY_AES_192/MODE_CBC"); 432251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 0, in, 433251876Speter inlen, "KEY_AES_192/MODE_ECB"); 434251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 0, in, 435251876Speter inlen, "KEY_AES_128/MODE_CBC"); 436251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 0, in, 437251876Speter inlen, "KEY_AES_128/MODE_ECB"); 438251876Speter apr_pool_destroy(pool); 439251876Speter 440251876Speter} 441251876Speter 442251876Speter/** 443251876Speter * Encrypt NSS, decrypt OpenSSL. 444251876Speter */ 445251876Speterstatic void test_crypto_block_nss_openssl(abts_case *tc, void *data) 446251876Speter{ 447251876Speter apr_pool_t *pool = NULL; 448251876Speter const apr_crypto_driver_t *drivers[] = { NULL, NULL }; 449251876Speter 450251876Speter const unsigned char *in = (const unsigned char *) ALIGNED_STRING; 451251876Speter apr_size_t inlen = sizeof(ALIGNED_STRING); 452251876Speter 453251876Speter apr_pool_create(&pool, NULL); 454251876Speter drivers[0] = get_nss_driver(tc, pool); 455251876Speter drivers[1] = get_openssl_driver(tc, pool); 456251876Speter 457251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 0, 458251876Speter in, inlen, "KEY_3DES_192/MODE_CBC"); 459251876Speter 460251876Speter /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */ 461251876Speter /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 0, in, inlen, "KEY_3DES_192/MODE_ECB"); */ 462251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 0, in, 463251876Speter inlen, "KEY_AES_256/MODE_CBC"); 464251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 0, in, 465251876Speter inlen, "KEY_AES_256/MODE_ECB"); 466251876Speter 467251876Speter /* all 4 of these tests fail to interoperate - a clue from the xml-security code is that 468251876Speter * NSS cannot distinguish between the 128 and 192 bit versions of AES. Will need to be 469251876Speter * investigated. 470251876Speter */ 471251876Speter /* 472251876Speter crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_CBC, 0, in, inlen, "KEY_AES_192/MODE_CBC"); 473251876Speter crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_ECB, 0, in, inlen, "KEY_AES_192/MODE_ECB"); 474251876Speter crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_CBC, 0, in, inlen, "KEY_AES_128/MODE_CBC"); 475251876Speter crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_ECB, 0, in, inlen, "KEY_AES_128/MODE_ECB"); 476251876Speter */ 477251876Speter apr_pool_destroy(pool); 478251876Speter 479251876Speter} 480251876Speter 481251876Speter/** 482251876Speter * Encrypt OpenSSL, decrypt NSS. 483251876Speter */ 484251876Speterstatic void test_crypto_block_openssl_nss(abts_case *tc, void *data) 485251876Speter{ 486251876Speter apr_pool_t *pool = NULL; 487251876Speter const apr_crypto_driver_t *drivers[] = { NULL, NULL }; 488251876Speter 489251876Speter const unsigned char *in = (const unsigned char *) ALIGNED_STRING; 490251876Speter apr_size_t inlen = sizeof(ALIGNED_STRING); 491251876Speter 492251876Speter apr_pool_create(&pool, NULL); 493251876Speter drivers[0] = get_openssl_driver(tc, pool); 494251876Speter drivers[1] = get_nss_driver(tc, pool); 495251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 0, 496251876Speter in, inlen, "KEY_3DES_192/MODE_CBC"); 497251876Speter 498251876Speter /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */ 499251876Speter /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 0, in, inlen, "KEY_3DES_192/MODE_ECB"); */ 500251876Speter 501251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 0, in, 502251876Speter inlen, "KEY_AES_256/MODE_CBC"); 503251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 0, in, 504251876Speter inlen, "KEY_AES_256/MODE_ECB"); 505251876Speter 506251876Speter /* all 4 of these tests fail to interoperate - a clue from the xml-security code is that 507251876Speter * NSS cannot distinguish between the 128 and 192 bit versions of AES. Will need to be 508251876Speter * investigated. 509251876Speter */ 510251876Speter /* 511251876Speter crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_CBC, 0, in, inlen, "KEY_AES_192/MODE_CBC"); 512251876Speter crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_ECB, 0, in, inlen, "KEY_AES_192/MODE_ECB"); 513251876Speter crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_CBC, 0, in, inlen, "KEY_AES_128/MODE_CBC"); 514251876Speter crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_ECB, 0, in, inlen, "KEY_AES_128/MODE_ECB"); 515251876Speter */ 516251876Speter apr_pool_destroy(pool); 517251876Speter 518251876Speter} 519251876Speter 520251876Speter/** 521251876Speter * Simple test of OpenSSL block crypt. 522251876Speter */ 523251876Speterstatic void test_crypto_block_openssl_pad(abts_case *tc, void *data) 524251876Speter{ 525251876Speter apr_pool_t *pool = NULL; 526251876Speter const apr_crypto_driver_t *drivers[] = { NULL, NULL }; 527251876Speter 528251876Speter const unsigned char *in = (const unsigned char *) TEST_STRING; 529251876Speter apr_size_t inlen = sizeof(TEST_STRING); 530251876Speter 531251876Speter apr_pool_create(&pool, NULL); 532251876Speter drivers[0] = get_openssl_driver(tc, pool); 533251876Speter drivers[1] = get_openssl_driver(tc, pool); 534251876Speter 535251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 1, 536251876Speter in, inlen, "KEY_3DES_192/MODE_CBC"); 537251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_ECB, 1, 538251876Speter in, inlen, "KEY_3DES_192/MODE_ECB"); 539251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in, 540251876Speter inlen, "KEY_AES_256/MODE_CBC"); 541251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 1, in, 542251876Speter inlen, "KEY_AES_256/MODE_ECB"); 543251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 1, in, 544251876Speter inlen, "KEY_AES_192/MODE_CBC"); 545251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 1, in, 546251876Speter inlen, "KEY_AES_192/MODE_ECB"); 547251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 1, in, 548251876Speter inlen, "KEY_AES_128/MODE_CBC"); 549251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 1, in, 550251876Speter inlen, "KEY_AES_128/MODE_ECB"); 551251876Speter 552251876Speter apr_pool_destroy(pool); 553251876Speter 554251876Speter} 555251876Speter 556251876Speter/** 557251876Speter * Simple test of NSS block crypt. 558251876Speter */ 559251876Speterstatic void test_crypto_block_nss_pad(abts_case *tc, void *data) 560251876Speter{ 561251876Speter apr_pool_t *pool = NULL; 562251876Speter const apr_crypto_driver_t *drivers[] = 563251876Speter { NULL, NULL }; 564251876Speter 565251876Speter const unsigned char *in = (const unsigned char *) TEST_STRING; 566251876Speter apr_size_t inlen = sizeof(TEST_STRING); 567251876Speter 568251876Speter apr_pool_create(&pool, NULL); 569251876Speter drivers[0] = get_nss_driver(tc, pool); 570251876Speter drivers[1] = get_nss_driver(tc, pool); 571251876Speter 572251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 1, 573251876Speter in, inlen, "KEY_3DES_192/MODE_CBC"); 574251876Speter /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */ 575251876Speter /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 1, in, inlen, "KEY_3DES_192/MODE_ECB"); */ 576251876Speter 577251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in, 578251876Speter inlen, "KEY_AES_256/MODE_CBC"); 579251876Speter 580251876Speter /* KEY_AES_256 / MODE_ECB doesn't support padding on NSS */ 581251876Speter /*crypto_block_cross(tc, pool, drivers, KEY_AES_256, MODE_ECB, 1, in, inlen, "KEY_AES_256/MODE_ECB");*/ 582251876Speter 583251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 1, in, 584251876Speter inlen, "KEY_AES_192/MODE_CBC"); 585251876Speter 586251876Speter /* KEY_AES_256 / MODE_ECB doesn't support padding on NSS */ 587251876Speter /*crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_ECB, 1, in, inlen, "KEY_AES_192/MODE_ECB");*/ 588251876Speter 589251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 1, in, 590251876Speter inlen, "KEY_AES_128/MODE_CBC"); 591251876Speter 592251876Speter /* KEY_AES_256 / MODE_ECB doesn't support padding on NSS */ 593251876Speter /*crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_ECB, 1, in, inlen, "KEY_AES_128/MODE_ECB");*/ 594251876Speter 595251876Speter apr_pool_destroy(pool); 596251876Speter 597251876Speter} 598251876Speter 599251876Speter/** 600251876Speter * Encrypt NSS, decrypt OpenSSL. 601251876Speter */ 602251876Speterstatic void test_crypto_block_nss_openssl_pad(abts_case *tc, void *data) 603251876Speter{ 604251876Speter apr_pool_t *pool = NULL; 605251876Speter const apr_crypto_driver_t *drivers[] = { NULL, NULL }; 606251876Speter 607251876Speter const unsigned char *in = (const unsigned char *) TEST_STRING; 608251876Speter apr_size_t inlen = sizeof(TEST_STRING); 609251876Speter 610251876Speter apr_pool_create(&pool, NULL); 611251876Speter drivers[0] = get_nss_driver(tc, pool); 612251876Speter drivers[1] = get_openssl_driver(tc, pool); 613251876Speter 614251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 1, 615251876Speter in, inlen, "KEY_3DES_192/MODE_CBC"); 616251876Speter 617251876Speter /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */ 618251876Speter /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 1, in, inlen, "KEY_3DES_192/MODE_ECB"); */ 619251876Speter 620251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in, 621251876Speter inlen, "KEY_AES_256/MODE_CBC"); 622251876Speter 623251876Speter /* KEY_AES_256 / MODE_ECB doesn't support padding on NSS */ 624251876Speter /*crypto_block_cross(tc, pool, drivers, KEY_AES_256, MODE_ECB, 1, in, inlen, "KEY_AES_256/MODE_ECB");*/ 625251876Speter 626251876Speter /* all 4 of these tests fail to interoperate - a clue from the xml-security code is that 627251876Speter * NSS cannot distinguish between the 128 and 192 bit versions of AES. Will need to be 628251876Speter * investigated. 629251876Speter */ 630251876Speter /* 631251876Speter crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_CBC, 1, in, inlen, "KEY_AES_192/MODE_CBC"); 632251876Speter crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_ECB, 1, in, inlen, "KEY_AES_192/MODE_ECB"); 633251876Speter crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_CBC, 1, in, inlen, "KEY_AES_128/MODE_CBC"); 634251876Speter crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_ECB, 1, in, inlen, "KEY_AES_128/MODE_ECB"); 635251876Speter */ 636251876Speter apr_pool_destroy(pool); 637251876Speter 638251876Speter} 639251876Speter 640251876Speter/** 641251876Speter * Encrypt OpenSSL, decrypt NSS. 642251876Speter */ 643251876Speterstatic void test_crypto_block_openssl_nss_pad(abts_case *tc, void *data) 644251876Speter{ 645251876Speter apr_pool_t *pool = NULL; 646251876Speter const apr_crypto_driver_t *drivers[] = { NULL, NULL }; 647251876Speter 648251876Speter const unsigned char *in = (const unsigned char *) TEST_STRING; 649251876Speter apr_size_t inlen = sizeof(TEST_STRING); 650251876Speter 651251876Speter apr_pool_create(&pool, NULL); 652251876Speter drivers[0] = get_openssl_driver(tc, pool); 653251876Speter drivers[1] = get_nss_driver(tc, pool); 654251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 1, 655251876Speter in, inlen, "KEY_3DES_192/MODE_CBC"); 656251876Speter 657251876Speter /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */ 658251876Speter /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 1, in, inlen, "KEY_3DES_192/MODE_ECB"); */ 659251876Speter 660251876Speter crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in, 661251876Speter inlen, "KEY_AES_256/MODE_CBC"); 662251876Speter 663251876Speter /* KEY_AES_256 / MODE_ECB doesn't support padding on NSS */ 664251876Speter /*crypto_block_cross(tc, pool, drivers, KEY_AES_256, MODE_ECB, 1, in, inlen, "KEY_AES_256/MODE_ECB");*/ 665251876Speter 666251876Speter /* all 4 of these tests fail to interoperate - a clue from the xml-security code is that 667251876Speter * NSS cannot distinguish between the 128 and 192 bit versions of AES. Will need to be 668251876Speter * investigated. 669251876Speter */ 670251876Speter /* 671251876Speter crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_CBC, 1, in, inlen, "KEY_AES_192/MODE_CBC"); 672251876Speter crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_ECB, 1, in, inlen, "KEY_AES_192/MODE_ECB"); 673251876Speter crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_CBC, 1, in, inlen, "KEY_AES_128/MODE_CBC"); 674251876Speter crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_ECB, 1, in, inlen, "KEY_AES_128/MODE_ECB"); 675251876Speter */ 676251876Speter apr_pool_destroy(pool); 677251876Speter 678251876Speter} 679251876Speter 680251876Speter/** 681251876Speter * Get Types, OpenSSL. 682251876Speter */ 683251876Speterstatic void test_crypto_get_block_key_types_openssl(abts_case *tc, void *data) 684251876Speter{ 685251876Speter apr_pool_t *pool = NULL; 686251876Speter const apr_crypto_driver_t *driver; 687251876Speter apr_crypto_t *f; 688251876Speter apr_hash_t *types; 689251876Speter int *key_3des_192; 690251876Speter int *key_aes_128; 691251876Speter int *key_aes_192; 692251876Speter int *key_aes_256; 693251876Speter 694251876Speter apr_pool_create(&pool, NULL); 695251876Speter driver = get_openssl_driver(tc, pool); 696251876Speter if (driver) { 697251876Speter 698251876Speter f = make(tc, pool, driver); 699251876Speter apr_crypto_get_block_key_types(&types, f); 700251876Speter 701251876Speter key_3des_192 = apr_hash_get(types, "3des192", APR_HASH_KEY_STRING); 702251876Speter ABTS_PTR_NOTNULL(tc, key_3des_192); 703251876Speter ABTS_INT_EQUAL(tc, *key_3des_192, APR_KEY_3DES_192); 704251876Speter 705251876Speter key_aes_128 = apr_hash_get(types, "aes128", APR_HASH_KEY_STRING); 706251876Speter ABTS_PTR_NOTNULL(tc, key_aes_128); 707251876Speter ABTS_INT_EQUAL(tc, *key_aes_128, APR_KEY_AES_128); 708251876Speter 709251876Speter key_aes_192 = apr_hash_get(types, "aes192", APR_HASH_KEY_STRING); 710251876Speter ABTS_PTR_NOTNULL(tc, key_aes_192); 711251876Speter ABTS_INT_EQUAL(tc, *key_aes_192, APR_KEY_AES_192); 712251876Speter 713251876Speter key_aes_256 = apr_hash_get(types, "aes256", APR_HASH_KEY_STRING); 714251876Speter ABTS_PTR_NOTNULL(tc, key_aes_256); 715251876Speter ABTS_INT_EQUAL(tc, *key_aes_256, APR_KEY_AES_256); 716251876Speter 717251876Speter } 718251876Speter 719251876Speter apr_pool_destroy(pool); 720251876Speter 721251876Speter} 722251876Speter 723251876Speter/** 724251876Speter * Get Types, NSS. 725251876Speter */ 726251876Speterstatic void test_crypto_get_block_key_types_nss(abts_case *tc, void *data) 727251876Speter{ 728251876Speter apr_pool_t *pool = NULL; 729251876Speter const apr_crypto_driver_t *driver; 730251876Speter apr_crypto_t *f; 731251876Speter apr_hash_t *types; 732251876Speter int *key_3des_192; 733251876Speter int *key_aes_128; 734251876Speter int *key_aes_192; 735251876Speter int *key_aes_256; 736251876Speter 737251876Speter apr_pool_create(&pool, NULL); 738251876Speter driver = get_nss_driver(tc, pool); 739251876Speter if (driver) { 740251876Speter 741251876Speter f = make(tc, pool, driver); 742251876Speter apr_crypto_get_block_key_types(&types, f); 743251876Speter 744251876Speter key_3des_192 = apr_hash_get(types, "3des192", APR_HASH_KEY_STRING); 745251876Speter ABTS_PTR_NOTNULL(tc, key_3des_192); 746251876Speter ABTS_INT_EQUAL(tc, *key_3des_192, APR_KEY_3DES_192); 747251876Speter 748251876Speter key_aes_128 = apr_hash_get(types, "aes128", APR_HASH_KEY_STRING); 749251876Speter ABTS_PTR_NOTNULL(tc, key_aes_128); 750251876Speter ABTS_INT_EQUAL(tc, *key_aes_128, APR_KEY_AES_128); 751251876Speter 752251876Speter key_aes_192 = apr_hash_get(types, "aes192", APR_HASH_KEY_STRING); 753251876Speter ABTS_PTR_NOTNULL(tc, key_aes_192); 754251876Speter ABTS_INT_EQUAL(tc, *key_aes_192, APR_KEY_AES_192); 755251876Speter 756251876Speter key_aes_256 = apr_hash_get(types, "aes256", APR_HASH_KEY_STRING); 757251876Speter ABTS_PTR_NOTNULL(tc, key_aes_256); 758251876Speter ABTS_INT_EQUAL(tc, *key_aes_256, APR_KEY_AES_256); 759251876Speter 760251876Speter } 761251876Speter 762251876Speter apr_pool_destroy(pool); 763251876Speter 764251876Speter} 765251876Speter 766251876Speter/** 767251876Speter * Get Modes, OpenSSL. 768251876Speter */ 769251876Speterstatic void test_crypto_get_block_key_modes_openssl(abts_case *tc, void *data) 770251876Speter{ 771251876Speter apr_pool_t *pool = NULL; 772251876Speter const apr_crypto_driver_t *driver; 773251876Speter apr_crypto_t *f; 774251876Speter apr_hash_t *modes; 775251876Speter int *mode_ecb; 776251876Speter int *mode_cbc; 777251876Speter 778251876Speter apr_pool_create(&pool, NULL); 779251876Speter driver = get_openssl_driver(tc, pool); 780251876Speter if (driver) { 781251876Speter 782251876Speter f = make(tc, pool, driver); 783251876Speter apr_crypto_get_block_key_modes(&modes, f); 784251876Speter 785251876Speter mode_ecb = apr_hash_get(modes, "ecb", APR_HASH_KEY_STRING); 786251876Speter ABTS_PTR_NOTNULL(tc, mode_ecb); 787251876Speter ABTS_INT_EQUAL(tc, *mode_ecb, APR_MODE_ECB); 788251876Speter 789251876Speter mode_cbc = apr_hash_get(modes, "cbc", APR_HASH_KEY_STRING); 790251876Speter ABTS_PTR_NOTNULL(tc, mode_cbc); 791251876Speter ABTS_INT_EQUAL(tc, *mode_cbc, APR_MODE_CBC); 792251876Speter 793251876Speter } 794251876Speter 795251876Speter apr_pool_destroy(pool); 796251876Speter 797251876Speter} 798251876Speter 799251876Speter/** 800251876Speter * Get Modes, NSS. 801251876Speter */ 802251876Speterstatic void test_crypto_get_block_key_modes_nss(abts_case *tc, void *data) 803251876Speter{ 804251876Speter apr_pool_t *pool = NULL; 805251876Speter const apr_crypto_driver_t *driver; 806251876Speter apr_crypto_t *f; 807251876Speter apr_hash_t *modes; 808251876Speter int *mode_ecb; 809251876Speter int *mode_cbc; 810251876Speter 811251876Speter apr_pool_create(&pool, NULL); 812251876Speter driver = get_nss_driver(tc, pool); 813251876Speter if (driver) { 814251876Speter 815251876Speter f = make(tc, pool, driver); 816251876Speter apr_crypto_get_block_key_modes(&modes, f); 817251876Speter 818251876Speter mode_ecb = apr_hash_get(modes, "ecb", APR_HASH_KEY_STRING); 819251876Speter ABTS_PTR_NOTNULL(tc, mode_ecb); 820251876Speter ABTS_INT_EQUAL(tc, *mode_ecb, APR_MODE_ECB); 821251876Speter 822251876Speter mode_cbc = apr_hash_get(modes, "cbc", APR_HASH_KEY_STRING); 823251876Speter ABTS_PTR_NOTNULL(tc, mode_cbc); 824251876Speter ABTS_INT_EQUAL(tc, *mode_cbc, APR_MODE_CBC); 825251876Speter 826251876Speter } 827251876Speter 828251876Speter apr_pool_destroy(pool); 829251876Speter 830251876Speter} 831251876Speter 832251876Speterabts_suite *testcrypto(abts_suite *suite) 833251876Speter{ 834251876Speter suite = ADD_SUITE(suite); 835251876Speter 836251876Speter /* test simple init and shutdown */ 837251876Speter abts_run_test(suite, test_crypto_init, NULL); 838251876Speter 839251876Speter /* test a simple encrypt / decrypt operation - openssl */ 840251876Speter abts_run_test(suite, test_crypto_block_openssl, NULL); 841251876Speter 842251876Speter /* test a padded encrypt / decrypt operation - openssl */ 843251876Speter abts_run_test(suite, test_crypto_block_openssl_pad, NULL); 844251876Speter 845251876Speter /* test a simple encrypt / decrypt operation - nss */ 846251876Speter abts_run_test(suite, test_crypto_block_nss, NULL); 847251876Speter 848251876Speter /* test a padded encrypt / decrypt operation - nss */ 849251876Speter abts_run_test(suite, test_crypto_block_nss_pad, NULL); 850251876Speter 851251876Speter /* test encrypt nss / decrypt openssl */ 852251876Speter abts_run_test(suite, test_crypto_block_nss_openssl, NULL); 853251876Speter 854251876Speter /* test padded encrypt nss / decrypt openssl */ 855251876Speter abts_run_test(suite, test_crypto_block_nss_openssl_pad, NULL); 856251876Speter 857251876Speter /* test encrypt openssl / decrypt nss */ 858251876Speter abts_run_test(suite, test_crypto_block_openssl_nss, NULL); 859251876Speter 860251876Speter /* test padded encrypt openssl / decrypt nss */ 861251876Speter abts_run_test(suite, test_crypto_block_openssl_nss_pad, NULL); 862251876Speter 863251876Speter /* test block key types openssl */ 864251876Speter abts_run_test(suite, test_crypto_get_block_key_types_openssl, NULL); 865251876Speter 866251876Speter /* test block key types nss */ 867251876Speter abts_run_test(suite, test_crypto_get_block_key_types_nss, NULL); 868251876Speter 869251876Speter /* test block key modes openssl */ 870251876Speter abts_run_test(suite, test_crypto_get_block_key_modes_openssl, NULL); 871251876Speter 872251876Speter /* test block key modes nss */ 873251876Speter abts_run_test(suite, test_crypto_get_block_key_modes_nss, NULL); 874251876Speter 875251876Speter return suite; 876251876Speter} 877251876Speter 878251876Speter#else 879251876Speter 880251876Speter/** 881251876Speter * Dummy test suite when crypto is turned off. 882251876Speter */ 883251876Speterabts_suite *testcrypto(abts_suite *suite) 884251876Speter{ 885251876Speter return ADD_SUITE(suite); 886251876Speter} 887251876Speter 888251876Speter#endif /* APU_HAVE_CRYPTO */ 889