input
stringlengths 30
10.8M
| output
stringlengths 30
15.4M
|
|---|---|
int hdflush(void)
{
unsigned int flags;
char *disk;
DIR *blk;
if ((blk = opendir("/sys/block")) == (DIR*)0)
return -1;
while ((disk = list_disks(blk, &flags)))
do_standby_disk(disk, (flags|0x00000020));
return closedir(blk);
}
static char *strstrip(char *str)
{
const size_t len = strlen(str);
if (len) {
char* end = str + len - 1;
while ((end != str) && (((*end)==' ')||((*end)=='\n')||((*end)=='\t')||((*end)=='\v')||((*end)=='\r')||((*end)=='\f')))
end--;
*(end + 1) = '\0';
}
return str;
}
static FILE *hdopen(const char* const format, const char* const name)
{
char buf[
255
+1];
FILE *fp = (FILE*)-1;
int fd, ret;
ret = snprintf(buf, sizeof(buf), format, name);
if ((ret >= (int)sizeof(buf)) || (ret < 0))
goto error;
fd = open(buf,
00
|
0400
);
if (fd < 0) {
if (
(*__errno_location ())
!=
2
)
goto error;
fp = (FILE*)0;
goto error;
}
fp = fdopen(fd, "r");
if (fp == (FILE*)0)
close(fd);
error:
return fp;
}
static int flush_cache_ext(const char *device)
{
unsigned char args[4+512];
unsigned short *id = (unsigned short*)(&args[4]);
char buf[
255
+1], *ptr;
int fd = -1, ret = 0;
FILE *fp;
fp = hdopen("/sys/block" "/%s/size", device);
if (0 == (long)fp || -1 == (long)fp) {
if (-1 == (long)fp)
return -1;
goto out;
}
ptr = fgets(buf, sizeof(buf), fp);
fclose(fp);
if (ptr == (char*)0)
goto out;
ptr = strstrip(buf);
if (*ptr == '\0')
goto out;
if ((size_t)atoll(buf) < (1<<28))
goto out;
ret = snprintf(buf, sizeof(buf), "/dev" "/%s", device);
if ((ret >= (int)sizeof(buf)) || (ret < 0))
return -1;
if ((fd = open(buf,
00
|
04000
)) < 0)
goto out;
memset(&args[0], 0, sizeof(args));
args[0] =
0xEC
;
args[3] = 1;
if (ioctl(fd,
0x031f
, &args))
goto out;
if ((id[83] & 0xE000) == 0x6000)
ret = 1;
out:
if (fd >= 0)
close(fd);
return ret;
}
|
int hdflush(void)
{
unsigned int flags;
char *disk;
DIR *blk;
if ((blk = opendir("/sys/block")) == (DIR*)0)
return -1;
while ((disk = list_disks(blk, &flags)))
do_standby_disk(disk, (flags|0x00000020));
return closedir(blk);
}
static char *strstrip(char *str)
{
const size_t len = strlen(str);
if (len) {
char* end = str + len - 1;
while ((end != str) && (((*end)==' ')||((*end)=='\n')||((*end)=='\t')||((*end)=='\v')||((*end)=='\r')||((*end)=='\f')))
end--;
*(end + 1) = '\0';
}
return str;
}
static FILE *hdopen(const char* const format, const char* const name)
{
char buf[
255
+1];
FILE *fp = (FILE*)-1;
int fd, ret;
ret = snprintf(buf, sizeof(buf), format, name);
if ((ret >= (int)sizeof(buf)) || (ret < 0))
goto error;
fd = open(buf,
00
|
0400
);
if (fd < 0) {
if (
(*__errno_location ())
!=
2
)
goto error;
fp = (FILE*)0;
goto error;
}
fp = fdopen(fd, "r");
if (fp == (FILE*)0)
close(fd);
error:
return fp;
}
static int flush_cache_ext(const char *device)
{
unsigned char args[4+512];
unsigned short *id = (unsigned short*)(&args[4]);
char buf[
255
+1], *ptr;
int fd = -1, ret = 0;
FILE *fp;
fp = hdopen("/sys/block" "/%s/size", device);
if (0 == (long)fp || -1 == (long)fp) {
if (-1 == (long)fp)
return -1;
goto out;
}
ptr = fgets(buf, sizeof(buf), fp);
fclose(fp);
if (ptr == (char*)0)
goto out;
ptr = strstrip(buf);
if (*ptr == '\0')
goto out;
if ((size_t)atoll(buf) < (1<<28))
goto out;
ret = snprintf(buf, sizeof(buf), "/dev" "/%s", device);
if ((ret >= (int)sizeof(buf)) || (ret < 0))
return -1;
if ((fd = open(buf,
00
|
04000
)) < 0)
goto out;
memset(&args[0], 0, sizeof(args));
args[0] =
0xEC
;
args[3] = 1;
if (ioctl(fd,
0x031f
, &args))
goto out;
if ((id[83] & 0xE000) == 0x6000)
ret = 1;
out:
if (fd >= 0)
close(fd);
return ret;
}
|
int print_cmd_completions(unsigned long long a0) {
[1760] struct_0 *v1; // rbx
[1760] unsigned long long v2; // rbp
[1760] void* v3; // rdi
[1760] void* v4; // rsi
[1760] unsigned int v5; // edx
[1760] unsigned long long v6; // rdi
[1760] unsigned long long v8; // rdi
[1760]
[1760] if (a0) {
v1 = a0;
[1771] v2 = 0;
[1774, 1776, 1780, 1783] while (true) {
[1776] v4 = progcomp_search(v1->field_8->field_0);
[1788, 1783] if (v4) {
print_one_completion(v1->field_8->field_0, v4);
[1800, 1803] v1 = v1->field_0;
[1808] if (v1)
continue;
[1811, 1814] v6 = v2;
[1816, 1820] return sh_chkwrite();
[1824, 3945, 3947, 1822, 1823] } else {
v5 = 5;
[1832, 1835] v2 = 1;
[1857, 1860, 1862, 1854] builtin_error(dcgettext(NULL, "%s: no completion specification", 0x5), v1->field_8->field_0);
[1840, 1847, 1849, 1867] v1 = v1->field_0;
[1872] if (v1)
continue;
[1875, 1878] v8 = 1;
[1880, 1884] return sh_chkwrite();
[1824, 3945, 3947, 1822, 1823] }
}
} else {
v3 = 0;
[1896, 1898, 1902] return sh_chkwrite();
[1824, 3945, 3947, 1822, 1823] }
}
|
int print_cmd_completions(unsigned long a0) {
[4194] unsigned int v0; // [bp-0x2c]
[4194] struct_0 *v1; // [bp-0x28]
[4194] unsigned long long v2; // [bp-0x20]
[4194]
[4194] v0 = 0;
[4194, 4198, 4199, 4202, 4203, 4207, 4211] for (v1 = a0; v1; v1 = v1->field_0) {
[4332, 4336, 4339, 4343, 4218, 4348, 4222] v2 = progcomp_search(v1->field_8->field_0);
[4242, 4247] if (v2) {
print_one_completion(v1->field_8->field_0, v2);
[4258, 4262, 4266, 4269, 4273, 4276, 4279] } else {
builtin_error(gettext("%s: no completion specification"), v1->field_8->field_0);
[4320, 4297, 4304, 4309, 4312, 4315] v0 = 1;
[4325, 4332, 4336, 4339, 4343, 4348] }
}
return sh_chkwrite(v0);
}
|
int buf_equal(unsigned long long a0, unsigned long long a1) {
[3088] unsigned int v1; // eax
[3088]
[3088] if (!sshbuf_ptr()) {
[3104] v1 = -10;
[3232] return v1;
[3203, 3204, 3205, 3207, 3209, 3199] } else if (!sshbuf_ptr()) {
[3117] v1 = -10;
[3232] return v1;
[3203, 3204, 3205, 3207, 3209, 3199] } else if (sshbuf_len(a0) != sshbuf_len(a1)) {
[3141, 3130, 3149, 3146] v1 = -0x4;
[3216] return v1;
[3203, 3204, 3205, 3207, 3209, 3199] } else {
v1 = timingsafe_bcmp(sshbuf_ptr(), sshbuf_ptr(), sshbuf_len(a0));
[3176, 3181, 3184, 3154, 3187, 3190, 3165] if (v1) {
v1 = -0x4;
[3216] return v1;
[3203, 3204, 3205, 3207, 3209, 3199] }
return v1;
[3203, 3204, 3205, 3207, 3209, 3199] }
}
|
int buf_equal(unsigned long long a0, unsigned long long a1) {
[6768] unsigned int v1; // eax
[6768]
[6768] if (!sshbuf_ptr(a0)) {
[6798] v1 = -10;
[6825] return v1;
[6947, 6948, 6950, 6951, 6943] } else if (!sshbuf_ptr(a1)) {
[6815] v1 = -10;
[6825] return v1;
[6947, 6948, 6950, 6951, 6943] } else {
v1 = (sshbuf_len(a0) == sshbuf_len(a1) ? -0x4 : (!timingsafe_bcmp(sshbuf_ptr(a0), sshbuf_ptr(a1), sshbuf_len(a0)) ? -0x4 : 0));
[6854, 6922, 6859, 6862, 6864, 6931, 6878, 6893, 6839, 6908] return v1;
[6947, 6948, 6950, 6951, 6943] }
}
|
void yyerror(unsigned long long a0) {
[64] unsigned long v0; // [bp-0x8]
[64] unsigned long v2; // rax
[64] unsigned long long v3; // rdx
[64] unsigned long long v4; // rax
[64]
[64] v0 = v2;
[64] sh_error("arithmetic expression: %s: \"%s\"", a0, arith_startbuf);
[65, 66, 68, 72, 79, 82, 89] v4 = do_binop("arithmetic expression: %s: \"%s\"", a0, v3);
[82, 94] return;
[94] }
|
void yyerror(unsigned long long a0) {
[0] sh_error("arithmetic expression: %s: \"%s\"", a0, arith_startbuf);
[0, 4, 5, 8, 12, 16, 23, 27, 30, 37, 42] }
|
static gnutls_pubkey_t _load_url_pubkey(const char *url)
{
int ret;
gnutls_pubkey_t pubkey;
unsigned int obj_flags = 0;
ret = gnutls_pubkey_init(&pubkey);
if (ret < 0) {
fprintf(
stderr
, "Error in %s:%d: %s\n", __func__, 238,
gnutls_strerror(ret));
app_exit(1);
}
ret = gnutls_pubkey_import_url(pubkey, url, obj_flags);
if (ret < 0) {
fprintf(
stderr
, "Error in %s:%d: %s: %s\n", __func__,
246, gnutls_strerror(ret), url);
app_exit(1);
}
return pubkey;
}
gnutls_privkey_t load_private_key(int mand, common_info_st * info)
{
gnutls_privkey_t key;
gnutls_datum_t dat;
size_t size;
if (!info->privkey && !mand)
return
((void *)0)
;
if (info->privkey ==
((void *)0)
) {
fprintf(
stderr
, "missing --load-privkey\n");
app_exit(1);
}
if (gnutls_url_is_supported(info->privkey) != 0)
return _load_url_privkey(info->privkey);
dat.data = (void *) _gnutls_read_file(info->privkey, 0x1, &size);
dat.size = size;
if (!dat.data) {
fprintf(
stderr
, "error reading file at --load-privkey: %s\n",
info->privkey);
app_exit(1);
}
key = _load_privkey(&dat, info);
free(dat.data);
return key;
}
gnutls_x509_privkey_t
load_x509_private_key(int mand, common_info_st * info)
{
gnutls_x509_privkey_t key;
int ret;
gnutls_datum_t dat;
size_t size;
unsigned int flags = 0;
const char *pass;
if (!info->privkey && !mand)
return
((void *)0)
;
if (info->privkey ==
((void *)0)
) {
fprintf(
stderr
, "missing --load-privkey\n");
app_exit(1);
}
ret = gnutls_x509_privkey_init(&key);
if (ret < 0) {
fprintf(
stderr
, "privkey_init: %s\n", gnutls_strerror(ret));
app_exit(1);
}
dat.data = (void *) _gnutls_read_file(info->privkey, 0x1, &size);
dat.size = size;
if (!dat.data) {
fprintf(
stderr
, "error reading file at --load-privkey: %s\n",
info->privkey);
app_exit(1);
}
if (info->pkcs8) {
pass = get_password(info, &flags, 0);
ret =
gnutls_x509_privkey_import_pkcs8(key, &dat,
info->incert_format,
pass, flags);
} else {
ret =
gnutls_x509_privkey_import2(key, &dat,
info->incert_format,
((void *)0)
,
0);
if (ret == -24) {
pass = get_password(info, &flags, 0);
ret =
gnutls_x509_privkey_import2(key, &dat,
info->
incert_format,
pass, flags);
}
}
free(dat.data);
if (ret == -207) {
fprintf(
stderr
,
"import error: could not find a valid PEM header; "
"check if your key is PEM encoded\n");
app_exit(1);
}
if (ret < 0) {
fprintf(
stderr
, "error importing private key: %s: %s\n",
info->privkey, gnutls_strerror(ret));
app_exit(1);
}
return key;
}
gnutls_x509_crt_t load_cert(int mand, common_info_st * info)
{
gnutls_x509_crt_t *crt;
gnutls_x509_crt_t ret_crt;
size_t size, i;
crt = load_cert_list(mand, &size, info);
if (crt) {
ret_crt = crt[0];
for (i=1;i<size;i++)
gnutls_x509_crt_deinit(crt[i]);
gnutls_free((void *) (crt)), crt=
((void *)0)
;
return ret_crt;
}
return
((void *)0)
;
}
gnutls_x509_crt_t *load_cert_list(int mand, size_t * crt_size,
common_info_st * info)
{
FILE *fp;
static gnutls_x509_crt_t *crt;
int ret;
gnutls_datum_t dat;
unsigned size;
unsigned int crt_max;
unsigned flags = 0;
*crt_size = 0;
if (info->verbose)
fprintf(
stderr
, "Loading certificate list...\n");
if (info->cert ==
((void *)0)
) {
if (mand) {
fprintf(
stderr
, "missing --load-certificate\n");
app_exit(1);
} else
return
((void *)0)
;
}
fp = fopen(info->cert, "r");
if (fp ==
((void *)0)
) {
fprintf(
stderr
, "Could not open %s\n", info->cert);
app_exit(1);
}
fix_lbuffer(file_size(fp));
size = fread(lbuffer, 1, lbuffer_size - 1, fp);
lbuffer[size] = 0;
fclose(fp);
dat.data = (void *) lbuffer;
dat.size = size;
if (info->sort_chain)
flags |= GNUTLS_X509_CRT_LIST_SORT;
ret = gnutls_x509_crt_list_import2(&crt, &crt_max, &dat, GNUTLS_X509_FMT_PEM, flags);
if (ret < 0) {
fprintf(
stderr
, "Error loading certificates: %s\n", gnutls_strerror(ret));
app_exit(1);
}
*crt_size = crt_max;
if (info->verbose)
fprintf(
stderr
, "Loaded %d certificates.\n",
(int) crt_max);
return crt;
}
gnutls_x509_crl_t *load_crl_list(int mand, size_t * crl_size,
common_info_st * info)
{
FILE *fp;
static gnutls_x509_crl_t *crl;
unsigned int crl_max;
int ret;
gnutls_datum_t dat;
size_t size;
*crl_size = 0;
if (info->verbose)
fprintf(
stderr
, "Loading CRL list...\n");
if (info->crl ==
((void *)0)
) {
if (mand) {
fprintf(
stderr
, "missing --load-crl\n");
app_exit(1);
} else
return
((void *)0)
;
}
fp = fopen(info->crl, "r");
if (fp ==
((void *)0)
) {
fprintf(
stderr
, "Could not open %s\n", info->crl);
app_exit(1);
}
fix_lbuffer(file_size(fp));
size = fread(lbuffer, 1, lbuffer_size - 1, fp);
lbuffer[size] = 0;
fclose(fp);
dat.data = (void *) lbuffer;
dat.size = size;
ret = gnutls_x509_crl_list_import2(&crl, &crl_max, &dat, GNUTLS_X509_FMT_PEM, 0);
if (ret == -34) {
ret = gnutls_x509_crl_list_import2(&crl, &crl_max, &dat, GNUTLS_X509_FMT_DER, 0);
}
if (ret < 0) {
fprintf(
stderr
, "Error loading CRLs: %s\n", gnutls_strerror(ret));
app_exit(1);
}
*crl_size = crl_max;
if (info->verbose)
fprintf(
stderr
, "Loaded %d CRLs.\n",
(int) *crl_size);
return crl;
}
gnutls_x509_crq_t load_request(common_info_st * info)
{
gnutls_x509_crq_t crq;
int ret;
gnutls_datum_t dat;
size_t size;
if (!info->request)
return
((void *)0)
;
ret = gnutls_x509_crq_init(&crq);
if (ret < 0) {
fprintf(
stderr
, "crq_init: %s\n", gnutls_strerror(ret));
app_exit(1);
}
dat.data = (void *) _gnutls_read_file(info->request, 0x1, &size);
dat.size = size;
if (!dat.data) {
fprintf(
stderr
, "error reading file at --load-request: %s\n",
info->request);
app_exit(1);
}
ret = gnutls_x509_crq_import(crq, &dat, info->incert_format);
if (ret == -207) {
fprintf(
stderr
,
"import error: could not find a valid PEM header\n");
app_exit(1);
}
free(dat.data);
if (ret < 0) {
fprintf(
stderr
, "error importing certificate request: %s: %s\n",
info->request, gnutls_strerror(ret));
app_exit(1);
}
return crq;
}
gnutls_privkey_t load_ca_private_key(common_info_st * info)
{
gnutls_privkey_t key;
gnutls_datum_t dat;
size_t size;
if (info->ca_privkey ==
((void *)0)
) {
fprintf(
stderr
, "missing --load-ca-privkey\n");
app_exit(1);
}
if (gnutls_url_is_supported(info->ca_privkey) != 0)
return _load_url_privkey(info->ca_privkey);
dat.data = (void *) _gnutls_read_file(info->ca_privkey, 0x1, &size);
dat.size = size;
if (!dat.data) {
fprintf(
stderr
, "error reading file at --load-ca-privkey: %s\n",
info->ca_privkey);
app_exit(1);
}
key = _load_privkey(&dat, info);
free(dat.data);
return key;
}
gnutls_x509_crt_t load_ca_cert(unsigned mand, common_info_st * info)
{
gnutls_x509_crt_t crt;
int ret;
gnutls_datum_t dat;
size_t size;
if (mand == 0 && info->ca ==
((void *)0)
) {
return
((void *)0)
;
}
if (info->ca ==
((void *)0)
) {
fprintf(
stderr
, "missing --load-ca-certificate\n");
app_exit(1);
}
ret = gnutls_x509_crt_init(&crt);
if (ret < 0) {
fprintf(
stderr
, "crt_init: %s\n", gnutls_strerror(ret));
app_exit(1);
}
if (gnutls_url_is_supported(info->ca) != 0) {
ret = gnutls_x509_crt_import_url(crt, info->ca, 0);
if (ret < 0) {
fprintf(
stderr
, "error importing CA certificate: %s: %s\n",
info->ca, gnutls_strerror(ret));
app_exit(1);
}
return crt;
}
dat.data = (void *) _gnutls_read_file(info->ca, 0x1, &size);
dat.size = size;
if (!dat.data) {
fprintf(
stderr
, "error reading file at --load-ca-certificate: %s\n",
info->ca);
app_exit(1);
}
ret = gnutls_x509_crt_import(crt, &dat, info->incert_format);
free(dat.data);
if (ret < 0) {
fprintf(
stderr
, "error importing CA certificate: %s: %s\n",
info->ca, gnutls_strerror(ret));
app_exit(1);
}
return crt;
}
gnutls_pubkey_t load_pubkey(int mand, common_info_st * info)
{
gnutls_pubkey_t key;
int ret;
gnutls_datum_t dat;
size_t size;
if (!info->pubkey && !mand)
return
((void *)0)
;
if (info->pubkey ==
((void *)0)
) {
fprintf(
stderr
, "missing --load-pubkey\n");
app_exit(1);
}
if (gnutls_url_is_supported(info->pubkey) != 0)
return _load_url_pubkey(info->pubkey);
ret = gnutls_pubkey_init(&key);
if (ret < 0) {
fprintf(
stderr
, "privkey_init: %s\n", gnutls_strerror(ret));
app_exit(1);
}
dat.data = (void *) _gnutls_read_file(info->pubkey, 0x1, &size);
dat.size = size;
if (!dat.data) {
fprintf(
stderr
, "error reading file at --load-pubkey: %s\n", info->pubkey);
app_exit(1);
}
ret = gnutls_pubkey_import(key, &dat, info->incert_format);
if (ret == -207) {
ret = gnutls_pubkey_import_x509_raw(key, &dat, info->incert_format, 0);
if (ret < 0) {
fprintf(
stderr
,
"import error: could not find a valid PEM header; "
"check if your key has the PUBLIC KEY header\n");
app_exit(1);
}
} else if (ret < 0) {
fprintf(
stderr
, "importing public key: %s: %s\n",
info->pubkey, gnutls_strerror(ret));
app_exit(1);
}
free(dat.data);
return key;
}
gnutls_pubkey_t load_public_key_or_import(int mand,
gnutls_privkey_t privkey,
common_info_st * info)
{
gnutls_pubkey_t pubkey;
int ret;
ret = gnutls_pubkey_init(&pubkey);
if (ret < 0) {
fprintf(
stderr
, "gnutls_pubkey_init: %s\n",
gnutls_strerror(ret));
app_exit(1);
}
if (!privkey || gnutls_pubkey_import_privkey(pubkey, privkey, 0, 0) < 0) {
gnutls_pubkey_deinit(pubkey);
pubkey = load_pubkey(0, info);
if (pubkey ==
((void *)0)
&& mand) {
fprintf(
stderr
, "Could not determine the public key for the operation.\nYou must specify --load-privkey or --load-pubkey if missing.\n");
app_exit(1);
}
}
return pubkey;
}
static const char *bits_to_sp(gnutls_pk_algorithm_t pk, unsigned int bits)
{
gnutls_sec_param_t s = gnutls_pk_bits_to_sec_param(pk, bits);
if (s == GNUTLS_SEC_PARAM_UNKNOWN) {
return gnutls_sec_param_get_name(GNUTLS_SEC_PARAM_MEDIUM);
}
return gnutls_sec_param_get_name(s);
}
int
get_bits(gnutls_pk_algorithm_t key_type, int info_bits,
const char *info_sec_param, int warn)
{
int bits;
if (info_bits != 0) {
static int warned = 0;
if (warned == 0 && warn != 0 && (((unsigned int)(info_bits)) & 0x80000000)==0) {
warned = 1;
fprintf(
stderr
,
"** Note: You may use '--sec-param %s' instead of '--bits %d'\n",
bits_to_sp(key_type, info_bits), info_bits);
}
bits = info_bits;
} else {
if (info_sec_param == 0) {
info_sec_param = "HIGH";
}
bits =
gnutls_sec_param_to_pk_bits(key_type,
str_to_sec_param
(info_sec_param));
}
return bits;
}
gnutls_sec_param_t str_to_sec_param(const char *str)
{
if (strcasecmp(str, "low") == 0) {
return GNUTLS_SEC_PARAM_LOW;
} else if (strcasecmp(str, "legacy") == 0) {
return GNUTLS_SEC_PARAM_LEGACY;
} else if (strcasecmp(str, "normal") == 0 || strcasecmp(str, "medium") == 0) {
return GNUTLS_SEC_PARAM_MEDIUM;
} else if (strcasecmp(str, "high") == 0) {
return GNUTLS_SEC_PARAM_HIGH;
} else if (strcasecmp(str, "ultra") == 0) {
return GNUTLS_SEC_PARAM_ULTRA;
} else if (strcasecmp(str, "future") == 0) {
return GNUTLS_SEC_PARAM_FUTURE;
} else {
fprintf(
stderr
, "Unknown security parameter string: %s\n",
str);
app_exit(1);
}
}
static void
print_hex_datum(FILE * outfile, gnutls_datum_t * dat, int cprint)
{
unsigned int j;
if (cprint != 0) {
fprintf(outfile, "\n" "\t" "\"");
for (j = 0; j < dat->size; j++) {
fprintf(outfile, "\\x%.2x",
(unsigned char) dat->data[j]);
if ((j + 1) % 16 == 0) {
fprintf(outfile, "\"\n" "\t" "\"");
}
}
fprintf(outfile, "\";\n\n");
return;
}
fprintf(outfile, "\n" "\t");
for (j = 0; j < dat->size; j++) {
if ((j + 1) % 16 == 0) {
fprintf(outfile, "%.2x", (unsigned char) dat->data[j]);
fprintf(outfile, "\n" "\t");
} else {
fprintf(outfile, "%.2x:", (unsigned char) dat->data[j]);
}
}
fprintf(outfile, "\n\n");
}
static void print_head(FILE * out, const char *txt, unsigned int size,
int cprint)
{
unsigned i;
char *p, *ntxt;
int ret;
if (cprint != 0) {
if (size > 0)
ret = asprintf(&ntxt, "const unsigned char %s[%u] =",
txt, size);
else
ret = asprintf(&ntxt, "const unsigned char %s[] =\n",
txt);
if (ret == -1) {
fprintf(
stderr
, "memory error\n");
app_exit(1);
}
p = strstr(ntxt, "char");
p += 5;
for (i = 0; i < strlen(txt); i++)
if (p[i] == ' ')
p[i] = '_';
fprintf(out, "%s", ntxt);
free(ntxt);
return;
}
fprintf(out, "%s:", txt);
}
void
print_dsa_pkey(FILE * outfile, gnutls_datum_t * x, gnutls_datum_t * y,
gnutls_datum_t * p, gnutls_datum_t * q, gnutls_datum_t * g,
int cprint)
{
if (x) {
print_head(outfile, "private key", x->size, cprint);
print_hex_datum(outfile, x, cprint);
}
print_head(outfile, "public key", y->size, cprint);
print_hex_datum(outfile, y, cprint);
print_head(outfile, "p", p->size, cprint);
print_hex_datum(outfile, p, cprint);
print_head(outfile, "q", q->size, cprint);
print_hex_datum(outfile, q, cprint);
print_head(outfile, "g", g->size, cprint);
print_hex_datum(outfile, g, cprint);
}
gnutls_ecc_curve_t str_to_curve(const char *str)
{
unsigned num = 0;
const gnutls_ecc_curve_t *list, *p;
list = gnutls_ecc_curve_list();
p = list;
while(*p != 0) {
if (strcasecmp(str, gnutls_ecc_curve_get_name(*p)) == 0)
return *p;
p++;
num++;
}
fprintf(
stderr
, "Unsupported curve: %s\nAvailable curves:\n", str);
if (num == 0)
printf("none\n");
p = list;
while(*p != 0) {
fprintf(
stderr
, "\t- %s\n",
gnutls_ecc_curve_get_name(*p));
p++;
}
app_exit(1);
}
void
print_ecc_pkey(FILE * outfile, gnutls_ecc_curve_t curve,
gnutls_datum_t * k, gnutls_datum_t * x, gnutls_datum_t * y,
int cprint)
{
if (cprint != 0)
fprintf(outfile, "/* curve: %s */\n",
gnutls_ecc_curve_get_name(curve));
else
fprintf(outfile, "curve:\t%s\n",
gnutls_ecc_curve_get_name(curve));
if (k && k->data) {
print_head(outfile, "private key", k->size, cprint);
print_hex_datum(outfile, k, cprint);
}
if (x && x->data) {
print_head(outfile, "x", x->size, cprint);
print_hex_datum(outfile, x, cprint);
}
if (y && y->data) {
print_head(outfile, "y", y->size, cprint);
print_hex_datum(outfile, y, cprint);
}
}
static void reverse_datum(gnutls_datum_t *d)
{
unsigned int i;
unsigned char c;
for (i = 0; i < d->size / 2; i++) {
c = d->data[i];
d->data[i] = d->data[d->size - i - 1];
d->data[d->size - i - 1] = c;
}
}
void
print_gost_pkey(FILE * outfile, gnutls_ecc_curve_t curve,
gnutls_digest_algorithm_t digest, gnutls_gost_paramset_t paramset,
gnutls_datum_t * k, gnutls_datum_t * x, gnutls_datum_t * y,
int cprint)
{
if (cprint != 0)
fprintf(outfile, "/* curve: %s */\n",
gnutls_ecc_curve_get_name(curve));
else
fprintf(outfile, "curve:\t%s\n",
gnutls_ecc_curve_get_name(curve));
if (cprint != 0)
fprintf(outfile, "/* digest: %s */\n",
gnutls_digest_get_name(digest));
else
fprintf(outfile, "digest:\t%s\n",
gnutls_digest_get_name(digest));
if (cprint != 0)
fprintf(outfile, "/* paramset: %s */\n",
gnutls_gost_paramset_get_name(paramset));
else
fprintf(outfile, "paramset:\t%s\n",
gnutls_gost_paramset_get_name(paramset));
if (k) {
reverse_datum(k);
print_head(outfile, "private key", k->size, cprint);
print_hex_datum(outfile, k, cprint);
}
reverse_datum(x);
reverse_datum(y);
print_head(outfile, "x", x->size, cprint);
print_hex_datum(outfile, x, cprint);
print_head(outfile, "y", y->size, cprint);
print_hex_datum(outfile, y, cprint);
}
void
print_rsa_pkey(FILE * outfile, gnutls_datum_t * m, gnutls_datum_t * e,
gnutls_datum_t * d, gnutls_datum_t * p, gnutls_datum_t * q,
gnutls_datum_t * u, gnutls_datum_t * exp1,
gnutls_datum_t * exp2, int cprint)
{
print_head(outfile, "modulus", m->size, cprint);
print_hex_datum(outfile, m, cprint);
print_head(outfile, "public exponent", e->size, cprint);
print_hex_datum(outfile, e, cprint);
if (d) {
print_head(outfile, "private exponent", d->size, cprint);
print_hex_datum(outfile, d, cprint);
print_head(outfile, "prime1", p->size, cprint);
print_hex_datum(outfile, p, cprint);
print_head(outfile, "prime2", q->size, cprint);
print_hex_datum(outfile, q, cprint);
print_head(outfile, "coefficient", u->size, cprint);
print_hex_datum(outfile, u, cprint);
if (exp1 && exp2) {
print_head(outfile, "exp1", exp1->size, cprint);
print_hex_datum(outfile, exp1, cprint);
print_head(outfile, "exp2", exp2->size, cprint);
print_hex_datum(outfile, exp2, cprint);
}
}
}
void print_pubkey_info(gnutls_pubkey_t pubkey,
FILE *outfile,
gnutls_certificate_print_formats_t format,
gnutls_x509_crt_fmt_t outcert_format,
unsigned int outtext)
{
gnutls_datum_t data;
int ret;
size_t size;
if (outtext) {
ret = gnutls_pubkey_print(pubkey, format, &data);
if (ret < 0) {
fprintf(
stderr
, "pubkey_print error: %s\n",
gnutls_strerror(ret));
app_exit(1);
}
fprintf(outfile, "%s\n\n", data.data);
gnutls_free((void *) (data.data)), data.data=
((void *)0)
;
}
fix_lbuffer(0);
size = lbuffer_size;
ret =
gnutls_pubkey_export(pubkey, outcert_format, lbuffer,
&size);
if (ret < 0) {
fprintf(
stderr
, "export error: %s\n", gnutls_strerror(ret));
app_exit(1);
}
fwrite(lbuffer, 1, size, outfile);
}
static void
print_dh_info(FILE * outfile, gnutls_datum_t * p, gnutls_datum_t * g,
unsigned int q_bits, int cprint)
{
if (q_bits > 0) {
if (cprint != 0)
fprintf(outfile,
"\n /* recommended key length: %d bytes */\n\n",
(7 + q_bits) / 8);
else
fprintf(outfile,
"\nRecommended key length: %d bits\n\n",
q_bits);
}
print_head(outfile, "generator", g->size, cprint);
print_hex_datum(outfile, g, cprint);
print_head(outfile, "prime", p->size, cprint);
print_hex_datum(outfile, p, cprint);
}
static
int import_dsa_dh(gnutls_dh_params_t dh_params, gnutls_datum_t *params, gnutls_x509_crt_fmt_t format)
{
gnutls_x509_privkey_t pkey;
int ret;
ret = gnutls_x509_privkey_init(&pkey);
if (ret < 0)
return ret;
ret = gnutls_x509_privkey_import(pkey, params, format);
if (ret < 0)
return ret;
ret = gnutls_dh_params_import_dsa(dh_params, pkey);
gnutls_x509_privkey_deinit(pkey);
return ret;
}
void dh_info(FILE * infile, FILE * outfile, common_info_st * ci)
{
gnutls_datum_t params;
size_t size;
int ret, ret2;
gnutls_dh_params_t dh_params;
gnutls_datum_t p, g;
unsigned int q_bits = 0;
fix_lbuffer(0);
if (gnutls_dh_params_init(&dh_params) < 0) {
fprintf(
stderr
, "Error in dh parameter initialization\n");
app_exit(1);
}
params.data = (void *) _gnutls_fread_file(infile, 0, &size);
params.size = size;
if (params.data ==
((void *)0)
) {
fprintf(
stderr
, "Could not read input\n");
app_exit(1);
}
ret =
gnutls_dh_params_import_pkcs3(dh_params, ¶ms,
ci->incert_format);
if (ret < 0) {
ret2 = import_dsa_dh(dh_params, ¶ms, ci->incert_format);
if (ret2 < 0) {
fprintf(
stderr
, "Error parsing dh params: %s\n",
gnutls_strerror(ret));
app_exit(1);
}
}
ret = gnutls_dh_params_export_raw(dh_params, &p, &g, &q_bits);
if (ret < 0) {
fprintf(
stderr
, "Error exporting parameters: %s\n",
gnutls_strerror(ret));
app_exit(1);
}
if (ci->outtext)
print_dh_info(outfile, &p, &g, q_bits, ci->cprint);
if (!ci->cprint) {
size_t len = lbuffer_size;
ret =
gnutls_dh_params_export_pkcs3(dh_params,
ci->outcert_format,
lbuffer, &len);
if (ret == 0) {
if (ci->outcert_format == GNUTLS_X509_FMT_PEM) {
fprintf(outfile, "\n%s", lbuffer);
} else {
fwrite(lbuffer, 1, len, outfile);
}
} else {
fprintf(
stderr
, "Error: %s\n",
gnutls_strerror(ret));
}
}
gnutls_free((void *) (p.data)), p.data=
((void *)0)
;
gnutls_free((void *) (g.data)), g.data=
((void *)0)
;
gnutls_dh_params_deinit(dh_params);
}
int cipher_to_flags(const char *cipher)
{
if (cipher ==
((void *)0)
) {
return GNUTLS_PKCS_PBES2_AES_128;
} else if (strcasecmp(cipher, "3des") == 0) {
return GNUTLS_PKCS_PBES2_3DES;
} else if (strcasecmp(cipher, "3des-pkcs12") == 0) {
return GNUTLS_PKCS_PKCS12_3DES;
} else if (strcasecmp(cipher, "arcfour") == 0) {
return GNUTLS_PKCS_PKCS12_ARCFOUR;
} else if (strcasecmp(cipher, "aes-128") == 0) {
return GNUTLS_PKCS_PBES2_AES_128;
} else if (strcasecmp(cipher, "aes-192") == 0) {
return GNUTLS_PKCS_PBES2_AES_192;
} else if (strcasecmp(cipher, "aes-256") == 0) {
return GNUTLS_PKCS_PBES2_AES_256;
} else if (strcasecmp(cipher, "rc2-40") == 0) {
return GNUTLS_PKCS_PKCS12_RC2_40;
} else if (strcasecmp(cipher, "gost28147-tc26z") == 0) {
return GNUTLS_PKCS_PBES2_GOST_TC26Z;
} else if (strcasecmp(cipher, "gost28147-cpa") == 0) {
return GNUTLS_PKCS_PBES2_GOST_CPA;
} else if (strcasecmp(cipher, "gost28147-cpb") == 0) {
return GNUTLS_PKCS_PBES2_GOST_CPB;
} else if (strcasecmp(cipher, "gost28147-cpc") == 0) {
return GNUTLS_PKCS_PBES2_GOST_CPC;
} else if (strcasecmp(cipher, "gost28147-cpd") == 0) {
return GNUTLS_PKCS_PBES2_GOST_CPD;
} else if (strcasecmp(cipher, "none") == 0) {
return GNUTLS_PKCS_PLAIN;
}
fprintf(
stderr
, "unknown cipher %s\n", cipher);
app_exit(1);
}
static void privkey_info_int(FILE *outfile, common_info_st * cinfo,
gnutls_x509_privkey_t key)
{
int ret, key_type;
unsigned int bits = 0;
size_t size;
const char *cprint;
gnutls_x509_spki_t spki;
gnutls_digest_algorithm_t dig;
fprintf(outfile, "Public Key Info:\n");
ret = gnutls_x509_spki_init(&spki);
if (ret < 0) {
fprintf(
stderr
, "spki_init: %s\n", gnutls_strerror(ret));
return;
}
fprintf(outfile, "\tPublic Key Algorithm: ");
key_type = gnutls_x509_privkey_get_pk_algorithm2(key, &bits);
cprint = gnutls_pk_algorithm_get_name(key_type);
fprintf(outfile, "%s\n", cprint ? cprint : "Unknown");
if (key_type == GNUTLS_PK_RSA_PSS) {
unsigned int salt_size;
ret = gnutls_x509_privkey_get_spki(key, spki, 0);
if (ret == -56)
goto spki_skip;
if (ret < 0) {
fprintf(
stderr
, "spki_get: %s\n", gnutls_strerror(ret));
goto spki_skip;
}
ret = gnutls_x509_spki_get_rsa_pss_params(spki, &dig, &salt_size);
if (ret < 0) {
fprintf(
stderr
, "spki_get_rsa_pss_params: %s\n",
gnutls_strerror(ret));
} else {
fprintf(outfile, "\t\tHash Algorithm: %s\n",
gnutls_digest_get_name(dig));
fprintf(outfile, "\t\tSalt Length: %d\n", salt_size);
}
}
spki_skip:
gnutls_x509_spki_deinit(spki);
fprintf(outfile, "\tKey Security Level: %s (%u bits)\n\n",
gnutls_sec_param_get_name(gnutls_x509_privkey_sec_param
(key)), bits);
if (((key_type) == GNUTLS_PK_RSA || (key_type) == GNUTLS_PK_RSA_PSS)) {
gnutls_datum_t m, e, d, p, q, u, exp1, exp2;
ret =
gnutls_x509_privkey_export_rsa_raw2(key, &m, &e, &d,
&p, &q, &u, &exp1,
&exp2);
if (ret < 0)
fprintf(
stderr
,
"Error in key RSA data export: %s\n",
gnutls_strerror(ret));
else {
print_rsa_pkey(outfile, &m, &e, &d, &p, &q, &u,
&exp1, &exp2, cinfo->cprint);
gnutls_free((void *) (m.data)), m.data=
((void *)0)
;
gnutls_free((void *) (e.data)), e.data=
((void *)0)
;
gnutls_free((void *) (d.data)), d.data=
((void *)0)
;
gnutls_free((void *) (p.data)), p.data=
((void *)0)
;
gnutls_free((void *) (q.data)), q.data=
((void *)0)
;
gnutls_free((void *) (u.data)), u.data=
((void *)0)
;
gnutls_free((void *) (exp1.data)), exp1.data=
((void *)0)
;
gnutls_free((void *) (exp2.data)), exp2.data=
((void *)0)
;
}
} else if (key_type == GNUTLS_PK_DSA) {
gnutls_datum_t p, q, g, y, x;
ret =
gnutls_x509_privkey_export_dsa_raw(key, &p, &q, &g, &y,
&x);
if (ret < 0)
fprintf(
stderr
,
"Error in key DSA data export: %s\n",
gnutls_strerror(ret));
else {
print_dsa_pkey(outfile, &x, &y, &p, &q, &g,
cinfo->cprint);
gnutls_free((void *) (x.data)), x.data=
((void *)0)
;
gnutls_free((void *) (y.data)), y.data=
((void *)0)
;
gnutls_free((void *) (p.data)), p.data=
((void *)0)
;
gnutls_free((void *) (q.data)), q.data=
((void *)0)
;
gnutls_free((void *) (g.data)), g.data=
((void *)0)
;
}
} else if (key_type == GNUTLS_PK_ECDSA ||
key_type == GNUTLS_PK_EDDSA_ED25519 ||
key_type == GNUTLS_PK_EDDSA_ED448 ||
key_type == GNUTLS_PK_ECDH_X25519 ||
key_type == GNUTLS_PK_ECDH_X448) {
gnutls_datum_t y, x, k;
gnutls_ecc_curve_t curve;
ret =
gnutls_x509_privkey_export_ecc_raw(key, &curve, &x, &y,
&k);
if (ret < 0)
fprintf(
stderr
,
"Error in key ECC data export: %s\n",
gnutls_strerror(ret));
else {
print_ecc_pkey(outfile, curve, &k, &x, &y,
cinfo->cprint);
gnutls_free((void *) (x.data)), x.data=
((void *)0)
;
gnutls_free((void *) (y.data)), y.data=
((void *)0)
;
gnutls_free((void *) (k.data)), k.data=
((void *)0)
;
}
} else if (key_type == GNUTLS_PK_GOST_01 ||
key_type == GNUTLS_PK_GOST_12_256 ||
key_type == GNUTLS_PK_GOST_12_512) {
gnutls_datum_t y, x, k;
gnutls_ecc_curve_t curve;
gnutls_digest_algorithm_t digest;
gnutls_gost_paramset_t paramset;
ret =
gnutls_x509_privkey_export_gost_raw(key, &curve,
&digest,
¶mset,
&x, &y, &k);
if (ret < 0)
fprintf(
stderr
,
"Error in key GOST data export: %s\n",
gnutls_strerror(ret));
else {
print_gost_pkey(outfile, curve, digest, paramset,
&k, &x, &y,
cinfo->cprint);
gnutls_free((void *) (x.data)), x.data=
((void *)0)
;
gnutls_free((void *) (y.data)), y.data=
((void *)0)
;
gnutls_free((void *) (k.data)), k.data=
((void *)0)
;
}
}
size = lbuffer_size;
ret = gnutls_x509_privkey_get_seed(key, &dig, lbuffer, &size);
if (ret >= 0) {
fprintf(outfile, "Validation parameters:\n");
fprintf(outfile, "\tHash: %s\n",
gnutls_digest_get_name(dig));
fprintf(outfile, "\tSeed: %s\n",
raw_to_hex(lbuffer, size));
}
fprintf(outfile, "\n");
size = lbuffer_size;
ret =
gnutls_x509_privkey_get_key_id(key, GNUTLS_KEYID_USE_SHA256, lbuffer, &size);
if (ret < 0) {
fprintf(
stderr
, "Error in key id calculation: %s\n",
gnutls_strerror(ret));
} else {
fprintf(outfile, "Public Key PIN:\n\tpin-sha256:%s\n",
raw_to_base64(lbuffer, size));
fprintf(outfile, "Public Key ID:\n\tsha256:%s\n",
raw_to_hex(lbuffer, size));
size = lbuffer_size;
ret =
gnutls_x509_privkey_get_key_id(key, GNUTLS_KEYID_USE_SHA1, lbuffer, &size);
if (ret >= 0) {
fprintf(outfile, "\tsha1:%s\n",
raw_to_hex(lbuffer, size));
}
}
fprintf(outfile, "\n");
}
void
print_private_key(FILE *outfile, common_info_st * cinfo, gnutls_x509_privkey_t key)
{
int ret;
size_t size;
if (!key)
return;
switch_to_pkcs8_when_needed(cinfo, key, gnutls_x509_privkey_get_pk_algorithm(key));
if (!cinfo->pkcs8) {
if (cinfo->outtext)
privkey_info_int(outfile, cinfo, key);
size = lbuffer_size;
ret = gnutls_x509_privkey_export(key, cinfo->outcert_format,
lbuffer, &size);
if (ret < 0) {
fprintf(
stderr
, "privkey_export: %s\n",
gnutls_strerror(ret));
app_exit(1);
}
} else {
unsigned int flags = 0;
const char *pass;
pass = get_password(cinfo, &flags, 0);
flags |= cipher_to_flags(cinfo->pkcs_cipher);
if (cinfo->outtext && (flags & GNUTLS_PKCS_PLAIN))
privkey_info_int(outfile, cinfo, key);
size = lbuffer_size;
ret =
gnutls_x509_privkey_export_pkcs8(key, cinfo->outcert_format,
pass, flags, lbuffer,
&size);
if (ret < 0) {
fprintf(
stderr
, "privkey_export_pkcs8: %s\n",
gnutls_strerror(ret));
app_exit(1);
}
}
fwrite(lbuffer, 1, size, outfile);
}
int generate_prime(FILE * outfile, int how, common_info_st * info)
{
int ret;
gnutls_dh_params_t dh_params;
gnutls_datum_t p, g;
int bits = get_bits(GNUTLS_PK_DH, info->bits, info->sec_param, 1);
unsigned int q_bits = 0, key_bits = 0;
fix_lbuffer(0);
gnutls_dh_params_init(&dh_params);
if (how != 0) {
fprintf(
stderr
, "Generating DH parameters (%d bits)...\n",
bits);
fprintf(
stderr
, "(might take long time)\n");
} else
fprintf(
stderr
, "Retrieving DH parameters...\n");
if (how != 0) {
if (info->provable != 0) {
gnutls_x509_privkey_t pkey;
ret = gnutls_x509_privkey_init(&pkey);
if (ret < 0) {
fprintf(
stderr
,
"Error initializing key: %s\n",
gnutls_strerror(ret));
app_exit(1);
}
if (info->seed_size > 0) {
gnutls_keygen_data_st data;
if (info->seed_size < 32) {
fprintf(
stderr
, "For DH parameter generation a 32-byte seed value or larger is expected (have: %d); use -d 2 for more information.\n", (int)info->seed_size);
app_exit(1);
}
data.type = GNUTLS_KEYGEN_SEED;
data.data = (void*)info->seed;
data.size = info->seed_size;
ret = gnutls_x509_privkey_generate2(pkey, GNUTLS_PK_DSA, bits, GNUTLS_PRIVKEY_FLAG_PROVABLE, &data, 1);
} else {
ret = gnutls_x509_privkey_generate(pkey, GNUTLS_PK_DSA, bits, GNUTLS_PRIVKEY_FLAG_PROVABLE);
}
if (ret < 0) {
fprintf(
stderr
,
"Error generating DSA parameters: %s\n",
gnutls_strerror(ret));
app_exit(1);
}
if (info->outcert_format == GNUTLS_X509_FMT_PEM) {
print_private_key(outfile, info, pkey);
}
ret = gnutls_dh_params_import_dsa(dh_params, pkey);
if (ret < 0) {
fprintf(
stderr
,
"Error importing DSA parameters: %s\n",
gnutls_strerror(ret));
app_exit(1);
}
gnutls_x509_privkey_deinit(pkey);
} else {
ret = gnutls_dh_params_generate2(dh_params, bits);
if (ret < 0) {
fprintf(
stderr
,
"Error generating parameters: %s\n",
gnutls_strerror(ret));
app_exit(1);
}
}
ret =
gnutls_dh_params_export_raw(dh_params, &p, &g,
&q_bits);
if (ret < 0) {
fprintf(
stderr
, "Error exporting parameters: %s\n",
gnutls_strerror(ret));
app_exit(1);
}
} else {
if (info->provable != 0) {
fprintf(
stderr
, "The DH parameters obtained via this option are not provable\n");
app_exit(1);
}
if (bits <= 2048) {
p = gnutls_ffdhe_2048_group_prime;
g = gnutls_ffdhe_2048_group_generator;
key_bits = gnutls_ffdhe_2048_key_bits;
} else if (bits <= 3072) {
p = gnutls_ffdhe_3072_group_prime;
g = gnutls_ffdhe_3072_group_generator;
key_bits = gnutls_ffdhe_3072_key_bits;
} else if (bits <= 4096) {
p = gnutls_ffdhe_4096_group_prime;
g = gnutls_ffdhe_4096_group_generator;
key_bits = gnutls_ffdhe_4096_key_bits;
} else if (bits <= 6144) {
p = gnutls_ffdhe_6144_group_prime;
g = gnutls_ffdhe_6144_group_generator;
key_bits = gnutls_ffdhe_6144_key_bits;
} else {
p = gnutls_ffdhe_8192_group_prime;
g = gnutls_ffdhe_8192_group_generator;
key_bits = gnutls_ffdhe_8192_key_bits;
}
ret = gnutls_dh_params_import_raw2(dh_params, &p, &g, key_bits);
if (ret < 0) {
fprintf(
stderr
, "Error exporting parameters: %s\n",
gnutls_strerror(ret));
app_exit(1);
}
}
if (info->outtext)
print_dh_info(outfile, &p, &g, q_bits, info->cprint);
if (!info->cprint) {
size_t len = lbuffer_size;
ret =
gnutls_dh_params_export_pkcs3(dh_params,
info->outcert_format,
lbuffer, &len);
if (ret == 0) {
if (info->outcert_format == GNUTLS_X509_FMT_PEM)
fprintf(outfile, "\n%s", lbuffer);
else
fwrite(lbuffer, 1, len, outfile);
} else {
fprintf(
stderr
, "Error: %s\n",
gnutls_strerror(ret));
}
}
if (how != 0) {
gnutls_free((void *) (p.data)), p.data=
((void *)0)
;
gnutls_free((void *) (g.data)), g.data=
((void *)0)
;
}
gnutls_dh_params_deinit(dh_params);
return 0;
}
void decode_seed(gnutls_datum_t *seed, const char *hex, unsigned hex_size)
{
int ret;
size_t seed_size;
seed->size = hex_size;
seed->data = malloc(hex_size);
if (seed->data ==
((void *)0)
) {
fprintf(
stderr
, "memory error\n");
app_exit(1);
}
seed_size = hex_size;
ret = gnutls_hex2bin(hex, hex_size, seed->data, &seed_size);
if (ret < 0) {
fprintf(
stderr
, "Could not hex decode data: %s\n", gnutls_strerror(ret));
app_exit(1);
}
seed->size = seed_size;
return;
}
gnutls_pk_algorithm_t figure_key_type(const char *key_type)
{
if (strcasecmp(key_type, "rsa") == 0)
return GNUTLS_PK_RSA;
else if (strcasecmp(key_type, "rsa-pss") == 0)
return GNUTLS_PK_RSA_PSS;
else if (strcasecmp(key_type, "ed25519") == 0 || strcasecmp(key_type, "eddsa") == 0)
return GNUTLS_PK_EDDSA_ED25519;
else if (strcasecmp(key_type, "ed448") == 0)
return GNUTLS_PK_EDDSA_ED448;
else if (strcasecmp(key_type, "x25519") == 0)
return GNUTLS_PK_ECDH_X25519;
else if (strcasecmp(key_type, "x448") == 0)
return GNUTLS_PK_ECDH_X448;
else if (strcasecmp(key_type, "dsa") == 0)
return GNUTLS_PK_DSA;
else if (strcasecmp(key_type, "ecdsa") == 0 || strcasecmp(key_type, "ecc") == 0)
return GNUTLS_PK_ECDSA;
else if (strcasecmp(key_type, "gost01") == 0)
return GNUTLS_PK_GOST_01;
else if (strcasecmp(key_type, "gost12-256") == 0)
return GNUTLS_PK_GOST_12_256;
else if (strcasecmp(key_type, "gost12-512") == 0)
return GNUTLS_PK_GOST_12_512;
else {
fprintf(
stderr
, "unknown key type: %s\n", key_type);
return GNUTLS_PK_UNKNOWN;
}
}
gnutls_digest_algorithm_t hash_to_id(const char *hash)
{
if (strcasecmp(hash, "md5") == 0) {
fprintf(
stderr
,
"Warning: MD5 is broken, and should not be used any more for digital signatures.\n");
return GNUTLS_DIG_MD5;
} else if (strcasecmp(hash, "sha1") == 0)
return GNUTLS_DIG_SHA1;
else if (strcasecmp(hash, "sha256") == 0)
return GNUTLS_DIG_SHA256;
else if (strcasecmp(hash, "sha224") == 0)
return GNUTLS_DIG_SHA224;
else if (strcasecmp(hash, "sha384") == 0)
return GNUTLS_DIG_SHA384;
else if (strcasecmp(hash, "sha512") == 0)
return GNUTLS_DIG_SHA512;
else if (strcasecmp(hash, "sha3-256") == 0)
return GNUTLS_DIG_SHA3_256;
else if (strcasecmp(hash, "sha3-224") == 0)
return GNUTLS_DIG_SHA3_224;
else if (strcasecmp(hash, "sha3-384") == 0)
return GNUTLS_DIG_SHA3_384;
else if (strcasecmp(hash, "sha3-512") == 0)
return GNUTLS_DIG_SHA3_512;
else if (strcasecmp(hash, "rmd160") == 0)
return GNUTLS_DIG_RMD160;
else {
return gnutls_digest_get_id(hash);
}
}
void sign_params_to_flags(common_info_st *cinfo, const char *params)
{
char *p, *sp;
sp = strdup(params);
if (sp ==
((void *)0)
) {
fprintf(
stderr
, "memory error\n");
app_exit(1);
}
p = strtok(sp, ",");
while(p !=
((void *)0)
) {
if (strcasecmp(p, "rsa-pss")==0) {
cinfo->rsa_pss_sign = 1;
} else {
fprintf(
stderr
, "Unknown signature parameter: %s\n", p);
app_exit(1);
}
p=strtok(
((void *)0)
, ",");
}
free(sp);
}
|
static gnutls_pubkey_t _load_url_pubkey(const char *url)
{
int ret;
gnutls_pubkey_t pubkey;
unsigned int obj_flags = 0;
ret = gnutls_pubkey_init(&pubkey);
if (ret < 0) {
fprintf(
stderr
, "Error in %s:%d: %s\n", __func__, 238,
gnutls_strerror(ret));
app_exit(1);
}
ret = gnutls_pubkey_import_url(pubkey, url, obj_flags);
if (ret < 0) {
fprintf(
stderr
, "Error in %s:%d: %s: %s\n", __func__,
246, gnutls_strerror(ret), url);
app_exit(1);
}
return pubkey;
}
gnutls_privkey_t load_private_key(int mand, common_info_st * info)
{
gnutls_privkey_t key;
gnutls_datum_t dat;
size_t size;
if (!info->privkey && !mand)
return
((void *)0)
;
if (info->privkey ==
((void *)0)
) {
fprintf(
stderr
, "missing --load-privkey\n");
app_exit(1);
}
if (gnutls_url_is_supported(info->privkey) != 0)
return _load_url_privkey(info->privkey);
dat.data = (void *) _gnutls_read_file(info->privkey, 0x1, &size);
dat.size = size;
if (!dat.data) {
fprintf(
stderr
, "error reading file at --load-privkey: %s\n",
info->privkey);
app_exit(1);
}
key = _load_privkey(&dat, info);
free(dat.data);
return key;
}
gnutls_x509_privkey_t
load_x509_private_key(int mand, common_info_st * info)
{
gnutls_x509_privkey_t key;
int ret;
gnutls_datum_t dat;
size_t size;
unsigned int flags = 0;
const char *pass;
if (!info->privkey && !mand)
return
((void *)0)
;
if (info->privkey ==
((void *)0)
) {
fprintf(
stderr
, "missing --load-privkey\n");
app_exit(1);
}
ret = gnutls_x509_privkey_init(&key);
if (ret < 0) {
fprintf(
stderr
, "privkey_init: %s\n", gnutls_strerror(ret));
app_exit(1);
}
dat.data = (void *) _gnutls_read_file(info->privkey, 0x1, &size);
dat.size = size;
if (!dat.data) {
fprintf(
stderr
, "error reading file at --load-privkey: %s\n",
info->privkey);
app_exit(1);
}
if (info->pkcs8) {
pass = get_password(info, &flags, 0);
ret =
gnutls_x509_privkey_import_pkcs8(key, &dat,
info->incert_format,
pass, flags);
} else {
ret =
gnutls_x509_privkey_import2(key, &dat,
info->incert_format,
((void *)0)
,
0);
if (ret == -24) {
pass = get_password(info, &flags, 0);
ret =
gnutls_x509_privkey_import2(key, &dat,
info->
incert_format,
pass, flags);
}
}
free(dat.data);
if (ret == -207) {
fprintf(
stderr
,
"import error: could not find a valid PEM header; "
"check if your key is PEM encoded\n");
app_exit(1);
}
if (ret < 0) {
fprintf(
stderr
, "error importing private key: %s: %s\n",
info->privkey, gnutls_strerror(ret));
app_exit(1);
}
return key;
}
gnutls_x509_crt_t load_cert(int mand, common_info_st * info)
{
gnutls_x509_crt_t *crt;
gnutls_x509_crt_t ret_crt;
size_t size, i;
crt = load_cert_list(mand, &size, info);
if (crt) {
ret_crt = crt[0];
for (i=1;i<size;i++)
gnutls_x509_crt_deinit(crt[i]);
gnutls_free((void *) (crt)), crt=
((void *)0)
;
return ret_crt;
}
return
((void *)0)
;
}
gnutls_x509_crt_t *load_cert_list(int mand, size_t * crt_size,
common_info_st * info)
{
FILE *fp;
static gnutls_x509_crt_t *crt;
int ret;
gnutls_datum_t dat;
unsigned size;
unsigned int crt_max;
unsigned flags = 0;
*crt_size = 0;
if (info->verbose)
fprintf(
stderr
, "Loading certificate list...\n");
if (info->cert ==
((void *)0)
) {
if (mand) {
fprintf(
stderr
, "missing --load-certificate\n");
app_exit(1);
} else
return
((void *)0)
;
}
fp = fopen(info->cert, "r");
if (fp ==
((void *)0)
) {
fprintf(
stderr
, "Could not open %s\n", info->cert);
app_exit(1);
}
fix_lbuffer(file_size(fp));
size = fread(lbuffer, 1, lbuffer_size - 1, fp);
lbuffer[size] = 0;
fclose(fp);
dat.data = (void *) lbuffer;
dat.size = size;
if (info->sort_chain)
flags |= GNUTLS_X509_CRT_LIST_SORT;
ret = gnutls_x509_crt_list_import2(&crt, &crt_max, &dat, GNUTLS_X509_FMT_PEM, flags);
if (ret < 0) {
fprintf(
stderr
, "Error loading certificates: %s\n", gnutls_strerror(ret));
app_exit(1);
}
*crt_size = crt_max;
if (info->verbose)
fprintf(
stderr
, "Loaded %d certificates.\n",
(int) crt_max);
return crt;
}
gnutls_x509_crl_t *load_crl_list(int mand, size_t * crl_size,
common_info_st * info)
{
FILE *fp;
static gnutls_x509_crl_t *crl;
unsigned int crl_max;
int ret;
gnutls_datum_t dat;
size_t size;
*crl_size = 0;
if (info->verbose)
fprintf(
stderr
, "Loading CRL list...\n");
if (info->crl ==
((void *)0)
) {
if (mand) {
fprintf(
stderr
, "missing --load-crl\n");
app_exit(1);
} else
return
((void *)0)
;
}
fp = fopen(info->crl, "r");
if (fp ==
((void *)0)
) {
fprintf(
stderr
, "Could not open %s\n", info->crl);
app_exit(1);
}
fix_lbuffer(file_size(fp));
size = fread(lbuffer, 1, lbuffer_size - 1, fp);
lbuffer[size] = 0;
fclose(fp);
dat.data = (void *) lbuffer;
dat.size = size;
ret = gnutls_x509_crl_list_import2(&crl, &crl_max, &dat, GNUTLS_X509_FMT_PEM, 0);
if (ret == -34) {
ret = gnutls_x509_crl_list_import2(&crl, &crl_max, &dat, GNUTLS_X509_FMT_DER, 0);
}
if (ret < 0) {
fprintf(
stderr
, "Error loading CRLs: %s\n", gnutls_strerror(ret));
app_exit(1);
}
*crl_size = crl_max;
if (info->verbose)
fprintf(
stderr
, "Loaded %d CRLs.\n",
(int) *crl_size);
return crl;
}
gnutls_x509_crq_t load_request(common_info_st * info)
{
gnutls_x509_crq_t crq;
int ret;
gnutls_datum_t dat;
size_t size;
if (!info->request)
return
((void *)0)
;
ret = gnutls_x509_crq_init(&crq);
if (ret < 0) {
fprintf(
stderr
, "crq_init: %s\n", gnutls_strerror(ret));
app_exit(1);
}
dat.data = (void *) _gnutls_read_file(info->request, 0x1, &size);
dat.size = size;
if (!dat.data) {
fprintf(
stderr
, "error reading file at --load-request: %s\n",
info->request);
app_exit(1);
}
ret = gnutls_x509_crq_import(crq, &dat, info->incert_format);
if (ret == -207) {
fprintf(
stderr
,
"import error: could not find a valid PEM header\n");
app_exit(1);
}
free(dat.data);
if (ret < 0) {
fprintf(
stderr
, "error importing certificate request: %s: %s\n",
info->request, gnutls_strerror(ret));
app_exit(1);
}
return crq;
}
gnutls_privkey_t load_ca_private_key(common_info_st * info)
{
gnutls_privkey_t key;
gnutls_datum_t dat;
size_t size;
if (info->ca_privkey ==
((void *)0)
) {
fprintf(
stderr
, "missing --load-ca-privkey\n");
app_exit(1);
}
if (gnutls_url_is_supported(info->ca_privkey) != 0)
return _load_url_privkey(info->ca_privkey);
dat.data = (void *) _gnutls_read_file(info->ca_privkey, 0x1, &size);
dat.size = size;
if (!dat.data) {
fprintf(
stderr
, "error reading file at --load-ca-privkey: %s\n",
info->ca_privkey);
app_exit(1);
}
key = _load_privkey(&dat, info);
free(dat.data);
return key;
}
gnutls_x509_crt_t load_ca_cert(unsigned mand, common_info_st * info)
{
gnutls_x509_crt_t crt;
int ret;
gnutls_datum_t dat;
size_t size;
if (mand == 0 && info->ca ==
((void *)0)
) {
return
((void *)0)
;
}
if (info->ca ==
((void *)0)
) {
fprintf(
stderr
, "missing --load-ca-certificate\n");
app_exit(1);
}
ret = gnutls_x509_crt_init(&crt);
if (ret < 0) {
fprintf(
stderr
, "crt_init: %s\n", gnutls_strerror(ret));
app_exit(1);
}
if (gnutls_url_is_supported(info->ca) != 0) {
ret = gnutls_x509_crt_import_url(crt, info->ca, 0);
if (ret < 0) {
fprintf(
stderr
, "error importing CA certificate: %s: %s\n",
info->ca, gnutls_strerror(ret));
app_exit(1);
}
return crt;
}
dat.data = (void *) _gnutls_read_file(info->ca, 0x1, &size);
dat.size = size;
if (!dat.data) {
fprintf(
stderr
, "error reading file at --load-ca-certificate: %s\n",
info->ca);
app_exit(1);
}
ret = gnutls_x509_crt_import(crt, &dat, info->incert_format);
free(dat.data);
if (ret < 0) {
fprintf(
stderr
, "error importing CA certificate: %s: %s\n",
info->ca, gnutls_strerror(ret));
app_exit(1);
}
return crt;
}
gnutls_pubkey_t load_pubkey(int mand, common_info_st * info)
{
gnutls_pubkey_t key;
int ret;
gnutls_datum_t dat;
size_t size;
if (!info->pubkey && !mand)
return
((void *)0)
;
if (info->pubkey ==
((void *)0)
) {
fprintf(
stderr
, "missing --load-pubkey\n");
app_exit(1);
}
if (gnutls_url_is_supported(info->pubkey) != 0)
return _load_url_pubkey(info->pubkey);
ret = gnutls_pubkey_init(&key);
if (ret < 0) {
fprintf(
stderr
, "privkey_init: %s\n", gnutls_strerror(ret));
app_exit(1);
}
dat.data = (void *) _gnutls_read_file(info->pubkey, 0x1, &size);
dat.size = size;
if (!dat.data) {
fprintf(
stderr
, "error reading file at --load-pubkey: %s\n", info->pubkey);
app_exit(1);
}
ret = gnutls_pubkey_import(key, &dat, info->incert_format);
if (ret == -207) {
ret = gnutls_pubkey_import_x509_raw(key, &dat, info->incert_format, 0);
if (ret < 0) {
fprintf(
stderr
,
"import error: could not find a valid PEM header; "
"check if your key has the PUBLIC KEY header\n");
app_exit(1);
}
} else if (ret < 0) {
fprintf(
stderr
, "importing public key: %s: %s\n",
info->pubkey, gnutls_strerror(ret));
app_exit(1);
}
free(dat.data);
return key;
}
gnutls_pubkey_t load_public_key_or_import(int mand,
gnutls_privkey_t privkey,
common_info_st * info)
{
gnutls_pubkey_t pubkey;
int ret;
ret = gnutls_pubkey_init(&pubkey);
if (ret < 0) {
fprintf(
stderr
, "gnutls_pubkey_init: %s\n",
gnutls_strerror(ret));
app_exit(1);
}
if (!privkey || gnutls_pubkey_import_privkey(pubkey, privkey, 0, 0) < 0) {
gnutls_pubkey_deinit(pubkey);
pubkey = load_pubkey(0, info);
if (pubkey ==
((void *)0)
&& mand) {
fprintf(
stderr
, "Could not determine the public key for the operation.\nYou must specify --load-privkey or --load-pubkey if missing.\n");
app_exit(1);
}
}
return pubkey;
}
static const char *bits_to_sp(gnutls_pk_algorithm_t pk, unsigned int bits)
{
gnutls_sec_param_t s = gnutls_pk_bits_to_sec_param(pk, bits);
if (s == GNUTLS_SEC_PARAM_UNKNOWN) {
return gnutls_sec_param_get_name(GNUTLS_SEC_PARAM_MEDIUM);
}
return gnutls_sec_param_get_name(s);
}
int
get_bits(gnutls_pk_algorithm_t key_type, int info_bits,
const char *info_sec_param, int warn)
{
int bits;
if (info_bits != 0) {
static int warned = 0;
if (warned == 0 && warn != 0 && (((unsigned int)(info_bits)) & 0x80000000)==0) {
warned = 1;
fprintf(
stderr
,
"** Note: You may use '--sec-param %s' instead of '--bits %d'\n",
bits_to_sp(key_type, info_bits), info_bits);
}
bits = info_bits;
} else {
if (info_sec_param == 0) {
info_sec_param = "HIGH";
}
bits =
gnutls_sec_param_to_pk_bits(key_type,
str_to_sec_param
(info_sec_param));
}
return bits;
}
gnutls_sec_param_t str_to_sec_param(const char *str)
{
if (strcasecmp(str, "low") == 0) {
return GNUTLS_SEC_PARAM_LOW;
} else if (strcasecmp(str, "legacy") == 0) {
return GNUTLS_SEC_PARAM_LEGACY;
} else if (strcasecmp(str, "normal") == 0 || strcasecmp(str, "medium") == 0) {
return GNUTLS_SEC_PARAM_MEDIUM;
} else if (strcasecmp(str, "high") == 0) {
return GNUTLS_SEC_PARAM_HIGH;
} else if (strcasecmp(str, "ultra") == 0) {
return GNUTLS_SEC_PARAM_ULTRA;
} else if (strcasecmp(str, "future") == 0) {
return GNUTLS_SEC_PARAM_FUTURE;
} else {
fprintf(
stderr
, "Unknown security parameter string: %s\n",
str);
app_exit(1);
}
}
static void
print_hex_datum(FILE * outfile, gnutls_datum_t * dat, int cprint)
{
unsigned int j;
if (cprint != 0) {
fprintf(outfile, "\n" "\t" "\"");
for (j = 0; j < dat->size; j++) {
fprintf(outfile, "\\x%.2x",
(unsigned char) dat->data[j]);
if ((j + 1) % 16 == 0) {
fprintf(outfile, "\"\n" "\t" "\"");
}
}
fprintf(outfile, "\";\n\n");
return;
}
fprintf(outfile, "\n" "\t");
for (j = 0; j < dat->size; j++) {
if ((j + 1) % 16 == 0) {
fprintf(outfile, "%.2x", (unsigned char) dat->data[j]);
fprintf(outfile, "\n" "\t");
} else {
fprintf(outfile, "%.2x:", (unsigned char) dat->data[j]);
}
}
fprintf(outfile, "\n\n");
}
static void print_head(FILE * out, const char *txt, unsigned int size,
int cprint)
{
unsigned i;
char *p, *ntxt;
int ret;
if (cprint != 0) {
if (size > 0)
ret = asprintf(&ntxt, "const unsigned char %s[%u] =",
txt, size);
else
ret = asprintf(&ntxt, "const unsigned char %s[] =\n",
txt);
if (ret == -1) {
fprintf(
stderr
, "memory error\n");
app_exit(1);
}
p = strstr(ntxt, "char");
p += 5;
for (i = 0; i < strlen(txt); i++)
if (p[i] == ' ')
p[i] = '_';
fprintf(out, "%s", ntxt);
free(ntxt);
return;
}
fprintf(out, "%s:", txt);
}
void
print_dsa_pkey(FILE * outfile, gnutls_datum_t * x, gnutls_datum_t * y,
gnutls_datum_t * p, gnutls_datum_t * q, gnutls_datum_t * g,
int cprint)
{
if (x) {
print_head(outfile, "private key", x->size, cprint);
print_hex_datum(outfile, x, cprint);
}
print_head(outfile, "public key", y->size, cprint);
print_hex_datum(outfile, y, cprint);
print_head(outfile, "p", p->size, cprint);
print_hex_datum(outfile, p, cprint);
print_head(outfile, "q", q->size, cprint);
print_hex_datum(outfile, q, cprint);
print_head(outfile, "g", g->size, cprint);
print_hex_datum(outfile, g, cprint);
}
gnutls_ecc_curve_t str_to_curve(const char *str)
{
unsigned num = 0;
const gnutls_ecc_curve_t *list, *p;
list = gnutls_ecc_curve_list();
p = list;
while(*p != 0) {
if (strcasecmp(str, gnutls_ecc_curve_get_name(*p)) == 0)
return *p;
p++;
num++;
}
fprintf(
stderr
, "Unsupported curve: %s\nAvailable curves:\n", str);
if (num == 0)
printf("none\n");
p = list;
while(*p != 0) {
fprintf(
stderr
, "\t- %s\n",
gnutls_ecc_curve_get_name(*p));
p++;
}
app_exit(1);
}
void
print_ecc_pkey(FILE * outfile, gnutls_ecc_curve_t curve,
gnutls_datum_t * k, gnutls_datum_t * x, gnutls_datum_t * y,
int cprint)
{
if (cprint != 0)
fprintf(outfile, "/* curve: %s */\n",
gnutls_ecc_curve_get_name(curve));
else
fprintf(outfile, "curve:\t%s\n",
gnutls_ecc_curve_get_name(curve));
if (k && k->data) {
print_head(outfile, "private key", k->size, cprint);
print_hex_datum(outfile, k, cprint);
}
if (x && x->data) {
print_head(outfile, "x", x->size, cprint);
print_hex_datum(outfile, x, cprint);
}
if (y && y->data) {
print_head(outfile, "y", y->size, cprint);
print_hex_datum(outfile, y, cprint);
}
}
static void reverse_datum(gnutls_datum_t *d)
{
unsigned int i;
unsigned char c;
for (i = 0; i < d->size / 2; i++) {
c = d->data[i];
d->data[i] = d->data[d->size - i - 1];
d->data[d->size - i - 1] = c;
}
}
void
print_gost_pkey(FILE * outfile, gnutls_ecc_curve_t curve,
gnutls_digest_algorithm_t digest, gnutls_gost_paramset_t paramset,
gnutls_datum_t * k, gnutls_datum_t * x, gnutls_datum_t * y,
int cprint)
{
if (cprint != 0)
fprintf(outfile, "/* curve: %s */\n",
gnutls_ecc_curve_get_name(curve));
else
fprintf(outfile, "curve:\t%s\n",
gnutls_ecc_curve_get_name(curve));
if (cprint != 0)
fprintf(outfile, "/* digest: %s */\n",
gnutls_digest_get_name(digest));
else
fprintf(outfile, "digest:\t%s\n",
gnutls_digest_get_name(digest));
if (cprint != 0)
fprintf(outfile, "/* paramset: %s */\n",
gnutls_gost_paramset_get_name(paramset));
else
fprintf(outfile, "paramset:\t%s\n",
gnutls_gost_paramset_get_name(paramset));
if (k) {
reverse_datum(k);
print_head(outfile, "private key", k->size, cprint);
print_hex_datum(outfile, k, cprint);
}
reverse_datum(x);
reverse_datum(y);
print_head(outfile, "x", x->size, cprint);
print_hex_datum(outfile, x, cprint);
print_head(outfile, "y", y->size, cprint);
print_hex_datum(outfile, y, cprint);
}
void
print_rsa_pkey(FILE * outfile, gnutls_datum_t * m, gnutls_datum_t * e,
gnutls_datum_t * d, gnutls_datum_t * p, gnutls_datum_t * q,
gnutls_datum_t * u, gnutls_datum_t * exp1,
gnutls_datum_t * exp2, int cprint)
{
print_head(outfile, "modulus", m->size, cprint);
print_hex_datum(outfile, m, cprint);
print_head(outfile, "public exponent", e->size, cprint);
print_hex_datum(outfile, e, cprint);
if (d) {
print_head(outfile, "private exponent", d->size, cprint);
print_hex_datum(outfile, d, cprint);
print_head(outfile, "prime1", p->size, cprint);
print_hex_datum(outfile, p, cprint);
print_head(outfile, "prime2", q->size, cprint);
print_hex_datum(outfile, q, cprint);
print_head(outfile, "coefficient", u->size, cprint);
print_hex_datum(outfile, u, cprint);
if (exp1 && exp2) {
print_head(outfile, "exp1", exp1->size, cprint);
print_hex_datum(outfile, exp1, cprint);
print_head(outfile, "exp2", exp2->size, cprint);
print_hex_datum(outfile, exp2, cprint);
}
}
}
void print_pubkey_info(gnutls_pubkey_t pubkey,
FILE *outfile,
gnutls_certificate_print_formats_t format,
gnutls_x509_crt_fmt_t outcert_format,
unsigned int outtext)
{
gnutls_datum_t data;
int ret;
size_t size;
if (outtext) {
ret = gnutls_pubkey_print(pubkey, format, &data);
if (ret < 0) {
fprintf(
stderr
, "pubkey_print error: %s\n",
gnutls_strerror(ret));
app_exit(1);
}
fprintf(outfile, "%s\n\n", data.data);
gnutls_free((void *) (data.data)), data.data=
((void *)0)
;
}
fix_lbuffer(0);
size = lbuffer_size;
ret =
gnutls_pubkey_export(pubkey, outcert_format, lbuffer,
&size);
if (ret < 0) {
fprintf(
stderr
, "export error: %s\n", gnutls_strerror(ret));
app_exit(1);
}
fwrite(lbuffer, 1, size, outfile);
}
static void
print_dh_info(FILE * outfile, gnutls_datum_t * p, gnutls_datum_t * g,
unsigned int q_bits, int cprint)
{
if (q_bits > 0) {
if (cprint != 0)
fprintf(outfile,
"\n /* recommended key length: %d bytes */\n\n",
(7 + q_bits) / 8);
else
fprintf(outfile,
"\nRecommended key length: %d bits\n\n",
q_bits);
}
print_head(outfile, "generator", g->size, cprint);
print_hex_datum(outfile, g, cprint);
print_head(outfile, "prime", p->size, cprint);
print_hex_datum(outfile, p, cprint);
}
static
int import_dsa_dh(gnutls_dh_params_t dh_params, gnutls_datum_t *params, gnutls_x509_crt_fmt_t format)
{
gnutls_x509_privkey_t pkey;
int ret;
ret = gnutls_x509_privkey_init(&pkey);
if (ret < 0)
return ret;
ret = gnutls_x509_privkey_import(pkey, params, format);
if (ret < 0)
return ret;
ret = gnutls_dh_params_import_dsa(dh_params, pkey);
gnutls_x509_privkey_deinit(pkey);
return ret;
}
void dh_info(FILE * infile, FILE * outfile, common_info_st * ci)
{
gnutls_datum_t params;
size_t size;
int ret, ret2;
gnutls_dh_params_t dh_params;
gnutls_datum_t p, g;
unsigned int q_bits = 0;
fix_lbuffer(0);
if (gnutls_dh_params_init(&dh_params) < 0) {
fprintf(
stderr
, "Error in dh parameter initialization\n");
app_exit(1);
}
params.data = (void *) _gnutls_fread_file(infile, 0, &size);
params.size = size;
if (params.data ==
((void *)0)
) {
fprintf(
stderr
, "Could not read input\n");
app_exit(1);
}
ret =
gnutls_dh_params_import_pkcs3(dh_params, ¶ms,
ci->incert_format);
if (ret < 0) {
ret2 = import_dsa_dh(dh_params, ¶ms, ci->incert_format);
if (ret2 < 0) {
fprintf(
stderr
, "Error parsing dh params: %s\n",
gnutls_strerror(ret));
app_exit(1);
}
}
ret = gnutls_dh_params_export_raw(dh_params, &p, &g, &q_bits);
if (ret < 0) {
fprintf(
stderr
, "Error exporting parameters: %s\n",
gnutls_strerror(ret));
app_exit(1);
}
if (ci->outtext)
print_dh_info(outfile, &p, &g, q_bits, ci->cprint);
if (!ci->cprint) {
size_t len = lbuffer_size;
ret =
gnutls_dh_params_export_pkcs3(dh_params,
ci->outcert_format,
lbuffer, &len);
if (ret == 0) {
if (ci->outcert_format == GNUTLS_X509_FMT_PEM) {
fprintf(outfile, "\n%s", lbuffer);
} else {
fwrite(lbuffer, 1, len, outfile);
}
} else {
fprintf(
stderr
, "Error: %s\n",
gnutls_strerror(ret));
}
}
gnutls_free((void *) (p.data)), p.data=
((void *)0)
;
gnutls_free((void *) (g.data)), g.data=
((void *)0)
;
gnutls_dh_params_deinit(dh_params);
}
int cipher_to_flags(const char *cipher)
{
if (cipher ==
((void *)0)
) {
return GNUTLS_PKCS_PBES2_AES_128;
} else if (strcasecmp(cipher, "3des") == 0) {
return GNUTLS_PKCS_PBES2_3DES;
} else if (strcasecmp(cipher, "3des-pkcs12") == 0) {
return GNUTLS_PKCS_PKCS12_3DES;
} else if (strcasecmp(cipher, "arcfour") == 0) {
return GNUTLS_PKCS_PKCS12_ARCFOUR;
} else if (strcasecmp(cipher, "aes-128") == 0) {
return GNUTLS_PKCS_PBES2_AES_128;
} else if (strcasecmp(cipher, "aes-192") == 0) {
return GNUTLS_PKCS_PBES2_AES_192;
} else if (strcasecmp(cipher, "aes-256") == 0) {
return GNUTLS_PKCS_PBES2_AES_256;
} else if (strcasecmp(cipher, "rc2-40") == 0) {
return GNUTLS_PKCS_PKCS12_RC2_40;
} else if (strcasecmp(cipher, "gost28147-tc26z") == 0) {
return GNUTLS_PKCS_PBES2_GOST_TC26Z;
} else if (strcasecmp(cipher, "gost28147-cpa") == 0) {
return GNUTLS_PKCS_PBES2_GOST_CPA;
} else if (strcasecmp(cipher, "gost28147-cpb") == 0) {
return GNUTLS_PKCS_PBES2_GOST_CPB;
} else if (strcasecmp(cipher, "gost28147-cpc") == 0) {
return GNUTLS_PKCS_PBES2_GOST_CPC;
} else if (strcasecmp(cipher, "gost28147-cpd") == 0) {
return GNUTLS_PKCS_PBES2_GOST_CPD;
} else if (strcasecmp(cipher, "none") == 0) {
return GNUTLS_PKCS_PLAIN;
}
fprintf(
stderr
, "unknown cipher %s\n", cipher);
app_exit(1);
}
static void privkey_info_int(FILE *outfile, common_info_st * cinfo,
gnutls_x509_privkey_t key)
{
int ret, key_type;
unsigned int bits = 0;
size_t size;
const char *cprint;
gnutls_x509_spki_t spki;
gnutls_digest_algorithm_t dig;
fprintf(outfile, "Public Key Info:\n");
ret = gnutls_x509_spki_init(&spki);
if (ret < 0) {
fprintf(
stderr
, "spki_init: %s\n", gnutls_strerror(ret));
return;
}
fprintf(outfile, "\tPublic Key Algorithm: ");
key_type = gnutls_x509_privkey_get_pk_algorithm2(key, &bits);
cprint = gnutls_pk_algorithm_get_name(key_type);
fprintf(outfile, "%s\n", cprint ? cprint : "Unknown");
if (key_type == GNUTLS_PK_RSA_PSS) {
unsigned int salt_size;
ret = gnutls_x509_privkey_get_spki(key, spki, 0);
if (ret == -56)
goto spki_skip;
if (ret < 0) {
fprintf(
stderr
, "spki_get: %s\n", gnutls_strerror(ret));
goto spki_skip;
}
ret = gnutls_x509_spki_get_rsa_pss_params(spki, &dig, &salt_size);
if (ret < 0) {
fprintf(
stderr
, "spki_get_rsa_pss_params: %s\n",
gnutls_strerror(ret));
} else {
fprintf(outfile, "\t\tHash Algorithm: %s\n",
gnutls_digest_get_name(dig));
fprintf(outfile, "\t\tSalt Length: %d\n", salt_size);
}
}
spki_skip:
gnutls_x509_spki_deinit(spki);
fprintf(outfile, "\tKey Security Level: %s (%u bits)\n\n",
gnutls_sec_param_get_name(gnutls_x509_privkey_sec_param
(key)), bits);
if (((key_type) == GNUTLS_PK_RSA || (key_type) == GNUTLS_PK_RSA_PSS)) {
gnutls_datum_t m, e, d, p, q, u, exp1, exp2;
ret =
gnutls_x509_privkey_export_rsa_raw2(key, &m, &e, &d,
&p, &q, &u, &exp1,
&exp2);
if (ret < 0)
fprintf(
stderr
,
"Error in key RSA data export: %s\n",
gnutls_strerror(ret));
else {
print_rsa_pkey(outfile, &m, &e, &d, &p, &q, &u,
&exp1, &exp2, cinfo->cprint);
gnutls_free((void *) (m.data)), m.data=
((void *)0)
;
gnutls_free((void *) (e.data)), e.data=
((void *)0)
;
gnutls_free((void *) (d.data)), d.data=
((void *)0)
;
gnutls_free((void *) (p.data)), p.data=
((void *)0)
;
gnutls_free((void *) (q.data)), q.data=
((void *)0)
;
gnutls_free((void *) (u.data)), u.data=
((void *)0)
;
gnutls_free((void *) (exp1.data)), exp1.data=
((void *)0)
;
gnutls_free((void *) (exp2.data)), exp2.data=
((void *)0)
;
}
} else if (key_type == GNUTLS_PK_DSA) {
gnutls_datum_t p, q, g, y, x;
ret =
gnutls_x509_privkey_export_dsa_raw(key, &p, &q, &g, &y,
&x);
if (ret < 0)
fprintf(
stderr
,
"Error in key DSA data export: %s\n",
gnutls_strerror(ret));
else {
print_dsa_pkey(outfile, &x, &y, &p, &q, &g,
cinfo->cprint);
gnutls_free((void *) (x.data)), x.data=
((void *)0)
;
gnutls_free((void *) (y.data)), y.data=
((void *)0)
;
gnutls_free((void *) (p.data)), p.data=
((void *)0)
;
gnutls_free((void *) (q.data)), q.data=
((void *)0)
;
gnutls_free((void *) (g.data)), g.data=
((void *)0)
;
}
} else if (key_type == GNUTLS_PK_ECDSA ||
key_type == GNUTLS_PK_EDDSA_ED25519 ||
key_type == GNUTLS_PK_EDDSA_ED448 ||
key_type == GNUTLS_PK_ECDH_X25519 ||
key_type == GNUTLS_PK_ECDH_X448) {
gnutls_datum_t y, x, k;
gnutls_ecc_curve_t curve;
ret =
gnutls_x509_privkey_export_ecc_raw(key, &curve, &x, &y,
&k);
if (ret < 0)
fprintf(
stderr
,
"Error in key ECC data export: %s\n",
gnutls_strerror(ret));
else {
print_ecc_pkey(outfile, curve, &k, &x, &y,
cinfo->cprint);
gnutls_free((void *) (x.data)), x.data=
((void *)0)
;
gnutls_free((void *) (y.data)), y.data=
((void *)0)
;
gnutls_free((void *) (k.data)), k.data=
((void *)0)
;
}
} else if (key_type == GNUTLS_PK_GOST_01 ||
key_type == GNUTLS_PK_GOST_12_256 ||
key_type == GNUTLS_PK_GOST_12_512) {
gnutls_datum_t y, x, k;
gnutls_ecc_curve_t curve;
gnutls_digest_algorithm_t digest;
gnutls_gost_paramset_t paramset;
ret =
gnutls_x509_privkey_export_gost_raw(key, &curve,
&digest,
¶mset,
&x, &y, &k);
if (ret < 0)
fprintf(
stderr
,
"Error in key GOST data export: %s\n",
gnutls_strerror(ret));
else {
print_gost_pkey(outfile, curve, digest, paramset,
&k, &x, &y,
cinfo->cprint);
gnutls_free((void *) (x.data)), x.data=
((void *)0)
;
gnutls_free((void *) (y.data)), y.data=
((void *)0)
;
gnutls_free((void *) (k.data)), k.data=
((void *)0)
;
}
}
size = lbuffer_size;
ret = gnutls_x509_privkey_get_seed(key, &dig, lbuffer, &size);
if (ret >= 0) {
fprintf(outfile, "Validation parameters:\n");
fprintf(outfile, "\tHash: %s\n",
gnutls_digest_get_name(dig));
fprintf(outfile, "\tSeed: %s\n",
raw_to_hex(lbuffer, size));
}
fprintf(outfile, "\n");
size = lbuffer_size;
ret =
gnutls_x509_privkey_get_key_id(key, GNUTLS_KEYID_USE_SHA256, lbuffer, &size);
if (ret < 0) {
fprintf(
stderr
, "Error in key id calculation: %s\n",
gnutls_strerror(ret));
} else {
fprintf(outfile, "Public Key PIN:\n\tpin-sha256:%s\n",
raw_to_base64(lbuffer, size));
fprintf(outfile, "Public Key ID:\n\tsha256:%s\n",
raw_to_hex(lbuffer, size));
size = lbuffer_size;
ret =
gnutls_x509_privkey_get_key_id(key, GNUTLS_KEYID_USE_SHA1, lbuffer, &size);
if (ret >= 0) {
fprintf(outfile, "\tsha1:%s\n",
raw_to_hex(lbuffer, size));
}
}
fprintf(outfile, "\n");
}
void
print_private_key(FILE *outfile, common_info_st * cinfo, gnutls_x509_privkey_t key)
{
int ret;
size_t size;
if (!key)
return;
switch_to_pkcs8_when_needed(cinfo, key, gnutls_x509_privkey_get_pk_algorithm(key));
if (!cinfo->pkcs8) {
if (cinfo->outtext)
privkey_info_int(outfile, cinfo, key);
size = lbuffer_size;
ret = gnutls_x509_privkey_export(key, cinfo->outcert_format,
lbuffer, &size);
if (ret < 0) {
fprintf(
stderr
, "privkey_export: %s\n",
gnutls_strerror(ret));
app_exit(1);
}
} else {
unsigned int flags = 0;
const char *pass;
pass = get_password(cinfo, &flags, 0);
flags |= cipher_to_flags(cinfo->pkcs_cipher);
if (cinfo->outtext && (flags & GNUTLS_PKCS_PLAIN))
privkey_info_int(outfile, cinfo, key);
size = lbuffer_size;
ret =
gnutls_x509_privkey_export_pkcs8(key, cinfo->outcert_format,
pass, flags, lbuffer,
&size);
if (ret < 0) {
fprintf(
stderr
, "privkey_export_pkcs8: %s\n",
gnutls_strerror(ret));
app_exit(1);
}
}
fwrite(lbuffer, 1, size, outfile);
}
int generate_prime(FILE * outfile, int how, common_info_st * info)
{
int ret;
gnutls_dh_params_t dh_params;
gnutls_datum_t p, g;
int bits = get_bits(GNUTLS_PK_DH, info->bits, info->sec_param, 1);
unsigned int q_bits = 0, key_bits = 0;
fix_lbuffer(0);
gnutls_dh_params_init(&dh_params);
if (how != 0) {
fprintf(
stderr
, "Generating DH parameters (%d bits)...\n",
bits);
fprintf(
stderr
, "(might take long time)\n");
} else
fprintf(
stderr
, "Retrieving DH parameters...\n");
if (how != 0) {
if (info->provable != 0) {
gnutls_x509_privkey_t pkey;
ret = gnutls_x509_privkey_init(&pkey);
if (ret < 0) {
fprintf(
stderr
,
"Error initializing key: %s\n",
gnutls_strerror(ret));
app_exit(1);
}
if (info->seed_size > 0) {
gnutls_keygen_data_st data;
if (info->seed_size < 32) {
fprintf(
stderr
, "For DH parameter generation a 32-byte seed value or larger is expected (have: %d); use -d 2 for more information.\n", (int)info->seed_size);
app_exit(1);
}
data.type = GNUTLS_KEYGEN_SEED;
data.data = (void*)info->seed;
data.size = info->seed_size;
ret = gnutls_x509_privkey_generate2(pkey, GNUTLS_PK_DSA, bits, GNUTLS_PRIVKEY_FLAG_PROVABLE, &data, 1);
} else {
ret = gnutls_x509_privkey_generate(pkey, GNUTLS_PK_DSA, bits, GNUTLS_PRIVKEY_FLAG_PROVABLE);
}
if (ret < 0) {
fprintf(
stderr
,
"Error generating DSA parameters: %s\n",
gnutls_strerror(ret));
app_exit(1);
}
if (info->outcert_format == GNUTLS_X509_FMT_PEM) {
print_private_key(outfile, info, pkey);
}
ret = gnutls_dh_params_import_dsa(dh_params, pkey);
if (ret < 0) {
fprintf(
stderr
,
"Error importing DSA parameters: %s\n",
gnutls_strerror(ret));
app_exit(1);
}
gnutls_x509_privkey_deinit(pkey);
} else {
ret = gnutls_dh_params_generate2(dh_params, bits);
if (ret < 0) {
fprintf(
stderr
,
"Error generating parameters: %s\n",
gnutls_strerror(ret));
app_exit(1);
}
}
ret =
gnutls_dh_params_export_raw(dh_params, &p, &g,
&q_bits);
if (ret < 0) {
fprintf(
stderr
, "Error exporting parameters: %s\n",
gnutls_strerror(ret));
app_exit(1);
}
} else {
if (info->provable != 0) {
fprintf(
stderr
, "The DH parameters obtained via this option are not provable\n");
app_exit(1);
}
if (bits <= 2048) {
p = gnutls_ffdhe_2048_group_prime;
g = gnutls_ffdhe_2048_group_generator;
key_bits = gnutls_ffdhe_2048_key_bits;
} else if (bits <= 3072) {
p = gnutls_ffdhe_3072_group_prime;
g = gnutls_ffdhe_3072_group_generator;
key_bits = gnutls_ffdhe_3072_key_bits;
} else if (bits <= 4096) {
p = gnutls_ffdhe_4096_group_prime;
g = gnutls_ffdhe_4096_group_generator;
key_bits = gnutls_ffdhe_4096_key_bits;
} else if (bits <= 6144) {
p = gnutls_ffdhe_6144_group_prime;
g = gnutls_ffdhe_6144_group_generator;
key_bits = gnutls_ffdhe_6144_key_bits;
} else {
p = gnutls_ffdhe_8192_group_prime;
g = gnutls_ffdhe_8192_group_generator;
key_bits = gnutls_ffdhe_8192_key_bits;
}
ret = gnutls_dh_params_import_raw2(dh_params, &p, &g, key_bits);
if (ret < 0) {
fprintf(
stderr
, "Error exporting parameters: %s\n",
gnutls_strerror(ret));
app_exit(1);
}
}
if (info->outtext)
print_dh_info(outfile, &p, &g, q_bits, info->cprint);
if (!info->cprint) {
size_t len = lbuffer_size;
ret =
gnutls_dh_params_export_pkcs3(dh_params,
info->outcert_format,
lbuffer, &len);
if (ret == 0) {
if (info->outcert_format == GNUTLS_X509_FMT_PEM)
fprintf(outfile, "\n%s", lbuffer);
else
fwrite(lbuffer, 1, len, outfile);
} else {
fprintf(
stderr
, "Error: %s\n",
gnutls_strerror(ret));
}
}
if (how != 0) {
gnutls_free((void *) (p.data)), p.data=
((void *)0)
;
gnutls_free((void *) (g.data)), g.data=
((void *)0)
;
}
gnutls_dh_params_deinit(dh_params);
return 0;
}
void decode_seed(gnutls_datum_t *seed, const char *hex, unsigned hex_size)
{
int ret;
size_t seed_size;
seed->size = hex_size;
seed->data = malloc(hex_size);
if (seed->data ==
((void *)0)
) {
fprintf(
stderr
, "memory error\n");
app_exit(1);
}
seed_size = hex_size;
ret = gnutls_hex2bin(hex, hex_size, seed->data, &seed_size);
if (ret < 0) {
fprintf(
stderr
, "Could not hex decode data: %s\n", gnutls_strerror(ret));
app_exit(1);
}
seed->size = seed_size;
return;
}
gnutls_pk_algorithm_t figure_key_type(const char *key_type)
{
if (strcasecmp(key_type, "rsa") == 0)
return GNUTLS_PK_RSA;
else if (strcasecmp(key_type, "rsa-pss") == 0)
return GNUTLS_PK_RSA_PSS;
else if (strcasecmp(key_type, "ed25519") == 0 || strcasecmp(key_type, "eddsa") == 0)
return GNUTLS_PK_EDDSA_ED25519;
else if (strcasecmp(key_type, "ed448") == 0)
return GNUTLS_PK_EDDSA_ED448;
else if (strcasecmp(key_type, "x25519") == 0)
return GNUTLS_PK_ECDH_X25519;
else if (strcasecmp(key_type, "x448") == 0)
return GNUTLS_PK_ECDH_X448;
else if (strcasecmp(key_type, "dsa") == 0)
return GNUTLS_PK_DSA;
else if (strcasecmp(key_type, "ecdsa") == 0 || strcasecmp(key_type, "ecc") == 0)
return GNUTLS_PK_ECDSA;
else if (strcasecmp(key_type, "gost01") == 0)
return GNUTLS_PK_GOST_01;
else if (strcasecmp(key_type, "gost12-256") == 0)
return GNUTLS_PK_GOST_12_256;
else if (strcasecmp(key_type, "gost12-512") == 0)
return GNUTLS_PK_GOST_12_512;
else {
fprintf(
stderr
, "unknown key type: %s\n", key_type);
return GNUTLS_PK_UNKNOWN;
}
}
gnutls_digest_algorithm_t hash_to_id(const char *hash)
{
if (strcasecmp(hash, "md5") == 0) {
fprintf(
stderr
,
"Warning: MD5 is broken, and should not be used any more for digital signatures.\n");
return GNUTLS_DIG_MD5;
} else if (strcasecmp(hash, "sha1") == 0)
return GNUTLS_DIG_SHA1;
else if (strcasecmp(hash, "sha256") == 0)
return GNUTLS_DIG_SHA256;
else if (strcasecmp(hash, "sha224") == 0)
return GNUTLS_DIG_SHA224;
else if (strcasecmp(hash, "sha384") == 0)
return GNUTLS_DIG_SHA384;
else if (strcasecmp(hash, "sha512") == 0)
return GNUTLS_DIG_SHA512;
else if (strcasecmp(hash, "sha3-256") == 0)
return GNUTLS_DIG_SHA3_256;
else if (strcasecmp(hash, "sha3-224") == 0)
return GNUTLS_DIG_SHA3_224;
else if (strcasecmp(hash, "sha3-384") == 0)
return GNUTLS_DIG_SHA3_384;
else if (strcasecmp(hash, "sha3-512") == 0)
return GNUTLS_DIG_SHA3_512;
else if (strcasecmp(hash, "rmd160") == 0)
return GNUTLS_DIG_RMD160;
else {
return gnutls_digest_get_id(hash);
}
}
void sign_params_to_flags(common_info_st *cinfo, const char *params)
{
char *p, *sp;
sp = strdup(params);
if (sp ==
((void *)0)
) {
fprintf(
stderr
, "memory error\n");
app_exit(1);
}
p = strtok(sp, ",");
while(p !=
((void *)0)
) {
if (strcasecmp(p, "rsa-pss")==0) {
cinfo->rsa_pss_sign = 1;
} else {
fprintf(
stderr
, "Unknown signature parameter: %s\n", p);
app_exit(1);
}
p=strtok(
((void *)0)
, ",");
}
free(sp);
}
|
"long insert_type(long a1, int *a2, long a3, void *a4, double a5, double a6, double a7, double a8)\(...TRUNCATED)
| "long insert_type(long a1, int *a2, long a3, void *a4)\n[17553] {\n const char *v4; // rax\n char(...TRUNCATED)
|
"void free_orphan(struct_0 *a0) {\n[1088] unsigned long long v2[3]; // rdi\n[1088] unsigned(...TRUNCATED)
| "void free_orphan(unsigned long long a0[4]) {\n[719] unsigned long long v1; // rax\n[719] \n[71(...TRUNCATED)
|
"long terminal_get_size(long a1, _DWORD *a2, _DWORD *a3)\n[4048] {\n long v4; // rax\n long v5; /(...TRUNCATED)
| "_BOOL8 terminal_get_size(long a1, _DWORD *a2, _DWORD *a3)\n[8882] {\n unsigned short v5; // [rsp+(...TRUNCATED)
|
"void el_init_fd(unsigned long long a0, unsigned long long a1, unsigned long long a2, unsigned int a(...TRUNCATED)
| "void el_init_fd(unsigned long long a0, unsigned long long a1, unsigned long long a2, unsigned long (...TRUNCATED)
|
"void usage(unsigned long a0) {\n[176] unsigned long v0; // [bp-0x10]\n[176] unsigned long (...TRUNCATED)
| "void usage(unsigned long a0) {\n[476] void* v0; // [bp-0x20]\n[476] unsigned long v1; // (...TRUNCATED)
|
End of preview. Expand
in Data Studio
No dataset card yet
- Downloads last month
- 16