/src/openssl36/crypto/asn1/x_int64.c

Source
/*
 * Copyright 2017-2021 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#include <stdio.h>
#include "internal/cryptlib.h"
#include "internal/numbers.h"
#include <openssl/asn1t.h>
#include <openssl/bn.h>
#include "asn1_local.h"

/*
 * Custom primitive types for handling int32_t, int64_t, uint32_t, uint64_t.
 * This converts between an ASN1_INTEGER and those types directly.
 * This is preferred to using the LONG / ZLONG primitives.
 */

/*
 * We abuse the ASN1_ITEM fields |size| as a flags field
 */
#define INTxx_FLAG_ZERO_DEFAULT (1 << 0)
#define INTxx_FLAG_SIGNED (1 << 1)

static int uint64_new(ASN1_VALUE **pval, const ASN1_ITEM *it)
{
    if ((*pval = (ASN1_VALUE *)OPENSSL_zalloc(sizeof(uint64_t))) == NULL)
        return 0;
    return 1;
}

static void uint64_free(ASN1_VALUE **pval, const ASN1_ITEM *it)
{
    OPENSSL_free(*pval);
    *pval = NULL;
}

static void uint64_clear(ASN1_VALUE **pval, const ASN1_ITEM *it)
{
    **(uint64_t **)pval = 0;
}

static int uint64_i2c(const ASN1_VALUE **pval, unsigned char *cont, int *putype,
    const ASN1_ITEM *it)
{
    uint64_t utmp;
    int neg = 0;
    /* this exists to bypass broken gcc optimization */
    char *cp = (char *)*pval;

    /* use memcpy, because we may not be uint64_t aligned */
    memcpy(&utmp, cp, sizeof(utmp));

    if ((it->size & INTxx_FLAG_ZERO_DEFAULT) == INTxx_FLAG_ZERO_DEFAULT
        && utmp == 0)
        return -1;
    if ((it->size & INTxx_FLAG_SIGNED) == INTxx_FLAG_SIGNED
        && (int64_t)utmp < 0) {
        /* ossl_i2c_uint64_int() assumes positive values */
        utmp = 0 - utmp;
        neg = 1;
    }

    return ossl_i2c_uint64_int(cont, utmp, neg);
}

static int uint64_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len,
    int utype, char *free_cont, const ASN1_ITEM *it)
{
    uint64_t utmp = 0;
    char *cp;
    int neg = 0;

    if (*pval == NULL && !uint64_new(pval, it))
        return 0;

    cp = (char *)*pval;

    /*
     * Strictly speaking, zero length is malformed.  However, long_c2i
     * (x_long.c) encodes 0 as a zero length INTEGER (wrongly, of course),
     * so for the sake of backward compatibility, we still decode zero
     * length INTEGERs as the number zero.
     */
    if (len == 0)
        goto long_compat;

    if (!ossl_c2i_uint64_int(&utmp, &neg, &cont, len))
        return 0;
    if ((it->size & INTxx_FLAG_SIGNED) == 0 && neg) {
        ERR_raise(ERR_LIB_ASN1, ASN1_R_ILLEGAL_NEGATIVE_VALUE);
        return 0;
    }
    if ((it->size & INTxx_FLAG_SIGNED) == INTxx_FLAG_SIGNED
        && !neg && utmp > INT64_MAX) {
        ERR_raise(ERR_LIB_ASN1, ASN1_R_TOO_LARGE);
        return 0;
    }
    if (neg)
        /* ossl_c2i_uint64_int() returns positive values */
        utmp = 0 - utmp;

long_compat:
    memcpy(cp, &utmp, sizeof(utmp));
    return 1;
}

static int uint64_print(BIO *out, const ASN1_VALUE **pval, const ASN1_ITEM *it,
    int indent, const ASN1_PCTX *pctx)
{
    if ((it->size & INTxx_FLAG_SIGNED) == INTxx_FLAG_SIGNED)
        return BIO_printf(out, "%jd\n", **(int64_t **)pval);
    return BIO_printf(out, "%ju\n", **(uint64_t **)pval);
}

