1 /* mpicoder.c - Coder for the external representation of MPIs
2 * Copyright (C) 1998, 1999 Free Software Foundation, Inc.
4 * This file is part of GnuPG.
6 * GnuPG is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * GnuPG is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
21 #include <linux/bitops.h>
22 #include <linux/count_zeros.h>
23 #include "mpi-internal.h"
25 #define MAX_EXTERN_MPI_BITS 16384
28 * mpi_read_raw_data - Read a raw byte stream as a positive integer
29 * @xbuffer: The data to read
30 * @nbytes: The amount of data to read
32 MPI mpi_read_raw_data(const void *xbuffer, size_t nbytes)
34 const uint8_t *buffer = xbuffer;
36 unsigned nbits, nlimbs;
40 while (nbytes > 0 && buffer[0] == 0) {
46 if (nbits > MAX_EXTERN_MPI_BITS) {
47 pr_info("MPI: mpi too large (%u bits)\n", nbits);
51 nbits -= count_leading_zeros(buffer[0]);
55 nlimbs = DIV_ROUND_UP(nbytes, BYTES_PER_MPI_LIMB);
56 val = mpi_alloc(nlimbs);
64 i = BYTES_PER_MPI_LIMB - nbytes % BYTES_PER_MPI_LIMB;
65 i %= BYTES_PER_MPI_LIMB;
66 for (j = nlimbs; j > 0; j--) {
68 for (; i < BYTES_PER_MPI_LIMB; i++) {
78 EXPORT_SYMBOL_GPL(mpi_read_raw_data);
80 MPI mpi_read_from_buffer(const void *xbuffer, unsigned *ret_nread)
82 const uint8_t *buffer = xbuffer;
84 unsigned nbits, nbytes, nlimbs, nread = 0;
90 nbits = buffer[0] << 8 | buffer[1];
92 if (nbits > MAX_EXTERN_MPI_BITS) {
93 pr_info("MPI: mpi too large (%u bits)\n", nbits);
99 nbytes = DIV_ROUND_UP(nbits, 8);
100 nlimbs = DIV_ROUND_UP(nbytes, BYTES_PER_MPI_LIMB);
101 val = mpi_alloc(nlimbs);
104 i = BYTES_PER_MPI_LIMB - nbytes % BYTES_PER_MPI_LIMB;
105 i %= BYTES_PER_MPI_LIMB;
107 j = val->nlimbs = nlimbs;
111 for (; i < BYTES_PER_MPI_LIMB; i++) {
112 if (++nread > *ret_nread) {
114 ("MPI: mpi larger than buffer nread=%d ret_nread=%d\n",
129 EXPORT_SYMBOL_GPL(mpi_read_from_buffer);
132 * mpi_read_buffer() - read MPI to a bufer provided by user (msb first)
134 * @a: a multi precision integer
135 * @buf: bufer to which the output will be written to. Needs to be at
136 * leaset mpi_get_size(a) long.
137 * @buf_len: size of the buf.
138 * @nbytes: receives the actual length of the data written on success and
139 * the data to-be-written on -EOVERFLOW in case buf_len was too
141 * @sign: if not NULL, it will be set to the sign of a.
143 * Return: 0 on success or error code in case of error
145 int mpi_read_buffer(MPI a, uint8_t *buf, unsigned buf_len, unsigned *nbytes,
150 unsigned int n = mpi_get_size(a);
159 p = (void *)&a->d[a->nlimbs] - 1;
161 for (i = a->nlimbs * sizeof(alimb) - 1; i >= 0; i--, p--) {
168 if (buf_len < n - lzeros) {
169 *nbytes = n - lzeros;
174 *nbytes = n - lzeros;
176 for (i = a->nlimbs - 1; i >= 0; i--) {
178 #if BYTES_PER_MPI_LIMB == 4
183 #elif BYTES_PER_MPI_LIMB == 8
193 #error please implement for this limb size.
197 if (lzeros >= sizeof(alimb)) {
200 mpi_limb_t *limb1 = (void *)p - sizeof(alimb);
201 mpi_limb_t *limb2 = (void *)p - sizeof(alimb)
206 lzeros -= sizeof(alimb);
211 EXPORT_SYMBOL_GPL(mpi_read_buffer);
214 * mpi_get_buffer() - Returns an allocated buffer with the MPI (msb first).
215 * Caller must free the return string.
216 * This function does return a 0 byte buffer with nbytes set to zero if the
217 * value of A is zero.
219 * @a: a multi precision integer.
220 * @nbytes: receives the length of this buffer.
221 * @sign: if not NULL, it will be set to the sign of the a.
223 * Return: Pointer to MPI buffer or NULL on error
225 void *mpi_get_buffer(MPI a, unsigned *nbytes, int *sign)
239 buf = kmalloc(n, GFP_KERNEL);
244 ret = mpi_read_buffer(a, buf, n, nbytes, sign);
252 EXPORT_SYMBOL_GPL(mpi_get_buffer);
255 * Use BUFFER to update MPI.
257 int mpi_set_buffer(MPI a, const void *xbuffer, unsigned nbytes, int sign)
259 const uint8_t *buffer = xbuffer, *p;
264 nlimbs = DIV_ROUND_UP(nbytes, BYTES_PER_MPI_LIMB);
265 if (RESIZE_IF_NEEDED(a, nlimbs) < 0)
269 for (i = 0, p = buffer + nbytes - 1; p >= buffer + BYTES_PER_MPI_LIMB;) {
270 #if BYTES_PER_MPI_LIMB == 4
271 alimb = (mpi_limb_t) *p--;
272 alimb |= (mpi_limb_t) *p-- << 8;
273 alimb |= (mpi_limb_t) *p-- << 16;
274 alimb |= (mpi_limb_t) *p-- << 24;
275 #elif BYTES_PER_MPI_LIMB == 8
276 alimb = (mpi_limb_t) *p--;
277 alimb |= (mpi_limb_t) *p-- << 8;
278 alimb |= (mpi_limb_t) *p-- << 16;
279 alimb |= (mpi_limb_t) *p-- << 24;
280 alimb |= (mpi_limb_t) *p-- << 32;
281 alimb |= (mpi_limb_t) *p-- << 40;
282 alimb |= (mpi_limb_t) *p-- << 48;
283 alimb |= (mpi_limb_t) *p-- << 56;
285 #error please implement for this limb size.
290 #if BYTES_PER_MPI_LIMB == 4
293 alimb |= (mpi_limb_t) *p-- << 8;
295 alimb |= (mpi_limb_t) *p-- << 16;
297 alimb |= (mpi_limb_t) *p-- << 24;
298 #elif BYTES_PER_MPI_LIMB == 8
299 alimb = (mpi_limb_t) *p--;
301 alimb |= (mpi_limb_t) *p-- << 8;
303 alimb |= (mpi_limb_t) *p-- << 16;
305 alimb |= (mpi_limb_t) *p-- << 24;
307 alimb |= (mpi_limb_t) *p-- << 32;
309 alimb |= (mpi_limb_t) *p-- << 40;
311 alimb |= (mpi_limb_t) *p-- << 48;
313 alimb |= (mpi_limb_t) *p-- << 56;
315 #error please implement for this limb size.
322 pr_emerg("MPI: mpi_set_buffer: Assertion failed (%d != %d)", i,
328 EXPORT_SYMBOL_GPL(mpi_set_buffer);
331 * mpi_write_to_sgl() - Funnction exports MPI to an sgl (msb first)
333 * This function works in the same way as the mpi_read_buffer, but it
334 * takes an sgl instead of u8 * buf.
336 * @a: a multi precision integer
337 * @sgl: scatterlist to write to. Needs to be at least
338 * mpi_get_size(a) long.
339 * @nbytes: in/out param - it has the be set to the maximum number of
340 * bytes that can be written to sgl. This has to be at least
341 * the size of the integer a. On return it receives the actual
342 * length of the data written on success or the data that would
343 * be written if buffer was too small.
344 * @sign: if not NULL, it will be set to the sign of a.
346 * Return: 0 on success or error code in case of error
348 int mpi_write_to_sgl(MPI a, struct scatterlist *sgl, unsigned *nbytes,
352 mpi_limb_t alimb, alimb2;
353 unsigned int n = mpi_get_size(a);
354 int i, x, y = 0, lzeros = 0, buf_len;
362 p = (void *)&a->d[a->nlimbs] - 1;
364 for (i = a->nlimbs * sizeof(alimb) - 1; i >= 0; i--, p--) {
371 if (*nbytes < n - lzeros) {
372 *nbytes = n - lzeros;
376 *nbytes = n - lzeros;
377 buf_len = sgl->length;
380 for (i = a->nlimbs - 1; i >= 0; i--) {
383 #if BYTES_PER_MPI_LIMB == 4
388 #elif BYTES_PER_MPI_LIMB == 8
398 #error please implement for this limb size.
401 if (lzeros >= sizeof(alimb)) {
405 mpi_limb_t *limb1 = (void *)p - sizeof(alimb);
406 mpi_limb_t *limb2 = (void *)p - sizeof(alimb)
412 lzeros -= sizeof(alimb);
415 p = p - (sizeof(alimb) - y);
417 for (x = 0; x < sizeof(alimb) - y; x++) {
422 buf_len = sgl->length;
432 EXPORT_SYMBOL_GPL(mpi_write_to_sgl);
435 * mpi_read_raw_from_sgl() - Function allocates an MPI and populates it with
438 * This function works in the same way as the mpi_read_raw_data, but it
439 * takes an sgl instead of void * buffer. i.e. it allocates
440 * a new MPI and reads the content of the sgl to the MPI.
442 * @sgl: scatterlist to read from
443 * @len: number of bytes to read
445 * Return: Pointer to a new MPI or NULL on error
447 MPI mpi_read_raw_from_sgl(struct scatterlist *sgl, unsigned int len)
449 struct scatterlist *sg;
450 int x, i, j, z, lzeros, ents;
451 unsigned int nbits, nlimbs, nbytes;
456 ents = sg_nents(sgl);
458 for_each_sg(sgl, sg, ents, i) {
459 const u8 *buff = sg_virt(sg);
460 int len = sg->length;
462 while (len && !*buff) {
480 nbytes = len - lzeros;
483 if (nbits > MAX_EXTERN_MPI_BITS) {
484 pr_info("MPI: mpi too large (%u bits)\n", nbits);
489 nbits -= count_leading_zeros(*(u8 *)(sg_virt(sgl) + lzeros));
493 nlimbs = DIV_ROUND_UP(nbytes, BYTES_PER_MPI_LIMB);
494 val = mpi_alloc(nlimbs);
500 val->nlimbs = nlimbs;
508 x = BYTES_PER_MPI_LIMB - nbytes % BYTES_PER_MPI_LIMB;
509 x %= BYTES_PER_MPI_LIMB;
511 for_each_sg(sgl, sg, ents, i) {
512 const u8 *buffer = sg_virt(sg) + lzeros;
513 int len = sg->length - lzeros;
516 if (sg_is_last(sg) && (len % BYTES_PER_MPI_LIMB))
517 len += BYTES_PER_MPI_LIMB - (len % BYTES_PER_MPI_LIMB);
519 for (; x < len + buf_shift; x++) {
522 if (((z + x + 1) % BYTES_PER_MPI_LIMB) == 0) {
533 EXPORT_SYMBOL_GPL(mpi_read_raw_from_sgl);