Diffstat (limited to 'pwmanager/libcrypt/mpi/mpi-inline.h') (more/less context) (ignore whitespace changes)
-rw-r--r-- | pwmanager/libcrypt/mpi/mpi-inline.h | 154 |
1 files changed, 154 insertions, 0 deletions
diff --git a/pwmanager/libcrypt/mpi/mpi-inline.h b/pwmanager/libcrypt/mpi/mpi-inline.h new file mode 100644 index 0000000..88d9f56 --- a/dev/null +++ b/pwmanager/libcrypt/mpi/mpi-inline.h | |||
@@ -0,0 +1,154 @@ | |||
1 | /* mpi-inline.h - Internal to the Multi Precision Integers | ||
2 | * Copyright (C) 1994, 1996, 1998, 1999, | ||
3 | * 2001, 2002 Free Software Foundation, Inc. | ||
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 | * Note: This code is heavily based on the GNU MP Library. | ||
22 | * Actually it's the same code with only minor changes in the | ||
23 | * way the data is stored; this is to support the abstraction | ||
24 | * of an optional secure memory allocation which may be used | ||
25 | * to avoid revealing of sensitive data due to paging etc. | ||
26 | */ | ||
27 | |||
28 | #ifndef G10_MPI_INLINE_H | ||
29 | #define G10_MPI_INLINE_H | ||
30 | |||
31 | #ifndef G10_MPI_INLINE_DECL | ||
32 | #define G10_MPI_INLINE_DECL extern __inline__ | ||
33 | #endif | ||
34 | |||
35 | G10_MPI_INLINE_DECL mpi_limb_t | ||
36 | _gcry_mpih_add_1( mpi_ptr_t res_ptr, mpi_ptr_t s1_ptr, | ||
37 | mpi_size_t s1_size, mpi_limb_t s2_limb) | ||
38 | { | ||
39 | mpi_limb_t x; | ||
40 | |||
41 | x = *s1_ptr++; | ||
42 | s2_limb += x; | ||
43 | *res_ptr++ = s2_limb; | ||
44 | if( s2_limb < x ) { /* sum is less than the left operand: handle carry */ | ||
45 | while( --s1_size ) { | ||
46 | x = *s1_ptr++ + 1;/* add carry */ | ||
47 | *res_ptr++ = x;/* and store */ | ||
48 | if( x ) /* not 0 (no overflow): we can stop */ | ||
49 | goto leave; | ||
50 | } | ||
51 | return 1; /* return carry (size of s1 to small) */ | ||
52 | } | ||
53 | |||
54 | leave: | ||
55 | if( res_ptr != s1_ptr ) { /* not the same variable */ | ||
56 | mpi_size_t i; /* copy the rest */ | ||
57 | for( i=0; i < s1_size-1; i++ ) | ||
58 | res_ptr[i] = s1_ptr[i]; | ||
59 | } | ||
60 | return 0; /* no carry */ | ||
61 | } | ||
62 | |||
63 | |||
64 | |||
65 | G10_MPI_INLINE_DECL mpi_limb_t | ||
66 | _gcry_mpih_add(mpi_ptr_t res_ptr, mpi_ptr_t s1_ptr, mpi_size_t s1_size, | ||
67 | mpi_ptr_t s2_ptr, mpi_size_t s2_size) | ||
68 | { | ||
69 | mpi_limb_t cy = 0; | ||
70 | |||
71 | if( s2_size ) | ||
72 | cy = _gcry_mpih_add_n( res_ptr, s1_ptr, s2_ptr, s2_size ); | ||
73 | |||
74 | if( s1_size - s2_size ) | ||
75 | cy = _gcry_mpih_add_1( res_ptr + s2_size, s1_ptr + s2_size, | ||
76 | s1_size - s2_size, cy); | ||
77 | return cy; | ||
78 | } | ||
79 | |||
80 | |||
81 | G10_MPI_INLINE_DECL mpi_limb_t | ||
82 | _gcry_mpih_sub_1(mpi_ptr_t res_ptr, mpi_ptr_t s1_ptr, | ||
83 | mpi_size_t s1_size, mpi_limb_t s2_limb ) | ||
84 | { | ||
85 | mpi_limb_t x; | ||
86 | |||
87 | x = *s1_ptr++; | ||
88 | s2_limb = x - s2_limb; | ||
89 | *res_ptr++ = s2_limb; | ||
90 | if( s2_limb > x ) { | ||
91 | while( --s1_size ) { | ||
92 | x = *s1_ptr++; | ||
93 | *res_ptr++ = x - 1; | ||
94 | if( x ) | ||
95 | goto leave; | ||
96 | } | ||
97 | return 1; | ||
98 | } | ||
99 | |||
100 | leave: | ||
101 | if( res_ptr != s1_ptr ) { | ||
102 | mpi_size_t i; | ||
103 | for( i=0; i < s1_size-1; i++ ) | ||
104 | res_ptr[i] = s1_ptr[i]; | ||
105 | } | ||
106 | return 0; | ||
107 | } | ||
108 | |||
109 | |||
110 | |||
111 | G10_MPI_INLINE_DECL mpi_limb_t | ||
112 | _gcry_mpih_sub( mpi_ptr_t res_ptr, mpi_ptr_t s1_ptr, mpi_size_t s1_size, | ||
113 | mpi_ptr_t s2_ptr, mpi_size_t s2_size) | ||
114 | { | ||
115 | mpi_limb_t cy = 0; | ||
116 | |||
117 | if( s2_size ) | ||
118 | cy = _gcry_mpih_sub_n(res_ptr, s1_ptr, s2_ptr, s2_size); | ||
119 | |||
120 | if( s1_size - s2_size ) | ||
121 | cy = _gcry_mpih_sub_1(res_ptr + s2_size, s1_ptr + s2_size, | ||
122 | s1_size - s2_size, cy); | ||
123 | return cy; | ||
124 | } | ||
125 | |||
126 | /**************** | ||
127 | * Compare OP1_PTR/OP1_SIZE with OP2_PTR/OP2_SIZE. | ||
128 | * There are no restrictions on the relative sizes of | ||
129 | * the two arguments. | ||
130 | * Return 1 if OP1 > OP2, 0 if they are equal, and -1 if OP1 < OP2. | ||
131 | */ | ||
132 | G10_MPI_INLINE_DECL int | ||
133 | _gcry_mpih_cmp( mpi_ptr_t op1_ptr, mpi_ptr_t op2_ptr, mpi_size_t size ) | ||
134 | { | ||
135 | mpi_size_t i; | ||
136 | mpi_limb_t op1_word, op2_word; | ||
137 | |||
138 | for( i = size - 1; i >= 0 ; i--) { | ||
139 | op1_word = op1_ptr[i]; | ||
140 | op2_word = op2_ptr[i]; | ||
141 | if( op1_word != op2_word ) | ||
142 | goto diff; | ||
143 | } | ||
144 | return 0; | ||
145 | |||
146 | diff: | ||
147 | /* This can *not* be simplified to | ||
148 | * op2_word - op2_word | ||
149 | * since that expression might give signed overflow. */ | ||
150 | return (op1_word > op2_word) ? 1 : -1; | ||
151 | } | ||
152 | |||
153 | |||
154 | #endif /*G10_MPI_INLINE_H*/ | ||