/* 32-bit variants */

static int uint32_new(ASN1_VALUE **pval, const ASN1_ITEM *it)
{
    if ((*pval = (ASN1_VALUE *)OPENSSL_zalloc(sizeof(uint32_t))) == NULL)
        return 0;
    return 1;
}

static void uint32_free(ASN1_VALUE **pval, const ASN1_ITEM *it)
{
    OPENSSL_free(*pval);
    *pval = NULL;
}

static void uint32_clear(ASN1_VALUE **pval, const ASN1_ITEM *it)
{
    **(uint32_t **)pval = 0;
}

static int uint32_i2c(const ASN1_VALUE **pval, unsigned char *cont, int *putype,
    const ASN1_ITEM *it)
{
    uint32_t utmp;
    int neg = 0;
    /* this exists to bypass broken gcc optimization */
    char *cp = (char *)*pval;

    /* use memcpy, because we may not be uint32_t aligned */
    memcpy(&utmp, cp, sizeof(utmp));

    if ((it->size & INTxx_FLAG_ZERO_DEFAULT) == INTxx_FLAG_ZERO_DEFAULT
        && utmp == 0)
        return -1;
    if ((it->size & INTxx_FLAG_SIGNED) == INTxx_FLAG_SIGNED
        && (int32_t)utmp < 0) {
        /* ossl_i2c_uint64_int() assumes positive values */
        utmp = 0 - utmp;
        neg = 1;
    }

    return ossl_i2c_uint64_int(cont, (uint64_t)utmp, neg);
}

/*
 * Absolute value of INT32_MIN: we can't just use -INT32_MIN as it produces
 * overflow warnings.
 */

#define ABS_INT32_MIN ((uint32_t)INT32_MAX + 1)

static int uint32_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len,
    int utype, char *free_cont, const ASN1_ITEM *it)
{
    uint64_t utmp = 0;
    uint32_t utmp2 = 0;
    char *cp;
    int neg = 0;

    if (*pval == NULL && !uint64_new(pval, it))
        return 0;

    cp = (char *)*pval;

    /*
     * Strictly speaking, zero length is malformed.  However, long_c2i
     * (x_long.c) encodes 0 as a zero length INTEGER (wrongly, of course),
     * so for the sake of backward compatibility, we still decode zero
     * length INTEGERs as the number zero.
     */
    if (len == 0)
        goto long_compat;

    if (!ossl_c2i_uint64_int(&utmp, &neg, &cont, len))
        return 0;
    if ((it->size & INTxx_FLAG_SIGNED) == 0 && neg) {
        ERR_raise(ERR_LIB_ASN1, ASN1_R_ILLEGAL_NEGATIVE_VALUE);
        return 0;
    }
    if (neg) {
        if (utmp > ABS_INT32_MIN) {
            ERR_raise(ERR_LIB_ASN1, ASN1_R_TOO_SMALL);
            return 0;
        }
        utmp = 0 - utmp;
    } else {
        if (((it->size & INTxx_FLAG_SIGNED) != 0 && utmp > INT32_MAX)
            || ((it->size & INTxx_FLAG_SIGNED) == 0 && utmp > UINT32_MAX)) {
            ERR_raise(ERR_LIB_ASN1, ASN1_R_TOO_LARGE);
            return 0;
        }
    }

long_compat:
    utmp2 = (uint32_t)utmp;
    memcpy(cp, &utmp2, sizeof(utmp2));
    return 1;
}

static int uint32_print(BIO *out, const ASN1_VALUE **pval, const ASN1_ITEM *it,
    int indent, const ASN1_PCTX *pctx)
{
    if ((it->size & INTxx_FLAG_SIGNED) == INTxx_FLAG_SIGNED)
        return BIO_printf(out, "%d\n", (int)**(int32_t **)pval);
    return BIO_printf(out, "%u\n", (unsigned int)**(uint32_t **)pval);
}

/* Define the primitives themselves */

