[thirdparty/openssl.git] / crypto / asn1 / x_int64.c

/*
 * Copyright 2017 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the OpenSSL license (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_locl.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)
{
    *pval = (ASN1_VALUE *)OPENSSL_zalloc(sizeof(uint64_t));
    if (*pval == 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(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) {
        /* i2c_uint64_int() assumes positive values */
        utmp = 0 - utmp;
        neg = 1;
    }

    return 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;
    if (!c2i_uint64_int(&utmp, &neg, &cont, len))
        return 0;
    if ((it->size & INTxx_FLAG_SIGNED) == 0 && neg) {
        ASN1err(ASN1_F_UINT64_C2I, ASN1_R_ILLEGAL_NEGATIVE_VALUE);
        return 0;
    }
    if ((it->size & INTxx_FLAG_SIGNED) == INTxx_FLAG_SIGNED
            && !neg && utmp > INT64_MAX) {
        ASN1err(ASN1_F_UINT64_C2I, ASN1_R_TOO_LARGE);
        return 0;
    }
    if (neg)
        /* c2i_uint64_int() returns positive values */
        utmp = 0 - utmp;
    memcpy(cp, &utmp, sizeof(utmp));
    return 1;
}

static int uint64_print(BIO *out, 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", (intmax_t)**(int64_t **)pval);
    return BIO_printf(out, "%ju\n", (uintmax_t)**(uint64_t **)pval);
}

/* 32-bit variants */

