Deleted Added
sdiff udiff text old ( 302408 ) new ( 362181 )
full compact
testcrypto.c (302408) testcrypto.c (362181)
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

--- 19 unchanged lines hidden (view full) ---

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;
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

--- 19 unchanged lines hidden (view full) ---

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 *err = 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
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, &err, pool);
43 if (APR_SUCCESS != rv && err) {
44 ABTS_NOT_IMPL(tc, err->msg);
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));
45 return NULL;
46 }
46 return NULL;
47 }
47 if (APR_ENOTIMPL == rv) {
48 ABTS_NOT_IMPL(tc, (char *)driver);
48 if (APR_EDSOOPEN == rv) {
49 ABTS_NOT_IMPL(tc,
50 apr_psprintf(pool, "Crypto driver '%s' DSO could not be opened", (char *)name));
49 return NULL;
50 }
51 return NULL;
52 }
51 ABTS_ASSERT(tc, "failed to apr_crypto_get_driver", rv == APR_SUCCESS);
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);
52 ABTS_ASSERT(tc, "apr_crypto_get_driver returned NULL", driver != NULL);
53 if (!driver || rv) {
54 return NULL;
55 }
56
57 return driver;
58
59}
60
61static const apr_crypto_driver_t *get_nss_driver(abts_case *tc,
62 apr_pool_t *pool)
63{
64
65 /* initialise NSS */
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 */
66 return get_driver(tc, pool, "nss", "dir=data");
76 return get_driver(tc, pool, "nss", "");
67
68}
69
70static const apr_crypto_driver_t *get_openssl_driver(abts_case *tc,
71 apr_pool_t *pool)
72{
73
74 return get_driver(tc, pool, "openssl", NULL);
75
76}
77
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
78static apr_crypto_t *make(abts_case *tc, apr_pool_t *pool,
79 const apr_crypto_driver_t *driver)
80{
81
82 apr_crypto_t *f = NULL;
83
84 if (!driver) {
85 return NULL;
86 }
87
88 /* get the context */
89 apr_crypto_make(&f, driver, "engine=openssl", pool);
90 ABTS_ASSERT(tc, "apr_crypto_make returned NULL", f != NULL);
91
92 return f;
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
96static const apr_crypto_key_t *passphrase(abts_case *tc, apr_pool_t *pool,
97 const apr_crypto_driver_t *driver, const apr_crypto_t *f,
98 apr_crypto_block_key_type_e type, apr_crypto_block_key_mode_e mode,
99 int doPad, const char *description)
100{
101
102 apr_crypto_key_t *key = NULL;
103 const apu_err_t *result = NULL;

--- 15 unchanged lines hidden (view full) ---

119 "skipped: %s %s passphrase return APR_ENOCIPHER: error %d: %s (%s)\n",
120 description, apr_crypto_driver_name(driver), result->rc,
121 result->reason ? result->reason : "", result->msg ? result->msg : ""));
122 return NULL;
123 }
124 else {
125 if (APR_SUCCESS != rv) {
126 apr_crypto_error(&result, f);
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;

--- 15 unchanged lines hidden (view full) ---

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);
127 fprintf(stderr, "passphrase: %s %s native error %d: %s (%s)\n",
128 description, apr_crypto_driver_name(driver), result->rc,
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,
129 result->reason ? result->reason : "",
130 result->msg ? result->msg : "");
131 }
132 ABTS_ASSERT(tc, "apr_crypto_passphrase returned APR_ENOKEY", rv != APR_ENOKEY);
133 ABTS_ASSERT(tc, "apr_crypto_passphrase returned APR_EPADDING", rv != APR_EPADDING);
134 ABTS_ASSERT(tc, "apr_crypto_passphrase returned APR_EKEYTYPE", rv != APR_EKEYTYPE);
135 ABTS_ASSERT(tc, "failed to apr_crypto_passphrase", rv == APR_SUCCESS);
136 ABTS_ASSERT(tc, "apr_crypto_passphrase returned NULL context", key != NULL);
137 }
138 if (rv) {
139 return NULL;
140 }
141 return key;
142
143}
144
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
145static unsigned char *encrypt_block(abts_case *tc, apr_pool_t *pool,
146 const apr_crypto_driver_t *driver, const apr_crypto_t *f,
147 const apr_crypto_key_t *key, const unsigned char *in,
148 const apr_size_t inlen, unsigned char **cipherText,
149 apr_size_t *cipherTextLen, const unsigned char **iv,
150 apr_size_t *blockSize, const char *description)
151{
152

--- 9 unchanged lines hidden (view full) ---

162 /* init the encryption */
163 rv = apr_crypto_block_encrypt_init(&block, iv, key, blockSize, pool);
164 if (APR_ENOTIMPL == rv) {
165 ABTS_NOT_IMPL(tc, "apr_crypto_block_encrypt_init returned APR_ENOTIMPL");
166 }
167 else {
168 if (APR_SUCCESS != rv) {
169 apr_crypto_error(&result, f);
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

--- 9 unchanged lines hidden (view full) ---

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);
170 fprintf(stderr, "encrypt_init: %s %s native error %d: %s (%s)\n",
171 description, apr_crypto_driver_name(driver), result->rc,
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,
172 result->reason ? result->reason : "",
173 result->msg ? result->msg : "");
174 }
302 result->reason ? result->reason : "",
303 result->msg ? result->msg : "");
304 }
175 ABTS_ASSERT(tc, "apr_crypto_block_encrypt_init returned APR_ENOKEY", rv != APR_ENOKEY);
176 ABTS_ASSERT(tc, "apr_crypto_block_encrypt_init returned APR_ENOIV", rv != APR_ENOIV);
177 ABTS_ASSERT(tc, "apr_crypto_block_encrypt_init returned APR_EKEYTYPE", rv != APR_EKEYTYPE);
178 ABTS_ASSERT(tc, "apr_crypto_block_encrypt_init returned APR_EKEYLENGTH", rv != APR_EKEYLENGTH);
179 ABTS_ASSERT(tc, "failed to apr_crypto_block_encrypt_init", rv == APR_SUCCESS);
180 ABTS_ASSERT(tc, "apr_crypto_block_encrypt_init returned NULL context", block != NULL);
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);
181 }
182 if (!block || rv) {
183 return NULL;
184 }
185
186 /* encrypt the block */
187 rv = apr_crypto_block_encrypt(cipherText, cipherTextLen, in, inlen, block);
188 if (APR_SUCCESS != rv) {
189 apr_crypto_error(&result, f);
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);
190 fprintf(stderr, "encrypt: %s %s native error %d: %s (%s)\n",
191 description, apr_crypto_driver_name(driver), result->rc,
192 result->reason ? result->reason : "", result->msg ? result->msg
193 : "");
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 : "");
194 }
195 ABTS_ASSERT(tc, "apr_crypto_block_encrypt returned APR_ECRYPT", rv != APR_ECRYPT);
196 ABTS_ASSERT(tc, "failed to apr_crypto_block_encrypt", rv == APR_SUCCESS);
197 ABTS_ASSERT(tc, "apr_crypto_block_encrypt failed to allocate buffer", *cipherText != NULL);
198 if (rv) {
199 return NULL;
200 }
201
202 /* finalise the encryption */
203 rv = apr_crypto_block_encrypt_finish(*cipherText + *cipherTextLen, &len,
204 block);
205 if (APR_SUCCESS != rv) {
206 apr_crypto_error(&result, f);
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);
207 fprintf(stderr, "encrypt_finish: %s %s native error %d: %s (%s)\n",
208 description, apr_crypto_driver_name(driver), result->rc,
209 result->reason ? result->reason : "", result->msg ? result->msg
210 : "");
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 : "");
211 }
212 ABTS_ASSERT(tc, "apr_crypto_block_encrypt_finish returned APR_ECRYPT", rv != APR_ECRYPT);
213 ABTS_ASSERT(tc, "apr_crypto_block_encrypt_finish returned APR_EPADDING", rv != APR_EPADDING);
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);
214 ABTS_ASSERT(tc, "failed to apr_crypto_block_encrypt_finish", rv == APR_SUCCESS);
215 *cipherTextLen += len;
216 apr_crypto_block_cleanup(block);
217 if (rv) {
218 return NULL;
219 }
220
221 return *cipherText;

