enc.c@ 94082

Last change on this file since 94082 was 94082, checked in by vboxsync, 3 years ago
libs/openssl-3.0.1: started applying and adjusting our OpenSSL changes to 3.0.1. bugref:10128
File size: 21.4 KB

Line
1	/*
2	* Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
3	*
4	* Licensed under the Apache License 2.0 (the "License"). You may not use
5	* this file except in compliance with the License. You can obtain a copy
6	* in the file LICENSE in the source distribution or at
7	* https://www.openssl.org/source/license.html
8	*/
9
10	#include <stdio.h>
11	#include <stdlib.h>
12	#include <string.h>
13	#include <limits.h>
14	#include "apps.h"
15	#include "progs.h"
16	#include <openssl/bio.h>
17	#include <openssl/err.h>
18	#include <openssl/evp.h>
19	#include <openssl/objects.h>
20	#include <openssl/x509.h>
21	#include <openssl/rand.h>
22	#include <openssl/pem.h>
23	#ifndef OPENSSL_NO_COMP
24	# include <openssl/comp.h>
25	#endif
26	#include <ctype.h>
27
28	#undef SIZE
29	#undef BSIZE
30	#define SIZE (512)
31	#define BSIZE (8*1024)
32
33	static int set_hex(const char in, unsigned char out, int size);
34	static void show_ciphers(const OBJ_NAME name, void bio_);
35
36	struct doall_enc_ciphers {
37	BIO *bio;
38	int n;
39	};
40
41	typedef enum OPTION_choice {
42	OPT_COMMON,
43	OPT_LIST,
44	OPT_E, OPT_IN, OPT_OUT, OPT_PASS, OPT_ENGINE, OPT_D, OPT_P, OPT_V,
45	OPT_NOPAD, OPT_SALT, OPT_NOSALT, OPT_DEBUG, OPT_UPPER_P, OPT_UPPER_A,
46	OPT_A, OPT_Z, OPT_BUFSIZE, OPT_K, OPT_KFILE, OPT_UPPER_K, OPT_NONE,
47	OPT_UPPER_S, OPT_IV, OPT_MD, OPT_ITER, OPT_PBKDF2, OPT_CIPHER,
48	OPT_R_ENUM, OPT_PROV_ENUM
49	} OPTION_CHOICE;
50
51	const OPTIONS enc_options[] = {
52	OPT_SECTION("General"),
53	{"help", OPT_HELP, '-', "Display this summary"},
54	{"list", OPT_LIST, '-', "List ciphers"},
55	#ifndef OPENSSL_NO_DEPRECATED_3_0
56	{"ciphers", OPT_LIST, '-', "Alias for -list"},
57	#endif
58	{"e", OPT_E, '-', "Encrypt"},
59	{"d", OPT_D, '-', "Decrypt"},
60	{"p", OPT_P, '-', "Print the iv/key"},
61	{"P", OPT_UPPER_P, '-', "Print the iv/key and exit"},
62	#ifndef OPENSSL_NO_ENGINE
63	{"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
64	#endif
65
66	OPT_SECTION("Input"),
67	{"in", OPT_IN, '<', "Input file"},
68	{"k", OPT_K, 's', "Passphrase"},
69	{"kfile", OPT_KFILE, '<', "Read passphrase from file"},
70
71	OPT_SECTION("Output"),
72	{"out", OPT_OUT, '>', "Output file"},
73	{"pass", OPT_PASS, 's', "Passphrase source"},
74	{"v", OPT_V, '-', "Verbose output"},
75	{"a", OPT_A, '-', "Base64 encode/decode, depending on encryption flag"},
76	{"base64", OPT_A, '-', "Same as option -a"},
77	{"A", OPT_UPPER_A, '-',
78	"Used with -[base64\|a] to specify base64 buffer as a single line"},
79
80	OPT_SECTION("Encryption"),
81	{"nopad", OPT_NOPAD, '-', "Disable standard block padding"},
82	{"salt", OPT_SALT, '-', "Use salt in the KDF (default)"},
83	{"nosalt", OPT_NOSALT, '-', "Do not use salt in the KDF"},
84	{"debug", OPT_DEBUG, '-', "Print debug info"},
85
86	{"bufsize", OPT_BUFSIZE, 's', "Buffer size"},
87	{"K", OPT_UPPER_K, 's', "Raw key, in hex"},
88	{"S", OPT_UPPER_S, 's', "Salt, in hex"},
89	{"iv", OPT_IV, 's', "IV in hex"},
90	{"md", OPT_MD, 's', "Use specified digest to create a key from the passphrase"},
91	{"iter", OPT_ITER, 'p', "Specify the iteration count and force use of PBKDF2"},
92	{"pbkdf2", OPT_PBKDF2, '-', "Use password-based key derivation function 2"},
93	{"none", OPT_NONE, '-', "Don't encrypt"},
94	#ifdef ZLIB
95	{"z", OPT_Z, '-', "Compress or decompress encrypted data using zlib"},
96	#endif
97	{"", OPT_CIPHER, '-', "Any supported cipher"},
98
99	OPT_R_OPTIONS,
100	OPT_PROV_OPTIONS,
101	{NULL}
102	};
103
104	int enc_main(int argc, char **argv)
105	{
106	static char buf[128];
107	static const char magic[] = "Salted__";
108	ENGINE *e = NULL;
109	BIO in = NULL, out = NULL, b64 = NULL, benc = NULL, *rbio =
110	NULL, *wbio = NULL;
111	EVP_CIPHER_CTX *ctx = NULL;
112	EVP_CIPHER *cipher = NULL;
113	EVP_MD *dgst = NULL;
114	const char *digestname = NULL;
115	char hkey = NULL, hiv = NULL, hsalt = NULL, p;
116	char infile = NULL, outfile = NULL, *prog;
117	char str = NULL, passarg = NULL, pass = NULL, strbuf = NULL;
118	const char *ciphername = NULL;
119	char mbuf[sizeof(magic) - 1];
120	OPTION_CHOICE o;
121	int bsize = BSIZE, verbose = 0, debug = 0, olb64 = 0, nosalt = 0;
122	int enc = 1, printkey = 0, i, k;
123	int base64 = 0, informat = FORMAT_BINARY, outformat = FORMAT_BINARY;
124	int ret = 1, inl, nopad = 0;
125	unsigned char key[EVP_MAX_KEY_LENGTH], iv[EVP_MAX_IV_LENGTH];
126	unsigned char *buff = NULL, salt[PKCS5_SALT_LEN];
127	int pbkdf2 = 0;
128	int iter = 0;
129	long n;
130	struct doall_enc_ciphers dec;
131	#ifdef ZLIB
132	int do_zlib = 0;
133	BIO *bzl = NULL;
134	#endif
135
136	/* first check the command name */
137	if (strcmp(argv[0], "base64") == 0)
138	base64 = 1;
139	#ifdef ZLIB
140	else if (strcmp(argv[0], "zlib") == 0)
141	do_zlib = 1;
142	#endif
143	else if (strcmp(argv[0], "enc") != 0)
144	ciphername = argv[0];
145
146	prog = opt_init(argc, argv, enc_options);
147	while ((o = opt_next()) != OPT_EOF) {
148	switch (o) {
149	case OPT_EOF:
150	case OPT_ERR:
151	opthelp:
152	BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
153	goto end;
154	case OPT_HELP:
155	opt_help(enc_options);
156	ret = 0;
157	goto end;
158	case OPT_LIST:
159	BIO_printf(bio_out, "Supported ciphers:\n");
160	dec.bio = bio_out;
161	dec.n = 0;
162	OBJ_NAME_do_all_sorted(OBJ_NAME_TYPE_CIPHER_METH,
163	show_ciphers, &dec);
164	BIO_printf(bio_out, "\n");
165	ret = 0;
166	goto end;
167	case OPT_E:
168	enc = 1;
169	break;
170	case OPT_IN:
171	infile = opt_arg();
172	break;
173	case OPT_OUT:
174	outfile = opt_arg();
175	break;
176	case OPT_PASS:
177	passarg = opt_arg();
178	break;
179	case OPT_ENGINE:
180	e = setup_engine(opt_arg(), 0);
181	break;
182	case OPT_D:
183	enc = 0;
184	break;
185	case OPT_P:
186	printkey = 1;
187	break;
188	case OPT_V:
189	verbose = 1;
190	break;
191	case OPT_NOPAD:
192	nopad = 1;
193	break;
194	case OPT_SALT:
195	nosalt = 0;
196	break;
197	case OPT_NOSALT:
198	nosalt = 1;
199	break;
200	case OPT_DEBUG:
201	debug = 1;
202	break;
203	case OPT_UPPER_P:
204	printkey = 2;
205	break;
206	case OPT_UPPER_A:
207	olb64 = 1;
208	break;
209	case OPT_A:
210	base64 = 1;
211	break;
212	case OPT_Z:
213	#ifdef ZLIB
214	do_zlib = 1;
215	#endif
216	break;
217	case OPT_BUFSIZE:
218	p = opt_arg();
219	i = (int)strlen(p) - 1;
220	k = i >= 1 && p[i] == 'k';
221	if (k)
222	p[i] = '\0';
223	if (!opt_long(opt_arg(), &n)
224	\|\| n < 0 \|\| (k && n >= LONG_MAX / 1024))
225	goto opthelp;
226	if (k)
227	n *= 1024;
228	bsize = (int)n;
229	break;
230	case OPT_K:
231	str = opt_arg();
232	break;
233	case OPT_KFILE:
234	in = bio_open_default(opt_arg(), 'r', FORMAT_TEXT);
235	if (in == NULL)
236	goto opthelp;
237	i = BIO_gets(in, buf, sizeof(buf));
238	BIO_free(in);
239	in = NULL;
240	if (i <= 0) {
241	BIO_printf(bio_err,
242	"%s Can't read key from %s\n", prog, opt_arg());
243	goto opthelp;
244	}
245	while (--i > 0 && (buf[i] == '\r' \|\| buf[i] == '\n'))
246	buf[i] = '\0';
247	if (i <= 0) {
248	BIO_printf(bio_err, "%s: zero length password\n", prog);
249	goto opthelp;
250	}
251	str = buf;
252	break;
253	case OPT_UPPER_K:
254	hkey = opt_arg();
255	break;
256	case OPT_UPPER_S:
257	hsalt = opt_arg();
258	break;
259	case OPT_IV:
260	hiv = opt_arg();
261	break;
262	case OPT_MD:
263	digestname = opt_arg();
264	break;
265	case OPT_CIPHER:
266	ciphername = opt_unknown();
267	break;
268	case OPT_ITER:
269	iter = opt_int_arg();
270	pbkdf2 = 1;
271	break;
272	case OPT_PBKDF2:
273	pbkdf2 = 1;
274	if (iter == 0) /* do not overwrite a chosen value */
275	iter = 10000;
276	break;
277	case OPT_NONE:
278	cipher = NULL;
279	break;
280	case OPT_R_CASES:
281	if (!opt_rand(o))
282	goto end;
283	break;
284	case OPT_PROV_CASES:
285	if (!opt_provider(o))
286	goto end;
287	break;
288	}
289	}
290
291	/* No extra arguments. */
292	argc = opt_num_rest();
293	if (argc != 0)
294	goto opthelp;
295	if (!app_RAND_load())
296	goto end;
297
298	/* Get the cipher name, either from progname (if set) or flag. */
299	if (ciphername != NULL) {
300	if (!opt_cipher(ciphername, &cipher))
301	goto opthelp;
302	}
303	if (digestname != NULL) {
304	if (!opt_md(digestname, &dgst))
305	goto opthelp;
306	}
307	if (dgst == NULL)
308	dgst = (EVP_MD *)EVP_sha256();
309
310	if (iter == 0)
311	iter = 1;
312
313	/* It must be large enough for a base64 encoded line */
314	if (base64 && bsize < 80)
315	bsize = 80;
316	if (verbose)
317	BIO_printf(bio_err, "bufsize=%d\n", bsize);
318
319	#ifdef ZLIB
320	if (!do_zlib)
321	#endif
322	if (base64) {
323	if (enc)
324	outformat = FORMAT_BASE64;
325	else
326	informat = FORMAT_BASE64;
327	}
328
329	strbuf = app_malloc(SIZE, "strbuf");
330	buff = app_malloc(EVP_ENCODE_LENGTH(bsize), "evp buffer");
331
332	if (infile == NULL) {
333	in = dup_bio_in(informat);
334	} else {
335	in = bio_open_default(infile, 'r', informat);
336	}
337	if (in == NULL)
338	goto end;
339
340	if (str == NULL && passarg != NULL) {
341	if (!app_passwd(passarg, NULL, &pass, NULL)) {
342	BIO_printf(bio_err, "Error getting password\n");
343	goto end;
344	}
345	str = pass;
346	}
347
348	if ((str == NULL) && (cipher != NULL) && (hkey == NULL)) {
349	if (1) {
350	#ifndef OPENSSL_NO_UI_CONSOLE
351	for (;;) {
352	char prompt[200];
353
354	BIO_snprintf(prompt, sizeof(prompt), "enter %s %s password:",
355	EVP_CIPHER_get0_name(cipher),
356	(enc) ? "encryption" : "decryption");
357	strbuf[0] = '\0';
358	i = EVP_read_pw_string((char *)strbuf, SIZE, prompt, enc);
359	if (i == 0) {
360	if (strbuf[0] == '\0') {
361	ret = 1;
362	goto end;
363	}
364	str = strbuf;
365	break;
366	}
367	if (i < 0) {
368	BIO_printf(bio_err, "bad password read\n");
369	goto end;
370	}
371	}
372	} else {
373	#endif
374	BIO_printf(bio_err, "password required\n");
375	goto end;
376	}
377	}
378
379	out = bio_open_default(outfile, 'w', outformat);
380	if (out == NULL)
381	goto end;
382
383	if (debug) {
384	BIO_set_callback_ex(in, BIO_debug_callback_ex);
385	BIO_set_callback_ex(out, BIO_debug_callback_ex);
386	BIO_set_callback_arg(in, (char *)bio_err);
387	BIO_set_callback_arg(out, (char *)bio_err);
388	}
389
390	rbio = in;
391	wbio = out;
392
393	#ifdef ZLIB
394	if (do_zlib) {
395	if ((bzl = BIO_new(BIO_f_zlib())) == NULL)
396	goto end;
397	if (debug) {
398	BIO_set_callback_ex(bzl, BIO_debug_callback_ex);
399	BIO_set_callback_arg(bzl, (char *)bio_err);
400	}
401	if (enc)
402	wbio = BIO_push(bzl, wbio);
403	else
404	rbio = BIO_push(bzl, rbio);
405	}
406	#endif
407
408	if (base64) {
409	if ((b64 = BIO_new(BIO_f_base64())) == NULL)
410	goto end;
411	if (debug) {
412	BIO_set_callback_ex(b64, BIO_debug_callback_ex);
413	BIO_set_callback_arg(b64, (char *)bio_err);
414	}
415	if (olb64)
416	BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
417	if (enc)
418	wbio = BIO_push(b64, wbio);
419	else
420	rbio = BIO_push(b64, rbio);
421	}
422
423	if (cipher != NULL) {
424	if (str != NULL) { /* a passphrase is available */
425	/*
426	* Salt handling: if encrypting generate a salt if not supplied,
427	* and write to output BIO. If decrypting use salt from input BIO
428	* if not given with args
429	*/
430	unsigned char *sptr;
431	size_t str_len = strlen(str);
432
433	if (nosalt) {
434	sptr = NULL;
435	} else {
436	if (hsalt != NULL && !set_hex(hsalt, salt, sizeof(salt))) {
437	BIO_printf(bio_err, "invalid hex salt value\n");
438	goto end;
439	}
440	if (enc) { /* encryption */
441	if (hsalt == NULL) {
442	if (RAND_bytes(salt, sizeof(salt)) <= 0) {
443	BIO_printf(bio_err, "RAND_bytes failed\n");
444	goto end;
445	}
446	/*
447	* If -P option then don't bother writing.
448	* If salt is given, shouldn't either ?
449	*/
450	if ((printkey != 2)
451	&& (BIO_write(wbio, magic,
452	sizeof(magic) - 1) != sizeof(magic) - 1
453	\|\| BIO_write(wbio,
454	(char *)salt,
455	sizeof(salt)) != sizeof(salt))) {
456	BIO_printf(bio_err, "error writing output file\n");
457	goto end;
458	}
459	}
460	} else { /* decryption */
461	if (hsalt == NULL) {
462	if (BIO_read(rbio, mbuf, sizeof(mbuf)) != sizeof(mbuf)) {
463	BIO_printf(bio_err, "error reading input file\n");
464	goto end;
465	}
466	if (memcmp(mbuf, magic, sizeof(mbuf)) == 0) { /* file IS salted */
467	if (BIO_read(rbio, salt,
468	sizeof(salt)) != sizeof(salt)) {
469	BIO_printf(bio_err, "error reading input file\n");
470	goto end;
471	}
472	} else { /* file is NOT salted, NO salt available */
473	BIO_printf(bio_err, "bad magic number\n");
474	goto end;
475	}
476	}
477	}
478	sptr = salt;
479	}
480
481	if (pbkdf2 == 1) {
482	/*
483	* derive key and default iv
484	* concatenated into a temporary buffer
485	*/
486	unsigned char tmpkeyiv[EVP_MAX_KEY_LENGTH + EVP_MAX_IV_LENGTH];
487	int iklen = EVP_CIPHER_get_key_length(cipher);
488	int ivlen = EVP_CIPHER_get_iv_length(cipher);
489	/* not needed if HASH_UPDATE() is fixed : */
490	int islen = (sptr != NULL ? sizeof(salt) : 0);
491	if (!PKCS5_PBKDF2_HMAC(str, str_len, sptr, islen,
492	iter, dgst, iklen+ivlen, tmpkeyiv)) {
493	BIO_printf(bio_err, "PKCS5_PBKDF2_HMAC failed\n");
494	goto end;
495	}
496	/* split and move data back to global buffer */
497	memcpy(key, tmpkeyiv, iklen);
498	memcpy(iv, tmpkeyiv+iklen, ivlen);
499	} else {
500	BIO_printf(bio_err, "*** WARNING : "
501	"deprecated key derivation used.\n"
502	"Using -iter or -pbkdf2 would be better.\n");
503	if (!EVP_BytesToKey(cipher, dgst, sptr,
504	(unsigned char *)str, str_len,
505	1, key, iv)) {
506	BIO_printf(bio_err, "EVP_BytesToKey failed\n");
507	goto end;
508	}
509	}
510	/*
511	* zero the complete buffer or the string passed from the command
512	* line.
513	*/
514	if (str == strbuf)
515	OPENSSL_cleanse(str, SIZE);
516	else
517	OPENSSL_cleanse(str, str_len);
518	}
519	if (hiv != NULL) {
520	int siz = EVP_CIPHER_get_iv_length(cipher);
521	if (siz == 0) {
522	BIO_printf(bio_err, "warning: iv not used by this cipher\n");
523	} else if (!set_hex(hiv, iv, siz)) {
524	BIO_printf(bio_err, "invalid hex iv value\n");
525	goto end;
526	}
527	}
528	if ((hiv == NULL) && (str == NULL)
529	&& EVP_CIPHER_get_iv_length(cipher) != 0) {
530	/*
531	* No IV was explicitly set and no IV was generated.
532	* Hence the IV is undefined, making correct decryption impossible.
533	*/
534	BIO_printf(bio_err, "iv undefined\n");
535	goto end;
536	}
537	if (hkey != NULL) {
538	if (!set_hex(hkey, key, EVP_CIPHER_get_key_length(cipher))) {
539	BIO_printf(bio_err, "invalid hex key value\n");
540	goto end;
541	}
542	/* wiping secret data as we no longer need it */
543	cleanse(hkey);
544	}
545
546	if ((benc = BIO_new(BIO_f_cipher())) == NULL)
547	goto end;
548
549	/*
550	* Since we may be changing parameters work on the encryption context
551	* rather than calling BIO_set_cipher().
552	*/
553
554	BIO_get_cipher_ctx(benc, &ctx);
555
556	if (!EVP_CipherInit_ex(ctx, cipher, e, NULL, NULL, enc)) {
557	BIO_printf(bio_err, "Error setting cipher %s\n",
558	EVP_CIPHER_get0_name(cipher));
559	ERR_print_errors(bio_err);
560	goto end;
561	}
562
563	if (nopad)
564	EVP_CIPHER_CTX_set_padding(ctx, 0);
565
566	if (!EVP_CipherInit_ex(ctx, NULL, NULL, key, iv, enc)) {
567	BIO_printf(bio_err, "Error setting cipher %s\n",
568	EVP_CIPHER_get0_name(cipher));
569	ERR_print_errors(bio_err);
570	goto end;
571	}
572
573	if (debug) {
574	BIO_set_callback_ex(benc, BIO_debug_callback_ex);
575	BIO_set_callback_arg(benc, (char *)bio_err);
576	}
577
578	if (printkey) {
579	if (!nosalt) {
580	printf("salt=");
581	for (i = 0; i < (int)sizeof(salt); i++)
582	printf("%02X", salt[i]);
583	printf("\n");
584	}
585	if (EVP_CIPHER_get_key_length(cipher) > 0) {
586	printf("key=");
587	for (i = 0; i < EVP_CIPHER_get_key_length(cipher); i++)
588	printf("%02X", key[i]);
589	printf("\n");
590	}
591	if (EVP_CIPHER_get_iv_length(cipher) > 0) {
592	printf("iv =");
593	for (i = 0; i < EVP_CIPHER_get_iv_length(cipher); i++)
594	printf("%02X", iv[i]);
595	printf("\n");
596	}
597	if (printkey == 2) {
598	ret = 0;
599	goto end;
600	}
601	}
602	}
603
604	/* Only encrypt/decrypt as we write the file */
605	if (benc != NULL)
606	wbio = BIO_push(benc, wbio);
607
608	while (BIO_pending(rbio) \|\| !BIO_eof(rbio)) {
609	inl = BIO_read(rbio, (char *)buff, bsize);
610	if (inl <= 0)
611	break;
612	if (BIO_write(wbio, (char *)buff, inl) != inl) {
613	BIO_printf(bio_err, "error writing output file\n");
614	goto end;
615	}
616	}
617	if (!BIO_flush(wbio)) {
618	BIO_printf(bio_err, "bad decrypt\n");
619	goto end;
620	}
621
622	ret = 0;
623	if (verbose) {
624	BIO_printf(bio_err, "bytes read : %8ju\n", BIO_number_read(in));
625	BIO_printf(bio_err, "bytes written: %8ju\n", BIO_number_written(out));
626	}
627	end:
628	ERR_print_errors(bio_err);
629	OPENSSL_free(strbuf);
630	OPENSSL_free(buff);
631	BIO_free(in);
632	BIO_free_all(out);
633	BIO_free(benc);
634	BIO_free(b64);
635	EVP_MD_free(dgst);
636	EVP_CIPHER_free(cipher);
637	#ifdef ZLIB
638	BIO_free(bzl);
639	#endif
640	release_engine(e);
641	OPENSSL_free(pass);
642	return ret;
643	}
644
645	static void show_ciphers(const OBJ_NAME name, void arg)
646	{
647	struct doall_enc_ciphers dec = (struct doall_enc_ciphers )arg;
648	const EVP_CIPHER *cipher;
649
650	if (!islower((unsigned char)*name->name))
651	return;
652
653	/* Filter out ciphers that we cannot use */
654	cipher = EVP_get_cipherbyname(name->name);
655	if (cipher == NULL
656	\|\| (EVP_CIPHER_get_flags(cipher) & EVP_CIPH_FLAG_AEAD_CIPHER) != 0
657	\|\| EVP_CIPHER_get_mode(cipher) == EVP_CIPH_XTS_MODE)
658	return;
659
660	BIO_printf(dec->bio, "-%-25s", name->name);
661	if (++dec->n == 3) {
662	BIO_printf(dec->bio, "\n");
663	dec->n = 0;
664	} else
665	BIO_printf(dec->bio, " ");
666	}
667
668	static int set_hex(const char in, unsigned char out, int size)
669	{
670	int i, n;
671	unsigned char j;
672
673	i = size * 2;
674	n = strlen(in);
675	if (n > i) {
676	BIO_printf(bio_err, "hex string is too long, ignoring excess\n");
677	n = i; /* ignore exceeding part */
678	} else if (n < i) {
679	BIO_printf(bio_err, "hex string is too short, padding with zero bytes to length\n");
680	}
681
682	memset(out, 0, size);
683	for (i = 0; i < n; i++) {
684	j = (unsigned char)*in++;
685	if (!isxdigit(j)) {
686	BIO_printf(bio_err, "non-hex digit\n");
687	return 0;
688	}
689	j = (unsigned char)OPENSSL_hexchar2int(j);
690	if (i & 1)
691	out[i / 2] \|= j;
692	else
693	out[i / 2] = (j << 4);
694	}
695	return 1;
696	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/openssl-3.0.1/apps/enc.c@ 94082

Download in other formats: