crypto: GnuPG based MPI lib - header files (part 2)

/* mpi.h  -  Multi Precision Integers

 *	Copyright (C) 1994, 1996, 1998, 1999,

 *                    2000, 2001 Free Software Foundation, Inc.

 *

 * This file is part of GNUPG.

 *

 * GNUPG is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * GNUPG 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA

 *

 * Note: This code is heavily based on the GNU MP Library.

 *	 Actually it's the same code with only minor changes in the

 *	 way the data is stored; this is to support the abstraction

 *	 of an optional secure memory allocation which may be used

 *	 to avoid revealing of sensitive data due to paging etc.

 *	 The GNU MP Library itself is published under the LGPL;

 *	 however I decided to publish this code under the plain GPL.

 */

#ifndef G10_MPI_H

#define G10_MPI_H

#include <linux/types.h>

/* DSI defines */

#define SHA1_DIGEST_LENGTH   20

/*end of DSI defines */

#define BYTES_PER_MPI_LIMB	(BITS_PER_LONG / 8)

#define BITS_PER_MPI_LIMB	BITS_PER_LONG

typedef unsigned long int mpi_limb_t;

typedef signed long int mpi_limb_signed_t;

struct gcry_mpi {

	int alloced;		/* array size (# of allocated limbs) */

	int nlimbs;		/* number of valid limbs */

	int nbits;		/* the real number of valid bits (info only) */

	int sign;		/* indicates a negative number */

	unsigned flags;		/* bit 0: array must be allocated in secure memory space */

	/* bit 1: not used */

	/* bit 2: the limb is a pointer to some m_alloced data */

	mpi_limb_t *d;		/* array with the limbs */

};

typedef struct gcry_mpi *MPI;

#define MPI_NULL NULL

#define mpi_get_nlimbs(a)     ((a)->nlimbs)

#define mpi_is_neg(a)	      ((a)->sign)

/*-- mpiutil.c --*/

MPI mpi_alloc(unsigned nlimbs);

MPI mpi_alloc_secure(unsigned nlimbs);

MPI mpi_alloc_like(MPI a);

void mpi_free(MPI a);

int mpi_resize(MPI a, unsigned nlimbs);

int mpi_copy(MPI *copy, const MPI a);

void mpi_clear(MPI a);

int mpi_set(MPI w, MPI u);

int mpi_set_ui(MPI w, ulong u);

MPI mpi_alloc_set_ui(unsigned long u);

void mpi_m_check(MPI a);

void mpi_swap(MPI a, MPI b);

/*-- mpicoder.c --*/

MPI do_encode_md(const void *sha_buffer, unsigned nbits);

MPI mpi_read_from_buffer(const void *buffer, unsigned *ret_nread);

int mpi_fromstr(MPI val, const char *str);

u32 mpi_get_keyid(MPI a, u32 *keyid);

void *mpi_get_buffer(MPI a, unsigned *nbytes, int *sign);

void *mpi_get_secure_buffer(MPI a, unsigned *nbytes, int *sign);

int mpi_set_buffer(MPI a, const void *buffer, unsigned nbytes, int sign);

#define log_mpidump g10_log_mpidump

/*-- mpi-add.c --*/

int mpi_add_ui(MPI w, MPI u, ulong v);

int mpi_add(MPI w, MPI u, MPI v);

int mpi_addm(MPI w, MPI u, MPI v, MPI m);

int mpi_sub_ui(MPI w, MPI u, ulong v);

int mpi_sub(MPI w, MPI u, MPI v);

int mpi_subm(MPI w, MPI u, MPI v, MPI m);

/*-- mpi-mul.c --*/

int mpi_mul_ui(MPI w, MPI u, ulong v);

int mpi_mul_2exp(MPI w, MPI u, ulong cnt);

int mpi_mul(MPI w, MPI u, MPI v);

int mpi_mulm(MPI w, MPI u, MPI v, MPI m);

/*-- mpi-div.c --*/

ulong mpi_fdiv_r_ui(MPI rem, MPI dividend, ulong divisor);

int mpi_fdiv_r(MPI rem, MPI dividend, MPI divisor);

int mpi_fdiv_q(MPI quot, MPI dividend, MPI divisor);

