Commit | Line | Data |
---|---|---|
cdec9cb5 DK |
1 | /* mpicoder.c - Coder for the external representation of MPIs |
2 | * Copyright (C) 1998, 1999 Free Software Foundation, Inc. | |
3 | * | |
4 | * This file is part of GnuPG. | |
5 | * | |
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. | |
10 | * | |
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. | |
15 | * | |
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 | |
19 | */ | |
20 | ||
e1045992 | 21 | #include <linux/bitops.h> |
a1164a3a | 22 | #include <linux/count_zeros.h> |
d7552906 | 23 | #include <linux/byteorder/generic.h> |
127827b9 | 24 | #include <linux/scatterlist.h> |
90f864e2 | 25 | #include <linux/string.h> |
cdec9cb5 DK |
26 | #include "mpi-internal.h" |
27 | ||
a8ea8bdd | 28 | #define MAX_EXTERN_SCAN_BYTES (16*1024*1024) |
cdec9cb5 DK |
29 | #define MAX_EXTERN_MPI_BITS 16384 |
30 | ||
e1045992 DH |
31 | /** |
32 | * mpi_read_raw_data - Read a raw byte stream as a positive integer | |
33 | * @xbuffer: The data to read | |
34 | * @nbytes: The amount of data to read | |
35 | */ | |
36 | MPI mpi_read_raw_data(const void *xbuffer, size_t nbytes) | |
37 | { | |
38 | const uint8_t *buffer = xbuffer; | |
39 | int i, j; | |
40 | unsigned nbits, nlimbs; | |
41 | mpi_limb_t a; | |
42 | MPI val = NULL; | |
43 | ||
5402b804 | 44 | while (nbytes > 0 && buffer[0] == 0) { |
e1045992 DH |
45 | buffer++; |
46 | nbytes--; | |
47 | } | |
48 | ||
49 | nbits = nbytes * 8; | |
50 | if (nbits > MAX_EXTERN_MPI_BITS) { | |
51 | pr_info("MPI: mpi too large (%u bits)\n", nbits); | |
52 | return NULL; | |
53 | } | |
54 | if (nbytes > 0) | |
eef0df6a | 55 | nbits -= count_leading_zeros(buffer[0]) - (BITS_PER_LONG - 8); |
e1045992 | 56 | |
0d2a1b2d | 57 | nlimbs = DIV_ROUND_UP(nbytes, BYTES_PER_MPI_LIMB); |
e1045992 DH |
58 | val = mpi_alloc(nlimbs); |
59 | if (!val) | |
60 | return NULL; | |
61 | val->nbits = nbits; | |
62 | val->sign = 0; | |
63 | val->nlimbs = nlimbs; | |
64 | ||
65 | if (nbytes > 0) { | |
66 | i = BYTES_PER_MPI_LIMB - nbytes % BYTES_PER_MPI_LIMB; | |
67 | i %= BYTES_PER_MPI_LIMB; | |
68 | for (j = nlimbs; j > 0; j--) { | |
69 | a = 0; | |
70 | for (; i < BYTES_PER_MPI_LIMB; i++) { | |
71 | a <<= 8; | |
72 | a |= *buffer++; | |
73 | } | |
74 | i = 0; | |
75 | val->d[j - 1] = a; | |
76 | } | |
77 | } | |
78 | return val; | |
79 | } | |
80 | EXPORT_SYMBOL_GPL(mpi_read_raw_data); | |
81 | ||
cdec9cb5 DK |
82 | MPI mpi_read_from_buffer(const void *xbuffer, unsigned *ret_nread) |
83 | { | |
84 | const uint8_t *buffer = xbuffer; | |
20b5b7f3 NS |
85 | unsigned int nbits, nbytes; |
86 | MPI val; | |
cdec9cb5 DK |
87 | |
88 | if (*ret_nread < 2) | |
03cdfaad | 89 | return ERR_PTR(-EINVAL); |
cdec9cb5 DK |
90 | nbits = buffer[0] << 8 | buffer[1]; |
91 | ||
92 | if (nbits > MAX_EXTERN_MPI_BITS) { | |
93 | pr_info("MPI: mpi too large (%u bits)\n", nbits); | |
03cdfaad | 94 | return ERR_PTR(-EINVAL); |
cdec9cb5 | 95 | } |
cdec9cb5 | 96 | |
0d2a1b2d | 97 | nbytes = DIV_ROUND_UP(nbits, 8); |
7af791e0 | 98 | if (nbytes + 2 > *ret_nread) { |
cdf24b42 NS |
99 | pr_info("MPI: mpi larger than buffer nbytes=%u ret_nread=%u\n", |
100 | nbytes, *ret_nread); | |
7af791e0 NS |
101 | return ERR_PTR(-EINVAL); |
102 | } | |
103 | ||
20b5b7f3 | 104 | val = mpi_read_raw_data(buffer + 2, nbytes); |
cdec9cb5 | 105 | if (!val) |
03cdfaad | 106 | return ERR_PTR(-ENOMEM); |
cdec9cb5 | 107 | |
7af791e0 | 108 | *ret_nread = nbytes + 2; |
cdec9cb5 DK |
109 | return val; |
110 | } | |
111 | EXPORT_SYMBOL_GPL(mpi_read_from_buffer); | |
112 | ||
a8ea8bdd TZ |
113 | /**************** |
114 | * Fill the mpi VAL from the hex string in STR. | |
115 | */ | |
116 | int mpi_fromstr(MPI val, const char *str) | |
117 | { | |
118 | int sign = 0; | |
119 | int prepend_zero = 0; | |
120 | int i, j, c, c1, c2; | |
121 | unsigned int nbits, nbytes, nlimbs; | |
122 | mpi_limb_t a; | |
123 | ||
124 | if (*str == '-') { | |
125 | sign = 1; | |
126 | str++; | |
127 | } | |
128 | ||
129 | /* Skip optional hex prefix. */ | |
130 | if (*str == '0' && str[1] == 'x') | |
131 | str += 2; | |
132 | ||
133 | nbits = strlen(str); | |
134 | if (nbits > MAX_EXTERN_SCAN_BYTES) { | |
135 | mpi_clear(val); | |
136 | return -EINVAL; | |
137 | } | |
138 | nbits *= 4; | |
139 | if ((nbits % 8)) | |
140 | prepend_zero = 1; | |
141 | ||
142 | nbytes = (nbits+7) / 8; | |
143 | nlimbs = (nbytes+BYTES_PER_MPI_LIMB-1) / BYTES_PER_MPI_LIMB; | |
144 | ||
145 | if (val->alloced < nlimbs) | |
146 | mpi_resize(val, nlimbs); | |
147 | ||
148 | i = BYTES_PER_MPI_LIMB - (nbytes % BYTES_PER_MPI_LIMB); | |
149 | i %= BYTES_PER_MPI_LIMB; | |
150 | j = val->nlimbs = nlimbs; | |
151 | val->sign = sign; | |
152 | for (; j > 0; j--) { | |
153 | a = 0; | |
154 | for (; i < BYTES_PER_MPI_LIMB; i++) { | |
155 | if (prepend_zero) { | |
156 | c1 = '0'; | |
157 | prepend_zero = 0; | |
158 | } else | |
159 | c1 = *str++; | |
160 | ||
161 | if (!c1) { | |
162 | mpi_clear(val); | |
163 | return -EINVAL; | |
164 | } | |
165 | c2 = *str++; | |
166 | if (!c2) { | |
167 | mpi_clear(val); | |
168 | return -EINVAL; | |
169 | } | |
170 | if (c1 >= '0' && c1 <= '9') | |
171 | c = c1 - '0'; | |
172 | else if (c1 >= 'a' && c1 <= 'f') | |
173 | c = c1 - 'a' + 10; | |
174 | else if (c1 >= 'A' && c1 <= 'F') | |
175 | c = c1 - 'A' + 10; | |
176 | else { | |
177 | mpi_clear(val); | |
178 | return -EINVAL; | |
179 | } | |
180 | c <<= 4; | |
181 | if (c2 >= '0' && c2 <= '9') | |
182 | c |= c2 - '0'; | |
183 | else if (c2 >= 'a' && c2 <= 'f') | |
184 | c |= c2 - 'a' + 10; | |
185 | else if (c2 >= 'A' && c2 <= 'F') | |
186 | c |= c2 - 'A' + 10; | |
187 | else { | |
188 | mpi_clear(val); | |
189 | return -EINVAL; | |
190 | } | |
191 | a <<= 8; | |
192 | a |= c; | |
193 | } | |
194 | i = 0; | |
195 | val->d[j-1] = a; | |
196 | } | |
197 | ||
198 | return 0; | |
199 | } | |
200 | EXPORT_SYMBOL_GPL(mpi_fromstr); | |
201 | ||
202 | MPI mpi_scanval(const char *string) | |
203 | { | |
204 | MPI a; | |
205 | ||
206 | a = mpi_alloc(0); | |
207 | if (!a) | |
208 | return NULL; | |
209 | ||
210 | if (mpi_fromstr(a, string)) { | |
211 | mpi_free(a); | |
212 | return NULL; | |
213 | } | |
214 | mpi_normalize(a); | |
215 | return a; | |
216 | } | |
217 | EXPORT_SYMBOL_GPL(mpi_scanval); | |
218 | ||
3ee0cb5f MM |
219 | static int count_lzeros(MPI a) |
220 | { | |
221 | mpi_limb_t alimb; | |
222 | int i, lzeros = 0; | |
223 | ||
224 | for (i = a->nlimbs - 1; i >= 0; i--) { | |
225 | alimb = a->d[i]; | |
226 | if (alimb == 0) { | |
227 | lzeros += sizeof(mpi_limb_t); | |
228 | } else { | |
229 | lzeros += count_leading_zeros(alimb) / 8; | |
230 | break; | |
231 | } | |
232 | } | |
233 | return lzeros; | |
234 | } | |
235 | ||
d37e2969 TS |
236 | /** |
237 | * mpi_read_buffer() - read MPI to a bufer provided by user (msb first) | |
238 | * | |
239 | * @a: a multi precision integer | |
240 | * @buf: bufer to which the output will be written to. Needs to be at | |
241 | * leaset mpi_get_size(a) long. | |
242 | * @buf_len: size of the buf. | |
9cbe21d8 AZ |
243 | * @nbytes: receives the actual length of the data written on success and |
244 | * the data to-be-written on -EOVERFLOW in case buf_len was too | |
245 | * small. | |
d37e2969 TS |
246 | * @sign: if not NULL, it will be set to the sign of a. |
247 | * | |
248 | * Return: 0 on success or error code in case of error | |
cdec9cb5 | 249 | */ |
d37e2969 TS |
250 | int mpi_read_buffer(MPI a, uint8_t *buf, unsigned buf_len, unsigned *nbytes, |
251 | int *sign) | |
cdec9cb5 | 252 | { |
d37e2969 | 253 | uint8_t *p; |
90f864e2 NS |
254 | #if BYTES_PER_MPI_LIMB == 4 |
255 | __be32 alimb; | |
256 | #elif BYTES_PER_MPI_LIMB == 8 | |
257 | __be64 alimb; | |
258 | #else | |
259 | #error please implement for this limb size. | |
260 | #endif | |
d37e2969 | 261 | unsigned int n = mpi_get_size(a); |
3ee0cb5f | 262 | int i, lzeros; |
d37e2969 | 263 | |
9cbe21d8 | 264 | if (!buf || !nbytes) |
d37e2969 | 265 | return -EINVAL; |
cdec9cb5 DK |
266 | |
267 | if (sign) | |
268 | *sign = a->sign; | |
d37e2969 | 269 | |
3ee0cb5f | 270 | lzeros = count_lzeros(a); |
d37e2969 | 271 | |
9cbe21d8 AZ |
272 | if (buf_len < n - lzeros) { |
273 | *nbytes = n - lzeros; | |
274 | return -EOVERFLOW; | |
275 | } | |
276 | ||
d37e2969 | 277 | p = buf; |
0f74fbf7 | 278 | *nbytes = n - lzeros; |
cdec9cb5 | 279 | |
f00fa241 NS |
280 | for (i = a->nlimbs - 1 - lzeros / BYTES_PER_MPI_LIMB, |
281 | lzeros %= BYTES_PER_MPI_LIMB; | |
282 | i >= 0; i--) { | |
cdec9cb5 | 283 | #if BYTES_PER_MPI_LIMB == 4 |
90f864e2 | 284 | alimb = cpu_to_be32(a->d[i]); |
cdec9cb5 | 285 | #elif BYTES_PER_MPI_LIMB == 8 |
90f864e2 | 286 | alimb = cpu_to_be64(a->d[i]); |
cdec9cb5 DK |
287 | #else |
288 | #error please implement for this limb size. | |
289 | #endif | |
462696fd NS |
290 | memcpy(p, (u8 *)&alimb + lzeros, BYTES_PER_MPI_LIMB - lzeros); |
291 | p += BYTES_PER_MPI_LIMB - lzeros; | |
292 | lzeros = 0; | |
cdec9cb5 | 293 | } |
d37e2969 TS |
294 | return 0; |
295 | } | |
296 | EXPORT_SYMBOL_GPL(mpi_read_buffer); | |
297 | ||
298 | /* | |
299 | * mpi_get_buffer() - Returns an allocated buffer with the MPI (msb first). | |
300 | * Caller must free the return string. | |
301 | * This function does return a 0 byte buffer with nbytes set to zero if the | |
302 | * value of A is zero. | |
303 | * | |
304 | * @a: a multi precision integer. | |
305 | * @nbytes: receives the length of this buffer. | |
306 | * @sign: if not NULL, it will be set to the sign of the a. | |
307 | * | |
308 | * Return: Pointer to MPI buffer or NULL on error | |
309 | */ | |
310 | void *mpi_get_buffer(MPI a, unsigned *nbytes, int *sign) | |
311 | { | |
0f74fbf7 | 312 | uint8_t *buf; |
d37e2969 TS |
313 | unsigned int n; |
314 | int ret; | |
315 | ||
316 | if (!nbytes) | |
317 | return NULL; | |
318 | ||
319 | n = mpi_get_size(a); | |
320 | ||
321 | if (!n) | |
322 | n++; | |
323 | ||
324 | buf = kmalloc(n, GFP_KERNEL); | |
325 | ||
326 | if (!buf) | |
327 | return NULL; | |
328 | ||
329 | ret = mpi_read_buffer(a, buf, n, nbytes, sign); | |
330 | ||
331 | if (ret) { | |
332 | kfree(buf); | |
333 | return NULL; | |
334 | } | |
d37e2969 | 335 | return buf; |
cdec9cb5 DK |
336 | } |
337 | EXPORT_SYMBOL_GPL(mpi_get_buffer); | |
338 | ||
2d4d1eea TS |
339 | /** |
340 | * mpi_write_to_sgl() - Funnction exports MPI to an sgl (msb first) | |
341 | * | |
342 | * This function works in the same way as the mpi_read_buffer, but it | |
343 | * takes an sgl instead of u8 * buf. | |
344 | * | |
345 | * @a: a multi precision integer | |
346 | * @sgl: scatterlist to write to. Needs to be at least | |
347 | * mpi_get_size(a) long. | |
9b45b7bb HX |
348 | * @nbytes: the number of bytes to write. Leading bytes will be |
349 | * filled with zero. | |
2d4d1eea TS |
350 | * @sign: if not NULL, it will be set to the sign of a. |
351 | * | |
352 | * Return: 0 on success or error code in case of error | |
353 | */ | |
9b45b7bb | 354 | int mpi_write_to_sgl(MPI a, struct scatterlist *sgl, unsigned nbytes, |
2d4d1eea TS |
355 | int *sign) |
356 | { | |
357 | u8 *p, *p2; | |
d7552906 NS |
358 | #if BYTES_PER_MPI_LIMB == 4 |
359 | __be32 alimb; | |
360 | #elif BYTES_PER_MPI_LIMB == 8 | |
361 | __be64 alimb; | |
362 | #else | |
363 | #error please implement for this limb size. | |
364 | #endif | |
2d4d1eea | 365 | unsigned int n = mpi_get_size(a); |
127827b9 | 366 | struct sg_mapping_iter miter; |
9b45b7bb | 367 | int i, x, buf_len; |
127827b9 | 368 | int nents; |
2d4d1eea TS |
369 | |
370 | if (sign) | |
371 | *sign = a->sign; | |
372 | ||
9b45b7bb | 373 | if (nbytes < n) |
9cbe21d8 | 374 | return -EOVERFLOW; |
9cbe21d8 | 375 | |
127827b9 HX |
376 | nents = sg_nents_for_len(sgl, nbytes); |
377 | if (nents < 0) | |
378 | return -EINVAL; | |
2d4d1eea | 379 | |
127827b9 HX |
380 | sg_miter_start(&miter, sgl, nents, SG_MITER_ATOMIC | SG_MITER_TO_SG); |
381 | sg_miter_next(&miter); | |
382 | buf_len = miter.length; | |
383 | p2 = miter.addr; | |
9b45b7bb | 384 | |
127827b9 | 385 | while (nbytes > n) { |
9b45b7bb HX |
386 | i = min_t(unsigned, nbytes - n, buf_len); |
387 | memset(p2, 0, i); | |
388 | p2 += i; | |
9b45b7bb | 389 | nbytes -= i; |
127827b9 HX |
390 | |
391 | buf_len -= i; | |
392 | if (!buf_len) { | |
393 | sg_miter_next(&miter); | |
394 | buf_len = miter.length; | |
395 | p2 = miter.addr; | |
396 | } | |
9b45b7bb HX |
397 | } |
398 | ||
399 | for (i = a->nlimbs - 1; i >= 0; i--) { | |
2d4d1eea | 400 | #if BYTES_PER_MPI_LIMB == 4 |
9b45b7bb | 401 | alimb = a->d[i] ? cpu_to_be32(a->d[i]) : 0; |
2d4d1eea | 402 | #elif BYTES_PER_MPI_LIMB == 8 |
9b45b7bb | 403 | alimb = a->d[i] ? cpu_to_be64(a->d[i]) : 0; |
2d4d1eea TS |
404 | #else |
405 | #error please implement for this limb size. | |
406 | #endif | |
9b45b7bb | 407 | p = (u8 *)&alimb; |
2d4d1eea | 408 | |
9b45b7bb | 409 | for (x = 0; x < sizeof(alimb); x++) { |
2d4d1eea | 410 | *p2++ = *p++; |
127827b9 HX |
411 | if (!--buf_len) { |
412 | sg_miter_next(&miter); | |
413 | buf_len = miter.length; | |
414 | p2 = miter.addr; | |
415 | } | |
2d4d1eea | 416 | } |
2d4d1eea | 417 | } |
127827b9 HX |
418 | |
419 | sg_miter_stop(&miter); | |
2d4d1eea TS |
420 | return 0; |
421 | } | |
422 | EXPORT_SYMBOL_GPL(mpi_write_to_sgl); | |
423 | ||
424 | /* | |
425 | * mpi_read_raw_from_sgl() - Function allocates an MPI and populates it with | |
426 | * data from the sgl | |
427 | * | |
428 | * This function works in the same way as the mpi_read_raw_data, but it | |
429 | * takes an sgl instead of void * buffer. i.e. it allocates | |
430 | * a new MPI and reads the content of the sgl to the MPI. | |
431 | * | |
432 | * @sgl: scatterlist to read from | |
b6985389 | 433 | * @nbytes: number of bytes to read |
2d4d1eea TS |
434 | * |
435 | * Return: Pointer to a new MPI or NULL on error | |
436 | */ | |
b6985389 | 437 | MPI mpi_read_raw_from_sgl(struct scatterlist *sgl, unsigned int nbytes) |
2d4d1eea | 438 | { |
127827b9 | 439 | struct sg_mapping_iter miter; |
b6985389 | 440 | unsigned int nbits, nlimbs; |
127827b9 HX |
441 | int x, j, z, lzeros, ents; |
442 | unsigned int len; | |
443 | const u8 *buff; | |
2d4d1eea TS |
444 | mpi_limb_t a; |
445 | MPI val = NULL; | |
446 | ||
127827b9 HX |
447 | ents = sg_nents_for_len(sgl, nbytes); |
448 | if (ents < 0) | |
449 | return NULL; | |
2d4d1eea | 450 | |
127827b9 | 451 | sg_miter_start(&miter, sgl, ents, SG_MITER_ATOMIC | SG_MITER_FROM_SG); |
2d4d1eea | 452 | |
127827b9 HX |
453 | lzeros = 0; |
454 | len = 0; | |
455 | while (nbytes > 0) { | |
63349d02 | 456 | while (len && !*buff) { |
2d4d1eea | 457 | lzeros++; |
63349d02 SM |
458 | len--; |
459 | buff++; | |
460 | } | |
2d4d1eea TS |
461 | |
462 | if (len && *buff) | |
463 | break; | |
464 | ||
127827b9 HX |
465 | sg_miter_next(&miter); |
466 | buff = miter.addr; | |
467 | len = miter.length; | |
468 | ||
ab1e912e | 469 | nbytes -= lzeros; |
2d4d1eea TS |
470 | lzeros = 0; |
471 | } | |
472 | ||
4816c940 | 473 | miter.consumed = lzeros; |
4816c940 | 474 | |
ab1e912e | 475 | nbytes -= lzeros; |
2d4d1eea TS |
476 | nbits = nbytes * 8; |
477 | if (nbits > MAX_EXTERN_MPI_BITS) { | |
dea3eb8b | 478 | sg_miter_stop(&miter); |
2d4d1eea TS |
479 | pr_info("MPI: mpi too large (%u bits)\n", nbits); |
480 | return NULL; | |
481 | } | |
482 | ||
483 | if (nbytes > 0) | |
127827b9 | 484 | nbits -= count_leading_zeros(*buff) - (BITS_PER_LONG - 8); |
2d4d1eea | 485 | |
dea3eb8b SM |
486 | sg_miter_stop(&miter); |
487 | ||
2d4d1eea TS |
488 | nlimbs = DIV_ROUND_UP(nbytes, BYTES_PER_MPI_LIMB); |
489 | val = mpi_alloc(nlimbs); | |
490 | if (!val) | |
491 | return NULL; | |
492 | ||
493 | val->nbits = nbits; | |
494 | val->sign = 0; | |
495 | val->nlimbs = nlimbs; | |
496 | ||
497 | if (nbytes == 0) | |
498 | return val; | |
499 | ||
500 | j = nlimbs - 1; | |
501 | a = 0; | |
85d541a3 NS |
502 | z = BYTES_PER_MPI_LIMB - nbytes % BYTES_PER_MPI_LIMB; |
503 | z %= BYTES_PER_MPI_LIMB; | |
2d4d1eea | 504 | |
4816c940 HX |
505 | while (sg_miter_next(&miter)) { |
506 | buff = miter.addr; | |
507 | len = miter.length; | |
508 | ||
85d541a3 | 509 | for (x = 0; x < len; x++) { |
2d4d1eea | 510 | a <<= 8; |
127827b9 | 511 | a |= *buff++; |
2d4d1eea TS |
512 | if (((z + x + 1) % BYTES_PER_MPI_LIMB) == 0) { |
513 | val->d[j--] = a; | |
514 | a = 0; | |
515 | } | |
516 | } | |
517 | z += x; | |
2d4d1eea | 518 | } |
127827b9 | 519 | |
2d4d1eea TS |
520 | return val; |
521 | } | |
522 | EXPORT_SYMBOL_GPL(mpi_read_raw_from_sgl); | |
a8ea8bdd TZ |
523 | |
524 | /* Perform a two's complement operation on buffer P of size N bytes. */ | |
525 | static void twocompl(unsigned char *p, unsigned int n) | |
526 | { | |
527 | int i; | |
528 | ||
529 | for (i = n-1; i >= 0 && !p[i]; i--) | |
530 | ; | |
531 | if (i >= 0) { | |
532 | if ((p[i] & 0x01)) | |
533 | p[i] = (((p[i] ^ 0xfe) | 0x01) & 0xff); | |
534 | else if ((p[i] & 0x02)) | |
535 | p[i] = (((p[i] ^ 0xfc) | 0x02) & 0xfe); | |
536 | else if ((p[i] & 0x04)) | |
537 | p[i] = (((p[i] ^ 0xf8) | 0x04) & 0xfc); | |
538 | else if ((p[i] & 0x08)) | |
539 | p[i] = (((p[i] ^ 0xf0) | 0x08) & 0xf8); | |
540 | else if ((p[i] & 0x10)) | |
541 | p[i] = (((p[i] ^ 0xe0) | 0x10) & 0xf0); | |
542 | else if ((p[i] & 0x20)) | |
543 | p[i] = (((p[i] ^ 0xc0) | 0x20) & 0xe0); | |
544 | else if ((p[i] & 0x40)) | |
545 | p[i] = (((p[i] ^ 0x80) | 0x40) & 0xc0); | |
546 | else | |
547 | p[i] = 0x80; | |
548 | ||
549 | for (i--; i >= 0; i--) | |
550 | p[i] ^= 0xff; | |
551 | } | |
552 | } | |
553 | ||
554 | int mpi_print(enum gcry_mpi_format format, unsigned char *buffer, | |
555 | size_t buflen, size_t *nwritten, MPI a) | |
556 | { | |
557 | unsigned int nbits = mpi_get_nbits(a); | |
558 | size_t len; | |
559 | size_t dummy_nwritten; | |
560 | int negative; | |
561 | ||
562 | if (!nwritten) | |
563 | nwritten = &dummy_nwritten; | |
564 | ||
565 | /* Libgcrypt does no always care to set clear the sign if the value | |
566 | * is 0. For printing this is a bit of a surprise, in particular | |
567 | * because if some of the formats don't support negative numbers but | |
568 | * should be able to print a zero. Thus we need this extra test | |
569 | * for a negative number. | |
570 | */ | |
571 | if (a->sign && mpi_cmp_ui(a, 0)) | |
572 | negative = 1; | |
573 | else | |
574 | negative = 0; | |
575 | ||
576 | len = buflen; | |
577 | *nwritten = 0; | |
578 | if (format == GCRYMPI_FMT_STD) { | |
579 | unsigned char *tmp; | |
580 | int extra = 0; | |
581 | unsigned int n; | |
582 | ||
583 | tmp = mpi_get_buffer(a, &n, NULL); | |
584 | if (!tmp) | |
585 | return -EINVAL; | |
586 | ||
587 | if (negative) { | |
588 | twocompl(tmp, n); | |
589 | if (!(*tmp & 0x80)) { | |
590 | /* Need to extend the sign. */ | |
591 | n++; | |
592 | extra = 2; | |
593 | } | |
594 | } else if (n && (*tmp & 0x80)) { | |
595 | /* Positive but the high bit of the returned buffer is set. | |
596 | * Thus we need to print an extra leading 0x00 so that the | |
597 | * output is interpreted as a positive number. | |
598 | */ | |
599 | n++; | |
600 | extra = 1; | |
601 | } | |
602 | ||
603 | if (buffer && n > len) { | |
604 | /* The provided buffer is too short. */ | |
605 | kfree(tmp); | |
606 | return -E2BIG; | |
607 | } | |
608 | if (buffer) { | |
609 | unsigned char *s = buffer; | |
610 | ||
611 | if (extra == 1) | |
612 | *s++ = 0; | |
613 | else if (extra) | |
614 | *s++ = 0xff; | |
615 | memcpy(s, tmp, n-!!extra); | |
616 | } | |
617 | kfree(tmp); | |
618 | *nwritten = n; | |
619 | return 0; | |
620 | } else if (format == GCRYMPI_FMT_USG) { | |
621 | unsigned int n = (nbits + 7)/8; | |
622 | ||
623 | /* Note: We ignore the sign for this format. */ | |
624 | /* FIXME: for performance reasons we should put this into | |
625 | * mpi_aprint because we can then use the buffer directly. | |
626 | */ | |
627 | ||
628 | if (buffer && n > len) | |
629 | return -E2BIG; | |
630 | if (buffer) { | |
631 | unsigned char *tmp; | |
632 | ||
633 | tmp = mpi_get_buffer(a, &n, NULL); | |
634 | if (!tmp) | |
635 | return -EINVAL; | |
636 | memcpy(buffer, tmp, n); | |
637 | kfree(tmp); | |
638 | } | |
639 | *nwritten = n; | |
640 | return 0; | |
641 | } else if (format == GCRYMPI_FMT_PGP) { | |
642 | unsigned int n = (nbits + 7)/8; | |
643 | ||
644 | /* The PGP format can only handle unsigned integers. */ | |
645 | if (negative) | |
646 | return -EINVAL; | |
647 | ||
648 | if (buffer && n+2 > len) | |
649 | return -E2BIG; | |
650 | ||
651 | if (buffer) { | |
652 | unsigned char *tmp; | |
653 | unsigned char *s = buffer; | |
654 | ||
655 | s[0] = nbits >> 8; | |
656 | s[1] = nbits; | |
657 | ||
658 | tmp = mpi_get_buffer(a, &n, NULL); | |
659 | if (!tmp) | |
660 | return -EINVAL; | |
661 | memcpy(s+2, tmp, n); | |
662 | kfree(tmp); | |
663 | } | |
664 | *nwritten = n+2; | |
665 | return 0; | |
666 | } else if (format == GCRYMPI_FMT_SSH) { | |
667 | unsigned char *tmp; | |
668 | int extra = 0; | |
669 | unsigned int n; | |
670 | ||
671 | tmp = mpi_get_buffer(a, &n, NULL); | |
672 | if (!tmp) | |
673 | return -EINVAL; | |
674 | ||
675 | if (negative) { | |
676 | twocompl(tmp, n); | |
677 | if (!(*tmp & 0x80)) { | |
678 | /* Need to extend the sign. */ | |
679 | n++; | |
680 | extra = 2; | |
681 | } | |
682 | } else if (n && (*tmp & 0x80)) { | |
683 | n++; | |
684 | extra = 1; | |
685 | } | |
686 | ||
687 | if (buffer && n+4 > len) { | |
688 | kfree(tmp); | |
689 | return -E2BIG; | |
690 | } | |
691 | ||
692 | if (buffer) { | |
693 | unsigned char *s = buffer; | |
694 | ||
695 | *s++ = n >> 24; | |
696 | *s++ = n >> 16; | |
697 | *s++ = n >> 8; | |
698 | *s++ = n; | |
699 | if (extra == 1) | |
700 | *s++ = 0; | |
701 | else if (extra) | |
702 | *s++ = 0xff; | |
703 | memcpy(s, tmp, n-!!extra); | |
704 | } | |
705 | kfree(tmp); | |
706 | *nwritten = 4+n; | |
707 | return 0; | |
708 | } else if (format == GCRYMPI_FMT_HEX) { | |
709 | unsigned char *tmp; | |
710 | int i; | |
711 | int extra = 0; | |
712 | unsigned int n = 0; | |
713 | ||
714 | tmp = mpi_get_buffer(a, &n, NULL); | |
715 | if (!tmp) | |
716 | return -EINVAL; | |
717 | if (!n || (*tmp & 0x80)) | |
718 | extra = 2; | |
719 | ||
720 | if (buffer && 2*n + extra + negative + 1 > len) { | |
721 | kfree(tmp); | |
722 | return -E2BIG; | |
723 | } | |
724 | if (buffer) { | |
725 | unsigned char *s = buffer; | |
726 | ||
727 | if (negative) | |
728 | *s++ = '-'; | |
729 | if (extra) { | |
730 | *s++ = '0'; | |
731 | *s++ = '0'; | |
732 | } | |
733 | ||
734 | for (i = 0; i < n; i++) { | |
735 | unsigned int c = tmp[i]; | |
736 | ||
737 | *s++ = (c >> 4) < 10 ? '0'+(c>>4) : 'A'+(c>>4)-10; | |
738 | c &= 15; | |
739 | *s++ = c < 10 ? '0'+c : 'A'+c-10; | |
740 | } | |
741 | *s++ = 0; | |
742 | *nwritten = s - buffer; | |
743 | } else { | |
744 | *nwritten = 2*n + extra + negative + 1; | |
745 | } | |
746 | kfree(tmp); | |
747 | return 0; | |
748 | } else | |
749 | return -EINVAL; | |
750 | } | |
751 | EXPORT_SYMBOL_GPL(mpi_print); |