--- 20 unchanged lines hidden (view full) ---

242 /* init the decryption */
243 rv = apr_crypto_block_decrypt_init(&block, blockSize, iv, key, pool);
244 if (APR_ENOTIMPL == rv) {
245 ABTS_NOT_IMPL(tc, "apr_crypto_block_decrypt_init returned APR_ENOTIMPL");
246 }
247 else {
248 if (APR_SUCCESS != rv) {
249 apr_crypto_error(&result, f);
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;

--- 20 unchanged lines hidden (view full) ---

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);
250 fprintf(stderr, "decrypt_init: %s %s native error %d: %s (%s)\n",
251 description, apr_crypto_driver_name(driver), result->rc,
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,
252 result->reason ? result->reason : "",
253 result->msg ? result->msg : "");
254 }
255 ABTS_ASSERT(tc, "apr_crypto_block_decrypt_init returned APR_ENOKEY", rv != APR_ENOKEY);
256 ABTS_ASSERT(tc, "apr_crypto_block_decrypt_init returned APR_ENOIV", rv != APR_ENOIV);
257 ABTS_ASSERT(tc, "apr_crypto_block_decrypt_init returned APR_EKEYTYPE", rv != APR_EKEYTYPE);
258 ABTS_ASSERT(tc, "apr_crypto_block_decrypt_init returned APR_EKEYLENGTH", rv != APR_EKEYLENGTH);
259 ABTS_ASSERT(tc, "failed to apr_crypto_block_decrypt_init", rv == APR_SUCCESS);
260 ABTS_ASSERT(tc, "apr_crypto_block_decrypt_init returned NULL context", block != NULL);
261 }
262 if (!block || rv) {
263 return NULL;
264 }
265
266 /* decrypt the block */
267 rv = apr_crypto_block_decrypt(plainText, plainTextLen, cipherText,
268 cipherTextLen, block);
269 if (APR_SUCCESS != rv) {
270 apr_crypto_error(&result, f);
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);
271 fprintf(stderr, "decrypt: %s %s native error %d: %s (%s)\n",
272 description, apr_crypto_driver_name(driver), result->rc,
273 result->reason ? result->reason : "", result->msg ? result->msg
274 : "");
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 : "");
275 }
276 ABTS_ASSERT(tc, "apr_crypto_block_decrypt returned APR_ECRYPT", rv != APR_ECRYPT);
277 ABTS_ASSERT(tc, "failed to apr_crypto_block_decrypt", rv == APR_SUCCESS);
278 ABTS_ASSERT(tc, "apr_crypto_block_decrypt failed to allocate buffer", *plainText != NULL);
279 if (rv) {
280 return NULL;
281 }
282
283 /* finalise the decryption */
284 rv = apr_crypto_block_decrypt_finish(*plainText + *plainTextLen, &len,
285 block);
286 if (APR_SUCCESS != rv) {
287 apr_crypto_error(&result, f);
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);
288 fprintf(stderr, "decrypt_finish: %s %s native error %d: %s (%s)\n",
289 description, apr_crypto_driver_name(driver), result->rc,
290 result->reason ? result->reason : "", result->msg ? result->msg
291 : "");
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 : "");
292 }
293 ABTS_ASSERT(tc, "apr_crypto_block_decrypt_finish returned APR_ECRYPT", rv != APR_ECRYPT);
294 ABTS_ASSERT(tc, "apr_crypto_block_decrypt_finish returned APR_EPADDING", rv != APR_EPADDING);
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);
295 ABTS_ASSERT(tc, "failed to apr_crypto_block_decrypt_finish", rv == APR_SUCCESS);
296 if (rv) {
297 return NULL;
298 }
299
300 *plainTextLen += len;
301 apr_crypto_block_cleanup(block);
302

--- 8 unchanged lines hidden (view full) ---

