1 /* SPDX-License-Identifier: BSD-2-Clause */
2 /*******************************************************************************
3 * Copyright 2018, Fraunhofer SIT sponsored by Infineon Technologies AG
4 * All rights reserved.
5 ******************************************************************************/
6
7 #ifdef HAVE_CONFIG_H
8 #include <config.h>
9 #endif
10
11 #include <stdarg.h>
12 #include <inttypes.h>
13 #include <string.h>
14 #include <stdlib.h>
15
16 #include <setjmp.h>
17 #include <cmocka.h>
18
19 #include "tss2_esys.h"
20 #include "esys_crypto.h"
21
22 #define LOGMODULE tests
23 #include "util/log.h"
24
25 /**
26 * This unit tst checks several error cases of the crypto backends, which are not
27 * covered by the integration tests.
28 */
29
30 static void
check_hash_functions(void ** state)31 check_hash_functions(void **state)
32 {
33 TSS2_RC rc;
34 IESYS_CRYPTO_CONTEXT_BLOB *context;
35 uint8_t buffer[10] = { 0 };
36 TPM2B tpm2b;
37 size_t size = 0;
38
39 rc = iesys_crypto_hash_start(NULL, TPM2_ALG_SHA384);
40 assert_int_equal (rc, TSS2_ESYS_RC_BAD_REFERENCE);
41
42 #ifndef OSSL
43 rc = iesys_crypto_hash_start(&context, TPM2_ALG_SHA512);
44 assert_int_equal (rc, TSS2_ESYS_RC_NOT_IMPLEMENTED);
45 #endif
46
47 rc = iesys_crypto_hash_start(&context, 0);
48 assert_int_equal (rc, TSS2_ESYS_RC_NOT_IMPLEMENTED);
49
50 rc = iesys_crypto_hash_start(&context, TPM2_ALG_SHA384);
51 assert_int_equal (rc, TSS2_RC_SUCCESS);
52
53 rc = iesys_crypto_hash_finish(NULL, &buffer[0], &size);
54 assert_int_equal (rc, TSS2_ESYS_RC_BAD_REFERENCE);
55
56 rc = iesys_crypto_hash_finish(&context, &buffer[0], &size);
57 assert_int_equal (rc, TSS2_ESYS_RC_BAD_SIZE);
58
59 iesys_crypto_hash_abort(NULL);
60 iesys_crypto_hash_abort(&context);
61
62 rc = iesys_crypto_hash_update(NULL, &buffer[0], 10);
63 assert_int_equal (rc, TSS2_ESYS_RC_BAD_REFERENCE);
64
65 rc = iesys_crypto_hash_update2b(NULL, &tpm2b);
66 assert_int_equal (rc, TSS2_ESYS_RC_BAD_REFERENCE);
67
68 /* Create invalid context */
69 rc = iesys_crypto_hmac_start(&context, TPM2_ALG_SHA1, &buffer[0], 10);
70 assert_int_equal (rc, TSS2_RC_SUCCESS);
71
72 iesys_crypto_hash_abort(&context);
73
74 rc = iesys_crypto_hash_update(context, &buffer[0], 10);
75 assert_int_equal (rc, TSS2_ESYS_RC_BAD_REFERENCE);
76
77 rc = iesys_crypto_hash_finish(&context, &buffer[0], &size);
78 assert_int_equal (rc, TSS2_ESYS_RC_BAD_REFERENCE);
79
80 /* cleanup */
81 iesys_crypto_hmac_abort(&context);
82 }
83
84 static void
check_hmac_functions(void ** state)85 check_hmac_functions(void **state)
86 {
87 TSS2_RC rc;
88 IESYS_CRYPTO_CONTEXT_BLOB *context;
89 uint8_t buffer[10] = { 0 };
90 TPM2B tpm2b;
91 size_t size = 0;
92
93 rc = iesys_crypto_hmac_start(NULL, TPM2_ALG_SHA384, &buffer[0], 10);
94 assert_int_equal (rc, TSS2_ESYS_RC_BAD_REFERENCE);
95
96 #ifndef OSSL
97 rc = iesys_crypto_hmac_start(&context, TPM2_ALG_SHA512, &buffer[0], 10);
98 assert_int_equal (rc, TSS2_ESYS_RC_NOT_IMPLEMENTED);
99 #endif
100
101 rc = iesys_crypto_hmac_start(&context, 0, &buffer[0], 10);
102 assert_int_equal (rc, TSS2_ESYS_RC_NOT_IMPLEMENTED);
103
104 rc = iesys_crypto_hmac_start(&context, TPM2_ALG_SHA1, &buffer[0], 10);
105 assert_int_equal (rc, TSS2_RC_SUCCESS);
106
107 rc = iesys_crypto_hmac_finish(NULL, &buffer[0], &size);
108 assert_int_equal (rc, TSS2_ESYS_RC_BAD_REFERENCE);
109
110 rc = iesys_crypto_hmac_finish2b(NULL, &tpm2b);
111 assert_int_equal (rc, TSS2_ESYS_RC_BAD_REFERENCE);
112
113 rc = iesys_crypto_hmac_finish(&context, &buffer[0], &size);
114 assert_int_equal (rc, TSS2_ESYS_RC_BAD_SIZE);
115
116 iesys_crypto_hmac_abort(NULL);
117 iesys_crypto_hmac_abort(&context);
118
119 rc = iesys_crypto_hmac_update(NULL, &buffer[0], 10);
120 assert_int_equal (rc, TSS2_ESYS_RC_BAD_REFERENCE);
121
122 rc = iesys_crypto_hmac_update2b(NULL, &tpm2b);
123 assert_int_equal (rc, TSS2_ESYS_RC_BAD_REFERENCE);
124
125 /* Create invalid context */
126 rc = iesys_crypto_hash_start(&context, TPM2_ALG_SHA1);
127 assert_int_equal (rc, TSS2_RC_SUCCESS);
128
129 iesys_crypto_hmac_abort(&context);
130
131 rc = iesys_crypto_hmac_update(context, &buffer[0], 10);
132 assert_int_equal (rc, TSS2_ESYS_RC_BAD_REFERENCE);
133
134 rc = iesys_crypto_hmac_finish(&context, &buffer[0], &size);
135 assert_int_equal (rc, TSS2_ESYS_RC_BAD_REFERENCE);
136
137 /* cleanup */
138 iesys_crypto_hash_abort(&context);
139 }
140
141 static void
check_random(void ** state)142 check_random(void **state)
143 {
144 TSS2_RC rc;
145 size_t num_bytes = 0;
146 TPM2B_NONCE nonce;
147 rc = iesys_crypto_random2b(&nonce, num_bytes);
148 assert_int_equal (rc, TSS2_RC_SUCCESS);
149 }
150
151 static void
check_pk_encrypt(void ** state)152 check_pk_encrypt(void **state)
153 {
154 TSS2_RC rc;
155 uint8_t in_buffer[5] = { 1, 2, 3, 4, 5 };
156 size_t size = 5;
157 uint8_t out_buffer[5];
158 TPM2B_PUBLIC inPublicRSA = {
159 .size = 0,
160 .publicArea = {
161 .type = TPM2_ALG_RSA,
162 .nameAlg = TPM2_ALG_SHA1,
163 .objectAttributes = (TPMA_OBJECT_USERWITHAUTH |
164 TPMA_OBJECT_RESTRICTED |
165 TPMA_OBJECT_DECRYPT |
166 TPMA_OBJECT_FIXEDTPM |
167 TPMA_OBJECT_FIXEDPARENT |
168 TPMA_OBJECT_SENSITIVEDATAORIGIN),
169 .authPolicy = {
170 .size = 0,
171 },
172 .parameters.rsaDetail = {
173 .symmetric = {
174 .algorithm = TPM2_ALG_AES,
175 .keyBits.aes = 128,
176 .mode.aes = TPM2_ALG_CFB,
177 },
178 .scheme = {
179 .scheme =
180 TPM2_ALG_NULL,
181 },
182 .keyBits = 2048,
183 .exponent = 0,
184 },
185 .unique.rsa = {
186 .size = 0,
187 .buffer = {}
188 ,
189 }
190 }
191 };
192
193 inPublicRSA.publicArea.nameAlg = 0;
194 rc = iesys_crypto_pk_encrypt(&inPublicRSA, size, &in_buffer[0], size, &out_buffer[0], &size, "LABEL");
195 assert_int_equal (rc, TSS2_ESYS_RC_NOT_IMPLEMENTED);
196
197 inPublicRSA.publicArea.nameAlg = TPM2_ALG_SHA1;
198 inPublicRSA.publicArea.parameters.rsaDetail.scheme.scheme = 0;
199 rc = iesys_crypto_pk_encrypt(&inPublicRSA, size, &in_buffer[0], size, &out_buffer[0], &size, "LABEL");
200 assert_int_equal (rc, TSS2_ESYS_RC_BAD_VALUE);
201 }
202
203 static void
check_aes_encrypt(void ** state)204 check_aes_encrypt(void **state)
205 {
206 TSS2_RC rc;
207 uint8_t key[32] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
208 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
209 uint8_t buffer[5] = { 1, 2, 3, 4, 5 };
210 size_t size = 5;
211
212 rc = iesys_crypto_sym_aes_encrypt(NULL, TPM2_ALG_AES, 192, TPM2_ALG_CFB, 16,
213 &buffer[0], size, &key[0]);
214 assert_int_equal (rc, TSS2_ESYS_RC_BAD_REFERENCE);
215
216 rc = iesys_crypto_sym_aes_encrypt(&key[0], TPM2_ALG_AES, 192, TPM2_ALG_CFB, 16,
217 &buffer[0], size, &key[0]);
218 assert_int_equal (rc, TSS2_RC_SUCCESS);
219 rc = iesys_crypto_sym_aes_encrypt(&key[0], TPM2_ALG_AES, 256, TPM2_ALG_CFB, 16,
220 &buffer[0], size, &key[0]);
221 assert_int_equal (rc, TSS2_RC_SUCCESS);
222
223 rc = iesys_crypto_sym_aes_encrypt(&key[0], 0, 256, TPM2_ALG_CFB, 16,
224 &buffer[0], size, &key[0]);
225 assert_int_equal (rc, TSS2_ESYS_RC_BAD_VALUE);
226
227 rc = iesys_crypto_sym_aes_encrypt(&key[0], TPM2_ALG_AES, 256, 0, 16,
228 &buffer[0], size, &key[0]);
229 assert_int_equal (rc, TSS2_ESYS_RC_BAD_VALUE);
230
231 rc = iesys_crypto_sym_aes_encrypt(&key[0], TPM2_ALG_AES, 999, TPM2_ALG_CFB, 16,
232 &buffer[0], size, &key[0]);
233 assert_int_equal (rc, TSS2_ESYS_RC_BAD_VALUE);
234
235 rc = iesys_crypto_sym_aes_decrypt(NULL, TPM2_ALG_AES, 192, TPM2_ALG_CFB, 16,
236 &buffer[0], size, &key[0]);
237 assert_int_equal (rc, TSS2_ESYS_RC_BAD_REFERENCE);
238
239 rc = iesys_crypto_sym_aes_decrypt(&key[0], 0, 192, TPM2_ALG_CFB, 16,
240 &buffer[0], size, &key[0]);
241 assert_int_equal (rc, TSS2_ESYS_RC_BAD_VALUE);
242 }
243
244 static void
check_free(void ** state)245 check_free(void **state)
246 {
247 uint8_t *buffer;
248
249 buffer = malloc(10);
250 Esys_Free(buffer);
251 }
252
253 static void
check_get_sys_context(void ** state)254 check_get_sys_context(void **state)
255 {
256 ESYS_CONTEXT *ctx;
257 TSS2_TCTI_CONTEXT_COMMON_V1 tcti = {0};
258 TSS2_SYS_CONTEXT *sys_ctx = NULL;
259 TSS2_RC rc;
260
261 rc = Esys_GetSysContext(NULL, NULL);
262 assert_int_equal(rc, TSS2_ESYS_RC_BAD_REFERENCE);
263
264 tcti.version = 1;
265 tcti.transmit = (void*) 0xdeadbeef;
266 tcti.receive = (void*) 0xdeadbeef;
267
268 rc = Esys_Initialize(&ctx, (TSS2_TCTI_CONTEXT *) &tcti, NULL);
269 assert_int_equal(rc, TSS2_RC_SUCCESS);
270
271 rc = Esys_GetSysContext(ctx, &sys_ctx);
272 assert_ptr_not_equal(sys_ctx, NULL);
273 assert_int_equal(rc, TSS2_RC_SUCCESS);
274
275 Esys_Finalize(&ctx);
276 }
277
278 int
main(int argc,char * argv[])279 main(int argc, char *argv[])
280 {
281 const struct CMUnitTest tests[] = {
282 cmocka_unit_test(check_hash_functions),
283 cmocka_unit_test(check_hmac_functions),
284 cmocka_unit_test(check_random),
285 cmocka_unit_test(check_pk_encrypt),
286 cmocka_unit_test(check_aes_encrypt),
287 cmocka_unit_test(check_free),
288 cmocka_unit_test(check_get_sys_context),
289 };
290 return cmocka_run_group_tests(tests, NULL, NULL);
291 }
292