Line data Source code
1 : /* mpi-bit.c - MPI bit level functions
2 : * Copyright (C) 1998, 1999, 2001, 2002, 2006 Free Software Foundation, Inc.
3 : * Copyright (C) 2013 g10 Code GmbH
4 : *
5 : * This file is part of Libgcrypt.
6 : *
7 : * Libgcrypt is free software; you can redistribute it and/or modify
8 : * it under the terms of the GNU Lesser General Public License as
9 : * published by the Free Software Foundation; either version 2.1 of
10 : * the License, or (at your option) any later version.
11 : *
12 : * Libgcrypt is distributed in the hope that it will be useful,
13 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 : * GNU Lesser General Public License for more details.
16 : *
17 : * You should have received a copy of the GNU Lesser General Public
18 : * License along with this program; if not, write to the Free Software
19 : * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20 : */
21 :
22 : #include <config.h>
23 : #include <stdio.h>
24 : #include <stdlib.h>
25 : #include "mpi-internal.h"
26 : #include "longlong.h"
27 :
28 :
29 : #ifdef MPI_INTERNAL_NEED_CLZ_TAB
30 : #ifdef __STDC__
31 : const
32 : #endif
33 : unsigned char
34 : _gcry_clz_tab[] =
35 : {
36 : 0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
37 : 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
38 : 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
39 : 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
40 : 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
41 : 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
42 : 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
43 : 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
44 : };
45 : #endif
46 :
47 :
48 : #define A_LIMB_1 ((mpi_limb_t)1)
49 :
50 :
51 : /****************
52 : * Sometimes we have MSL (most significant limbs) which are 0;
53 : * this is for some reasons not good, so this function removes them.
54 : */
55 : void
56 3480539 : _gcry_mpi_normalize( gcry_mpi_t a )
57 : {
58 3480539 : if( mpi_is_opaque(a) )
59 3480542 : return;
60 :
61 3480536 : for( ; a->nlimbs && !a->d[a->nlimbs-1]; a->nlimbs-- )
62 : ;
63 : }
64 :
65 :
66 :
67 : /****************
68 : * Return the number of bits in A.
69 : */
70 : unsigned int
71 64528 : _gcry_mpi_get_nbits (gcry_mpi_t a)
72 : {
73 : unsigned n;
74 :
75 64528 : if( mpi_is_opaque(a) ) {
76 0 : return a->sign; /* which holds the number of bits */
77 : }
78 :
79 64528 : _gcry_mpi_normalize( a );
80 64528 : if( a->nlimbs ) {
81 64045 : mpi_limb_t alimb = a->d[a->nlimbs-1];
82 64045 : if( alimb )
83 64045 : count_leading_zeros( n, alimb );
84 : else
85 0 : n = BITS_PER_MPI_LIMB;
86 64045 : n = BITS_PER_MPI_LIMB - n + (a->nlimbs-1) * BITS_PER_MPI_LIMB;
87 : }
88 : else
89 483 : n = 0;
90 64528 : return n;
91 : }
92 :
93 :
94 : /****************
95 : * Test whether bit N is set.
96 : */
97 : int
98 11427946 : _gcry_mpi_test_bit( gcry_mpi_t a, unsigned int n )
99 : {
100 : unsigned int limbno, bitno;
101 : mpi_limb_t limb;
102 :
103 11427946 : limbno = n / BITS_PER_MPI_LIMB;
104 11427946 : bitno = n % BITS_PER_MPI_LIMB;
105 :
106 11427946 : if( limbno >= a->nlimbs )
107 11130 : return 0; /* too far left: this is a 0 */
108 11416816 : limb = a->d[limbno];
109 11416816 : return (limb & (A_LIMB_1 << bitno))? 1: 0;
110 : }
111 :
112 :
113 : /****************
114 : * Set bit N of A.
115 : */
116 : void
117 1599 : _gcry_mpi_set_bit( gcry_mpi_t a, unsigned int n )
118 : {
119 : unsigned int i, limbno, bitno;
120 :
121 1599 : if (mpi_is_immutable (a))
122 : {
123 0 : mpi_immutable_failed ();
124 1599 : return;
125 : }
126 :
127 1599 : limbno = n / BITS_PER_MPI_LIMB;
128 1599 : bitno = n % BITS_PER_MPI_LIMB;
129 :
130 1599 : if ( limbno >= a->nlimbs )
131 : {
132 30 : for (i=a->nlimbs; i < a->alloced; i++)
133 26 : a->d[i] = 0;
134 4 : mpi_resize (a, limbno+1 );
135 4 : a->nlimbs = limbno+1;
136 : }
137 1599 : a->d[limbno] |= (A_LIMB_1<<bitno);
138 : }
139 :
140 : /****************
141 : * Set bit N of A. and clear all bits above
142 : */
143 : void
144 13844 : _gcry_mpi_set_highbit( gcry_mpi_t a, unsigned int n )
145 : {
146 : unsigned int i, limbno, bitno;
147 :
148 13844 : if (mpi_is_immutable (a))
149 : {
150 0 : mpi_immutable_failed ();
151 13844 : return;
152 : }
153 :
154 13844 : limbno = n / BITS_PER_MPI_LIMB;
155 13844 : bitno = n % BITS_PER_MPI_LIMB;
156 :
157 13844 : if ( limbno >= a->nlimbs )
158 : {
159 159857 : for (i=a->nlimbs; i < a->alloced; i++)
160 153605 : a->d[i] = 0;
161 6252 : mpi_resize (a, limbno+1 );
162 6252 : a->nlimbs = limbno+1;
163 : }
164 13844 : a->d[limbno] |= (A_LIMB_1<<bitno);
165 178666 : for ( bitno++; bitno < BITS_PER_MPI_LIMB; bitno++ )
166 164822 : a->d[limbno] &= ~(A_LIMB_1 << bitno);
167 13844 : a->nlimbs = limbno+1;
168 : }
169 :
170 : /****************
171 : * clear bit N of A and all bits above
172 : */
173 : void
174 6383 : _gcry_mpi_clear_highbit( gcry_mpi_t a, unsigned int n )
175 : {
176 : unsigned int limbno, bitno;
177 :
178 6383 : if (mpi_is_immutable (a))
179 : {
180 0 : mpi_immutable_failed ();
181 0 : return;
182 : }
183 :
184 6383 : limbno = n / BITS_PER_MPI_LIMB;
185 6383 : bitno = n % BITS_PER_MPI_LIMB;
186 :
187 6383 : if( limbno >= a->nlimbs )
188 13 : return; /* not allocated, therefore no need to clear bits :-) */
189 :
190 112103 : for( ; bitno < BITS_PER_MPI_LIMB; bitno++ )
191 105733 : a->d[limbno] &= ~(A_LIMB_1 << bitno);
192 6370 : a->nlimbs = limbno+1;
193 : }
194 :
195 : /****************
196 : * Clear bit N of A.
197 : */
198 : void
199 7357 : _gcry_mpi_clear_bit( gcry_mpi_t a, unsigned int n )
200 : {
201 : unsigned int limbno, bitno;
202 :
203 7357 : if (mpi_is_immutable (a))
204 : {
205 0 : mpi_immutable_failed ();
206 0 : return;
207 : }
208 :
209 7357 : limbno = n / BITS_PER_MPI_LIMB;
210 7357 : bitno = n % BITS_PER_MPI_LIMB;
211 :
212 7357 : if (limbno >= a->nlimbs)
213 0 : return; /* Don't need to clear this bit, it's far too left. */
214 7357 : a->d[limbno] &= ~(A_LIMB_1 << bitno);
215 : }
216 :
217 :
218 : /****************
219 : * Shift A by COUNT limbs to the right
220 : * This is used only within the MPI library
221 : */
222 : void
223 0 : _gcry_mpi_rshift_limbs( gcry_mpi_t a, unsigned int count )
224 : {
225 0 : mpi_ptr_t ap = a->d;
226 0 : mpi_size_t n = a->nlimbs;
227 : unsigned int i;
228 :
229 0 : if (mpi_is_immutable (a))
230 : {
231 0 : mpi_immutable_failed ();
232 0 : return;
233 : }
234 :
235 0 : if (count >= n)
236 : {
237 0 : a->nlimbs = 0;
238 0 : return;
239 : }
240 :
241 0 : for( i = 0; i < n - count; i++ )
242 0 : ap[i] = ap[i+count];
243 0 : ap[i] = 0;
244 0 : a->nlimbs -= count;
245 : }
246 :
247 :
248 : /*
249 : * Shift A by N bits to the right.
250 : */
251 : void
252 10286396 : _gcry_mpi_rshift ( gcry_mpi_t x, gcry_mpi_t a, unsigned int n )
253 : {
254 : mpi_size_t xsize;
255 : unsigned int i;
256 10286396 : unsigned int nlimbs = (n/BITS_PER_MPI_LIMB);
257 10286396 : unsigned int nbits = (n%BITS_PER_MPI_LIMB);
258 :
259 10286396 : if (mpi_is_immutable (x))
260 : {
261 0 : mpi_immutable_failed ();
262 0 : return;
263 : }
264 :
265 10286396 : if ( x == a )
266 : {
267 : /* In-place operation. */
268 10286021 : if ( nlimbs >= x->nlimbs )
269 : {
270 219 : x->nlimbs = 0;
271 219 : return;
272 : }
273 :
274 10285802 : if (nlimbs)
275 : {
276 864 : for (i=0; i < x->nlimbs - nlimbs; i++ )
277 662 : x->d[i] = x->d[i+nlimbs];
278 202 : x->d[i] = 0;
279 202 : x->nlimbs -= nlimbs;
280 :
281 : }
282 10285802 : if ( x->nlimbs && nbits )
283 10285702 : _gcry_mpih_rshift ( x->d, x->d, x->nlimbs, nbits );
284 : }
285 375 : else if ( nlimbs )
286 : {
287 : /* Copy and shift by more or equal bits than in a limb. */
288 55 : xsize = a->nlimbs;
289 55 : x->sign = a->sign;
290 55 : RESIZE_IF_NEEDED (x, xsize);
291 55 : x->nlimbs = xsize;
292 165 : for (i=0; i < a->nlimbs; i++ )
293 110 : x->d[i] = a->d[i];
294 55 : x->nlimbs = i;
295 :
296 55 : if ( nlimbs >= x->nlimbs )
297 : {
298 0 : x->nlimbs = 0;
299 0 : return;
300 : }
301 :
302 55 : if (nlimbs)
303 : {
304 110 : for (i=0; i < x->nlimbs - nlimbs; i++ )
305 55 : x->d[i] = x->d[i+nlimbs];
306 55 : x->d[i] = 0;
307 55 : x->nlimbs -= nlimbs;
308 : }
309 :
310 55 : if ( x->nlimbs && nbits )
311 50 : _gcry_mpih_rshift ( x->d, x->d, x->nlimbs, nbits );
312 : }
313 : else
314 : {
315 : /* Copy and shift by less than bits in a limb. */
316 320 : xsize = a->nlimbs;
317 320 : x->sign = a->sign;
318 320 : RESIZE_IF_NEEDED (x, xsize);
319 320 : x->nlimbs = xsize;
320 :
321 320 : if ( xsize )
322 : {
323 320 : if (nbits )
324 315 : _gcry_mpih_rshift (x->d, a->d, x->nlimbs, nbits );
325 : else
326 : {
327 : /* The rshift helper function is not specified for
328 : NBITS==0, thus we do a plain copy here. */
329 15 : for (i=0; i < x->nlimbs; i++ )
330 10 : x->d[i] = a->d[i];
331 : }
332 : }
333 : }
334 10286177 : MPN_NORMALIZE (x->d, x->nlimbs);
335 : }
336 :
337 :
338 : /****************
339 : * Shift A by COUNT limbs to the left
340 : * This is used only within the MPI library
341 : */
342 : void
343 2044128 : _gcry_mpi_lshift_limbs (gcry_mpi_t a, unsigned int count)
344 : {
345 : mpi_ptr_t ap;
346 2044128 : int n = a->nlimbs;
347 : int i;
348 :
349 2044128 : if (!count || !n)
350 2044350 : return;
351 :
352 2043906 : RESIZE_IF_NEEDED (a, n+count);
353 :
354 2043906 : ap = a->d;
355 10906686 : for (i = n-1; i >= 0; i--)
356 8862780 : ap[i+count] = ap[i];
357 4693314 : for (i=0; i < count; i++ )
358 2649408 : ap[i] = 0;
359 2043906 : a->nlimbs += count;
360 : }
361 :
362 :
363 : /*
364 : * Shift A by N bits to the left.
365 : */
366 : void
367 2050447 : _gcry_mpi_lshift ( gcry_mpi_t x, gcry_mpi_t a, unsigned int n )
368 : {
369 2050447 : unsigned int nlimbs = (n/BITS_PER_MPI_LIMB);
370 2050447 : unsigned int nbits = (n%BITS_PER_MPI_LIMB);
371 :
372 2050447 : if (mpi_is_immutable (x))
373 : {
374 0 : mpi_immutable_failed ();
375 0 : return;
376 : }
377 :
378 2050447 : if (x == a && !n)
379 6284 : return; /* In-place shift with an amount of zero. */
380 :
381 2044163 : if ( x != a )
382 : {
383 : /* Copy A to X. */
384 1832696 : unsigned int alimbs = a->nlimbs;
385 1832696 : int asign = a->sign;
386 : mpi_ptr_t xp, ap;
387 :
388 1832696 : RESIZE_IF_NEEDED (x, alimbs+nlimbs+1);
389 1832696 : xp = x->d;
390 1832696 : ap = a->d;
391 1832696 : MPN_COPY (xp, ap, alimbs);
392 1832696 : x->nlimbs = alimbs;
393 1832696 : x->flags = a->flags;
394 1832696 : x->sign = asign;
395 : }
396 :
397 2044163 : if (nlimbs && !nbits)
398 : {
399 : /* Shift a full number of limbs. */
400 21777 : _gcry_mpi_lshift_limbs (x, nlimbs);
401 : }
402 2022386 : else if (n)
403 : {
404 : /* We use a very dump approach: Shift left by the number of
405 : limbs plus one and than fix it up by an rshift. */
406 2022351 : _gcry_mpi_lshift_limbs (x, nlimbs+1);
407 2022351 : mpi_rshift (x, x, BITS_PER_MPI_LIMB - nbits);
408 : }
409 :
410 2044163 : MPN_NORMALIZE (x->d, x->nlimbs);
411 : }
|