static int uint32_new(ASN1_VALUE **pval, const ASN1_ITEM *it)
{
    *pval = (ASN1_VALUE *)OPENSSL_zalloc(sizeof(uint32_t));
    if (*pval == 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(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) {
        /* i2c_uint64_int() assumes positive values */
        utmp = 0 - utmp;
        neg = 1;
    }

    return 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;
    if (!c2i_uint64_int(&utmp, &neg, &cont, len))
        return 0;
    if ((it->size & INTxx_FLAG_SIGNED) == 0 && neg) {
        ASN1err(ASN1_F_UINT32_C2I, ASN1_R_ILLEGAL_NEGATIVE_VALUE);
        return 0;
    }
    if (neg) {
        if (utmp > ABS_INT32_MIN) {
            ASN1err(ASN1_F_UINT32_C2I, 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)) {
            ASN1err(ASN1_F_UINT32_C2I, ASN1_R_TOO_LARGE);
            return 0;
        }
    }
    utmp2 = (uint32_t)utmp;
    memcpy(cp, &utmp2, sizeof(utmp2));
    return 1;
}

static int uint32_print(BIO *out, 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)
Commit	Line	Data
93f7d6fc RL	1	/*
	2	* Copyright 2017 The OpenSSL Project Authors. All Rights Reserved.
	3	*
	4	* Licensed under the OpenSSL license (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"
93f7d6fc	12	#include "internal/numbers.h"
64f11ee8	13	#include <openssl/asn1t.h>
93f7d6fc RL	14	#include <openssl/bn.h>
	15	#include "asn1_locl.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	#define INTxx_FLAG_ZERO_DEFAULT (1<<0)
	27	#define INTxx_FLAG_SIGNED (1<<1)
	28
	29	static int uint64_new(ASN1_VALUE *pval, const ASN1_ITEM it)
	30	{
da26ff30 RL	31	pval = (ASN1_VALUE )OPENSSL_zalloc(sizeof(uint64_t));
	32	if (*pval == NULL)
	33	return 0;
93f7d6fc RL	34	return 1;
	35	}
	36
	37	static void uint64_free(ASN1_VALUE *pval, const ASN1_ITEM it)
	38	{
da26ff30 RL	39	OPENSSL_free(*pval);
	40	*pval = NULL;
	41	}
	42
	43	static void uint64_clear(ASN1_VALUE *pval, const ASN1_ITEM it)
	44	{
	45	(uint64_t )pval = 0;
93f7d6fc RL	46	}
	47
	48	static int uint64_i2c(ASN1_VALUE *pval, unsigned char cont, int *putype,
	49	const ASN1_ITEM *it)
	50	{
	51	uint64_t utmp;
	52	int neg = 0;
	53	/* this exists to bypass broken gcc optimization */
da26ff30	54	char cp = (char )*pval;
93f7d6fc RL	55
	56	/* use memcpy, because we may not be uint64_t aligned */
	57	memcpy(&utmp, cp, sizeof(utmp));
	58
	59	if ((it->size & INTxx_FLAG_ZERO_DEFAULT) == INTxx_FLAG_ZERO_DEFAULT
	60	&& utmp == 0)
	61	return -1;
	62	if ((it->size & INTxx_FLAG_SIGNED) == INTxx_FLAG_SIGNED
429223d1 RL	63	&& (int64_t)utmp < 0) {
	64	/* i2c_uint64_int() assumes positive values */
	65	utmp = 0 - utmp;
93f7d6fc	66	neg = 1;
429223d1	67	}
93f7d6fc RL	68
	69	return i2c_uint64_int(cont, utmp, neg);
	70	}
	71
	72	static int uint64_c2i(ASN1_VALUE *pval, const unsigned char cont, int len,
	73	int utype, char free_cont, const ASN1_ITEM it)
	74	{
	75	uint64_t utmp = 0;
da26ff30	76	char *cp;
93f7d6fc RL	77	int neg = 0;
93f7d6fc RL	78
da26ff30 RL	79	if (*pval == NULL && !uint64_new(pval, it))
	80	return 0;
	81
	82	cp = (char )pval;
93f7d6fc RL	83	if (!c2i_uint64_int(&utmp, &neg, &cont, len))
	84	return 0;
	85	if ((it->size & INTxx_FLAG_SIGNED) == 0 && neg) {
	86	ASN1err(ASN1_F_UINT64_C2I, ASN1_R_ILLEGAL_NEGATIVE_VALUE);
	87	return 0;
	88	}
0856e3f1 MC	89	if ((it->size & INTxx_FLAG_SIGNED) == INTxx_FLAG_SIGNED
	90	&& !neg && utmp > INT64_MAX) {
	91	ASN1err(ASN1_F_UINT64_C2I, ASN1_R_TOO_LARGE);
	92	return 0;
	93	}
429223d1 RL	94	if (neg)
	95	/* c2i_uint64_int() returns positive values */
	96	utmp = 0 - utmp;
93f7d6fc RL	97	memcpy(cp, &utmp, sizeof(utmp));
	98	return 1;
	99	}
	100
	101	static int uint64_print(BIO out, ASN1_VALUE pval, const ASN1_ITEM it,
	102	int indent, const ASN1_PCTX *pctx)
	103	{
	104	if ((it->size & INTxx_FLAG_SIGNED) == INTxx_FLAG_SIGNED)
c4d2e483 RS	105	return BIO_printf(out, "%jd\n", (intmax_t)(int64_t )pval);
c4d2e483 RS	106	return BIO_printf(out, "%ju\n", (uintmax_t)(uint64_t )pval);
93f7d6fc RL	107	}
	108
	109	/* 32-bit variants */
	110
	111	static int uint32_new(ASN1_VALUE *pval, const ASN1_ITEM it)
	112	{
da26ff30 RL	113	pval = (ASN1_VALUE )OPENSSL_zalloc(sizeof(uint32_t));
	114	if (*pval == NULL)
	115	return 0;
93f7d6fc RL	116	return 1;
	117	}
	118
	119	static void uint32_free(ASN1_VALUE *pval, const ASN1_ITEM it)
	120	{
da26ff30 RL	121	OPENSSL_free(*pval);
	122	*pval = NULL;
	123	}
	124
	125	static void uint32_clear(ASN1_VALUE *pval, const ASN1_ITEM it)
	126	{
	127	(uint32_t )pval = 0;
93f7d6fc RL	128	}
	129
	130	static int uint32_i2c(ASN1_VALUE *pval, unsigned char cont, int *putype,
	131	const ASN1_ITEM *it)
	132	{
	133	uint32_t utmp;
	134	int neg = 0;
	135	/* this exists to bypass broken gcc optimization */
da26ff30	136	char cp = (char )*pval;
93f7d6fc RL	137
	138	/* use memcpy, because we may not be uint32_t aligned */
	139	memcpy(&utmp, cp, sizeof(utmp));
	140
	141	if ((it->size & INTxx_FLAG_ZERO_DEFAULT) == INTxx_FLAG_ZERO_DEFAULT
	142	&& utmp == 0)
	143	return -1;
	144	if ((it->size & INTxx_FLAG_SIGNED) == INTxx_FLAG_SIGNED
429223d1 RL	145	&& (int32_t)utmp < 0) {
	146	/* i2c_uint64_int() assumes positive values */
	147	utmp = 0 - utmp;
93f7d6fc	148	neg = 1;
429223d1	149	}
93f7d6fc RL	150
	151	return i2c_uint64_int(cont, (uint64_t)utmp, neg);
	152	}
	153
429223d1 RL	154	/*
	155	* Absolute value of INT32_MIN: we can't just use -INT32_MIN as it produces
	156	* overflow warnings.
	157	*/
	158
	159	#define ABS_INT32_MIN ((uint32_t)INT32_MAX + 1)
	160
