/src/openssl30/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) {
        ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
        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) {
        ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
        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", **(int32_t **)pval);
    return BIO_printf(out, "%u\n", **(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-04-09 06:50

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.44M	#define INTxx_FLAG_ZERO_DEFAULT (1 << 0)
27	8.02M	#define INTxx_FLAG_SIGNED (1 << 1)
28
29		static int uint64_new(ASN1_VALUE *pval, const ASN1_ITEM it)
30	24.1k	{
31	24.1k	if ((pval = (ASN1_VALUE )OPENSSL_zalloc(sizeof(uint64_t))) == NULL) {
32	0	ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
33	0	return 0;
34	0	}
35	24.1k	return 1;
36	24.1k	}
37
38		static void uint64_free(ASN1_VALUE *pval, const ASN1_ITEM it)
39	280k	{
40	280k	OPENSSL_free(*pval);
41	280k	*pval = NULL;
42	280k	}
43
44		static void uint64_clear(ASN1_VALUE *pval, const ASN1_ITEM it)
45	471k	{
46	471k	(uint64_t )pval = 0;
47	471k	}
48
49		static int uint64_i2c(const ASN1_VALUE *pval, unsigned char cont, int *putype,
50		const ASN1_ITEM *it)
51	55.7k	{
52	55.7k	uint64_t utmp;
53	55.7k	int neg = 0;
54		/* this exists to bypass broken gcc optimization */
55	55.7k	char cp = (char )*pval;
56
57		/* use memcpy, because we may not be uint64_t aligned */
58	55.7k	memcpy(&utmp, cp, sizeof(utmp));
59
60	55.7k	if ((it->size & INTxx_FLAG_ZERO_DEFAULT) == INTxx_FLAG_ZERO_DEFAULT
61	45.4k	&& utmp == 0)
62	10.7k	return -1;
63	45.0k	if ((it->size & INTxx_FLAG_SIGNED) == INTxx_FLAG_SIGNED
64	33.2k	&& (int64_t)utmp < 0) {
65		/* ossl_i2c_uint64_int() assumes positive values */
66	5.87k	utmp = 0 - utmp;
67	5.87k	neg = 1;
68	5.87k	}
69
70	45.0k	return ossl_i2c_uint64_int(cont, utmp, neg);
71	55.7k	}
72
73		static int uint64_c2i(ASN1_VALUE *pval, const unsigned char cont, int len,
74		int utype, char free_cont, const ASN1_ITEM it)
75	15.7k	{
76	15.7k	uint64_t utmp = 0;
77	15.7k	char *cp;
78	15.7k	int neg = 0;
79
80	15.7k	if (*pval == NULL && !uint64_new(pval, it))
81	0	return 0;
82
83	15.7k	cp = (char )pval;
84
85		/*
86		* Strictly speaking, zero length is malformed. However, long_c2i
87		* (x_long.c) encodes 0 as a zero length INTEGER (wrongly, of course),
88		* so for the sake of backward compatibility, we still decode zero
89		* length INTEGERs as the number zero.
90		*/
91	15.7k	if (len == 0)
92	40	goto long_compat;
93
94	15.6k	if (!ossl_c2i_uint64_int(&utmp, &neg, &cont, len))
95	2.49k	return 0;
96	13.1k	if ((it->size & INTxx_FLAG_SIGNED) == 0 && neg) {
97	2.02k	ERR_raise(ERR_LIB_ASN1, ASN1_R_ILLEGAL_NEGATIVE_VALUE);
98	2.02k	return 0;
99	2.02k	}
100	11.1k	if ((it->size & INTxx_FLAG_SIGNED) == INTxx_FLAG_SIGNED
101	7.37k	&& !neg && utmp > INT64_MAX) {
102	752	ERR_raise(ERR_LIB_ASN1, ASN1_R_TOO_LARGE);
103	752	return 0;
104	752	}
105	10.3k	if (neg)
106		/* ossl_c2i_uint64_int() returns positive values */
107	3.18k	utmp = 0 - utmp;
108
109	10.4k	long_compat:
110	10.4k	memcpy(cp, &utmp, sizeof(utmp));
111	10.4k	return 1;
112	10.3k	}
113
114		static int uint64_print(BIO out, const ASN1_VALUE pval, const ASN1_ITEM it,
115		int indent, const ASN1_PCTX *pctx)
116	6.81k	{
117	6.81k	if ((it->size & INTxx_FLAG_SIGNED) == INTxx_FLAG_SIGNED)
118	4.04k	return BIO_printf(out, "%jd\n", (int64_t )pval);
119	2.77k	return BIO_printf(out, "%ju\n", (uint64_t )pval);
120	6.81k	}
121
122		/* 32-bit variants */
123
124		static int uint32_new(ASN1_VALUE *pval, const ASN1_ITEM it)
125	0	{
126	0	if ((pval = (ASN1_VALUE )OPENSSL_zalloc(sizeof(uint32_t))) == NULL) {
127	0	ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
128	0	return 0;
129	0	}
130	0	return 1;
131	0	}
132
133		static void uint32_free(ASN1_VALUE *pval, const ASN1_ITEM it)
134	280k	{
135	280k	OPENSSL_free(*pval);
136	280k	*pval = NULL;
137	280k	}
138
139		static void uint32_clear(ASN1_VALUE *pval, const ASN1_ITEM it)
140	2.46M	{
141	2.46M	(uint32_t )pval = 0;
142	2.46M	}
143
144		static int uint32_i2c(const ASN1_VALUE *pval, unsigned char cont, int *putype,
145		const ASN1_ITEM *it)
146	499k	{
147	499k	uint32_t utmp;
148	499k	int neg = 0;
149		/* this exists to bypass broken gcc optimization */
150	499k	char cp = (char )*pval;
151
152		/* use memcpy, because we may not be uint32_t aligned */
153	499k	memcpy(&utmp, cp, sizeof(utmp));
154
155	499k	if ((it->size & INTxx_FLAG_ZERO_DEFAULT) == INTxx_FLAG_ZERO_DEFAULT
156	33.1k	&& utmp == 0)
157	26.7k	return -1;
158	472k	if ((it->size & INTxx_FLAG_SIGNED) == INTxx_FLAG_SIGNED
159	449k	&& (int32_t)utmp < 0) {
160		/* ossl_i2c_uint64_int() assumes positive values */
161	102k	utmp = 0 - utmp;
162	102k	neg = 1;
163	102k	}
164
165	472k	return ossl_i2c_uint64_int(cont, (uint64_t)utmp, neg);
166	499k	}
167
168		/*
169		* Absolute value of INT32_MIN: we can't just use -INT32_MIN as it produces
170		* overflow warnings.
171		*/
172
173	132k	#define ABS_INT32_MIN ((uint32_t)INT32_MAX + 1)
174
175		static int uint32_c2i(ASN1_VALUE *pval, const unsigned char cont, int len,
176		int utype, char free_cont, const ASN1_ITEM it)
177	943k	{
178	943k	uint64_t utmp = 0;
179	943k	uint32_t utmp2 = 0;
180	943k	char *cp;
181	943k	int neg = 0;
182
183	943k	if (*pval == NULL && !uint64_new(pval, it))
184	0	return 0;
185
186	943k	cp = (char )pval;
187
188		/*
189		* Strictly speaking, zero length is malformed. However, long_c2i
190		* (x_long.c) encodes 0 as a zero length INTEGER (wrongly, of course),
191		* so for the sake of backward compatibility, we still decode zero
192		* length INTEGERs as the number zero.
193		*/
194	943k	if (len == 0)
195	112k	goto long_compat;
196
197	830k	if (!ossl_c2i_uint64_int(&utmp, &neg, &cont, len))
198	36.0k	return 0;
199	794k	if ((it->size & INTxx_FLAG_SIGNED) == 0 && neg) {
200	6.31k	ERR_raise(ERR_LIB_ASN1, ASN1_R_ILLEGAL_NEGATIVE_VALUE);
201	6.31k	return 0;
202	6.31k	}
203	788k	if (neg) {
204	132k	if (utmp > ABS_INT32_MIN) {
205	21.4k	ERR_raise(ERR_LIB_ASN1, ASN1_R_TOO_SMALL);
206	21.4k	return 0;
207	21.4k	}
208	111k	utmp = 0 - utmp;
209	655k	} else {
210	655k	if (((it->size & INTxx_FLAG_SIGNED) != 0 && utmp > INT32_MAX)
211	634k	\|\| ((it->size & INTxx_FLAG_SIGNED) == 0 && utmp > UINT32_MAX)) {
212	23.2k	ERR_raise(ERR_LIB_ASN1, ASN1_R_TOO_LARGE);
213	23.2k	return 0;
214	23.2k	}
215	655k	}
216
217	856k	long_compat:
218	856k	utmp2 = (uint32_t)utmp;
219	856k	memcpy(cp, &utmp2, sizeof(utmp2));
220	856k	return 1;
221	788k	}
222
223		static int uint32_print(BIO out, const ASN1_VALUE pval, const ASN1_ITEM it,
224		int indent, const ASN1_PCTX *pctx)
225	16.4k	{
226	16.4k	if ((it->size & INTxx_FLAG_SIGNED) == INTxx_FLAG_SIGNED)
227	15.2k	return BIO_printf(out, "%d\n", (int32_t )pval);
228	1.17k	return BIO_printf(out, "%u\n", (uint32_t )pval);
229	16.4k	}
230
231		/* Define the primitives themselves */
232
233		static ASN1_PRIMITIVE_FUNCS uint32_pf = {
234		NULL, 0,
235		uint32_new,
236		uint32_free,
237		uint32_clear,
238		uint32_c2i,
239		uint32_i2c,
240		uint32_print
241		};
242
243		static ASN1_PRIMITIVE_FUNCS uint64_pf = {
244		NULL, 0,
245		uint64_new,
246		uint64_free,
247		uint64_clear,
248		uint64_c2i,
249		uint64_i2c,
250		uint64_print
251		};
252
253	3.50M	ASN1_ITEM_start(INT32)
254	3.50M	ASN1_ITYPE_PRIMITIVE,
255	3.50M	V_ASN1_INTEGER, NULL, 0, &uint32_pf,
256	3.50M	INTxx_FLAG_SIGNED, "INT32" ASN1_ITEM_end(INT32)
257
258	434k	ASN1_ITEM_start(UINT32) ASN1_ITYPE_PRIMITIVE,
259	434k	V_ASN1_INTEGER, NULL, 0, &uint32_pf, 0, "UINT32" ASN1_ITEM_end(UINT32)
260
261	70.0k	ASN1_ITEM_start(INT64) ASN1_ITYPE_PRIMITIVE,
262	70.0k	V_ASN1_INTEGER, NULL, 0, &uint64_pf,
263	70.0k	INTxx_FLAG_SIGNED, "INT64" ASN1_ITEM_end(INT64)
264
265	70.0k	ASN1_ITEM_start(UINT64) ASN1_ITYPE_PRIMITIVE,
266	70.0k	V_ASN1_INTEGER, NULL, 0, &uint64_pf, 0, "UINT64" ASN1_ITEM_end(UINT64)
267
268	282k	ASN1_ITEM_start(ZINT32) ASN1_ITYPE_PRIMITIVE,
269	282k	V_ASN1_INTEGER, NULL, 0, &uint32_pf,
270	282k	INTxx_FLAG_ZERO_DEFAULT \| INTxx_FLAG_SIGNED, "ZINT32" ASN1_ITEM_end(ZINT32)
271
272	618k	ASN1_ITEM_start(ZUINT32) ASN1_ITYPE_PRIMITIVE,
273	618k	V_ASN1_INTEGER, NULL, 0, &uint32_pf,
274	618k	INTxx_FLAG_ZERO_DEFAULT, "ZUINT32" ASN1_ITEM_end(ZUINT32)
275
276	440k	ASN1_ITEM_start(ZINT64) ASN1_ITYPE_PRIMITIVE,
277	440k	V_ASN1_INTEGER, NULL, 0, &uint64_pf,
278	440k	INTxx_FLAG_ZERO_DEFAULT \| INTxx_FLAG_SIGNED, "ZINT64" ASN1_ITEM_end(ZINT64)
279
280	436k	ASN1_ITEM_start(ZUINT64) ASN1_ITYPE_PRIMITIVE,
281	436k	V_ASN1_INTEGER, NULL, 0, &uint64_pf,
282	436k	INTxx_FLAG_ZERO_DEFAULT, "ZUINT64" ASN1_ITEM_end(ZUINT64)