311 * with the first driver, and decrypted with the second.
312 *
313 * If the two drivers interoperate, the test passes.
314 */
315static void crypto_block_cross(abts_case *tc, apr_pool_t *pool,
316 const apr_crypto_driver_t **drivers,
317 const apr_crypto_block_key_type_e type,
318 const apr_crypto_block_key_mode_e mode, int doPad,
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

--- 8 unchanged lines hidden (view full) ---

455 * with the first driver, and decrypted with the second.
456 *
457 * If the two drivers interoperate, the test passes.
458 */
459static void crypto_block_cross(abts_case *tc, apr_pool_t *pool,
460 const apr_crypto_driver_t **drivers,
461 const apr_crypto_block_key_type_e type,
462 const apr_crypto_block_key_mode_e mode, int doPad,
319 const unsigned char *in, apr_size_t inlen, const char *description)
463 const unsigned char *in, apr_size_t inlen, apr_size_t secretLen,
464 const char *description)
320{
321 const apr_crypto_driver_t *driver1 = drivers[0];
322 const apr_crypto_driver_t *driver2 = drivers[1];
323 apr_crypto_t *f1 = NULL;
324 apr_crypto_t *f2 = NULL;
325 const apr_crypto_key_t *key1 = NULL;
326 const apr_crypto_key_t *key2 = NULL;
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;
327
328 unsigned char *cipherText = NULL;
329 apr_size_t cipherTextLen = 0;
330 unsigned char *plainText = NULL;
331 apr_size_t plainTextLen = 0;
332 const unsigned char *iv = NULL;
333 apr_size_t blockSize = 0;
334

--- 5 unchanged lines hidden (view full) ---

340 cipherText = encrypt_block(tc, pool, driver1, f1, key1, in, inlen,
341 &cipherText, &cipherTextLen, &iv, &blockSize, description);
342 plainText = decrypt_block(tc, pool, driver2, f2, key2, cipherText,
343 cipherTextLen, &plainText, &plainTextLen, iv, &blockSize,
344 description);
345
346 if (cipherText && plainText) {
347 if (memcmp(in, plainText, inlen)) {
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

--- 5 unchanged lines hidden (view full) ---

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)) {
348 fprintf(stderr, "cross mismatch: %s %s/%s\n", description,
497 fprintf(stderr, "passphrase cross mismatch: %s %s/%s\n", description,
349 apr_crypto_driver_name(driver1), apr_crypto_driver_name(
350 driver2));
351 }
352 ABTS_STR_EQUAL(tc, (char *)in, (char *)plainText);
353 }
354
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
355}
356
357/**
358 * Test initialisation.
359 */
360static void test_crypto_init(abts_case *tc, void *data)
361{
362 apr_pool_t *pool = NULL;

--- 4 unchanged lines hidden (view full) ---

367 rv = apr_crypto_init(pool);
368 ABTS_ASSERT(tc, "failed to init apr_crypto", rv == APR_SUCCESS);
369
370 apr_pool_destroy(pool);
371
372}
373
374/**
548}
549
550/**
551 * Test initialisation.
552 */
553static void test_crypto_init(abts_case *tc, void *data)
554{
555 apr_pool_t *pool = NULL;

--- 4 unchanged lines hidden (view full) ---

560 rv = apr_crypto_init(pool);
561 ABTS_ASSERT(tc, "failed to init apr_crypto", rv == APR_SUCCESS);
562
563 apr_pool_destroy(pool);
564
565}
566
567/**
568 * Simple test of OpenSSL key.
569 */
570static void test_crypto_key_openssl(abts_case *tc, void *data)
571{
572 apr_pool_t *pool = NULL;
573 const apr_crypto_driver_t *driver;
574 apr_crypto_t *f = NULL;
575
576 apr_pool_create(&pool, NULL);
577 driver = get_openssl_driver(tc, pool);
578
579 f = make(tc, pool, driver);
580 keysecret(tc, pool, driver, f, APR_KEY_AES_256, APR_MODE_CBC, 1, 32,
581 "KEY_AES_256/MODE_CBC");
582 apr_pool_destroy(pool);
583
584}
585
586/**
587 * Simple test of NSS key.
588 */
589static void test_crypto_key_nss(abts_case *tc, void *data)
590{
591 apr_pool_t *pool = NULL;
592 const apr_crypto_driver_t *driver;
593 apr_crypto_t *f = NULL;
594
595 apr_pool_create(&pool, NULL);
596 driver = get_nss_driver(tc, pool);
597
598 f = make(tc, pool, driver);
599 keysecret(tc, pool, driver, f, APR_KEY_AES_256, APR_MODE_CBC, 1, 32,
600 "KEY_AES_256/MODE_CBC");
601 apr_pool_destroy(pool);
602
603}
604
605/**
606 * Simple test of CommonCrypto key.
607 */
608static void test_crypto_key_commoncrypto(abts_case *tc, void *data)
609{
610 apr_pool_t *pool = NULL;
611 const apr_crypto_driver_t *driver;
612 apr_crypto_t *f = NULL;
613
614 apr_pool_create(&pool, NULL);
615 driver = get_commoncrypto_driver(tc, pool);
616
617 f = make(tc, pool, driver);
618 keysecret(tc, pool, driver, f, APR_KEY_AES_256, APR_MODE_CBC, 1, 32,
619 "KEY_AES_256/MODE_CBC");
620 apr_pool_destroy(pool);
621
622}
623
624/**
375 * Simple test of OpenSSL block crypt.
376 */
377static void test_crypto_block_openssl(abts_case *tc, void *data)
378{
379 apr_pool_t *pool = NULL;
380 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
381
382 const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
383 apr_size_t inlen = sizeof(ALIGNED_STRING);
384
385 apr_pool_create(&pool, NULL);
386 drivers[0] = get_openssl_driver(tc, pool);
387 drivers[1] = get_openssl_driver(tc, pool);
388 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 0,
625 * Simple test of OpenSSL block crypt.
626 */
627static void test_crypto_block_openssl(abts_case *tc, void *data)
628{
629 apr_pool_t *pool = NULL;
630 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
631
632 const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
633 apr_size_t inlen = sizeof(ALIGNED_STRING);
634
635 apr_pool_create(&pool, NULL);
636 drivers[0] = get_openssl_driver(tc, pool);
637 drivers[1] = get_openssl_driver(tc, pool);
638 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 0,
389 in, inlen, "KEY_3DES_192/MODE_CBC");
639 in, inlen, 24, "KEY_3DES_192/MODE_CBC");
390 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_ECB, 0,
640 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_ECB, 0,
391 in, inlen, "KEY_3DES_192/MODE_ECB");
641 in, inlen, 24, "KEY_3DES_192/MODE_ECB");
392 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 0, in,
642 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 0, in,
393 inlen, "KEY_AES_256/MODE_CBC");
643 inlen, 32, "KEY_AES_256/MODE_CBC");
394 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 0, in,
644 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 0, in,
395 inlen, "KEY_AES_256/MODE_ECB");
645 inlen, 32, "KEY_AES_256/MODE_ECB");
396 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 0, in,
646 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 0, in,
397 inlen, "KEY_AES_192/MODE_CBC");
647 inlen, 24, "KEY_AES_192/MODE_CBC");
398 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 0, in,
648 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 0, in,
399 inlen, "KEY_AES_192/MODE_ECB");
649 inlen, 24, "KEY_AES_192/MODE_ECB");
400 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 0, in,
650 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 0, in,
401 inlen, "KEY_AES_128/MODE_CBC");
651 inlen, 16, "KEY_AES_128/MODE_CBC");
402 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 0, in,
652 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 0, in,
403 inlen, "KEY_AES_128/MODE_ECB");
653 inlen, 16, "KEY_AES_128/MODE_ECB");
404 apr_pool_destroy(pool);
405
406}
407
408/**
409 * Simple test of NSS block crypt.
410 */
411static void test_crypto_block_nss(abts_case *tc, void *data)
412{
413 apr_pool_t *pool = NULL;
414 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
415
416 const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
417 apr_size_t inlen = sizeof(ALIGNED_STRING);
418
419 apr_pool_create(&pool, NULL);
420 drivers[0] = get_nss_driver(tc, pool);
421 drivers[1] = get_nss_driver(tc, pool);
422 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 0,
654 apr_pool_destroy(pool);
655
656}
657
658/**
659 * Simple test of NSS block crypt.
660 */
661static void test_crypto_block_nss(abts_case *tc, void *data)
662{
663 apr_pool_t *pool = NULL;
664 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
665
666 const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
667 apr_size_t inlen = sizeof(ALIGNED_STRING);
668
669 apr_pool_create(&pool, NULL);
670 drivers[0] = get_nss_driver(tc, pool);
671 drivers[1] = get_nss_driver(tc, pool);
672 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 0,
423 in, inlen, "KEY_3DES_192/MODE_CBC");
673 in, inlen, 24, "KEY_3DES_192/MODE_CBC");
424 /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */
425 /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 0, in, inlen, "KEY_3DES_192/MODE_ECB"); */
426 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 0, in,
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,
427 inlen, "KEY_AES_256/MODE_CBC");
677 inlen, 32, "KEY_AES_256/MODE_CBC");
428 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 0, in,
678 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 0, in,
429 inlen, "KEY_AES_256/MODE_ECB");
679 inlen, 32, "KEY_AES_256/MODE_ECB");
430 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 0, in,
680 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 0, in,
431 inlen, "KEY_AES_192/MODE_CBC");
681 inlen, 24, "KEY_AES_192/MODE_CBC");
432 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 0, in,
682 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 0, in,
433 inlen, "KEY_AES_192/MODE_ECB");
683 inlen, 24, "KEY_AES_192/MODE_ECB");
434 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 0, in,
684 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 0, in,
435 inlen, "KEY_AES_128/MODE_CBC");
685 inlen, 16, "KEY_AES_128/MODE_CBC");
436 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 0, in,
686 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 0, in,
437 inlen, "KEY_AES_128/MODE_ECB");
687 inlen, 16, "KEY_AES_128/MODE_ECB");
438 apr_pool_destroy(pool);
439
440}
441
442/**
688 apr_pool_destroy(pool);
689
690}
691
692/**
693 * Simple test of Common Crypto block crypt.
694 */
695static void test_crypto_block_commoncrypto(abts_case *tc, void *data)
696{
697 apr_pool_t *pool = NULL;
698 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
699
700 const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
701 apr_size_t inlen = sizeof(ALIGNED_STRING);
702
703 apr_pool_create(&pool, NULL);
704 drivers[0] = get_commoncrypto_driver(tc, pool);
705 drivers[1] = get_commoncrypto_driver(tc, pool);
706 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 0,
707 in, inlen, 24, "KEY_3DES_192/MODE_CBC");
708 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_ECB, 0,
709 in, inlen, 24, "KEY_3DES_192/MODE_ECB");
710 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 0, in,
711 inlen, 32, "KEY_AES_256/MODE_CBC");
712 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 0, in,
713 inlen, 32, "KEY_AES_256/MODE_ECB");
714 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 0, in,
715 inlen, 24, "KEY_AES_192/MODE_CBC");
716 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 0, in,
717 inlen, 24, "KEY_AES_192/MODE_ECB");
718 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 0, in,
719 inlen, 16, "KEY_AES_128/MODE_CBC");
720 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 0, in,
721 inlen, 16, "KEY_AES_128/MODE_ECB");
722 apr_pool_destroy(pool);
723
724}
725
726/**
443 * Encrypt NSS, decrypt OpenSSL.
444 */
445static void test_crypto_block_nss_openssl(abts_case *tc, void *data)
446{
447 apr_pool_t *pool = NULL;
448 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
449
450 const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
451 apr_size_t inlen = sizeof(ALIGNED_STRING);
452
453 apr_pool_create(&pool, NULL);
454 drivers[0] = get_nss_driver(tc, pool);
455 drivers[1] = get_openssl_driver(tc, pool);
456
457 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 0,
727 * Encrypt NSS, decrypt OpenSSL.
728 */
729static void test_crypto_block_nss_openssl(abts_case *tc, void *data)
730{
731 apr_pool_t *pool = NULL;
732 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
733
734 const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
735 apr_size_t inlen = sizeof(ALIGNED_STRING);
736
737 apr_pool_create(&pool, NULL);
738 drivers[0] = get_nss_driver(tc, pool);
739 drivers[1] = get_openssl_driver(tc, pool);
740
741 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 0,
458 in, inlen, "KEY_3DES_192/MODE_CBC");
742 in, inlen, 24, "KEY_3DES_192/MODE_CBC");
459
460 /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */
743
744 /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */
461 /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 0, in, inlen, "KEY_3DES_192/MODE_ECB"); */
745 /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 0, in, inlen, 24, "KEY_3DES_192/MODE_ECB"); */
462 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 0, in,
746 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 0, in,
463 inlen, "KEY_AES_256/MODE_CBC");
747 inlen, 32, "KEY_AES_256/MODE_CBC");
464 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 0, in,
748 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 0, in,
465 inlen, "KEY_AES_256/MODE_ECB");
466
467 /* all 4 of these tests fail to interoperate - a clue from the xml-security code is that
468 * NSS cannot distinguish between the 128 and 192 bit versions of AES. Will need to be
469 * investigated.
470 */
471 /*
472 crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_CBC, 0, in, inlen, "KEY_AES_192/MODE_CBC");
473 crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_ECB, 0, in, inlen, "KEY_AES_192/MODE_ECB");
474 crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_CBC, 0, in, inlen, "KEY_AES_128/MODE_CBC");
475 crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_ECB, 0, in, inlen, "KEY_AES_128/MODE_ECB");
476 */
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");
477 apr_pool_destroy(pool);
478
479}
480
481/**
482 * Encrypt OpenSSL, decrypt NSS.
483 */
484static void test_crypto_block_openssl_nss(abts_case *tc, void *data)
485{
486 apr_pool_t *pool = NULL;
487 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
488
489 const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
490 apr_size_t inlen = sizeof(ALIGNED_STRING);
491
492 apr_pool_create(&pool, NULL);
493 drivers[0] = get_openssl_driver(tc, pool);
494 drivers[1] = get_nss_driver(tc, pool);
495 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 0,
758 apr_pool_destroy(pool);
759
760}
761
762/**
763 * Encrypt OpenSSL, decrypt NSS.
764 */
765static void test_crypto_block_openssl_nss(abts_case *tc, void *data)
766{
767 apr_pool_t *pool = NULL;
768 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
769
770 const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
771 apr_size_t inlen = sizeof(ALIGNED_STRING);
772
773 apr_pool_create(&pool, NULL);
774 drivers[0] = get_openssl_driver(tc, pool);
775 drivers[1] = get_nss_driver(tc, pool);
776 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 0,
496 in, inlen, "KEY_3DES_192/MODE_CBC");
777 in, inlen, 24, "KEY_3DES_192/MODE_CBC");
497
498 /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */
778
779 /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */
499 /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 0, in, inlen, "KEY_3DES_192/MODE_ECB"); */
780 /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 0, in, inlen, 24, "KEY_3DES_192/MODE_ECB"); */
500
501 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 0, in,
781
782 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 0, in,
502 inlen, "KEY_AES_256/MODE_CBC");
783 inlen, 32, "KEY_AES_256/MODE_CBC");
503 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 0, in,
784 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 0, in,
504 inlen, "KEY_AES_256/MODE_ECB");
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);
505
795
506 /* all 4 of these tests fail to interoperate - a clue from the xml-security code is that
507 * NSS cannot distinguish between the 128 and 192 bit versions of AES. Will need to be
508 * investigated.
509 */
510 /*
511 crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_CBC, 0, in, inlen, "KEY_AES_192/MODE_CBC");
512 crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_ECB, 0, in, inlen, "KEY_AES_192/MODE_ECB");
513 crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_CBC, 0, in, inlen, "KEY_AES_128/MODE_CBC");
514 crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_ECB, 0, in, inlen, "KEY_AES_128/MODE_ECB");
515 */
796}
797
798/**
799 * Encrypt OpenSSL, decrypt CommonCrypto.
800 */
801static void test_crypto_block_openssl_commoncrypto(abts_case *tc, void *data)
802{
803 apr_pool_t *pool = NULL;
804 const apr_crypto_driver_t *drivers[] =
805 { NULL, NULL };
806
807 const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
808 apr_size_t inlen = sizeof(ALIGNED_STRING);
809
810 apr_pool_create(&pool, NULL);
811 drivers[0] = get_openssl_driver(tc, pool);
812 drivers[1] = get_commoncrypto_driver(tc, pool);
813
814 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 0, in,
815 inlen, 24, "KEY_3DES_192/MODE_CBC");
816 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_ECB, 0, in,
817 inlen, 24, "KEY_3DES_192/MODE_ECB");
818 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 0, in,
819 inlen, 32, "KEY_AES_256/MODE_CBC");
820 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 0, in,
821 inlen, 32, "KEY_AES_256/MODE_ECB");
822 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 0, in,
823 inlen, 24, "KEY_AES_192/MODE_CBC");
824 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 0, in,
825 inlen, 24, "KEY_AES_192/MODE_ECB");
826 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 0, in,
827 inlen, 16, "KEY_AES_128/MODE_CBC");
828 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 0, in,
829 inlen, 16, "KEY_AES_128/MODE_ECB");
516 apr_pool_destroy(pool);
517
518}
519
520/**
830 apr_pool_destroy(pool);
831
832}
833
834/**
835 * Encrypt OpenSSL, decrypt CommonCrypto.
836 */
837static void test_crypto_block_commoncrypto_openssl(abts_case *tc, void *data)
838{
839 apr_pool_t *pool = NULL;
840 const apr_crypto_driver_t *drivers[] =
841 { NULL, NULL };
842
843 const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
844 apr_size_t inlen = sizeof(ALIGNED_STRING);
845
846 apr_pool_create(&pool, NULL);
847 drivers[0] = get_commoncrypto_driver(tc, pool);
848 drivers[1] = get_openssl_driver(tc, pool);
849
850 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 0, in,
851 inlen, 24, "KEY_3DES_192/MODE_CBC");
852 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_ECB, 0, in,
853 inlen, 24, "KEY_3DES_192/MODE_ECB");
854 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 0, in,
855 inlen, 32, "KEY_AES_256/MODE_CBC");
856 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 0, in,
857 inlen, 32, "KEY_AES_256/MODE_ECB");
858 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 0, in,
859 inlen, 24, "KEY_AES_192/MODE_CBC");
860 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 0, in,
861 inlen, 24, "KEY_AES_192/MODE_ECB");
862 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 0, in,
863 inlen, 16, "KEY_AES_128/MODE_CBC");
864 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 0, in,
865 inlen, 16, "KEY_AES_128/MODE_ECB");
866 apr_pool_destroy(pool);
867
868}
869
870/**
521 * Simple test of OpenSSL block crypt.
522 */
523static void test_crypto_block_openssl_pad(abts_case *tc, void *data)
524{
525 apr_pool_t *pool = NULL;
526 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
527
528 const unsigned char *in = (const unsigned char *) TEST_STRING;
529 apr_size_t inlen = sizeof(TEST_STRING);
530
531 apr_pool_create(&pool, NULL);
532 drivers[0] = get_openssl_driver(tc, pool);
533 drivers[1] = get_openssl_driver(tc, pool);
534
535 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 1,
871 * Simple test of OpenSSL block crypt.
872 */
873static void test_crypto_block_openssl_pad(abts_case *tc, void *data)
874{
875 apr_pool_t *pool = NULL;
876 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
877
878 const unsigned char *in = (const unsigned char *) TEST_STRING;
879 apr_size_t inlen = sizeof(TEST_STRING);
880
881 apr_pool_create(&pool, NULL);
882 drivers[0] = get_openssl_driver(tc, pool);
883 drivers[1] = get_openssl_driver(tc, pool);
884
885 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 1,
536 in, inlen, "KEY_3DES_192/MODE_CBC");
886 in, inlen, 24, "KEY_3DES_192/MODE_CBC");
537 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_ECB, 1,
887 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_ECB, 1,
538 in, inlen, "KEY_3DES_192/MODE_ECB");
888 in, inlen, 24, "KEY_3DES_192/MODE_ECB");
539 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in,
889 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in,
540 inlen, "KEY_AES_256/MODE_CBC");
890 inlen, 32, "KEY_AES_256/MODE_CBC");
541 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 1, in,
891 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 1, in,
542 inlen, "KEY_AES_256/MODE_ECB");
892 inlen, 32, "KEY_AES_256/MODE_ECB");
543 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 1, in,
893 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 1, in,
544 inlen, "KEY_AES_192/MODE_CBC");
894 inlen, 24, "KEY_AES_192/MODE_CBC");
545 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 1, in,
895 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 1, in,
546 inlen, "KEY_AES_192/MODE_ECB");
896 inlen, 24, "KEY_AES_192/MODE_ECB");
547 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 1, in,
897 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 1, in,
548 inlen, "KEY_AES_128/MODE_CBC");
898 inlen, 16, "KEY_AES_128/MODE_CBC");
549 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 1, in,
899 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 1, in,
550 inlen, "KEY_AES_128/MODE_ECB");
900 inlen, 16, "KEY_AES_128/MODE_ECB");
551
552 apr_pool_destroy(pool);
553
554}
555
556/**
557 * Simple test of NSS block crypt.
558 */

