/*
* Copyright (C) 2001-2012 Free Software Foundation, Inc.
*
* Author: Nikos Mavrogiannopoulos
*
* This file is part of GnuTLS.
*
* The GnuTLS is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>
*
*/
/* Here lie everything that has to do with large numbers, libgcrypt and
* other stuff that didn't fit anywhere else.
*/
#include "gnutls_int.h"
#include <libtasn1.h>
#include "errors.h"
#include <num.h>
#include <mpi.h>
#include <random.h>
#include <x509/x509_int.h>
/* Functions that refer to the mpi library.
*/
/* Returns a random number r, 0 < r < p */
bigint_t
_gnutls_mpi_random_modp(bigint_t r, bigint_t p,
gnutls_rnd_level_t level)
{
size_t size;
int ret;
bigint_t tmp;
uint8_t tmpbuf[512];
uint8_t *buf;
int buf_release = 0;
size = ((_gnutls_mpi_get_nbits(p)+64)/8) + 1;
if (size < sizeof(tmpbuf)) {
buf = tmpbuf;
} else {
buf = gnutls_malloc(size);
if (buf == NULL) {
gnutls_assert();
goto cleanup;
}
buf_release = 1;
}
ret = gnutls_rnd(level, buf, size);
if (ret < 0) {
gnutls_assert();
goto cleanup;
}
ret = _gnutls_mpi_init_scan(&tmp, buf, size);
if (ret < 0) {
gnutls_assert();
goto cleanup;
}
ret = _gnutls_mpi_modm(tmp, tmp, p);
if (ret < 0) {
gnutls_assert();
goto cleanup;
}
if (_gnutls_mpi_cmp_ui(tmp, 0) == 0) {
ret = _gnutls_mpi_add_ui(tmp, tmp, 1);
if (ret < 0) {
gnutls_assert();
goto cleanup;
}
}
if (buf_release != 0) {
gnutls_free(buf);
}
if (r != NULL) {
ret = _gnutls_mpi_set(r, tmp);
if (ret < 0)
goto cleanup;
_gnutls_mpi_release(&tmp);
return r;
}
return tmp;
cleanup:
if (buf_release != 0)
gnutls_free(buf);
return NULL;
}
/* returns %GNUTLS_E_SUCCESS (0) on success
*/
int _gnutls_mpi_init_scan(bigint_t * ret_mpi, const void *buffer, size_t nbytes)
{
bigint_t r;
int ret;
ret = _gnutls_mpi_init(&r);
if (ret < 0)
return gnutls_assert_val(ret);
ret =
_gnutls_mpi_scan(r, buffer, nbytes);
if (ret < 0) {
gnutls_assert();
_gnutls_mpi_release(&r);
return ret;
}
*ret_mpi = r;
return 0;
}
/* returns %GNUTLS_E_SUCCESS (0) on success. Fails if the number is zero.
*/
int
_gnutls_mpi_init_scan_nz(bigint_t * ret_mpi, const void *buffer, size_t nbytes)
{
int ret;
ret = _gnutls_mpi_init_scan(ret_mpi, buffer, nbytes);
if (ret < 0)
return ret;
/* MPIs with 0 bits are illegal
*/
if (_gnutls_mpi_cmp_ui(*ret_mpi, 0) == 0) {
_gnutls_mpi_release(ret_mpi);
return GNUTLS_E_MPI_SCAN_FAILED;
}
return 0;
}
int
_gnutls_mpi_init_scan_le(bigint_t * ret_mpi, const void *buffer, size_t nbytes)
{
bigint_t r;
int ret;
ret = _gnutls_mpi_init(&r);
if (ret < 0)
return gnutls_assert_val(ret);
ret = _gnutls_mpi_scan_le(r, buffer, nbytes);
if (ret < 0) {
gnutls_assert();
_gnutls_mpi_release(&r);
return ret;
}
*ret_mpi = r;
return 0;
}
int _gnutls_mpi_dprint_le(const bigint_t a, gnutls_datum_t * dest)
{
int ret;
uint8_t *buf = NULL;
size_t bytes = 0;
if (dest == NULL || a == NULL)
return GNUTLS_E_INVALID_REQUEST;
_gnutls_mpi_print_le(a, NULL, &bytes);
if (bytes != 0)
buf = gnutls_malloc(bytes);
if (buf == NULL)
return GNUTLS_E_MEMORY_ERROR;
ret = _gnutls_mpi_print_le(a, buf, &bytes);
if (ret < 0) {
gnutls_free(buf);
return ret;
}
dest->data = buf;
dest->size = bytes;
return 0;
}
/* Always has the first bit zero */
int _gnutls_mpi_dprint_lz(const bigint_t a, gnutls_datum_t * dest)
{
int ret;
uint8_t *buf = NULL;
size_t bytes = 0;
if (dest == NULL || a == NULL)
return GNUTLS_E_INVALID_REQUEST;
_gnutls_mpi_print_lz(a, NULL, &bytes);
if (bytes != 0)
buf = gnutls_malloc(bytes);
if (buf == NULL)
return GNUTLS_E_MEMORY_ERROR;
ret = _gnutls_mpi_print_lz(a, buf, &bytes);
if (ret < 0) {
gnutls_free(buf);
return ret;
}
dest->data = buf;
dest->size = bytes;
return 0;
}
int _gnutls_mpi_dprint(const bigint_t a, gnutls_datum_t * dest)
{
int ret;
uint8_t *buf = NULL;
size_t bytes = 0;
if (dest == NULL || a == NULL)
return GNUTLS_E_INVALID_REQUEST;
_gnutls_mpi_print(a, NULL, &bytes);
if (bytes != 0)
buf = gnutls_malloc(bytes);
if (buf == NULL)
return GNUTLS_E_MEMORY_ERROR;
ret = _gnutls_mpi_print(a, buf, &bytes);
if (ret < 0) {
gnutls_free(buf);
return ret;
}
dest->data = buf;
dest->size = bytes;
return 0;
}
/* This function will copy the mpi data into a datum,
* but will set minimum size to 'size'. That means that
* the output value is left padded with zeros.
*/
int
_gnutls_mpi_dprint_size(const bigint_t a, gnutls_datum_t * dest,
size_t size)
{
int ret;
uint8_t *buf = NULL;
size_t bytes = 0;
unsigned int i;
if (dest == NULL || a == NULL)
return GNUTLS_E_INVALID_REQUEST;
_gnutls_mpi_print(a, NULL, &bytes);
if (bytes != 0)
buf = gnutls_malloc(MAX(size, bytes));
if (buf == NULL)
return GNUTLS_E_MEMORY_ERROR;
if (bytes <= size) {
size_t diff = size - bytes;
for (i = 0; i < diff; i++)
buf[i] = 0;
ret = _gnutls_mpi_print(a, &buf[diff], &bytes);
} else {
ret = _gnutls_mpi_print(a, buf, &bytes);
}
if (ret < 0) {
gnutls_free(buf);
return ret;
}
dest->data = buf;
dest->size = MAX(size, bytes);
return 0;
}
/* like _gnutls_mpi_dprint_size, but prints into preallocated byte buffer */
int
_gnutls_mpi_bprint_size(const bigint_t a, uint8_t *buf, size_t size)
{
int result;
size_t bytes = 0;
result = _gnutls_mpi_print(a, NULL, &bytes);
if (result != GNUTLS_E_SHORT_MEMORY_BUFFER)
return gnutls_assert_val(result);
if (bytes <= size) {
unsigned i;
size_t diff = size - bytes;
for (i = 0; i < diff; i++)
buf[i] = 0;
result = _gnutls_mpi_print(a, &buf[diff], &bytes);
} else {
result = _gnutls_mpi_print(a, buf, &bytes);
}
return result;
}
/* Flags for __gnutls_x509_read_int() and __gnutls_x509_write_int */
#define GNUTLS_X509_INT_OVERWRITE (1 << 0)
#define GNUTLS_X509_INT_LE (1 << 1)
#define GNUTLS_X509_INT_LZ (1 << 2) /* write only */
/* this function reads an integer
* from asn1 structs. Combines the read and mpi_scan
* steps.
*/
static int
__gnutls_x509_read_int(ASN1_TYPE node, const char *value,
bigint_t * ret_mpi, unsigned int flags)
{
int result;
uint8_t *tmpstr = NULL;
int tmpstr_size;
tmpstr_size = 0;
result = asn1_read_value(node, value, NULL, &tmpstr_size);
if (result != ASN1_MEM_ERROR) {
gnutls_assert();
return _gnutls_asn2err(result);
}
tmpstr = gnutls_malloc(tmpstr_size);
if (tmpstr == NULL) {
gnutls_assert();
return GNUTLS_E_MEMORY_ERROR;
}
result = asn1_read_value(node, value, tmpstr, &tmpstr_size);
if (result != ASN1_SUCCESS) {
gnutls_assert();
gnutls_free(tmpstr);
return _gnutls_asn2err(result);
}
if (flags & GNUTLS_X509_INT_LE)
result = _gnutls_mpi_init_scan_le(ret_mpi, tmpstr,
tmpstr_size);
else
result = _gnutls_mpi_init_scan(ret_mpi, tmpstr,
tmpstr_size);
if (flags & GNUTLS_X509_INT_OVERWRITE)
zeroize_key(tmpstr, tmpstr_size);
gnutls_free(tmpstr);
if (result < 0) {
gnutls_assert();
return result;
}
return 0;
}
int
_gnutls_x509_read_int(ASN1_TYPE node, const char *value,
bigint_t * ret_mpi)
{
return __gnutls_x509_read_int(node, value, ret_mpi,
0);
}
int
_gnutls_x509_read_key_int(ASN1_TYPE node, const char *value,
bigint_t * ret_mpi)
{
return __gnutls_x509_read_int(node, value, ret_mpi,
GNUTLS_X509_INT_OVERWRITE);
}
int
_gnutls_x509_read_key_int_le(ASN1_TYPE node, const char *value,
bigint_t * ret_mpi)
{
return __gnutls_x509_read_int(node, value, ret_mpi,
GNUTLS_X509_INT_OVERWRITE |
GNUTLS_X509_INT_LE);
}
/* Writes the specified integer into the specified node.
*/
static int
__gnutls_x509_write_int(ASN1_TYPE node, const char *value, bigint_t mpi,
unsigned int flags)
{
uint8_t *tmpstr;
size_t s_len;
int result;
s_len = 0;
if (flags & GNUTLS_X509_INT_LZ)
result = _gnutls_mpi_print_lz(mpi, NULL, &s_len);
else if (GNUTLS_X509_INT_LE)
result = _gnutls_mpi_print_le(mpi, NULL, &s_len);
else
result = _gnutls_mpi_print(mpi, NULL, &s_len);
if (result != GNUTLS_E_SHORT_MEMORY_BUFFER) {
gnutls_assert();
return result;
}
tmpstr = gnutls_malloc(s_len);
if (tmpstr == NULL) {
gnutls_assert();
return GNUTLS_E_MEMORY_ERROR;
}
if (flags & GNUTLS_X509_INT_LZ)
result = _gnutls_mpi_print_lz(mpi, tmpstr, &s_len);
else if (GNUTLS_X509_INT_LE)
result = _gnutls_mpi_print_le(mpi, tmpstr, &s_len);
else
result = _gnutls_mpi_print(mpi, tmpstr, &s_len);
if (result != 0) {
gnutls_assert();
gnutls_free(tmpstr);
return GNUTLS_E_MPI_PRINT_FAILED;
}
result = asn1_write_value(node, value, tmpstr, s_len);
if (flags & GNUTLS_X509_INT_OVERWRITE)
zeroize_key(tmpstr, s_len);
gnutls_free(tmpstr);
if (result != ASN1_SUCCESS) {
gnutls_assert();
return _gnutls_asn2err(result);
}
return 0;
}
int
_gnutls_x509_write_int(ASN1_TYPE node, const char *value, bigint_t mpi,
int lz)
{
return __gnutls_x509_write_int(node, value, mpi,
lz ? GNUTLS_X509_INT_LZ : 0);
}
int
_gnutls_x509_write_key_int(ASN1_TYPE node, const char *value, bigint_t mpi,
int lz)
{
return __gnutls_x509_write_int(node, value, mpi,
(lz ? GNUTLS_X509_INT_LZ : 0) |
GNUTLS_X509_INT_OVERWRITE);
}
int
_gnutls_x509_write_key_int_le(ASN1_TYPE node, const char *value, bigint_t mpi)
{
return __gnutls_x509_write_int(node, value, mpi,
GNUTLS_X509_INT_OVERWRITE |
GNUTLS_X509_INT_LE);
}