static ASN1_PRIMITIVE_FUNCS uint32_pf = {
    NULL, 0,
    uint32_new,
    uint32_free,
    uint32_clear,
    uint32_c2i,
    uint32_i2c,
    uint32_print
};

static ASN1_PRIMITIVE_FUNCS uint64_pf = {
    NULL, 0,
    uint64_new,
    uint64_free,
    uint64_clear,
    uint64_c2i,
    uint64_i2c,
    uint64_print
};

ASN1_ITEM_start(INT32)
    ASN1_ITYPE_PRIMITIVE,
    V_ASN1_INTEGER, NULL, 0, &uint32_pf,
    INTxx_FLAG_SIGNED, "INT32" ASN1_ITEM_end(INT32)

                           ASN1_ITEM_start(UINT32) ASN1_ITYPE_PRIMITIVE,
    V_ASN1_INTEGER, NULL, 0, &uint32_pf, 0, "UINT32" ASN1_ITEM_end(UINT32)

                                                ASN1_ITEM_start(INT64) ASN1_ITYPE_PRIMITIVE,
    V_ASN1_INTEGER, NULL, 0, &uint64_pf,
    INTxx_FLAG_SIGNED, "INT64" ASN1_ITEM_end(INT64)

                           ASN1_ITEM_start(UINT64) ASN1_ITYPE_PRIMITIVE,
    V_ASN1_INTEGER, NULL, 0, &uint64_pf, 0, "UINT64" ASN1_ITEM_end(UINT64)

                                                ASN1_ITEM_start(ZINT32) ASN1_ITYPE_PRIMITIVE,
    V_ASN1_INTEGER, NULL, 0, &uint32_pf,
    INTxx_FLAG_ZERO_DEFAULT | INTxx_FLAG_SIGNED, "ZINT32" ASN1_ITEM_end(ZINT32)

                                                     ASN1_ITEM_start(ZUINT32) ASN1_ITYPE_PRIMITIVE,
    V_ASN1_INTEGER, NULL, 0, &uint32_pf,
    INTxx_FLAG_ZERO_DEFAULT, "ZUINT32" ASN1_ITEM_end(ZUINT32)

                                 ASN1_ITEM_start(ZINT64) ASN1_ITYPE_PRIMITIVE,
    V_ASN1_INTEGER, NULL, 0, &uint64_pf,
    INTxx_FLAG_ZERO_DEFAULT | INTxx_FLAG_SIGNED, "ZINT64" ASN1_ITEM_end(ZINT64)

                                                     ASN1_ITEM_start(ZUINT64) ASN1_ITYPE_PRIMITIVE,
    V_ASN1_INTEGER, NULL, 0, &uint64_pf,
    INTxx_FLAG_ZERO_DEFAULT, "ZUINT64" ASN1_ITEM_end(ZUINT64)

Coverage Report

Created: 2026-07-23 06:28