int mpi_fdiv_qr(MPI quot, MPI rem, MPI dividend, MPI divisor);

int mpi_tdiv_r(MPI rem, MPI num, MPI den);

int mpi_tdiv_qr(MPI quot, MPI rem, MPI num, MPI den);

int mpi_tdiv_q_2exp(MPI w, MPI u, unsigned count);

int mpi_divisible_ui(const MPI dividend, ulong divisor);

/*-- mpi-gcd.c --*/

int mpi_gcd(MPI g, const MPI a, const MPI b);

/*-- mpi-pow.c --*/

int mpi_pow(MPI w, MPI u, MPI v);

int mpi_powm(MPI res, MPI base, MPI exp, MPI mod);

/*-- mpi-mpow.c --*/

int mpi_mulpowm(MPI res, MPI *basearray, MPI *exparray, MPI mod);

/*-- mpi-cmp.c --*/

int mpi_cmp_ui(MPI u, ulong v);

int mpi_cmp(MPI u, MPI v);

/*-- mpi-scan.c --*/

int mpi_getbyte(MPI a, unsigned idx);

void mpi_putbyte(MPI a, unsigned idx, int value);

unsigned mpi_trailing_zeros(MPI a);

/*-- mpi-bit.c --*/

void mpi_normalize(MPI a);

unsigned mpi_get_nbits(MPI a);

int mpi_test_bit(MPI a, unsigned n);

int mpi_set_bit(MPI a, unsigned n);

int mpi_set_highbit(MPI a, unsigned n);

void mpi_clear_highbit(MPI a, unsigned n);

void mpi_clear_bit(MPI a, unsigned n);

int mpi_rshift(MPI x, MPI a, unsigned n);

/*-- mpi-inv.c --*/

int mpi_invm(MPI x, MPI u, MPI v);

#endif /*G10_MPI_H */

/* mpi-inline.h  -  Internal to the Multi Precision Integers

 *	Copyright (C) 1994, 1996, 1998, 1999 Free Software Foundation, Inc.

 *

 * This file is part of GnuPG.

 *

 * GnuPG is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * GnuPG 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA

 *

 * Note: This code is heavily based on the GNU MP Library.

 *	 Actually it's the same code with only minor changes in the

 *	 way the data is stored; this is to support the abstraction

 *	 of an optional secure memory allocation which may be used

 *	 to avoid revealing of sensitive data due to paging etc.

 *	 The GNU MP Library itself is published under the LGPL;

 *	 however I decided to publish this code under the plain GPL.

 */

#ifndef G10_MPI_INLINE_H

#define G10_MPI_INLINE_H

#ifndef G10_MPI_INLINE_DECL

#define G10_MPI_INLINE_DECL  extern inline

#endif

G10_MPI_INLINE_DECL mpi_limb_t

mpihelp_add_1(mpi_ptr_t res_ptr, mpi_ptr_t s1_ptr,

	      mpi_size_t s1_size, mpi_limb_t s2_limb)

{

	mpi_limb_t x;

	x = *s1_ptr++;

	s2_limb += x;

	*res_ptr++ = s2_limb;

	if (s2_limb < x) {	/* sum is less than the left operand: handle carry */

		while (--s1_size) {

			x = *s1_ptr++ + 1;	/* add carry */

			*res_ptr++ = x;	/* and store */

			if (x)	/* not 0 (no overflow): we can stop */

				goto leave;

		}

		return 1;	/* return carry (size of s1 to small) */

	}

leave:

	if (res_ptr != s1_ptr) {	/* not the same variable */

		mpi_size_t i;	/* copy the rest */

		for (i = 0; i < s1_size - 1; i++)

			res_ptr[i] = s1_ptr[i];

	}

	return 0;		/* no carry */

}

G10_MPI_INLINE_DECL mpi_limb_t

mpihelp_add(mpi_ptr_t res_ptr, mpi_ptr_t s1_ptr, mpi_size_t s1_size,

	    mpi_ptr_t s2_ptr, mpi_size_t s2_size)

{

	mpi_limb_t cy = 0;

	if (s2_size)

		cy = mpihelp_add_n(res_ptr, s1_ptr, s2_ptr, s2_size);

	if (s1_size - s2_size)

		cy = mpihelp_add_1(res_ptr + s2_size, s1_ptr + s2_size,

				   s1_size - s2_size, cy);

	return cy;

}

