lib/mpi: Extend the MPI library (a8ea8bdd) · Commits · EulixOS / Software / Kernel

include/linux/mpi.h

+87 −0

Original line number	Diff line number	Diff line
		@@ -40,21 +40,79 @@ struct gcry_mpi {
		typedef struct gcry_mpi *MPI;

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

		/-- mpiutil.c --/
		MPI mpi_alloc(unsigned nlimbs);
		void mpi_clear(MPI a);
		void mpi_free(MPI a);
		int mpi_resize(MPI a, unsigned nlimbs);

		static inline MPI mpi_new(unsigned int nbits)
		{
		return mpi_alloc((nbits + BITS_PER_MPI_LIMB - 1) / BITS_PER_MPI_LIMB);
		}

		MPI mpi_copy(MPI a);
		MPI mpi_alloc_like(MPI a);
		void mpi_snatch(MPI w, MPI u);
		MPI mpi_set(MPI w, MPI u);
		MPI mpi_set_ui(MPI w, unsigned long u);
		MPI mpi_alloc_set_ui(unsigned long u);
		void mpi_swap_cond(MPI a, MPI b, unsigned long swap);

		/* Constants used to return constant MPIs. See mpi_init if you
		* want to add more constants.
		*/
		#define MPI_NUMBER_OF_CONSTANTS 6
		enum gcry_mpi_constants {
		MPI_C_ZERO,
		MPI_C_ONE,
		MPI_C_TWO,
		MPI_C_THREE,
		MPI_C_FOUR,
		MPI_C_EIGHT
		};

		MPI mpi_const(enum gcry_mpi_constants no);

		/-- mpicoder.c --/

		/* Different formats of external big integer representation. */
		enum gcry_mpi_format {
		GCRYMPI_FMT_NONE = 0,
		GCRYMPI_FMT_STD = 1, /* Twos complement stored without length. */
		GCRYMPI_FMT_PGP = 2, /* As used by OpenPGP (unsigned only). */
		GCRYMPI_FMT_SSH = 3, /* As used by SSH (like STD but with length). */
		GCRYMPI_FMT_HEX = 4, /* Hex format. */
		GCRYMPI_FMT_USG = 5, /* Like STD but unsigned. */
		GCRYMPI_FMT_OPAQUE = 8 /* Opaque format (some functions only). */
		};

		MPI mpi_read_raw_data(const void *xbuffer, size_t nbytes);
		MPI mpi_read_from_buffer(const void buffer, unsigned ret_nread);
		int mpi_fromstr(MPI val, const char *str);
		MPI mpi_scanval(const char *string);
		MPI mpi_read_raw_from_sgl(struct scatterlist *sgl, unsigned int len);
		void mpi_get_buffer(MPI a, unsigned nbytes, int *sign);
		int mpi_read_buffer(MPI a, uint8_t buf, unsigned buf_len, unsigned nbytes,
		int *sign);
		int mpi_write_to_sgl(MPI a, struct scatterlist *sg, unsigned nbytes,
		int *sign);
		int mpi_print(enum gcry_mpi_format format, unsigned char *buffer,
		size_t buflen, size_t *nwritten, MPI a);

		/-- mpi-mod.c --/
		void mpi_mod(MPI rem, MPI dividend, MPI divisor);

		/* Context used with Barrett reduction. */
		struct barrett_ctx_s;
		typedef struct barrett_ctx_s *mpi_barrett_t;

		mpi_barrett_t mpi_barrett_init(MPI m, int copy);
		void mpi_barrett_free(mpi_barrett_t ctx);
		void mpi_mod_barrett(MPI r, MPI x, mpi_barrett_t ctx);
		void mpi_mul_barrett(MPI w, MPI u, MPI v, mpi_barrett_t ctx);

		/-- mpi-pow.c --/
		int mpi_powm(MPI res, MPI base, MPI exp, MPI mod);
		@@ -62,6 +120,7 @@ int mpi_powm(MPI res, MPI base, MPI exp, MPI mod);
		/-- mpi-cmp.c --/
		int mpi_cmp_ui(MPI u, ulong v);
		int mpi_cmp(MPI u, MPI v);
		int mpi_cmpabs(MPI u, MPI v);

		/-- mpi-sub-ui.c --/
		int mpi_sub_ui(MPI w, MPI u, unsigned long vval);
		@@ -69,6 +128,34 @@ int mpi_sub_ui(MPI w, MPI u, unsigned long vval);
		/-- mpi-bit.c --/
		void mpi_normalize(MPI a);
		unsigned mpi_get_nbits(MPI a);
		int mpi_test_bit(MPI a, unsigned int n);
		void mpi_set_bit(MPI a, unsigned int n);
		void mpi_set_highbit(MPI a, unsigned int n);
		void mpi_clear_highbit(MPI a, unsigned int n);
		void mpi_clear_bit(MPI a, unsigned int n);
		void mpi_rshift_limbs(MPI a, unsigned int count);
		void mpi_rshift(MPI x, MPI a, unsigned int n);
		void mpi_lshift_limbs(MPI a, unsigned int count);
		void mpi_lshift(MPI x, MPI a, unsigned int n);

		/-- mpi-add.c --/
		void mpi_add_ui(MPI w, MPI u, unsigned long v);
		void mpi_add(MPI w, MPI u, MPI v);
		void mpi_sub(MPI w, MPI u, MPI v);
		void mpi_addm(MPI w, MPI u, MPI v, MPI m);
		void mpi_subm(MPI w, MPI u, MPI v, MPI m);

		/-- mpi-mul.c --/
		void mpi_mul(MPI w, MPI u, MPI v);
		void mpi_mulm(MPI w, MPI u, MPI v, MPI m);

		/-- mpi-div.c --/
		void mpi_tdiv_r(MPI rem, MPI num, MPI den);
		void mpi_fdiv_r(MPI rem, MPI dividend, MPI divisor);
		void mpi_fdiv_q(MPI quot, MPI dividend, MPI divisor);

		/-- mpi-inv.c --/
		int mpi_invm(MPI x, MPI a, MPI n);

		/* inline functions */

lib/mpi/Makefile

+5 −0

Original line number	Diff line number	Diff line
		@@ -14,9 +14,14 @@ mpi-y = \
		generic_mpih-sub1.o \
		generic_mpih-add1.o \
		mpicoder.o \
		mpi-add.o \
		mpi-bit.o \
		mpi-cmp.o \
		mpi-sub-ui.o \
		mpi-div.o \
		mpi-inv.o \
		mpi-mod.o \
		mpi-mul.o \
		mpih-cmp.o \
		mpih-div.o \
		mpih-mul.o \

lib/mpi/mpi-add.c

0 → 100644

+155 −0

Original line number	Diff line number	Diff line
		/* mpi-add.c - MPI functions
		* Copyright (C) 1994, 1996, 1998, 2001, 2002,
		* 2003 Free Software Foundation, Inc.
		*
		* This file is part of Libgcrypt.
		*
		* 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.
		*/

		#include "mpi-internal.h"

		/****************
		* Add the unsigned integer V to the mpi-integer U and store the
		* result in W. U and V may be the same.
		*/
		void mpi_add_ui(MPI w, MPI u, unsigned long v)
		{
		mpi_ptr_t wp, up;
		mpi_size_t usize, wsize;
		int usign, wsign;

		usize = u->nlimbs;
		usign = u->sign;
		wsign = 0;

		/* If not space for W (and possible carry), increase space. */
		wsize = usize + 1;
		if (w->alloced < wsize)
		mpi_resize(w, wsize);

		/* These must be after realloc (U may be the same as W). */
		up = u->d;
		wp = w->d;

		if (!usize) { /* simple */
		wp[0] = v;
		wsize = v ? 1:0;
		} else if (!usign) { /* mpi is not negative */
		mpi_limb_t cy;
		cy = mpihelp_add_1(wp, up, usize, v);
		wp[usize] = cy;
		wsize = usize + cy;
		} else {
		/* The signs are different. Need exact comparison to determine
		* which operand to subtract from which.
		*/
		if (usize == 1 && up[0] < v) {
		wp[0] = v - up[0];
		wsize = 1;
		} else {
		mpihelp_sub_1(wp, up, usize, v);
		/* Size can decrease with at most one limb. */
		wsize = usize - (wp[usize-1] == 0);
		wsign = 1;
		}
		}

		w->nlimbs = wsize;
		w->sign = wsign;
		}


		void mpi_add(MPI w, MPI u, MPI v)
		{
		mpi_ptr_t wp, up, vp;
		mpi_size_t usize, vsize, wsize;
		int usign, vsign, wsign;

		if (u->nlimbs < v->nlimbs) { /* Swap U and V. */
		usize = v->nlimbs;
		usign = v->sign;
		vsize = u->nlimbs;
		vsign = u->sign;
		wsize = usize + 1;
		RESIZE_IF_NEEDED(w, wsize);
		/* These must be after realloc (u or v may be the same as w). */
		up = v->d;
		vp = u->d;
		} else {
		usize = u->nlimbs;
		usign = u->sign;
		vsize = v->nlimbs;
		vsign = v->sign;
		wsize = usize + 1;
		RESIZE_IF_NEEDED(w, wsize);
		/* These must be after realloc (u or v may be the same as w). */
		up = u->d;
		vp = v->d;
		}
		wp = w->d;
		wsign = 0;

		if (!vsize) { /* simple */
		MPN_COPY(wp, up, usize);
		wsize = usize;
		wsign = usign;
		} else if (usign != vsign) { /* different sign */
		/* This test is right since USIZE >= VSIZE */
		if (usize != vsize) {
		mpihelp_sub(wp, up, usize, vp, vsize);
		wsize = usize;
		MPN_NORMALIZE(wp, wsize);
		wsign = usign;
		} else if (mpihelp_cmp(up, vp, usize) < 0) {
		mpihelp_sub_n(wp, vp, up, usize);
		wsize = usize;
		MPN_NORMALIZE(wp, wsize);
		if (!usign)
		wsign = 1;
		} else {
		mpihelp_sub_n(wp, up, vp, usize);
		wsize = usize;
		MPN_NORMALIZE(wp, wsize);
		if (usign)
		wsign = 1;
		}
		} else { /* U and V have same sign. Add them. */
		mpi_limb_t cy = mpihelp_add(wp, up, usize, vp, vsize);
		wp[usize] = cy;
		wsize = usize + cy;
		if (usign)
		wsign = 1;
		}

		w->nlimbs = wsize;
		w->sign = wsign;
		}
		EXPORT_SYMBOL_GPL(mpi_add);

		void mpi_sub(MPI w, MPI u, MPI v)
		{
		MPI vv = mpi_copy(v);
		vv->sign = !vv->sign;
		mpi_add(w, u, vv);
		mpi_free(vv);
		}


		void mpi_addm(MPI w, MPI u, MPI v, MPI m)
		{
		mpi_add(w, u, v);
		mpi_mod(w, w, m);
		}
		EXPORT_SYMBOL_GPL(mpi_addm);

		void mpi_subm(MPI w, MPI u, MPI v, MPI m)
		{
		mpi_sub(w, u, v);
		mpi_mod(w, w, m);
		}
		EXPORT_SYMBOL_GPL(mpi_subm);

lib/mpi/mpi-bit.c

+251 −0

Original line number	Diff line number	Diff line
		@@ -32,6 +32,7 @@ void mpi_normalize(MPI a)
		for (; a->nlimbs && !a->d[a->nlimbs - 1]; a->nlimbs--)
		;
		}
		EXPORT_SYMBOL_GPL(mpi_normalize);

		/****************
		* Return the number of bits in A.
		@@ -54,3 +55,253 @@ unsigned mpi_get_nbits(MPI a)
		return n;
		}
		EXPORT_SYMBOL_GPL(mpi_get_nbits);

		/****************
		* Test whether bit N is set.
		*/
		int mpi_test_bit(MPI a, unsigned int n)
		{
		unsigned int limbno, bitno;
		mpi_limb_t limb;

		limbno = n / BITS_PER_MPI_LIMB;
		bitno = n % BITS_PER_MPI_LIMB;

		if (limbno >= a->nlimbs)
		return 0; /* too far left: this is a 0 */
		limb = a->d[limbno];
		return (limb & (A_LIMB_1 << bitno)) ? 1 : 0;
		}
		EXPORT_SYMBOL_GPL(mpi_test_bit);

		/****************
		* Set bit N of A.
		*/
		void mpi_set_bit(MPI a, unsigned int n)
		{
		unsigned int i, limbno, bitno;

		limbno = n / BITS_PER_MPI_LIMB;
		bitno = n % BITS_PER_MPI_LIMB;

		if (limbno >= a->nlimbs) {
		for (i = a->nlimbs; i < a->alloced; i++)
		a->d[i] = 0;
		mpi_resize(a, limbno+1);
		a->nlimbs = limbno+1;
		}
		a->d[limbno] \|= (A_LIMB_1<<bitno);
		}

		/****************
		* Set bit N of A. and clear all bits above
		*/
		void mpi_set_highbit(MPI a, unsigned int n)
		{
		unsigned int i, limbno, bitno;

		limbno = n / BITS_PER_MPI_LIMB;
		bitno = n % BITS_PER_MPI_LIMB;

		if (limbno >= a->nlimbs) {
		for (i = a->nlimbs; i < a->alloced; i++)
		a->d[i] = 0;
		mpi_resize(a, limbno+1);
		a->nlimbs = limbno+1;
		}
		a->d[limbno] \|= (A_LIMB_1<<bitno);
		for (bitno++; bitno < BITS_PER_MPI_LIMB; bitno++)
		a->d[limbno] &= ~(A_LIMB_1 << bitno);
		a->nlimbs = limbno+1;
		}
		EXPORT_SYMBOL_GPL(mpi_set_highbit);

		/****************
		* clear bit N of A and all bits above
		*/
		void mpi_clear_highbit(MPI a, unsigned int n)
		{
		unsigned int limbno, bitno;

		limbno = n / BITS_PER_MPI_LIMB;
		bitno = n % BITS_PER_MPI_LIMB;

		if (limbno >= a->nlimbs)
		return; /* not allocated, therefore no need to clear bits :-) */

		for ( ; bitno < BITS_PER_MPI_LIMB; bitno++)
		a->d[limbno] &= ~(A_LIMB_1 << bitno);
		a->nlimbs = limbno+1;
		}

		/****************
		* Clear bit N of A.
		*/
		void mpi_clear_bit(MPI a, unsigned int n)
		{
		unsigned int limbno, bitno;

		limbno = n / BITS_PER_MPI_LIMB;
		bitno = n % BITS_PER_MPI_LIMB;

		if (limbno >= a->nlimbs)
		return; /* Don't need to clear this bit, it's far too left. */
		a->d[limbno] &= ~(A_LIMB_1 << bitno);
		}
		EXPORT_SYMBOL_GPL(mpi_clear_bit);


		/****************
		* Shift A by COUNT limbs to the right
		* This is used only within the MPI library
		*/
		void mpi_rshift_limbs(MPI a, unsigned int count)
		{
		mpi_ptr_t ap = a->d;
		mpi_size_t n = a->nlimbs;
		unsigned int i;

		if (count >= n) {
		a->nlimbs = 0;
		return;
		}

		for (i = 0; i < n - count; i++)
		ap[i] = ap[i+count];
		ap[i] = 0;
		a->nlimbs -= count;
		}

		/*
		* Shift A by N bits to the right.
		*/
		void mpi_rshift(MPI x, MPI a, unsigned int n)
		{
		mpi_size_t xsize;
		unsigned int i;
		unsigned int nlimbs = (n/BITS_PER_MPI_LIMB);
		unsigned int nbits = (n%BITS_PER_MPI_LIMB);

		if (x == a) {
		/* In-place operation. */
		if (nlimbs >= x->nlimbs) {
		x->nlimbs = 0;
		return;
		}

		if (nlimbs) {
		for (i = 0; i < x->nlimbs - nlimbs; i++)
		x->d[i] = x->d[i+nlimbs];
		x->d[i] = 0;
		x->nlimbs -= nlimbs;
		}
		if (x->nlimbs && nbits)
		mpihelp_rshift(x->d, x->d, x->nlimbs, nbits);
		} else if (nlimbs) {
		/* Copy and shift by more or equal bits than in a limb. */
		xsize = a->nlimbs;
		x->sign = a->sign;
		RESIZE_IF_NEEDED(x, xsize);
		x->nlimbs = xsize;
		for (i = 0; i < a->nlimbs; i++)
		x->d[i] = a->d[i];
		x->nlimbs = i;

		if (nlimbs >= x->nlimbs) {
		x->nlimbs = 0;
		return;
		}

		if (nlimbs) {
		for (i = 0; i < x->nlimbs - nlimbs; i++)
		x->d[i] = x->d[i+nlimbs];
		x->d[i] = 0;
		x->nlimbs -= nlimbs;
		}

		if (x->nlimbs && nbits)
		mpihelp_rshift(x->d, x->d, x->nlimbs, nbits);
		} else {
		/* Copy and shift by less than bits in a limb. */
		xsize = a->nlimbs;
		x->sign = a->sign;
		RESIZE_IF_NEEDED(x, xsize);
		x->nlimbs = xsize;

		if (xsize) {
		if (nbits)
		mpihelp_rshift(x->d, a->d, x->nlimbs, nbits);
		else {
		/* The rshift helper function is not specified for
		* NBITS==0, thus we do a plain copy here.
		*/
		for (i = 0; i < x->nlimbs; i++)
		x->d[i] = a->d[i];
		}
		}
		}
		MPN_NORMALIZE(x->d, x->nlimbs);
		}

		/****************
		* Shift A by COUNT limbs to the left
		* This is used only within the MPI library
		*/
		void mpi_lshift_limbs(MPI a, unsigned int count)
		{
		mpi_ptr_t ap;
		int n = a->nlimbs;
		int i;

		if (!count \|\| !n)
		return;

		RESIZE_IF_NEEDED(a, n+count);

		ap = a->d;
		for (i = n-1; i >= 0; i--)
		ap[i+count] = ap[i];
		for (i = 0; i < count; i++)
		ap[i] = 0;
		a->nlimbs += count;
		}

		/*
		* Shift A by N bits to the left.
		*/
		void mpi_lshift(MPI x, MPI a, unsigned int n)
		{
		unsigned int nlimbs = (n/BITS_PER_MPI_LIMB);
		unsigned int nbits = (n%BITS_PER_MPI_LIMB);

		if (x == a && !n)
		return; /* In-place shift with an amount of zero. */

		if (x != a) {
		/* Copy A to X. */
		unsigned int alimbs = a->nlimbs;
		int asign = a->sign;
		mpi_ptr_t xp, ap;

		RESIZE_IF_NEEDED(x, alimbs+nlimbs+1);
		xp = x->d;
		ap = a->d;
		MPN_COPY(xp, ap, alimbs);
		x->nlimbs = alimbs;
		x->flags = a->flags;
		x->sign = asign;
		}

		if (nlimbs && !nbits) {
		/* Shift a full number of limbs. */
		mpi_lshift_limbs(x, nlimbs);
		} else if (n) {
		/* We use a very dump approach: Shift left by the number of
		* limbs plus one and than fix it up by an rshift.
		*/
		mpi_lshift_limbs(x, nlimbs+1);
		mpi_rshift(x, x, BITS_PER_MPI_LIMB - nbits);
		}

		MPN_NORMALIZE(x->d, x->nlimbs);
		}

