1 /*
2 * This file and its contents are supplied under the terms of the
3 * Common Development and Distribution License ("CDDL"), version 1.0.
4 * You may only use this file in accordance with the terms of version
5 * 1.0 of the CDDL.
6 *
7 * A full copy of the text of the CDDL should have accompanied this
8 * source. A copy of the CDDL is also available via the Internet at
9 * http://www.illumos.org/license/CDDL.
10 */
11
12 /*
13 * Copyright 2016 Nexenta Systems, Inc. All rights reserved.
14 */
15
16 #define __EXTENSIONS__
17 #include <strings.h>
18 #include <stdlib.h>
19 #include <stdio.h>
20 #include "cryptotest.h"
21
22
23
24 test_fg_t cryptotest_decr_fg = {test_decrypt_single, test_decrypt};
25 test_fg_t cryptotest_encr_fg = {test_encrypt_single, test_encrypt};
26 test_fg_t cryptotest_mac_fg = {test_mac_single, test_mac};
27
28 /*
29 * Utils
30 */
31
32 void
33 printbuf(uint8_t *buf, char *name, size_t size)
34 {
35 size_t i;
36
37 flockfile(stderr);
38 (void) fprintf(stderr, "%s%s", name, (size > 0) ? " " : "");
39 for (i = 0; i < size; i++)
40 (void) fprintf(stderr, "%02x", buf[i]);
41 (void) fputc('\n', stderr);
42 funlockfile(stderr);
43 }
44
45 int
46 bufcmp(uint8_t *auth, uint8_t *cmp, size_t size)
47 {
48 if (memcmp(cmp, auth, size) != 0) {
49 (void) fprintf(stderr, "mismatched result\n\n");
50 printbuf(cmp, "calc", size);
51 printbuf(auth, "orig", size);
52 return (1);
53 } else {
54 (void) fprintf(stderr, "result matches\n\n");
55 return (0);
56 }
57 }
58
59 /*
60 * Wrapper functions
61 */
62
63 int
64 run_test(cryptotest_t *args, uint8_t *cmp, size_t cmplen,
65 test_fg_t *funcs)
66 {
67 int ret, errs = 0;
68 static int i = 0;
69
70 (void) fprintf(stderr, "%s: run %d\n", args->mechname, ++i);
71 bzero(args->out, args->outlen);
72 ret = funcs->update(args);
73 if (ret > 0) {
74 (void) fprintf(stderr, "failure %x\n", ret);
75 errs += 1;
76 } else if (ret < 0) {
77 (void) fprintf(stderr, "fatal error %d\n", ret);
78 exit(1);
79 } else
80 errs += bufcmp(cmp, args->out, cmplen);
81
82 bzero(args->out, args->outlen);
83 ret = funcs->single(args);
84 if (ret > 0) {
85 (void) fprintf(stderr, "failure %x\n", ret);
86 errs += 1;
87 } else if (ret < 0) {
88 (void) fprintf(stderr, "fatal error %d\n", ret);
89 exit(2);
90 } else
91 errs += bufcmp(cmp, args->out, cmplen);
92
93 return (errs);
94 }
95
96 static int
97 test_mac_common(cryptotest_t *args, boolean_t AIO)
98 {
99 int ret, i;
100 crypto_op_t *crypto_op;
101
102 if (args->in == NULL || args->key == NULL)
103 return (CRYPTO_FAILED);
104
105 if ((crypto_op = cryptotest_init(args, CRYPTO_FG_MAC)) == NULL) {
106 (void) fprintf(stderr, "Error occured during initialization\n");
107 (void) cryptotest_close(NULL);
108 return (CTEST_INIT_FAILED);
109 }
110
111 if ((ret = get_mech_info(crypto_op)) != CRYPTO_SUCCESS)
112 goto out;
113
114 if ((ret = get_hsession_by_mech(crypto_op)) != CRYPTO_SUCCESS)
115 goto out;
116
117 if ((ret = mac_init(crypto_op)) != CRYPTO_SUCCESS)
118 goto out;
119
120 if (AIO) {
121 if ((ret = mac_single(crypto_op)) != CRYPTO_SUCCESS)
122 goto out;
123 } else {
124 for (i = 0; i < args->inlen; i += args->updatelen) {
125
126 if ((ret = mac_update(crypto_op, i)) != CRYPTO_SUCCESS)
127 goto out;
128 }
129
130 if ((ret = mac_final(crypto_op)) != CRYPTO_SUCCESS)
131 goto out;
132
133 }
134
135 out:
136 (void) cryptotest_close(crypto_op);
137 return (ret);
138 }
139
140 int
141 test_mac_single(cryptotest_t *args)
142 {
143 return (test_mac_common(args, B_TRUE));
144 }
145
146 int
147 test_mac(cryptotest_t *args)
148 {
149 return (test_mac_common(args, B_FALSE));
150 }
151
152 static int
153 test_encrypt_common(cryptotest_t *args, boolean_t AIO)
154 {
155 int ret, i;
156 size_t encrlen = 0;
157 crypto_op_t *crypto_op;
158
159 if (args->key == NULL)
160 return (CRYPTO_FAILED);
161
162 if ((crypto_op = cryptotest_init(args, CRYPTO_FG_ENCRYPT)) == NULL) {
163 (void) fprintf(stderr, "Error occured during initialization\n");
164 (void) cryptotest_close(NULL);
165 return (CTEST_INIT_FAILED);
166 }
167
168 if ((ret = get_mech_info(crypto_op)) != CRYPTO_SUCCESS)
169 goto out;
170
171 if ((ret = get_hsession_by_mech(crypto_op)) != CRYPTO_SUCCESS)
172 goto out;
173
174 if ((ret = encrypt_init(crypto_op)) != CRYPTO_SUCCESS)
175 goto out;
176
177 if (AIO) {
178 if ((ret = encrypt_single(crypto_op)) != CRYPTO_SUCCESS)
179 goto out;
180 } else {
181 for (i = 0; i < args->inlen; i += args->updatelen) {
182
183 if ((ret = encrypt_update(crypto_op, i,
184 &encrlen)) != CRYPTO_SUCCESS)
185 goto out;
186 }
187
188 if ((ret = encrypt_final(crypto_op, encrlen)) != CRYPTO_SUCCESS)
189 goto out;
190
191 }
192
193 out:
194 (void) cryptotest_close(crypto_op);
195 return (ret);
196 }
197
198 int
199 test_encrypt_single(cryptotest_t *args)
200 {
201 return (test_encrypt_common(args, B_TRUE));
202 }
203
204
205 int
206 test_encrypt(cryptotest_t *args)
207 {
208 return (test_encrypt_common(args, B_FALSE));
209 }
210
211 static int
212 test_decrypt_common(cryptotest_t *args, boolean_t AIO)
213 {
214 int ret, i;
215 size_t encrlen = 0;
216 crypto_op_t *crypto_op;
217
218 if (args->key == NULL)
219 return (CRYPTO_FAILED);
220
221 if ((crypto_op = cryptotest_init(args, CRYPTO_FG_DECRYPT)) == NULL) {
222 (void) fprintf(stderr, "Error occured during initialization\n");
223 (void) cryptotest_close(NULL);
224 return (CTEST_INIT_FAILED);
225 }
226
227 if ((ret = get_mech_info(crypto_op)) != CRYPTO_SUCCESS)
228 goto out;
229
230 if ((ret = get_hsession_by_mech(crypto_op)) != CRYPTO_SUCCESS)
231 goto out;
232
233 if ((ret = decrypt_init(crypto_op)) != CRYPTO_SUCCESS)
234 goto out;
235
236 if (AIO) {
237 if ((ret = decrypt_single(crypto_op)) != CRYPTO_SUCCESS)
238 goto out;
239 } else {
240 for (i = 0; i < args->inlen; i += args->updatelen) {
241
242 if ((ret = decrypt_update(crypto_op, i,
243 &encrlen)) != CRYPTO_SUCCESS)
244 goto out;
245 }
246
247 if ((ret = decrypt_final(crypto_op, encrlen)) != CRYPTO_SUCCESS)
248 goto out;
249
250 }
251
252 out:
253 (void) cryptotest_close(crypto_op);
254 return (ret);
255 }
256
257 int
258 test_decrypt_single(cryptotest_t *args)
259 {
260 return (test_decrypt_common(args, B_TRUE));
261 }
262
263
264 int
265 test_decrypt(cryptotest_t *args)
266 {
267 return (test_decrypt_common(args, B_FALSE));
268 }