gmp-glue.c 5.41 KB
Newer Older
1
2
3
4
5
/* gmp-glue.c */

/* nettle, low-level cryptographics library
 *
 * Copyright (C) 2013 Niels Möller
6
7
 * Copyright (C) 2013 Red Hat
 *
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 * The nettle library 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.
 * 
 * The nettle 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 the nettle library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA 02111-1301, USA.
 */

24
25
26
27
#if HAVE_CONFIG_H
# include "config.h"
#endif

28
#include <assert.h>
Niels Möller's avatar
Niels Möller committed
29
#include <stdlib.h>
30
31
32

#include "gmp-glue.h"

33
34
#if !GMP_HAVE_mpz_limbs_read

35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
/* This implementation tries to make a minimal use of GMP internals.
   We access and _mp_size and _mp_d, but not _mp_alloc. */

/* Use macros compatible with gmp-impl.h. */
#define ABS(x) ((x) >= 0 ? (x) : -(x))
#define PTR(x) ((x)->_mp_d)
#define SIZ(x) ((x)->_mp_size)
#define ABSIZ(x) ABS (SIZ (x))

#define MPN_NORMALIZE(xp, xn) do {		\
    while ( (xn) > 0 && (xp)[xn-1] == 0)	\
      (xn)--;					\
  }  while (0)

/* NOTE: Makes an unnecessary realloc if allocation is already large
   enough, but looking at _mp_alloc may break in future GMP
   versions. */
#define MPZ_REALLOC(x, n) \
  (ABSIZ(x) >= (n) ? PTR(x) : (_mpz_realloc ((x),(n)), PTR (x)))

#define MPZ_NEWALLOC MPZ_REALLOC

/* Read access to mpz numbers. */

/* Return limb pointer, for read-only operations. Use mpz_size to get
   the number of limbs. */
const mp_limb_t *
62
mpz_limbs_read (mpz_srcptr x)
63
64
65
66
67
68
69
70
71
{
  return PTR (x);
}

/* Write access to mpz numbers. */

/* Get a limb pointer for writing, previous contents may be
   destroyed. */
mp_limb_t *
72
mpz_limbs_write (mpz_ptr x, mp_size_t n)
73
74
75
76
77
78
79
{
  assert (n > 0);
  return MPZ_NEWALLOC (x, n);
}

/* Get a limb pointer for writing, previous contents is intact. */
mp_limb_t *
80
mpz_limbs_modify (mpz_ptr x, mp_size_t n)
81
82
83
84
85
86
{
  assert (n > 0);
  return MPZ_REALLOC (x, n);
}

void
87
mpz_limbs_finish (mpz_ptr x, mp_size_t n)
88
89
90
91
92
93
94
95
96
{
  assert (n >= 0);
  MPN_NORMALIZE (PTR(x), n);

  SIZ (x) = n;
}

/* Needs some ugly casts. */
mpz_srcptr
97
mpz_roinit_n (mpz_ptr x, const mp_limb_t *xp, mp_size_t xs)
98
99
100
101
102
103
104
105
106
107
{
  mp_size_t xn = ABS (xs);
  
  MPN_NORMALIZE (xp, xn);

  x->_mp_size = xs < 0 ? -xn : xn;
  x->_mp_alloc = 0;
  x->_mp_d = (mp_limb_t *) xp;
  return x;
}
108
109
#endif /* !GMP_HAVE_mpz_limbs_read */

110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
#if !GMP_HAVE_mpn_copyd
void
mpn_copyd (mp_ptr dst, mp_srcptr src, mp_size_t n)
{
  mp_size_t i;
  for (i = n - 1; i >= 0; i--)
    dst[i] = src[i];
}

void
mpn_copyi (mp_ptr dst, mp_srcptr src, mp_size_t n)
{
  mp_size_t i;
  for (i = 0; i < n; i++)
    dst[i] = src[i];
}

