githubmirror/gnutls

lib/mpi.c
468 строк10 KB
Avinash Sonawane
lib/mpi.c: extract flag correctly
13 фев 2024, 12:37
13 фев 2024, 12:377cea763
/*
 * 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_node 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_node 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_node 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_node 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_node 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 (flags & 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 (flags & 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_node 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_node 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_node node, const char *value,
				  bigint_t mpi)
{
	return __gnutls_x509_write_int(node, value, mpi,
				       GNUTLS_X509_INT_OVERWRITE |
					       GNUTLS_X509_INT_LE);
}