--- 6 unchanged lines hidden (view full) ---

565 const unsigned char *in = (const unsigned char *) TEST_STRING;
566 apr_size_t inlen = sizeof(TEST_STRING);
567
568 apr_pool_create(&pool, NULL);
569 drivers[0] = get_nss_driver(tc, pool);
570 drivers[1] = get_nss_driver(tc, pool);
571
572 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 1,
901
902 apr_pool_destroy(pool);
903
904}
905
906/**
907 * Simple test of NSS block crypt.
908 */

--- 6 unchanged lines hidden (view full) ---

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,
573 in, inlen, "KEY_3DES_192/MODE_CBC");
923 in, inlen, 24, "KEY_3DES_192/MODE_CBC");
574 /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */
924 /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */
575 /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 1, in, inlen, "KEY_3DES_192/MODE_ECB"); */
925 /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 1, in, inlen, 24, "KEY_3DES_192/MODE_ECB"); */
576
577 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in,
926
927 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in,
578 inlen, "KEY_AES_256/MODE_CBC");
928 inlen, 32, "KEY_AES_256/MODE_CBC");
579
580 /* KEY_AES_256 / MODE_ECB doesn't support padding on NSS */
929
930 /* KEY_AES_256 / MODE_ECB doesn't support padding on NSS */
581 /*crypto_block_cross(tc, pool, drivers, KEY_AES_256, MODE_ECB, 1, in, inlen, "KEY_AES_256/MODE_ECB");*/
931 /*crypto_block_cross(tc, pool, drivers, KEY_AES_256, MODE_ECB, 1, in, inlen, 32, "KEY_AES_256/MODE_ECB");*/
582
583 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 1, in,
932
933 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 1, in,
584 inlen, "KEY_AES_192/MODE_CBC");
934 inlen, 24, "KEY_AES_192/MODE_CBC");
585
586 /* KEY_AES_256 / MODE_ECB doesn't support padding on NSS */
935
936 /* KEY_AES_256 / MODE_ECB doesn't support padding on NSS */
587 /*crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_ECB, 1, in, inlen, "KEY_AES_192/MODE_ECB");*/
937 /*crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_ECB, 1, in, inlen, 24, "KEY_AES_192/MODE_ECB");*/
588
589 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 1, in,
938
939 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 1, in,
590 inlen, "KEY_AES_128/MODE_CBC");
940 inlen, 16, "KEY_AES_128/MODE_CBC");
591
592 /* KEY_AES_256 / MODE_ECB doesn't support padding on NSS */
941
942 /* KEY_AES_256 / MODE_ECB doesn't support padding on NSS */
593 /*crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_ECB, 1, in, inlen, "KEY_AES_128/MODE_ECB");*/
943 /*crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_ECB, 1, in, inlen, 16, "KEY_AES_128/MODE_ECB");*/
594
595 apr_pool_destroy(pool);
596
597}
598
599/**
944
945 apr_pool_destroy(pool);
946
947}
948
949/**
950 * Simple test of Common Crypto block crypt.
951 */
952static void test_crypto_block_commoncrypto_pad(abts_case *tc, void *data)
953{
954 apr_pool_t *pool = NULL;
955 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
956
957 const unsigned char *in = (const unsigned char *) TEST_STRING;
958 apr_size_t inlen = sizeof(TEST_STRING);
959
960 apr_pool_create(&pool, NULL);
961 drivers[0] = get_commoncrypto_driver(tc, pool);
962 drivers[1] = get_commoncrypto_driver(tc, pool);
963
964 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 1,
965 in, inlen, 24, "KEY_3DES_192/MODE_CBC");
966 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_ECB, 1,
967 in, inlen, 24, "KEY_3DES_192/MODE_ECB");
968 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in,
969 inlen, 32, "KEY_AES_256/MODE_CBC");
970 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 1, in,
971 inlen, 32, "KEY_AES_256/MODE_ECB");
972 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 1, in,
973 inlen, 24, "KEY_AES_192/MODE_CBC");
974 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 1, in,
975 inlen, 24, "KEY_AES_192/MODE_ECB");
976 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 1, in,
977 inlen, 16, "KEY_AES_128/MODE_CBC");
978 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 1, in,
979 inlen, 16, "KEY_AES_128/MODE_ECB");
980
981 apr_pool_destroy(pool);
982
983}
984
985/**
600 * Encrypt NSS, decrypt OpenSSL.
601 */
602static void test_crypto_block_nss_openssl_pad(abts_case *tc, void *data)
603{
604 apr_pool_t *pool = NULL;
605 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
606
607 const unsigned char *in = (const unsigned char *) TEST_STRING;
608 apr_size_t inlen = sizeof(TEST_STRING);
609
610 apr_pool_create(&pool, NULL);
611 drivers[0] = get_nss_driver(tc, pool);
612 drivers[1] = get_openssl_driver(tc, pool);
613
614 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 1,
986 * Encrypt NSS, decrypt OpenSSL.
987 */
988static void test_crypto_block_nss_openssl_pad(abts_case *tc, void *data)
989{
990 apr_pool_t *pool = NULL;
991 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
992
993 const unsigned char *in = (const unsigned char *) TEST_STRING;
994 apr_size_t inlen = sizeof(TEST_STRING);
995
996 apr_pool_create(&pool, NULL);
997 drivers[0] = get_nss_driver(tc, pool);
998 drivers[1] = get_openssl_driver(tc, pool);
999
1000 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 1,
615 in, inlen, "KEY_3DES_192/MODE_CBC");
1001 in, inlen, 24, "KEY_3DES_192/MODE_CBC");
616
617 /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */
1002
1003 /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */
618 /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 1, in, inlen, "KEY_3DES_192/MODE_ECB"); */
1004 /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 1, in, inlen, 24, "KEY_3DES_192/MODE_ECB"); */
619
620 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in,
1005
1006 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in,
621 inlen, "KEY_AES_256/MODE_CBC");
1007 inlen, 32, "KEY_AES_256/MODE_CBC");
622
623 /* KEY_AES_256 / MODE_ECB doesn't support padding on NSS */
1008
1009 /* KEY_AES_256 / MODE_ECB doesn't support padding on NSS */
624 /*crypto_block_cross(tc, pool, drivers, KEY_AES_256, MODE_ECB, 1, in, inlen, "KEY_AES_256/MODE_ECB");*/
1010 /*crypto_block_cross(tc, pool, drivers, KEY_AES_256, MODE_ECB, 1, in, inlen, 32, "KEY_AES_256/MODE_ECB");*/
625
1011
626 /* all 4 of these tests fail to interoperate - a clue from the xml-security code is that
627 * NSS cannot distinguish between the 128 and 192 bit versions of AES. Will need to be
628 * investigated.
629 */
630 /*
631 crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_CBC, 1, in, inlen, "KEY_AES_192/MODE_CBC");
632 crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_ECB, 1, in, inlen, "KEY_AES_192/MODE_ECB");
633 crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_CBC, 1, in, inlen, "KEY_AES_128/MODE_CBC");
634 crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_ECB, 1, in, inlen, "KEY_AES_128/MODE_ECB");
635 */
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
636 apr_pool_destroy(pool);
637
638}
639
640/**
641 * Encrypt OpenSSL, decrypt NSS.
642 */
643static void test_crypto_block_openssl_nss_pad(abts_case *tc, void *data)
644{
645 apr_pool_t *pool = NULL;
646 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
647
648 const unsigned char *in = (const unsigned char *) TEST_STRING;
649 apr_size_t inlen = sizeof(TEST_STRING);
650
651 apr_pool_create(&pool, NULL);
652 drivers[0] = get_openssl_driver(tc, pool);
653 drivers[1] = get_nss_driver(tc, pool);
654 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 1,
1026 apr_pool_destroy(pool);
1027
1028}
1029
1030/**
1031 * Encrypt OpenSSL, decrypt NSS.
1032 */
1033static void test_crypto_block_openssl_nss_pad(abts_case *tc, void *data)
1034{
1035 apr_pool_t *pool = NULL;
1036 const apr_crypto_driver_t *drivers[] = { NULL, NULL };
1037
1038 const unsigned char *in = (const unsigned char *) TEST_STRING;
1039 apr_size_t inlen = sizeof(TEST_STRING);
1040
1041 apr_pool_create(&pool, NULL);
1042 drivers[0] = get_openssl_driver(tc, pool);
1043 drivers[1] = get_nss_driver(tc, pool);
1044 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 1,
655 in, inlen, "KEY_3DES_192/MODE_CBC");
1045 in, inlen, 24, "KEY_3DES_192/MODE_CBC");
656
657 /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */
1046
1047 /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */
658 /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 1, in, inlen, "KEY_3DES_192/MODE_ECB"); */
1048 /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 1, in, inlen, 24, "KEY_3DES_192/MODE_ECB"); */
659
660 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in,
1049
1050 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in,
661 inlen, "KEY_AES_256/MODE_CBC");
1051 inlen, 32, "KEY_AES_256/MODE_CBC");
662
663 /* KEY_AES_256 / MODE_ECB doesn't support padding on NSS */
1052
1053 /* KEY_AES_256 / MODE_ECB doesn't support padding on NSS */
664 /*crypto_block_cross(tc, pool, drivers, KEY_AES_256, MODE_ECB, 1, in, inlen, "KEY_AES_256/MODE_ECB");*/
1054 /*crypto_block_cross(tc, pool, drivers, KEY_AES_256, MODE_ECB, 1, in, inlen, 32, "KEY_AES_256/MODE_ECB");*/
665
1055
666 /* all 4 of these tests fail to interoperate - a clue from the xml-security code is that
667 * NSS cannot distinguish between the 128 and 192 bit versions of AES. Will need to be
668 * investigated.
669 */
670 /*
671 crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_CBC, 1, in, inlen, "KEY_AES_192/MODE_CBC");
672 crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_ECB, 1, in, inlen, "KEY_AES_192/MODE_ECB");
673 crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_CBC, 1, in, inlen, "KEY_AES_128/MODE_CBC");
674 crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_ECB, 1, in, inlen, "KEY_AES_128/MODE_ECB");
675 */
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
676 apr_pool_destroy(pool);
677
678}
679
680/**
1070 apr_pool_destroy(pool);
1071
1072}
1073
1074/**
1075 * Encrypt CommonCrypto, decrypt OpenSSL.
1076 */
1077static void test_crypto_block_commoncrypto_openssl_pad(abts_case *tc,
1078 void *data)
1079{
1080 apr_pool_t *pool = NULL;
1081 const apr_crypto_driver_t *drivers[] =
1082 { NULL, NULL };
1083
1084 const unsigned char *in = (const unsigned char *) TEST_STRING;
1085 apr_size_t inlen = sizeof(TEST_STRING);
1086
1087 apr_pool_create(&pool, NULL);
1088 drivers[0] = get_commoncrypto_driver(tc, pool);
1089 drivers[1] = get_openssl_driver(tc, pool);
1090
1091 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 1, in,
1092 inlen, 24, "KEY_3DES_192/MODE_CBC");
1093 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_ECB, 1, in,
1094 inlen, 24, "KEY_3DES_192/MODE_ECB");
1095 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in,
1096 inlen, 32, "KEY_AES_256/MODE_CBC");
1097 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 1, in,
1098 inlen, 32, "KEY_AES_256/MODE_ECB");
1099 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 1, in,
1100 inlen, 24, "KEY_AES_192/MODE_CBC");
1101 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 1, in,
1102 inlen, 24, "KEY_AES_192/MODE_ECB");
1103 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 1, in,
1104 inlen, 16, "KEY_AES_128/MODE_CBC");
1105 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 1, in,
1106 inlen, 16, "KEY_AES_128/MODE_ECB");
1107
1108 apr_pool_destroy(pool);
1109
1110}
1111
1112/**
1113 * Encrypt OpenSSL, decrypt CommonCrypto.
1114 */
1115static void test_crypto_block_openssl_commoncrypto_pad(abts_case *tc,
1116 void *data)
1117{
1118 apr_pool_t *pool = NULL;
1119 const apr_crypto_driver_t *drivers[] =
1120 { NULL, NULL };
1121
1122 const unsigned char *in = (const unsigned char *) TEST_STRING;
1123 apr_size_t inlen = sizeof(TEST_STRING);
1124
1125 apr_pool_create(&pool, NULL);
1126 drivers[0] = get_openssl_driver(tc, pool);
1127 drivers[1] = get_commoncrypto_driver(tc, pool);
1128
1129 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 1, in,
1130 inlen, 24, "KEY_3DES_192/MODE_CBC");
1131 crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_ECB, 1, in,
1132 inlen, 24, "KEY_3DES_192/MODE_ECB");
1133 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in,
1134 inlen, 32, "KEY_AES_256/MODE_CBC");
1135 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 1, in,
1136 inlen, 32, "KEY_AES_256/MODE_ECB");
1137 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 1, in,
1138 inlen, 24, "KEY_AES_192/MODE_CBC");
1139 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 1, in,
1140 inlen, 24, "KEY_AES_192/MODE_ECB");
1141 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 1, in,
1142 inlen, 16, "KEY_AES_128/MODE_CBC");
1143 crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 1, in,
1144 inlen, 16, "KEY_AES_128/MODE_ECB");
1145
1146 apr_pool_destroy(pool);
1147
1148}
1149
1150/**
681 * Get Types, OpenSSL.
682 */
683static void test_crypto_get_block_key_types_openssl(abts_case *tc, void *data)
684{
685 apr_pool_t *pool = NULL;
686 const apr_crypto_driver_t *driver;
687 apr_crypto_t *f;
688 apr_hash_t *types;

--- 70 unchanged lines hidden (view full) ---

759
760 }
761
762 apr_pool_destroy(pool);
763
764}
765
766/**
1151 * Get Types, OpenSSL.
1152 */
1153static void test_crypto_get_block_key_types_openssl(abts_case *tc, void *data)
1154{
1155 apr_pool_t *pool = NULL;
1156 const apr_crypto_driver_t *driver;
1157 apr_crypto_t *f;
1158 apr_hash_t *types;

--- 70 unchanged lines hidden (view full) ---

1229
1230 }
1231
1232 apr_pool_destroy(pool);
1233
1234}
1235
1236/**
1237 * Get Types, Common Crypto.
1238 */
1239static void test_crypto_get_block_key_types_commoncrypto(abts_case *tc, void *data)
1240{
1241 apr_pool_t *pool = NULL;
1242 const apr_crypto_driver_t *driver;
1243 apr_crypto_t *f;
1244 apr_hash_t *types;
1245 int *key_3des_192;
1246 int *key_aes_128;
1247 int *key_aes_192;
1248 int *key_aes_256;
1249
1250 apr_pool_create(&pool, NULL);
1251 driver = get_commoncrypto_driver(tc, pool);
1252 if (driver) {
1253
1254 f = make(tc, pool, driver);
1255 apr_crypto_get_block_key_types(&types, f);
1256
1257 key_3des_192 = apr_hash_get(types, "3des192", APR_HASH_KEY_STRING);
1258 ABTS_PTR_NOTNULL(tc, key_3des_192);
1259 ABTS_INT_EQUAL(tc, *key_3des_192, APR_KEY_3DES_192);
1260
1261 key_aes_128 = apr_hash_get(types, "aes128", APR_HASH_KEY_STRING);
1262 ABTS_PTR_NOTNULL(tc, key_aes_128);
1263 ABTS_INT_EQUAL(tc, *key_aes_128, APR_KEY_AES_128);
1264
1265 key_aes_192 = apr_hash_get(types, "aes192", APR_HASH_KEY_STRING);
1266 ABTS_PTR_NOTNULL(tc, key_aes_192);
1267 ABTS_INT_EQUAL(tc, *key_aes_192, APR_KEY_AES_192);
1268
1269 key_aes_256 = apr_hash_get(types, "aes256", APR_HASH_KEY_STRING);
1270 ABTS_PTR_NOTNULL(tc, key_aes_256);
1271 ABTS_INT_EQUAL(tc, *key_aes_256, APR_KEY_AES_256);
1272
1273 }
1274
1275 apr_pool_destroy(pool);
1276
1277}
1278
1279/**
767 * Get Modes, OpenSSL.
768 */
769static void test_crypto_get_block_key_modes_openssl(abts_case *tc, void *data)
770{
771 apr_pool_t *pool = NULL;
772 const apr_crypto_driver_t *driver;
773 apr_crypto_t *f;
774 apr_hash_t *modes;

--- 49 unchanged lines hidden (view full) ---

824 ABTS_INT_EQUAL(tc, *mode_cbc, APR_MODE_CBC);
825
826 }
827
828 apr_pool_destroy(pool);
829
830}
831
1280 * Get Modes, OpenSSL.
1281 */
1282static void test_crypto_get_block_key_modes_openssl(abts_case *tc, void *data)
1283{
1284 apr_pool_t *pool = NULL;
1285 const apr_crypto_driver_t *driver;
1286 apr_crypto_t *f;
1287 apr_hash_t *modes;

--- 49 unchanged lines hidden (view full) ---

1337 ABTS_INT_EQUAL(tc, *mode_cbc, APR_MODE_CBC);
1338
1339 }
1340
1341 apr_pool_destroy(pool);
1342
1343}
1344
1345/**
1346 * Get Modes, Common Crypto.
1347 */
1348static void test_crypto_get_block_key_modes_commoncrypto(abts_case *tc, void *data)
1349{
1350 apr_pool_t *pool = NULL;
1351 const apr_crypto_driver_t *driver;
1352 apr_crypto_t *f;
1353 apr_hash_t *modes;
1354 int *mode_ecb;
1355 int *mode_cbc;
1356
1357 apr_pool_create(&pool, NULL);
1358 driver = get_commoncrypto_driver(tc, pool);
1359 if (driver) {
1360
1361 f = make(tc, pool, driver);
1362 apr_crypto_get_block_key_modes(&modes, f);
1363
1364 mode_ecb = apr_hash_get(modes, "ecb", APR_HASH_KEY_STRING);
1365 ABTS_PTR_NOTNULL(tc, mode_ecb);
1366 ABTS_INT_EQUAL(tc, *mode_ecb, APR_MODE_ECB);
1367
1368 mode_cbc = apr_hash_get(modes, "cbc", APR_HASH_KEY_STRING);
1369 ABTS_PTR_NOTNULL(tc, mode_cbc);
1370 ABTS_INT_EQUAL(tc, *mode_cbc, APR_MODE_CBC);
1371
1372 }
1373
1374 apr_pool_destroy(pool);
1375
1376}
1377
1378static void test_crypto_memzero(abts_case *tc, void *data)
1379{
1380 /* Aligned message */
1381 struct {
1382 char buf[7 * sizeof(int)];
1383 int untouched;
1384 } msg;
1385 /* A bit of type punning such that 'msg' might look unused
1386 * after the call to apr_crypto_memzero().
1387 */
1388 int *ptr = (int *)&msg;
1389 int i;
1390
1391 /* Fill buf with non-zeros (odds) */
1392 for (i = 1; i < 2 * sizeof(msg.buf); i += 2) {
1393 msg.buf[i / 2] = (char)i;
1394 ABTS_ASSERT(tc, "test_crypto_memzero() barrier", msg.buf[i / 2] != 0);
1395 }
1396
1397 /* Zero out the whole, and check it */
1398 apr_crypto_memzero(&msg, sizeof msg);
1399 for (i = 0; i < sizeof(msg) / sizeof(*ptr); ++i) {
1400 ABTS_ASSERT(tc, "test_crypto_memzero() optimized out", ptr[i] == 0);
1401 }
1402}
1403
1404static void test_crypto_equals(abts_case *tc, void *data)
1405{
1406 /* Buffers of each type of scalar */
1407 union {
1408 char c;
1409 short s;
1410 int i;
1411 long l;
1412 float f;
1413 double d;
1414 void *p;
1415 } buf0[7], buf1[7], buf[7];
1416 char *ptr = (char *)buf;
1417 int i;
1418
1419#define TEST_SCALAR_MATCH(i, x, r) \
1420 ABTS_ASSERT(tc, "test_crypto_equals(" APR_STRINGIFY(x) ")" \
1421 " != " APR_STRINGIFY(r), \
1422 apr_crypto_equals(&buf##r[i].x, &buf[i].x, \
1423 sizeof(buf[i].x)) == r)
1424
1425 /* Fill buf with non-zeros (odds) */
1426 for (i = 1; i < 2 * sizeof(buf); i += 2) {
1427 ptr[i / 2] = (char)i;
1428 }
1429 /* Set buf1 = buf */
1430 memcpy(buf1, buf, sizeof buf);
1431 /* Set buf0 = {0} */
1432 memset(buf0, 0, sizeof buf0);
1433
1434 /* Check that buf1 == buf for each scalar */
1435 TEST_SCALAR_MATCH(0, c, 1);
1436 TEST_SCALAR_MATCH(1, s, 1);
1437 TEST_SCALAR_MATCH(2, i, 1);
1438 TEST_SCALAR_MATCH(3, l, 1);
1439 TEST_SCALAR_MATCH(4, f, 1);
1440 TEST_SCALAR_MATCH(5, d, 1);
1441 TEST_SCALAR_MATCH(6, p, 1);
1442
1443 /* Check that buf0 != buf for each scalar */
1444 TEST_SCALAR_MATCH(0, c, 0);
1445 TEST_SCALAR_MATCH(1, s, 0);
1446 TEST_SCALAR_MATCH(2, i, 0);
1447 TEST_SCALAR_MATCH(3, l, 0);
1448 TEST_SCALAR_MATCH(4, f, 0);
1449 TEST_SCALAR_MATCH(5, d, 0);
1450 TEST_SCALAR_MATCH(6, p, 0);
1451}
1452
832abts_suite *testcrypto(abts_suite *suite)
833{
834 suite = ADD_SUITE(suite);
835
836 /* test simple init and shutdown */
837 abts_run_test(suite, test_crypto_init, NULL);
838
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
839 /* test a simple encrypt / decrypt operation - openssl */
840 abts_run_test(suite, test_crypto_block_openssl, NULL);
841
842 /* test a padded encrypt / decrypt operation - openssl */
843 abts_run_test(suite, test_crypto_block_openssl_pad, NULL);
844
845 /* test a simple encrypt / decrypt operation - nss */
846 abts_run_test(suite, test_crypto_block_nss, NULL);
847
848 /* test a padded encrypt / decrypt operation - nss */
849 abts_run_test(suite, test_crypto_block_nss_pad, NULL);
850
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
851 /* test encrypt nss / decrypt openssl */
852 abts_run_test(suite, test_crypto_block_nss_openssl, NULL);
853
854 /* test padded encrypt nss / decrypt openssl */
855 abts_run_test(suite, test_crypto_block_nss_openssl_pad, NULL);
856
857 /* test encrypt openssl / decrypt nss */
858 abts_run_test(suite, test_crypto_block_openssl_nss, NULL);
859
860 /* test padded encrypt openssl / decrypt nss */
861 abts_run_test(suite, test_crypto_block_openssl_nss_pad, NULL);
862
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
863 /* test block key types openssl */
864 abts_run_test(suite, test_crypto_get_block_key_types_openssl, NULL);
865
866 /* test block key types nss */
867 abts_run_test(suite, test_crypto_get_block_key_types_nss, NULL);
868
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
869 /* test block key modes openssl */
870 abts_run_test(suite, test_crypto_get_block_key_modes_openssl, NULL);
871
872 /* test block key modes nss */
873 abts_run_test(suite, test_crypto_get_block_key_modes_nss, NULL);
874
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
875 return suite;
876}
877
878#else
879
880/**
881 * Dummy test suite when crypto is turned off.
882 */
883abts_suite *testcrypto(abts_suite *suite)
884{
885 return ADD_SUITE(suite);
886}
887
888#endif /* APU_HAVE_CRYPTO */
1532 return suite;
1533}
1534
1535#else
1536
1537/**
1538 * Dummy test suite when crypto is turned off.
1539 */
1540abts_suite *testcrypto(abts_suite *suite)
1541{
1542 return ADD_SUITE(suite);
1543}
1544
1545#endif /* APU_HAVE_CRYPTO */