G10_MPI_INLINE_DECL mpi_limb_t

mpihelp_sub_1(mpi_ptr_t res_ptr, mpi_ptr_t s1_ptr,

	      mpi_size_t s1_size, mpi_limb_t s2_limb)

{

	mpi_limb_t x;

	x = *s1_ptr++;

	s2_limb = x - s2_limb;

	*res_ptr++ = s2_limb;

	if (s2_limb > x) {

		while (--s1_size) {

			x = *s1_ptr++;

			*res_ptr++ = x - 1;

			if (x)

				goto leave;

		}

		return 1;

	}

leave:

	if (res_ptr != s1_ptr) {

		mpi_size_t i;

		for (i = 0; i < s1_size - 1; i++)

			res_ptr[i] = s1_ptr[i];

	}

	return 0;

}

G10_MPI_INLINE_DECL mpi_limb_t

mpihelp_sub(mpi_ptr_t res_ptr, mpi_ptr_t s1_ptr, mpi_size_t s1_size,

	    mpi_ptr_t s2_ptr, mpi_size_t s2_size)

{

	mpi_limb_t cy = 0;

	if (s2_size)

		cy = mpihelp_sub_n(res_ptr, s1_ptr, s2_ptr, s2_size);

	if (s1_size - s2_size)

		cy = mpihelp_sub_1(res_ptr + s2_size, s1_ptr + s2_size,

				   s1_size - s2_size, cy);

	return cy;

}

#endif /*G10_MPI_INLINE_H */

/* mpi-internal.h  -  Internal to the Multi Precision Integers

 *	Copyright (C) 1994, 1996 Free Software Foundation, Inc.

 *	Copyright (C) 1998, 2000 Free Software Foundation, Inc.

 *

 * This file is part of GnuPG.

 *

 * GnuPG is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * GnuPG 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA

 *

 * Note: This code is heavily based on the GNU MP Library.

 *	 Actually it's the same code with only minor changes in the

 *	 way the data is stored; this is to support the abstraction

 *	 of an optional secure memory allocation which may be used

 *	 to avoid revealing of sensitive data due to paging etc.

 *	 The GNU MP Library itself is published under the LGPL;

 *	 however I decided to publish this code under the plain GPL.

 */

#ifndef G10_MPI_INTERNAL_H

#define G10_MPI_INTERNAL_H

#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/slab.h>

#include <linux/string.h>

#include <linux/mpi.h>

#include <linux/errno.h>

#define log_debug printk

#define log_bug printk

#define assert(x) \

	do { \

		if (!x) \

			log_bug("failed assertion\n"); \

	} while (0);

/* If KARATSUBA_THRESHOLD is not already defined, define it to a

 * value which is good on most machines.  */

/* tested 4, 16, 32 and 64, where 16 gave the best performance when

 * checking a 768 and a 1024 bit ElGamal signature.

 * (wk 22.12.97) */

#ifndef KARATSUBA_THRESHOLD

#define KARATSUBA_THRESHOLD 16

#endif

/* The code can't handle KARATSUBA_THRESHOLD smaller than 2.  */

#if KARATSUBA_THRESHOLD < 2

#undef KARATSUBA_THRESHOLD

#define KARATSUBA_THRESHOLD 2

#endif

typedef mpi_limb_t *mpi_ptr_t;	/* pointer to a limb */

typedef int mpi_size_t;		/* (must be a signed type) */

#define ABS(x) (x >= 0 ? x : -x)

#define MIN(l, o) ((l) < (o) ? (l) : (o))

#define MAX(h, i) ((h) > (i) ? (h) : (i))

static inline int RESIZE_IF_NEEDED(MPI a, unsigned b)

{

	if (a->alloced < b)

		return mpi_resize(a, b);

	return 0;

}

/* Copy N limbs from S to D.  */

#define MPN_COPY(d, s, n) \

	do {					\

		mpi_size_t _i;			\

		for (_i = 0; _i < (n); _i++)	\

			(d)[_i] = (s)[_i];	\

	} while (0)

