Apache HTTPD
testcrypto.c
Go to the documentation of this file.
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
1540abts_suite *testcrypto(abts_suite *suite)
1541{
1542 return ADD_SUITE(suite);
1543}
1544
1545#endif /* APU_HAVE_CRYPTO */
len
const char apr_size_t len
Definition ap_regex.h:187
abts_run_test
void abts_run_test(abts_suite *ts, test_func f, void *value)
Definition abts.c:175
ADD_SUITE
#define ADD_SUITE(suite)
Definition abts.h:67
ABTS_PTR_NOTNULL
#define ABTS_PTR_NOTNULL(a, b)
Definition abts.h:125
ABTS_NOT_IMPL
#define ABTS_NOT_IMPL(a, b)
Definition abts.h:129
ABTS_STR_EQUAL
#define ABTS_STR_EQUAL(a, b, c)
Definition abts.h:123
ABTS_ASSERT
#define ABTS_ASSERT(a, b, c)
Definition abts.h:130
ABTS_INT_EQUAL
#define ABTS_INT_EQUAL(a, b, c)
Definition abts.h:109
apr_crypto.h
APR-UTIL Crypto library.
drivers
static apr_hash_t * drivers
Definition apr_dbd.c:36
apr_dso.h
APR Dynamic Object Handling Routines.
apr_pools.h
APR memory allocation.
f2
#define f2(x, y, z)
Definition apr_sha1.c:64
f1
#define f1(x, y, z)
Definition apr_sha1.c:63
d
apr_size_t const unsigned char unsigned int unsigned int d
Definition apr_siphash.h:72
apr_strings.h
APR Strings library.
apu_errno.h
APR-Util Error Codes.
buf
const unsigned char * buf
Definition util_md5.h:50
APR_ENOTIMPL
#define APR_ENOTIMPL
Definition apr_errno.h:476
APR_ENOTENOUGHENTROPY
#define APR_ENOTENOUGHENTROPY
Definition apr_errno.h:340
APR_EDSOOPEN
#define APR_EDSOOPEN
Definition apr_errno.h:322
salt
const char * salt
Definition apr_md5.h:139
f
apr_file_t * f
Definition apr_buckets.h:927
driver
const char const apr_dbd_driver_t ** driver
Definition apr_dbd.h:106
mode
apr_dbd_transaction_t int mode
Definition apr_dbd.h:261
params
apr_pool_t const char * params
Definition apr_dbd.h:141
APR_ENOIV
#define APR_ENOIV
Definition apu_errno.h:65
APR_ECRYPT
#define APR_ECRYPT
Definition apu_errno.h:71
APR_EKEYTYPE
#define APR_EKEYTYPE
Definition apu_errno.h:67
APR_ENOCIPHER
#define APR_ENOCIPHER
Definition apu_errno.h:77
APR_EKEYLENGTH
#define APR_EKEYLENGTH
Definition apu_errno.h:75
APR_ENOKEY
#define APR_ENOKEY
Definition apu_errno.h:63
APR_EPADDING
#define APR_EPADDING
Definition apu_errno.h:73
APR_ENOSPACE
#define APR_ENOSPACE
Definition apu_errno.h:69
size
apr_size_t size
Definition apr_allocator.h:115
pool
const char int apr_pool_t * pool
Definition apr_cstr.h:84
APR_SUCCESS
#define APR_SUCCESS
Definition apr_errno.h:225
apr_status_t
int apr_status_t
Definition apr_errno.h:44
key
const char * key
Definition apr_file_io.h:822
data
void * data
Definition apr_file_io.h:832
type
int type
Definition apr_file_io.h:798
result
apr_array_header_t ** result
Definition apr_fnmatch.h:144
APR_HASH_KEY_STRING
#define APR_HASH_KEY_STRING
Definition apr_hash.h:47
rec
void * rec
Definition apr_hash.h:270
c
apr_vformatter_buff_t * c
Definition apr_lib.h:175
apr_pool_create
#define apr_pool_create(newpool, parent)
Definition apr_pools.h:322
apr_pcalloc
#define apr_pcalloc(p, size)
Definition apr_pools.h:465
s
const char * s
Definition apr_strings.h:95
err
apr_int32_t apr_int32_t apr_int32_t err
Definition apr_thread_proc.h:418
in
apr_int32_t in
Definition apr_thread_proc.h:417
p
apr_pool_t * p
Definition md_event.c:32
types
static const char *const types[]
Definition mod_mime_magic.c:260
NULL
return NULL
Definition mod_so.c:359
i
int i
Definition mod_so.c:347
name
char * name
Definition ssl_engine_vars.c:563
abts_case
Definition abts.h:58
abts_suite
Definition abts.h:52
apr_hash_t
Definition apr_hash.c:75
apr_pool_t
Definition apr_pools.c:562
apu_err_t
Definition apu_errno.h:161
testcrypto
abts_suite * testcrypto(abts_suite *suite)
Definition testcrypto.c:1540
int
typedef int(WSAAPI *apr_winapi_fpt_WSAPoll)(IN OUT LPWSAPOLLFD fdArray
Generated by doxygen 1.9.8