void
mpn_zero (mp_ptr ptr, mp_size_t n)
{
  mp_size_t i;
  for (i = 0; i < n; i++)
    ptr[i] = 0;
}
#endif /* !GMP_HAVE_mpn_copyd */

136
137
138
139
140
/* Additional convenience functions. */

int
mpz_limbs_cmp (mpz_srcptr a, const mp_limb_t *bp, mp_size_t bn)
{
141
142
143
144
  mp_size_t an = mpz_size (a);
  assert (mpz_sgn (a) >= 0);
  assert (bn >= 0);

145
146
147
148
149
150
151
  if (an < bn)
    return -1;
  if (an > bn)
    return 1;
  if (an == 0)
    return 0;

152
  return mpn_cmp (mpz_limbs_read(a), bp, an);
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
}

/* Get a pointer to an n limb area, for read-only operation. n must be
   greater or equal to the current size, and the mpz is zero-padded if
   needed. */
const mp_limb_t *
mpz_limbs_read_n (mpz_ptr x, mp_size_t n)
{
  mp_size_t xn = mpz_size (x);
  mp_ptr xp;
  
  assert (xn <= n);

  xp = mpz_limbs_modify (x, n);

  if (xn < n)
    mpn_zero (xp + xn, n - xn);

  return xp;
}

void
mpz_limbs_copy (mp_limb_t *xp, mpz_srcptr x, mp_size_t n)
{
  mp_size_t xn = mpz_size (x);

  assert (xn <= n);
  mpn_copyi (xp, mpz_limbs_read (x), xn);
  if (xn < n)
    mpn_zero (xp + xn, n - xn);
}

void
mpz_set_n (mpz_t r, const mp_limb_t *xp, mp_size_t xn)
{
  mpn_copyi (mpz_limbs_write (r, xn), xp, xn);
  mpz_limbs_finish (r, xn);
}
Niels Möller's avatar
Niels Möller committed
191
192

void
193
mpn_set_base256 (mp_limb_t *rp, mp_size_t rn,
Niels Möller's avatar
Niels Möller committed
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
		 const uint8_t *xp, size_t xn)
{
  size_t xi;
  mp_limb_t out;
  unsigned bits;
  for (xi = xn, out = bits = 0; xi > 0 && rn > 0; )
    {
      mp_limb_t in = xp[--xi];
      out |= (in << bits) & GMP_NUMB_MASK;
      bits += 8;
      if (bits >= GMP_NUMB_BITS)
	{
	  *rp++ = out;
	  rn--;

	  bits -= GMP_NUMB_BITS;
	  out = in >> (8 - bits);
	}
    }
  if (rn > 0)
    {
      *rp++ = out;
      if (--rn > 0)
	mpn_zero (rp, rn);
    }
}

mp_limb_t *
222
gmp_alloc_limbs (mp_size_t n)
Niels Möller's avatar
Niels Möller committed
223
224
225
226
227
228
229
230
231
232
233
{

  void *(*alloc_func)(size_t);

  assert (n > 0);

  mp_get_memory_functions (&alloc_func, NULL, NULL);
  return (mp_limb_t *) alloc_func ( (size_t) n * sizeof(mp_limb_t));
}

void
234
gmp_free_limbs (mp_limb_t *p, mp_size_t n)
Niels Möller's avatar
Niels Möller committed
235
236
237
238
239
240
241
242
{
  void (*free_func)(void *, size_t);
  assert (n > 0);
  assert (p != 0);
  mp_get_memory_functions (NULL, NULL, &free_func);

  free_func (p, (size_t) n * sizeof(mp_limb_t));
}
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264

void *
gmp_alloc(size_t n)
{
  void *(*alloc_func)(size_t);
  assert (n > 0);

  mp_get_memory_functions(&alloc_func, NULL, NULL);

  return alloc_func (n);
}

void
gmp_free(void *p, size_t n)
{
  void (*free_func)(void *, size_t);
  assert (n > 0);
  assert (p != 0);
  mp_get_memory_functions (NULL, NULL, &free_func);

  free_func (p, (size_t) n);
}