#define MPN_COPY_INCR(d, s, n) \

	do {					\

		mpi_size_t _i;			\

		for (_i = 0; _i < (n); _i++)	\

			(d)[_i] = (d)[_i];	\

	} while (0)

#define MPN_COPY_DECR(d, s, n) \

	do {					\

		mpi_size_t _i;			\

		for (_i = (n)-1; _i >= 0; _i--) \

			(d)[_i] = (s)[_i];	\

	} while (0)

/* Zero N limbs at D */

#define MPN_ZERO(d, n) \

	do {					\

		int  _i;			\

		for (_i = 0; _i < (n); _i++)	\

			(d)[_i] = 0;		\

	} while (0)

#define MPN_NORMALIZE(d, n)  \

	do {					\

		while ((n) > 0) {		\

			if ((d)[(n)-1])		\

				break;		\

			(n)--;			\

		}				\

	} while (0)

#define MPN_NORMALIZE_NOT_ZERO(d, n) \

	do {				\

		for (;;) {		\

			if ((d)[(n)-1])	\

				break;	\

			(n)--;		\

		}			\

	} while (0)

#define MPN_MUL_N_RECURSE(prodp, up, vp, size, tspace) \

	do {							\

		if ((size) < KARATSUBA_THRESHOLD)		\

			mul_n_basecase(prodp, up, vp, size);	\

		else						\

			mul_n(prodp, up, vp, size, tspace);	\

	} while (0);

/* Divide the two-limb number in (NH,,NL) by D, with DI being the largest

 * limb not larger than (2**(2*BITS_PER_MP_LIMB))/D - (2**BITS_PER_MP_LIMB).

 * If this would yield overflow, DI should be the largest possible number

 * (i.e., only ones).  For correct operation, the most significant bit of D

 * has to be set.  Put the quotient in Q and the remainder in R.

 */

#define UDIV_QRNND_PREINV(q, r, nh, nl, d, di) \

	do {								\

		mpi_limb_t _q, _ql, _r;					\

		mpi_limb_t _xh, _xl;					\

		umul_ppmm(_q, _ql, (nh), (di));				\

		_q += (nh);	/* DI is 2**BITS_PER_MPI_LIMB too small */ \

		umul_ppmm(_xh, _xl, _q, (d));				\

		sub_ddmmss(_xh, _r, (nh), (nl), _xh, _xl);		\

		if (_xh) {						\

			sub_ddmmss(_xh, _r, _xh, _r, 0, (d));		\

			_q++;						\

			if (_xh) {					\

				sub_ddmmss(_xh, _r, _xh, _r, 0, (d));	\

				_q++;					\

			}						\

		}							\

		if (_r >= (d)) {					\

			_r -= (d);					\

			_q++;						\

		}							\

		(r) = _r;						\

		(q) = _q;						\

	} while (0)

/*-- mpiutil.c --*/

mpi_ptr_t mpi_alloc_limb_space(unsigned nlimbs);

void mpi_free_limb_space(mpi_ptr_t a);

void mpi_assign_limb_space(MPI a, mpi_ptr_t ap, unsigned nlimbs);

/*-- mpi-bit.c --*/

void mpi_rshift_limbs(MPI a, unsigned int count);

int mpi_lshift_limbs(MPI a, unsigned int count);

/*-- mpihelp-add.c --*/

mpi_limb_t mpihelp_add_1(mpi_ptr_t res_ptr, mpi_ptr_t s1_ptr,

			 mpi_size_t s1_size, mpi_limb_t s2_limb);

mpi_limb_t mpihelp_add_n(mpi_ptr_t res_ptr, mpi_ptr_t s1_ptr,

			 mpi_ptr_t s2_ptr, mpi_size_t size);

mpi_limb_t mpihelp_add(mpi_ptr_t res_ptr, mpi_ptr_t s1_ptr, mpi_size_t s1_size,

		       mpi_ptr_t s2_ptr, mpi_size_t s2_size);

/*-- mpihelp-sub.c --*/

mpi_limb_t mpihelp_sub_1(mpi_ptr_t res_ptr, mpi_ptr_t s1_ptr,

			 mpi_size_t s1_size, mpi_limb_t s2_limb);

mpi_limb_t mpihelp_sub_n(mpi_ptr_t res_ptr, mpi_ptr_t s1_ptr,

			 mpi_ptr_t s2_ptr, mpi_size_t size);

