blob: 88426854db94b93ce9de3ea4c9836e5da7d0d3a7 [file] [log] [blame]
Bence Szépkúti700ee442020-05-26 00:33:31 +02001/*
Bence Szépkúti1e148272020-08-07 13:07:28 +02002 * Copyright The Mbed TLS Contributors
Bence Szépkúti86974652020-06-15 11:59:37 +02003 * SPDX-License-Identifier: Apache-2.0
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License"); you may
6 * not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
13 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
Bence Szépkúti700ee442020-05-26 00:33:31 +020016 */
17
Gilles Peskine3f775262019-02-13 18:42:06 +010018#include <errno.h>
19#include <stdint.h>
Gilles Peskine029b5d62018-07-16 23:13:37 +020020#include <stdio.h>
21#include <stdlib.h>
22#include <string.h>
23
24#include "psa/crypto.h"
25
Darryl Green608e0912018-10-17 14:48:27 +010026/* This block is present to support Visual Studio builds prior to 2015 */
27#if defined(_MSC_VER) && _MSC_VER < 1900
28#include <stdarg.h>
Gilles Peskine449bd832023-01-11 14:50:10 +010029int snprintf(char *s, size_t n, const char *fmt, ...)
Darryl Green608e0912018-10-17 14:48:27 +010030{
31 int ret;
32 va_list argp;
33
34 /* Avoid calling the invalid parameter handler by checking ourselves */
Gilles Peskine449bd832023-01-11 14:50:10 +010035 if (s == NULL || n == 0 || fmt == NULL) {
36 return -1;
37 }
Darryl Green608e0912018-10-17 14:48:27 +010038
Gilles Peskine449bd832023-01-11 14:50:10 +010039 va_start(argp, fmt);
Darryl Green608e0912018-10-17 14:48:27 +010040#if defined(_TRUNCATE) && !defined(__MINGW32__)
Gilles Peskine449bd832023-01-11 14:50:10 +010041 ret = _vsnprintf_s(s, n, _TRUNCATE, fmt, argp);
Darryl Green608e0912018-10-17 14:48:27 +010042#else
Gilles Peskine449bd832023-01-11 14:50:10 +010043 ret = _vsnprintf(s, n, fmt, argp);
44 if (ret < 0 || (size_t) ret == n) {
Darryl Green608e0912018-10-17 14:48:27 +010045 s[n-1] = '\0';
46 ret = -1;
47 }
48#endif
Gilles Peskine449bd832023-01-11 14:50:10 +010049 va_end(argp);
Darryl Green608e0912018-10-17 14:48:27 +010050
Gilles Peskine449bd832023-01-11 14:50:10 +010051 return ret;
Darryl Green608e0912018-10-17 14:48:27 +010052}
53#endif
54
Gilles Peskine029b5d62018-07-16 23:13:37 +020055static void append(char **buffer, size_t buffer_size,
56 size_t *required_size,
57 const char *string, size_t length)
58{
59 *required_size += length;
60 if (*required_size < buffer_size) {
61 memcpy(*buffer, string, length);
62 *buffer += length;
63 }
64}
65
Gilles Peskine0deaf3d2018-08-20 15:06:39 +020066static void append_integer(char **buffer, size_t buffer_size,
67 size_t *required_size,
68 const char *format /*printf format for value*/,
69 unsigned long value)
70{
71 size_t n = snprintf(*buffer, buffer_size - *required_size, format, value);
Gilles Peskine449bd832023-01-11 14:50:10 +010072 if (n < buffer_size - *required_size) {
73 *buffer += n;
74 }
Gilles Peskine0deaf3d2018-08-20 15:06:39 +020075 *required_size += n;
76}
77
Gilles Peskine029b5d62018-07-16 23:13:37 +020078/* The code of these function is automatically generated and included below. */
Paul Elliott8ff510a2020-06-02 17:19:28 +010079static const char *psa_ecc_family_name(psa_ecc_family_t curve);
Paul Elliott75e27032020-06-03 15:17:39 +010080static const char *psa_dh_family_name(psa_dh_family_t group);
Gilles Peskine029b5d62018-07-16 23:13:37 +020081static const char *psa_hash_algorithm_name(psa_algorithm_t hash_alg);
82
83static void append_with_curve(char **buffer, size_t buffer_size,
84 size_t *required_size,
85 const char *string, size_t length,
Paul Elliott8ff510a2020-06-02 17:19:28 +010086 psa_ecc_family_t curve)
Gilles Peskine029b5d62018-07-16 23:13:37 +020087{
Paul Elliott8ff510a2020-06-02 17:19:28 +010088 const char *family_name = psa_ecc_family_name(curve);
Gilles Peskine029b5d62018-07-16 23:13:37 +020089 append(buffer, buffer_size, required_size, string, length);
90 append(buffer, buffer_size, required_size, "(", 1);
Paul Elliott8ff510a2020-06-02 17:19:28 +010091 if (family_name != NULL) {
Gilles Peskine029b5d62018-07-16 23:13:37 +020092 append(buffer, buffer_size, required_size,
Paul Elliott8ff510a2020-06-02 17:19:28 +010093 family_name, strlen(family_name));
Gilles Peskine029b5d62018-07-16 23:13:37 +020094 } else {
Gilles Peskine0deaf3d2018-08-20 15:06:39 +020095 append_integer(buffer, buffer_size, required_size,
Gilles Peskinef65ed6f2019-12-04 17:18:41 +010096 "0x%02x", curve);
Gilles Peskine029b5d62018-07-16 23:13:37 +020097 }
98 append(buffer, buffer_size, required_size, ")", 1);
99}
100
Gilles Peskinedcaefae2019-05-16 12:55:35 +0200101static void append_with_group(char **buffer, size_t buffer_size,
102 size_t *required_size,
103 const char *string, size_t length,
Paul Elliott75e27032020-06-03 15:17:39 +0100104 psa_dh_family_t group)
Gilles Peskinedcaefae2019-05-16 12:55:35 +0200105{
Paul Elliott75e27032020-06-03 15:17:39 +0100106 const char *group_name = psa_dh_family_name(group);
Gilles Peskinedcaefae2019-05-16 12:55:35 +0200107 append(buffer, buffer_size, required_size, string, length);
108 append(buffer, buffer_size, required_size, "(", 1);
109 if (group_name != NULL) {
110 append(buffer, buffer_size, required_size,
111 group_name, strlen(group_name));
112 } else {
113 append_integer(buffer, buffer_size, required_size,
Gilles Peskinef65ed6f2019-12-04 17:18:41 +0100114 "0x%02x", group);
Gilles Peskinedcaefae2019-05-16 12:55:35 +0200115 }
116 append(buffer, buffer_size, required_size, ")", 1);
117}
118
Gilles Peskine882e57e2019-04-12 00:12:07 +0200119typedef const char *(*psa_get_algorithm_name_func_ptr)(psa_algorithm_t alg);
120
121static void append_with_alg(char **buffer, size_t buffer_size,
122 size_t *required_size,
123 psa_get_algorithm_name_func_ptr get_name,
124 psa_algorithm_t alg)
Gilles Peskine029b5d62018-07-16 23:13:37 +0200125{
Gilles Peskine882e57e2019-04-12 00:12:07 +0200126 const char *name = get_name(alg);
127 if (name != NULL) {
Gilles Peskine029b5d62018-07-16 23:13:37 +0200128 append(buffer, buffer_size, required_size,
Gilles Peskine882e57e2019-04-12 00:12:07 +0200129 name, strlen(name));
Gilles Peskine029b5d62018-07-16 23:13:37 +0200130 } else {
Gilles Peskine0deaf3d2018-08-20 15:06:39 +0200131 append_integer(buffer, buffer_size, required_size,
Gilles Peskine882e57e2019-04-12 00:12:07 +0200132 "0x%08lx", alg);
Gilles Peskine029b5d62018-07-16 23:13:37 +0200133 }
Gilles Peskine029b5d62018-07-16 23:13:37 +0200134}
135
136#include "psa_constant_names_generated.c"
137
138static int psa_snprint_status(char *buffer, size_t buffer_size,
139 psa_status_t status)
140{
141 const char *name = psa_strerror(status);
142 if (name == NULL) {
143 return snprintf(buffer, buffer_size, "%ld", (long) status);
144 } else {
145 size_t length = strlen(name);
146 if (length < buffer_size) {
147 memcpy(buffer, name, length + 1);
Darryl Green18246962018-10-17 15:01:45 +0100148 return (int) length;
Gilles Peskine029b5d62018-07-16 23:13:37 +0200149 } else {
Darryl Green18246962018-10-17 15:01:45 +0100150 return (int) buffer_size;
Gilles Peskine029b5d62018-07-16 23:13:37 +0200151 }
152 }
153}
154
155static int psa_snprint_ecc_curve(char *buffer, size_t buffer_size,
Paul Elliott8ff510a2020-06-02 17:19:28 +0100156 psa_ecc_family_t curve)
Gilles Peskine029b5d62018-07-16 23:13:37 +0200157{
Paul Elliott8ff510a2020-06-02 17:19:28 +0100158 const char *name = psa_ecc_family_name(curve);
Gilles Peskine029b5d62018-07-16 23:13:37 +0200159 if (name == NULL) {
Gilles Peskinef65ed6f2019-12-04 17:18:41 +0100160 return snprintf(buffer, buffer_size, "0x%02x", (unsigned) curve);
Gilles Peskine029b5d62018-07-16 23:13:37 +0200161 } else {
162 size_t length = strlen(name);
163 if (length < buffer_size) {
164 memcpy(buffer, name, length + 1);
Darryl Green18246962018-10-17 15:01:45 +0100165 return (int) length;
Gilles Peskine029b5d62018-07-16 23:13:37 +0200166 } else {
Darryl Green18246962018-10-17 15:01:45 +0100167 return (int) buffer_size;
Gilles Peskine029b5d62018-07-16 23:13:37 +0200168 }
169 }
170}
171
Gilles Peskinedcaefae2019-05-16 12:55:35 +0200172static int psa_snprint_dh_group(char *buffer, size_t buffer_size,
Paul Elliott75e27032020-06-03 15:17:39 +0100173 psa_dh_family_t group)
Gilles Peskinedcaefae2019-05-16 12:55:35 +0200174{
Paul Elliott75e27032020-06-03 15:17:39 +0100175 const char *name = psa_dh_family_name(group);
Gilles Peskinedcaefae2019-05-16 12:55:35 +0200176 if (name == NULL) {
Gilles Peskinef65ed6f2019-12-04 17:18:41 +0100177 return snprintf(buffer, buffer_size, "0x%02x", (unsigned) group);
Gilles Peskinedcaefae2019-05-16 12:55:35 +0200178 } else {
179 size_t length = strlen(name);
180 if (length < buffer_size) {
181 memcpy(buffer, name, length + 1);
182 return (int) length;
183 } else {
184 return (int) buffer_size;
185 }
186 }
187}
188
Gilles Peskine029b5d62018-07-16 23:13:37 +0200189static void usage(const char *program_name)
190{
Gilles Peskine567840e2018-09-25 18:27:53 +0200191 printf("Usage: %s TYPE VALUE [VALUE...]\n",
Gilles Peskine029b5d62018-07-16 23:13:37 +0200192 program_name == NULL ? "psa_constant_names" : program_name);
193 printf("Print the symbolic name whose numerical value is VALUE in TYPE.\n");
194 printf("Supported types (with = between aliases):\n");
Gilles Peskine38808fa2018-08-20 15:07:37 +0200195 printf(" alg=algorithm Algorithm (psa_algorithm_t)\n");
Paul Elliott8ff510a2020-06-02 17:19:28 +0100196 printf(" curve=ecc_curve Elliptic curve identifier (psa_ecc_family_t)\n");
Paul Elliott75e27032020-06-03 15:17:39 +0100197 printf(" group=dh_group Diffie-Hellman group identifier (psa_dh_family_t)\n");
Gilles Peskine38808fa2018-08-20 15:07:37 +0200198 printf(" type=key_type Key type (psa_key_type_t)\n");
Gilles Peskine029b5d62018-07-16 23:13:37 +0200199 printf(" usage=key_usage Key usage (psa_key_usage_t)\n");
200 printf(" error=status Status code (psa_status_t)\n");
201}
202
Gilles Peskine567840e2018-09-25 18:27:53 +0200203typedef enum {
204 TYPE_STATUS,
Gilles Peskine3f775262019-02-13 18:42:06 +0100205} signed_value_type;
206
207int process_signed(signed_value_type type, long min, long max, char **argp)
208{
209 for (; *argp != NULL; argp++) {
210 char buffer[200];
211 char *end;
212 long value = strtol(*argp, &end, 0);
213 if (*end) {
214 printf("Non-numeric value: %s\n", *argp);
215 return EXIT_FAILURE;
216 }
217 if (value < min || (errno == ERANGE && value < 0)) {
218 printf("Value too small: %s\n", *argp);
219 return EXIT_FAILURE;
220 }
221 if (value > max || (errno == ERANGE && value > 0)) {
222 printf("Value too large: %s\n", *argp);
223 return EXIT_FAILURE;
224 }
225
226 switch (type) {
227 case TYPE_STATUS:
228 psa_snprint_status(buffer, sizeof(buffer),
229 (psa_status_t) value);
230 break;
231 }
232 puts(buffer);
233 }
234
235 return EXIT_SUCCESS;
236}
237
238typedef enum {
Gilles Peskine567840e2018-09-25 18:27:53 +0200239 TYPE_ALGORITHM,
240 TYPE_ECC_CURVE,
Gilles Peskinedcaefae2019-05-16 12:55:35 +0200241 TYPE_DH_GROUP,
Gilles Peskine567840e2018-09-25 18:27:53 +0200242 TYPE_KEY_TYPE,
243 TYPE_KEY_USAGE,
Gilles Peskine1b879842019-02-13 18:40:50 +0100244} unsigned_value_type;
Gilles Peskine567840e2018-09-25 18:27:53 +0200245
Gilles Peskine1b879842019-02-13 18:40:50 +0100246int process_unsigned(unsigned_value_type type, unsigned long max, char **argp)
Gilles Peskine029b5d62018-07-16 23:13:37 +0200247{
Gilles Peskine1b879842019-02-13 18:40:50 +0100248 for (; *argp != NULL; argp++) {
Gilles Peskine567840e2018-09-25 18:27:53 +0200249 char buffer[200];
250 char *end;
Gilles Peskine1b879842019-02-13 18:40:50 +0100251 unsigned long value = strtoul(*argp, &end, 0);
Gilles Peskine567840e2018-09-25 18:27:53 +0200252 if (*end) {
Gilles Peskine1b879842019-02-13 18:40:50 +0100253 printf("Non-numeric value: %s\n", *argp);
Gilles Peskine567840e2018-09-25 18:27:53 +0200254 return EXIT_FAILURE;
255 }
Gilles Peskine3f775262019-02-13 18:42:06 +0100256 if (value > max || errno == ERANGE) {
Gilles Peskine1b879842019-02-13 18:40:50 +0100257 printf("Value out of range: %s\n", *argp);
Gilles Peskine265a1712018-10-31 14:52:28 +0100258 return EXIT_FAILURE;
259 }
Gilles Peskine567840e2018-09-25 18:27:53 +0200260
261 switch (type) {
Gilles Peskine567840e2018-09-25 18:27:53 +0200262 case TYPE_ALGORITHM:
263 psa_snprint_algorithm(buffer, sizeof(buffer),
264 (psa_algorithm_t) value);
265 break;
266 case TYPE_ECC_CURVE:
267 psa_snprint_ecc_curve(buffer, sizeof(buffer),
Paul Elliott8ff510a2020-06-02 17:19:28 +0100268 (psa_ecc_family_t) value);
Gilles Peskine567840e2018-09-25 18:27:53 +0200269 break;
Gilles Peskinedcaefae2019-05-16 12:55:35 +0200270 case TYPE_DH_GROUP:
271 psa_snprint_dh_group(buffer, sizeof(buffer),
Paul Elliott75e27032020-06-03 15:17:39 +0100272 (psa_dh_family_t) value);
Gilles Peskinedcaefae2019-05-16 12:55:35 +0200273 break;
Gilles Peskine567840e2018-09-25 18:27:53 +0200274 case TYPE_KEY_TYPE:
275 psa_snprint_key_type(buffer, sizeof(buffer),
276 (psa_key_type_t) value);
277 break;
278 case TYPE_KEY_USAGE:
279 psa_snprint_key_usage(buffer, sizeof(buffer),
280 (psa_key_usage_t) value);
281 break;
282 }
283 puts(buffer);
284 }
285
Gilles Peskine029b5d62018-07-16 23:13:37 +0200286 return EXIT_SUCCESS;
287}
Gilles Peskine1b879842019-02-13 18:40:50 +0100288
289int main(int argc, char *argv[])
290{
291 if (argc <= 1 ||
292 !strcmp(argv[1], "help") ||
Gilles Peskine449bd832023-01-11 14:50:10 +0100293 !strcmp(argv[1], "--help")) {
Gilles Peskine1b879842019-02-13 18:40:50 +0100294 usage(argv[0]);
295 return EXIT_FAILURE;
296 }
297
298 if (!strcmp(argv[1], "error") || !strcmp(argv[1], "status")) {
Gilles Peskine3f775262019-02-13 18:42:06 +0100299 /* There's no way to obtain the actual range of a signed type,
300 * so hard-code it here: psa_status_t is int32_t. */
301 return process_signed(TYPE_STATUS, INT32_MIN, INT32_MAX,
302 argv + 2);
Gilles Peskine1b879842019-02-13 18:40:50 +0100303 } else if (!strcmp(argv[1], "alg") || !strcmp(argv[1], "algorithm")) {
304 return process_unsigned(TYPE_ALGORITHM, (psa_algorithm_t) (-1),
305 argv + 2);
306 } else if (!strcmp(argv[1], "curve") || !strcmp(argv[1], "ecc_curve")) {
Paul Elliott8ff510a2020-06-02 17:19:28 +0100307 return process_unsigned(TYPE_ECC_CURVE, (psa_ecc_family_t) (-1),
Gilles Peskine1b879842019-02-13 18:40:50 +0100308 argv + 2);
Gilles Peskinedcaefae2019-05-16 12:55:35 +0200309 } else if (!strcmp(argv[1], "group") || !strcmp(argv[1], "dh_group")) {
Paul Elliott75e27032020-06-03 15:17:39 +0100310 return process_unsigned(TYPE_DH_GROUP, (psa_dh_family_t) (-1),
Gilles Peskinedcaefae2019-05-16 12:55:35 +0200311 argv + 2);
Gilles Peskine1b879842019-02-13 18:40:50 +0100312 } else if (!strcmp(argv[1], "type") || !strcmp(argv[1], "key_type")) {
313 return process_unsigned(TYPE_KEY_TYPE, (psa_key_type_t) (-1),
314 argv + 2);
315 } else if (!strcmp(argv[1], "usage") || !strcmp(argv[1], "key_usage")) {
316 return process_unsigned(TYPE_KEY_USAGE, (psa_key_usage_t) (-1),
317 argv + 2);
318 } else {
319 printf("Unknown type: %s\n", argv[1]);
320 return EXIT_FAILURE;
321 }
322}