Line	Count	Source
1		/*
2		* Copyright 2017-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 "internal/cryptlib.h"
12		#include "internal/numbers.h"
13		#include <openssl/asn1t.h>
14		#include <openssl/bn.h>
15		#include "asn1_local.h"
16
17		/*
18		* Custom primitive types for handling int32_t, int64_t, uint32_t, uint64_t.
19		* This converts between an ASN1_INTEGER and those types directly.
20		* This is preferred to using the LONG / ZLONG primitives.
21		*/
22
23		/*
24		* We abuse the ASN1_ITEM fields \|size\| as a flags field
25		*/
26	3.08M	#define INTxx_FLAG_ZERO_DEFAULT (1 << 0)
27	7.30M	#define INTxx_FLAG_SIGNED (1 << 1)
28
29		static int uint64_new(ASN1_VALUE *pval, const ASN1_ITEM it)
30	20.3k	{
31	20.3k	if ((pval = (ASN1_VALUE )OPENSSL_zalloc(sizeof(uint64_t))) == NULL)
32	0	return 0;
33	20.3k	return 1;
34	20.3k	}
35
36		static void uint64_free(ASN1_VALUE *pval, const ASN1_ITEM it)
37	237k	{
38	237k	OPENSSL_free(*pval);
39	237k	*pval = NULL;
40	237k	}
41
42		static void uint64_clear(ASN1_VALUE *pval, const ASN1_ITEM it)
43	403k	{
44	403k	(uint64_t )pval = 0;
45	403k	}
46
47		static int uint64_i2c(const ASN1_VALUE *pval, unsigned char cont, int *putype,
48		const ASN1_ITEM *it)
49	50.3k	{
50	50.3k	uint64_t utmp;
51	50.3k	int neg = 0;
52		/* this exists to bypass broken gcc optimization */
53	50.3k	char cp = (char )*pval;
54
55		/* use memcpy, because we may not be uint64_t aligned */
56	50.3k	memcpy(&utmp, cp, sizeof(utmp));
57
58	50.3k	if ((it->size & INTxx_FLAG_ZERO_DEFAULT) == INTxx_FLAG_ZERO_DEFAULT
59	42.0k	&& utmp == 0)
60	10.5k	return -1;
61	39.8k	if ((it->size & INTxx_FLAG_SIGNED) == INTxx_FLAG_SIGNED
62	30.2k	&& (int64_t)utmp < 0) {
63		/* ossl_i2c_uint64_int() assumes positive values */
64	5.22k	utmp = 0 - utmp;
65	5.22k	neg = 1;
66	5.22k	}
67
68	39.8k	return ossl_i2c_uint64_int(cont, utmp, neg);
69	50.3k	}
70
71		static int uint64_c2i(ASN1_VALUE *pval, const unsigned char cont, int len,
72		int utype, char free_cont, const ASN1_ITEM it)
73	13.5k	{
74	13.5k	uint64_t utmp = 0;
75	13.5k	char *cp;
76	13.5k	int neg = 0;
77
78	13.5k	if (*pval == NULL && !uint64_new(pval, it))
79	0	return 0;
80
81	13.5k	cp = (char )pval;
82
83		/*
84		* Strictly speaking, zero length is malformed. However, long_c2i
85		* (x_long.c) encodes 0 as a zero length INTEGER (wrongly, of course),
86		* so for the sake of backward compatibility, we still decode zero
87		* length INTEGERs as the number zero.
88		*/
89	13.5k	if (len == 0)
90	43	goto long_compat;
91
92	13.5k	if (!ossl_c2i_uint64_int(&utmp, &neg, &cont, len))
93	2.28k	return 0;
94	11.2k	if ((it->size & INTxx_FLAG_SIGNED) == 0 && neg) {
95	1.71k	ERR_raise(ERR_LIB_ASN1, ASN1_R_ILLEGAL_NEGATIVE_VALUE);
96	1.71k	return 0;
97	1.71k	}
98	9.53k	if ((it->size & INTxx_FLAG_SIGNED) == INTxx_FLAG_SIGNED
99	6.44k	&& !neg && utmp > INT64_MAX) {
100	617	ERR_raise(ERR_LIB_ASN1, ASN1_R_TOO_LARGE);
101	617	return 0;
102	617	}
103	8.92k	if (neg)
104		/* ossl_c2i_uint64_int() returns positive values */
105	2.78k	utmp = 0 - utmp;
106
107	8.96k	long_compat:
108	8.96k	memcpy(cp, &utmp, sizeof(utmp));
109	8.96k	return 1;
110	8.92k	}
111
112		static int uint64_print(BIO out, const ASN1_VALUE pval, const ASN1_ITEM it,
113		int indent, const ASN1_PCTX *pctx)
114	5.57k	{
115	5.57k	if ((it->size & INTxx_FLAG_SIGNED) == INTxx_FLAG_SIGNED)
116	3.33k	return BIO_printf(out, "%jd\n", (int64_t )pval);
117	2.23k	return BIO_printf(out, "%ju\n", (uint64_t )pval);
118	5.57k	}
119
120		/* 32-bit variants */
121
122		static int uint32_new(ASN1_VALUE *pval, const ASN1_ITEM it)
123	0	{
124	0	if ((pval = (ASN1_VALUE )OPENSSL_zalloc(sizeof(uint32_t))) == NULL)
125	0	return 0;
126	0	return 1;
127	0	}
128
129		static void uint32_free(ASN1_VALUE *pval, const ASN1_ITEM it)
130	237k	{
131	237k	OPENSSL_free(*pval);
132	237k	*pval = NULL;
133	237k	}
134
135		static void uint32_clear(ASN1_VALUE *pval, const ASN1_ITEM it)
136	2.22M	{
137	2.22M	(uint32_t )pval = 0;
138	2.22M	}
139
140		static int uint32_i2c(const ASN1_VALUE *pval, unsigned char cont, int *putype,
141		const ASN1_ITEM *it)
142	467k	{
143	467k	uint32_t utmp;
144	467k	int neg = 0;
145		/* this exists to bypass broken gcc optimization */
146	467k	char cp = (char )*pval;
147
148		/* use memcpy, because we may not be uint32_t aligned */
149	467k	memcpy(&utmp, cp, sizeof(utmp));
150
151	467k	if ((it->size & INTxx_FLAG_ZERO_DEFAULT) == INTxx_FLAG_ZERO_DEFAULT
152	30.8k	&& utmp == 0)
153	25.9k	return -1;
154	441k	if ((it->size & INTxx_FLAG_SIGNED) == INTxx_FLAG_SIGNED
155	420k	&& (int32_t)utmp < 0) {
156		/* ossl_i2c_uint64_int() assumes positive values */
157	103k	utmp = 0 - utmp;
158	103k	neg = 1;
159	103k	}
160
161	441k	return ossl_i2c_uint64_int(cont, (uint64_t)utmp, neg);
162	467k	}
163
164		/*
165		* Absolute value of INT32_MIN: we can't just use -INT32_MIN as it produces
166		* overflow warnings.
167		*/
168
169	128k	#define ABS_INT32_MIN ((uint32_t)INT32_MAX + 1)
170
171		static int uint32_c2i(ASN1_VALUE *pval, const unsigned char cont, int len,
172		int utype, char free_cont, const ASN1_ITEM it)
173	872k	{
174	872k	uint64_t utmp = 0;
175	872k	uint32_t utmp2 = 0;
176	872k	char *cp;
177	872k	int neg = 0;
178
179	872k	if (*pval == NULL && !uint64_new(pval, it))
180	0	return 0;
181
182	872k	cp = (char )pval;
183
184		/*
185		* Strictly speaking, zero length is malformed. However, long_c2i
186		* (x_long.c) encodes 0 as a zero length INTEGER (wrongly, of course),
187		* so for the sake of backward compatibility, we still decode zero
188		* length INTEGERs as the number zero.
189		*/
190	872k	if (len == 0)
191	114k	goto long_compat;
192
193	757k	if (!ossl_c2i_uint64_int(&utmp, &neg, &cont, len))
194	34.1k	return 0;
195	723k	if ((it->size & INTxx_FLAG_SIGNED) == 0 && neg) {
196	5.63k	ERR_raise(ERR_LIB_ASN1, ASN1_R_ILLEGAL_NEGATIVE_VALUE);
197	5.63k	return 0;
198	5.63k	}
199	717k	if (neg) {
200	128k	if (utmp > ABS_INT32_MIN) {
201	20.6k	ERR_raise(ERR_LIB_ASN1, ASN1_R_TOO_SMALL);
202	20.6k	return 0;
203	20.6k	}
204	108k	utmp = 0 - utmp;
205	588k	} else {
206	588k	if (((it->size & INTxx_FLAG_SIGNED) != 0 && utmp > INT32_MAX)
207	568k	\|\| ((it->size & INTxx_FLAG_SIGNED) == 0 && utmp > UINT32_MAX)) {
208	21.8k	ERR_raise(ERR_LIB_ASN1, ASN1_R_TOO_LARGE);
209	21.8k	return 0;
210	21.8k	}
211	588k	}
212
213	790k	long_compat:
214	790k	utmp2 = (uint32_t)utmp;
215	790k	memcpy(cp, &utmp2, sizeof(utmp2));
216	790k	return 1;
217	717k	}
218
219		static int uint32_print(BIO out, const ASN1_VALUE pval, const ASN1_ITEM it,
220		int indent, const ASN1_PCTX *pctx)
221	14.8k	{
222	14.8k	if ((it->size & INTxx_FLAG_SIGNED) == INTxx_FLAG_SIGNED)
223	13.9k	return BIO_printf(out, "%d\n", (int)(int32_t )pval);
224	912	return BIO_printf(out, "%u\n", (unsigned int)(uint32_t )pval);
225	14.8k	}
226
227		/* Define the primitives themselves */
228
229		static ASN1_PRIMITIVE_FUNCS uint32_pf = {
230		NULL, 0,
231		uint32_new,
232		uint32_free,
233		uint32_clear,
234		uint32_c2i,
235		uint32_i2c,
236		uint32_print
237		};
238
239		static ASN1_PRIMITIVE_FUNCS uint64_pf = {
240		NULL, 0,
241		uint64_new,
242		uint64_free,
243		uint64_clear,
244		uint64_c2i,
245		uint64_i2c,
246		uint64_print
247		};
248
249	3.21M	ASN1_ITEM_start(INT32)
250	3.21M	ASN1_ITYPE_PRIMITIVE,
251	3.21M	V_ASN1_INTEGER, NULL, 0, &uint32_pf,
252	3.21M	INTxx_FLAG_SIGNED, "INT32" ASN1_ITEM_end(INT32)
253
254	372k	ASN1_ITEM_start(UINT32) ASN1_ITYPE_PRIMITIVE,
255	372k	V_ASN1_INTEGER, NULL, 0, &uint32_pf, 0, "UINT32" ASN1_ITEM_end(UINT32)
256
257	59.4k	ASN1_ITEM_start(INT64) ASN1_ITYPE_PRIMITIVE,
258	59.4k	V_ASN1_INTEGER, NULL, 0, &uint64_pf,
259	59.4k	INTxx_FLAG_SIGNED, "INT64" ASN1_ITEM_end(INT64)
260
261	59.4k	ASN1_ITEM_start(UINT64) ASN1_ITYPE_PRIMITIVE,
262	59.4k	V_ASN1_INTEGER, NULL, 0, &uint64_pf, 0, "UINT64" ASN1_ITEM_end(UINT64)
263
264	245k	ASN1_ITEM_start(ZINT32) ASN1_ITYPE_PRIMITIVE,
265	245k	V_ASN1_INTEGER, NULL, 0, &uint32_pf,
266	245k	INTxx_FLAG_ZERO_DEFAULT \| INTxx_FLAG_SIGNED, "ZINT32" ASN1_ITEM_end(ZINT32)
267
268	531k	ASN1_ITEM_start(ZUINT32) ASN1_ITYPE_PRIMITIVE,
269	531k	V_ASN1_INTEGER, NULL, 0, &uint32_pf,
270	531k	INTxx_FLAG_ZERO_DEFAULT, "ZUINT32" ASN1_ITEM_end(ZUINT32)
271
272	378k	ASN1_ITEM_start(ZINT64) ASN1_ITYPE_PRIMITIVE,
273	378k	V_ASN1_INTEGER, NULL, 0, &uint64_pf,
274	378k	INTxx_FLAG_ZERO_DEFAULT \| INTxx_FLAG_SIGNED, "ZINT64" ASN1_ITEM_end(ZINT64)
275
276	374k	ASN1_ITEM_start(ZUINT64) ASN1_ITYPE_PRIMITIVE,
277	374k	V_ASN1_INTEGER, NULL, 0, &uint64_pf,
278	374k	INTxx_FLAG_ZERO_DEFAULT, "ZUINT64" ASN1_ITEM_end(ZUINT64)