mpi_limb_t mpihelp_sub(mpi_ptr_t res_ptr, mpi_ptr_t s1_ptr, mpi_size_t s1_size,

		       mpi_ptr_t s2_ptr, mpi_size_t s2_size);

/*-- mpihelp-cmp.c --*/

int mpihelp_cmp(mpi_ptr_t op1_ptr, mpi_ptr_t op2_ptr, mpi_size_t size);

/*-- mpihelp-mul.c --*/

struct karatsuba_ctx {

	struct karatsuba_ctx *next;

	mpi_ptr_t tspace;

	mpi_size_t tspace_size;

	mpi_ptr_t tp;

	mpi_size_t tp_size;

};

void mpihelp_release_karatsuba_ctx(struct karatsuba_ctx *ctx);

mpi_limb_t mpihelp_addmul_1(mpi_ptr_t res_ptr, mpi_ptr_t s1_ptr,

			    mpi_size_t s1_size, mpi_limb_t s2_limb);

mpi_limb_t mpihelp_submul_1(mpi_ptr_t res_ptr, mpi_ptr_t s1_ptr,

			    mpi_size_t s1_size, mpi_limb_t s2_limb);

int mpihelp_mul_n(mpi_ptr_t prodp, mpi_ptr_t up, mpi_ptr_t vp, mpi_size_t size);

int mpihelp_mul(mpi_ptr_t prodp, mpi_ptr_t up, mpi_size_t usize,

		mpi_ptr_t vp, mpi_size_t vsize, mpi_limb_t *_result);

void mpih_sqr_n_basecase(mpi_ptr_t prodp, mpi_ptr_t up, mpi_size_t size);

void mpih_sqr_n(mpi_ptr_t prodp, mpi_ptr_t up, mpi_size_t size,

		mpi_ptr_t tspace);

int mpihelp_mul_karatsuba_case(mpi_ptr_t prodp,

			       mpi_ptr_t up, mpi_size_t usize,

			       mpi_ptr_t vp, mpi_size_t vsize,

			       struct karatsuba_ctx *ctx);

/*-- mpihelp-mul_1.c (or xxx/cpu/ *.S) --*/

mpi_limb_t mpihelp_mul_1(mpi_ptr_t res_ptr, mpi_ptr_t s1_ptr,

			 mpi_size_t s1_size, mpi_limb_t s2_limb);

/*-- mpihelp-div.c --*/

mpi_limb_t mpihelp_mod_1(mpi_ptr_t dividend_ptr, mpi_size_t dividend_size,

			 mpi_limb_t divisor_limb);

mpi_limb_t mpihelp_divrem(mpi_ptr_t qp, mpi_size_t qextra_limbs,

			  mpi_ptr_t np, mpi_size_t nsize,

			  mpi_ptr_t dp, mpi_size_t dsize);

mpi_limb_t mpihelp_divmod_1(mpi_ptr_t quot_ptr,

			    mpi_ptr_t dividend_ptr, mpi_size_t dividend_size,

			    mpi_limb_t divisor_limb);

/*-- mpihelp-shift.c --*/

mpi_limb_t mpihelp_lshift(mpi_ptr_t wp, mpi_ptr_t up, mpi_size_t usize,

			  unsigned cnt);

mpi_limb_t mpihelp_rshift(mpi_ptr_t wp, mpi_ptr_t up, mpi_size_t usize,

			  unsigned cnt);

/* Define stuff for longlong.h.  */

#define W_TYPE_SIZE BITS_PER_MPI_LIMB

typedef mpi_limb_t UWtype;

typedef unsigned int UHWtype;

#if defined(__GNUC__)

typedef unsigned int UQItype __attribute__ ((mode(QI)));

typedef int SItype __attribute__ ((mode(SI)));

typedef unsigned int USItype __attribute__ ((mode(SI)));

typedef int DItype __attribute__ ((mode(DI)));

typedef unsigned int UDItype __attribute__ ((mode(DI)));

#else

typedef unsigned char UQItype;

typedef long SItype;

typedef unsigned long USItype;

#endif

#ifdef __GNUC__

#include "mpi-inline.h"

#endif

#endif /*G10_MPI_INTERNAL_H */