93f7d6fc RL	161	static int uint32_c2i(ASN1_VALUE *pval, const unsigned char cont, int len,
	162	int utype, char free_cont, const ASN1_ITEM it)
	163	{
	164	uint64_t utmp = 0;
	165	uint32_t utmp2 = 0;
da26ff30	166	char *cp;
93f7d6fc RL	167	int neg = 0;
93f7d6fc RL	168
da26ff30 RL	169	if (*pval == NULL && !uint64_new(pval, it))
	170	return 0;
	171
	172	cp = (char )pval;
93f7d6fc RL	173	if (!c2i_uint64_int(&utmp, &neg, &cont, len))
	174	return 0;
	175	if ((it->size & INTxx_FLAG_SIGNED) == 0 && neg) {
	176	ASN1err(ASN1_F_UINT32_C2I, ASN1_R_ILLEGAL_NEGATIVE_VALUE);
	177	return 0;
	178	}
429223d1 RL	179	if (neg) {
	180	if (utmp > ABS_INT32_MIN) {
	181	ASN1err(ASN1_F_UINT32_C2I, ASN1_R_TOO_SMALL);
	182	return 0;
	183	}
	184	utmp = 0 - utmp;
	185	} else {
	186	if (((it->size & INTxx_FLAG_SIGNED) != 0 && utmp > INT32_MAX)
	187	\|\| ((it->size & INTxx_FLAG_SIGNED) == 0 && utmp > UINT32_MAX)) {
	188	ASN1err(ASN1_F_UINT32_C2I, ASN1_R_TOO_LARGE);
	189	return 0;
	190	}
93f7d6fc	191	}
429223d1	192	utmp2 = (uint32_t)utmp;
93f7d6fc RL	193	memcpy(cp, &utmp2, sizeof(utmp2));
	194	return 1;
	195	}
	196
	197	static int uint32_print(BIO out, ASN1_VALUE pval, const ASN1_ITEM it,
	198	int indent, const ASN1_PCTX *pctx)
	199	{
	200	if ((it->size & INTxx_FLAG_SIGNED) == INTxx_FLAG_SIGNED)
da26ff30 RL	201	return BIO_printf(out, "%d\n", (int32_t )pval);
da26ff30 RL	202	return BIO_printf(out, "%u\n", (uint32_t )pval);
93f7d6fc RL	203	}
	204
	205
	206	/* Define the primitives themselves */
	207
	208	static ASN1_PRIMITIVE_FUNCS uint32_pf = {
	209	NULL, 0,
	210	uint32_new,
	211	uint32_free,
da26ff30	212	uint32_clear,
93f7d6fc RL	213	uint32_c2i,
	214	uint32_i2c,
	215	uint32_print
	216	};
	217
	218	static ASN1_PRIMITIVE_FUNCS uint64_pf = {
	219	NULL, 0,
	220	uint64_new,
	221	uint64_free,
da26ff30	222	uint64_clear,
93f7d6fc RL	223	uint64_c2i,
	224	uint64_i2c,
	225	uint64_print
	226	};
	227
	228	ASN1_ITEM_start(INT32)
	229	ASN1_ITYPE_PRIMITIVE, V_ASN1_INTEGER, NULL, 0, &uint32_pf,
	230	INTxx_FLAG_SIGNED, "INT32"
	231	ASN1_ITEM_end(INT32)
	232
	233	ASN1_ITEM_start(UINT32)
	234	ASN1_ITYPE_PRIMITIVE, V_ASN1_INTEGER, NULL, 0, &uint32_pf, 0, "UINT32"
	235	ASN1_ITEM_end(UINT32)
	236
	237	ASN1_ITEM_start(INT64)
	238	ASN1_ITYPE_PRIMITIVE, V_ASN1_INTEGER, NULL, 0, &uint64_pf,
	239	INTxx_FLAG_SIGNED, "INT64"
	240	ASN1_ITEM_end(INT64)
	241
	242	ASN1_ITEM_start(UINT64)
	243	ASN1_ITYPE_PRIMITIVE, V_ASN1_INTEGER, NULL, 0, &uint64_pf, 0, "UINT64"
	244	ASN1_ITEM_end(UINT64)
	245
	246	ASN1_ITEM_start(ZINT32)
	247	ASN1_ITYPE_PRIMITIVE, V_ASN1_INTEGER, NULL, 0, &uint32_pf,
	248	INTxx_FLAG_ZERO_DEFAULT\|INTxx_FLAG_SIGNED, "ZINT32"
	249	ASN1_ITEM_end(ZINT32)
	250
	251	ASN1_ITEM_start(ZUINT32)
	252	ASN1_ITYPE_PRIMITIVE, V_ASN1_INTEGER, NULL, 0, &uint32_pf,
	253	INTxx_FLAG_ZERO_DEFAULT, "ZUINT32"
	254	ASN1_ITEM_end(ZUINT32)
	255
	256	ASN1_ITEM_start(ZINT64)
	257	ASN1_ITYPE_PRIMITIVE, V_ASN1_INTEGER, NULL, 0, &uint64_pf,
	258	INTxx_FLAG_ZERO_DEFAULT\|INTxx_FLAG_SIGNED, "ZINT64"
	259	ASN1_ITEM_end(ZINT64)
	260
	261	ASN1_ITEM_start(ZUINT64)
	262	ASN1_ITYPE_PRIMITIVE, V_ASN1_INTEGER, NULL, 0, &uint64_pf,
	263	INTxx_FLAG_ZERO_DEFAULT, "ZUINT64"
	264	ASN1_ITEM_end(ZUINT64)
	265