lib/mpi/mpi-cmp.c

+36 −10

Original line number	Diff line number	Diff line
		@@ -41,28 +41,54 @@ int mpi_cmp_ui(MPI u, unsigned long v)
		}
		EXPORT_SYMBOL_GPL(mpi_cmp_ui);

		int mpi_cmp(MPI u, MPI v)
		static int do_mpi_cmp(MPI u, MPI v, int absmode)
		{
		mpi_size_t usize, vsize;
		mpi_size_t usize;
		mpi_size_t vsize;
		int usign;
		int vsign;
		int cmp;

		mpi_normalize(u);
		mpi_normalize(v);

		usize = u->nlimbs;
		vsize = v->nlimbs;
		if (!u->sign && v->sign)
		usign = absmode ? 0 : u->sign;
		vsign = absmode ? 0 : v->sign;

		/* Compare sign bits. */

		if (!usign && vsign)
		return 1;
		if (u->sign && !v->sign)
		if (usign && !vsign)
		return -1;
		if (usize != vsize && !u->sign && !v->sign)

		/* U and V are either both positive or both negative. */

		if (usize != vsize && !usign && !vsign)
		return usize - vsize;
		if (usize != vsize && u->sign && v->sign)
		return vsize - usize;
		if (usize != vsize && usign && vsign)
		return vsize + usize;
		if (!usize)
		return 0;
		cmp = mpihelp_cmp(u->d, v->d, usize);
		if (u->sign)
		return -cmp;
		return cmp;
		if (!cmp)
		return 0;
		if ((cmp < 0?1:0) == (usign?1:0))
		return 1;

		return -1;
		}

		int mpi_cmp(MPI u, MPI v)
		{
		return do_mpi_cmp(u, v, 0);
		}
		EXPORT_SYMBOL_GPL(mpi_cmp);

		int mpi_cmpabs(MPI u, MPI v)
		{
		return do_mpi_cmp(u, v, 1);
		}
		EXPORT_SYMBOL_GPL(mpi_cmpabs);