#include <stdio.h>
#include "internal/cryptlib.h"
-#include "internal/asn1t.h"
#include "internal/numbers.h"
+#include <openssl/asn1t.h>
#include <openssl/bn.h>
#include "asn1_locl.h"
static int uint64_new(ASN1_VALUE **pval, const ASN1_ITEM *it)
{
- *(uint64_t *)pval = 0;
+ *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)
{
- *(uint64_t *)pval = 0;
+ 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,
uint64_t utmp;
int neg = 0;
/* this exists to bypass broken gcc optimization */
- char *cp = (char *)pval;
+ char *cp = (char *)*pval;
/* use memcpy, because we may not be uint64_t aligned */
memcpy(&utmp, cp, sizeof(utmp));
&& utmp == 0)
return -1;
if ((it->size & INTxx_FLAG_SIGNED) == INTxx_FLAG_SIGNED
- && (int64_t)utmp < 0)
+ && (int64_t)utmp < 0) {
+ /* i2c_uint64_int() assumes positive values */
+ utmp = 0 - utmp;
neg = 1;
+ }
return i2c_uint64_int(cont, utmp, neg);
}
int utype, char *free_cont, const ASN1_ITEM *it)
{
uint64_t utmp = 0;
- char *cp = (char *)pval;
+ 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;
}
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);
+ 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)
{
- *(uint32_t *)pval = 0;
+ *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)
{
- *(uint32_t *)pval = 0;
+ 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,
uint32_t utmp;
int neg = 0;
/* this exists to bypass broken gcc optimization */
- char *cp = (char *)pval;
+ char *cp = (char *)*pval;
/* use memcpy, because we may not be uint32_t aligned */
memcpy(&utmp, cp, sizeof(utmp));
&& utmp == 0)
return -1;
if ((it->size & INTxx_FLAG_SIGNED) == INTxx_FLAG_SIGNED
- && (int32_t)utmp < 0)
+ && (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 = (char *)pval;
+ 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;
}
- utmp2 = (uint32_t)utmp;
- if (utmp != utmp2
- || ((it->size & INTxx_FLAG_SIGNED) == INTxx_FLAG_SIGNED
- && !neg && utmp2 > INT32_MAX)) {
- ASN1err(ASN1_F_UINT32_C2I, ASN1_R_TOO_LARGE);
- 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;
}
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);
+ return BIO_printf(out, "%d\n", **(int32_t **)pval);
+ return BIO_printf(out, "%u\n", **(uint32_t **)pval);
}
NULL, 0,
uint32_new,
uint32_free,
- uint32_free, /* Clear should set to initial value */
+ uint32_clear,
uint32_c2i,
uint32_i2c,
uint32_print
NULL, 0,
uint64_new,
uint64_free,
- uint64_free, /* Clear should set to initial value */
+ uint64_clear,
uint64_c2i,
uint64_i2c,
uint64_print