Line data Source code
1 : /* mpi-add.c - MPI functions
2 : * Copyright (C) 1994, 1996, 1998, 2001, 2002, 2003 Free Software Foundation, Inc.
3 : *
4 : * This file is part of Libgcrypt.
5 : *
6 : * Libgcrypt is free software; you can redistribute it and/or modify
7 : * it under the terms of the GNU Lesser General Public License as
8 : * published by the Free Software Foundation; either version 2.1 of
9 : * the License, or (at your option) any later version.
10 : *
11 : * Libgcrypt 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 Lesser General Public License for more details.
15 : *
16 : * You should have received a copy of the GNU Lesser General Public
17 : * License 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 : * Note: This code is heavily based on the GNU MP Library.
21 : * Actually it's the same code with only minor changes in the
22 : * way the data is stored; this is to support the abstraction
23 : * of an optional secure memory allocation which may be used
24 : * to avoid revealing of sensitive data due to paging etc.
25 : */
26 :
27 : #include <config.h>
28 : #include <stdio.h>
29 : #include <stdlib.h>
30 :
31 : #include "mpi-internal.h"
32 :
33 :
34 : /****************
35 : * Add the unsigned integer V to the mpi-integer U and store the
36 : * result in W. U and V may be the same.
37 : */
38 : void
39 33650 : _gcry_mpi_add_ui (gcry_mpi_t w, gcry_mpi_t u, unsigned long v )
40 : {
41 : mpi_ptr_t wp, up;
42 : mpi_size_t usize, wsize;
43 : int usign, wsign;
44 :
45 33650 : usize = u->nlimbs;
46 33650 : usign = u->sign;
47 33650 : wsign = 0;
48 :
49 : /* If not space for W (and possible carry), increase space. */
50 33650 : wsize = usize + 1;
51 33650 : if( w->alloced < wsize )
52 697 : mpi_resize(w, wsize);
53 :
54 : /* These must be after realloc (U may be the same as W). */
55 33650 : up = u->d;
56 33650 : wp = w->d;
57 :
58 33650 : if( !usize ) { /* simple */
59 0 : wp[0] = v;
60 0 : wsize = v? 1:0;
61 : }
62 33650 : else if( !usign ) { /* mpi is not negative */
63 : mpi_limb_t cy;
64 33649 : cy = _gcry_mpih_add_1(wp, up, usize, v);
65 33649 : wp[usize] = cy;
66 33649 : wsize = usize + cy;
67 : }
68 : else { /* The signs are different. Need exact comparison to determine
69 : * which operand to subtract from which. */
70 1 : if( usize == 1 && up[0] < v ) {
71 0 : wp[0] = v - up[0];
72 0 : wsize = 1;
73 : }
74 : else {
75 1 : _gcry_mpih_sub_1(wp, up, usize, v);
76 : /* Size can decrease with at most one limb. */
77 1 : wsize = usize - (wp[usize-1]==0);
78 1 : wsign = 1;
79 : }
80 : }
81 :
82 33650 : w->nlimbs = wsize;
83 33650 : w->sign = wsign;
84 33650 : }
85 :
86 :
87 : void
88 36044298 : _gcry_mpi_add(gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v)
89 : {
90 : mpi_ptr_t wp, up, vp;
91 : mpi_size_t usize, vsize, wsize;
92 : int usign, vsign, wsign;
93 :
94 36044298 : if( u->nlimbs < v->nlimbs ) { /* Swap U and V. */
95 1074675 : usize = v->nlimbs;
96 1074675 : usign = v->sign;
97 1074675 : vsize = u->nlimbs;
98 1074675 : vsign = u->sign;
99 1074675 : wsize = usize + 1;
100 1074675 : RESIZE_IF_NEEDED(w, wsize);
101 : /* These must be after realloc (u or v may be the same as w). */
102 1074675 : up = v->d;
103 1074675 : vp = u->d;
104 : }
105 : else {
106 34969623 : usize = u->nlimbs;
107 34969623 : usign = u->sign;
108 34969623 : vsize = v->nlimbs;
109 34969623 : vsign = v->sign;
110 34969623 : wsize = usize + 1;
111 34969623 : RESIZE_IF_NEEDED(w, wsize);
112 : /* These must be after realloc (u or v may be the same as w). */
113 34969623 : up = u->d;
114 34969623 : vp = v->d;
115 : }
116 36044298 : wp = w->d;
117 36044298 : wsign = 0;
118 :
119 36044298 : if( !vsize ) { /* simple */
120 78768 : MPN_COPY(wp, up, usize );
121 78768 : wsize = usize;
122 78768 : wsign = usign;
123 : }
124 35965530 : else if( usign != vsign ) { /* different sign */
125 : /* This test is right since USIZE >= VSIZE */
126 25494800 : if( usize != vsize ) {
127 1044110 : _gcry_mpih_sub(wp, up, usize, vp, vsize);
128 1044110 : wsize = usize;
129 1044110 : MPN_NORMALIZE(wp, wsize);
130 1044110 : wsign = usign;
131 : }
132 24450690 : else if( _gcry_mpih_cmp(up, vp, usize) < 0 ) {
133 14204602 : _gcry_mpih_sub_n(wp, vp, up, usize);
134 14204602 : wsize = usize;
135 14204602 : MPN_NORMALIZE(wp, wsize);
136 14204602 : if( !usign )
137 7616103 : wsign = 1;
138 : }
139 : else {
140 10246088 : _gcry_mpih_sub_n(wp, up, vp, usize);
141 10246088 : wsize = usize;
142 10246088 : MPN_NORMALIZE(wp, wsize);
143 10246088 : if( usign )
144 25484 : wsign = 1;
145 : }
146 : }
147 : else { /* U and V have same sign. Add them. */
148 10470730 : mpi_limb_t cy = _gcry_mpih_add(wp, up, usize, vp, vsize);
149 10470730 : wp[usize] = cy;
150 10470730 : wsize = usize + cy;
151 10470730 : if( usign )
152 25666 : wsign = 1;
153 : }
154 :
155 36044298 : w->nlimbs = wsize;
156 36044298 : w->sign = wsign;
157 36044298 : }
158 :
159 :
160 : /****************
161 : * Subtract the unsigned integer V from the mpi-integer U and store the
162 : * result in W.
163 : */
164 : void
165 17633 : _gcry_mpi_sub_ui(gcry_mpi_t w, gcry_mpi_t u, unsigned long v )
166 : {
167 : mpi_ptr_t wp, up;
168 : mpi_size_t usize, wsize;
169 : int usign, wsign;
170 :
171 17633 : usize = u->nlimbs;
172 17633 : usign = u->sign;
173 17633 : wsign = 0;
174 :
175 : /* If not space for W (and possible carry), increase space. */
176 17633 : wsize = usize + 1;
177 17633 : if( w->alloced < wsize )
178 4306 : mpi_resize(w, wsize);
179 :
180 : /* These must be after realloc (U may be the same as W). */
181 17633 : up = u->d;
182 17633 : wp = w->d;
183 :
184 17633 : if( !usize ) { /* simple */
185 1 : wp[0] = v;
186 1 : wsize = v? 1:0;
187 1 : wsign = 1;
188 : }
189 17632 : else if( usign ) { /* mpi and v are negative */
190 : mpi_limb_t cy;
191 0 : cy = _gcry_mpih_add_1(wp, up, usize, v);
192 0 : wp[usize] = cy;
193 0 : wsize = usize + cy;
194 : }
195 : else { /* The signs are different. Need exact comparison to determine
196 : * which operand to subtract from which. */
197 17632 : if( usize == 1 && up[0] < v ) {
198 0 : wp[0] = v - up[0];
199 0 : wsize = 1;
200 0 : wsign = 1;
201 : }
202 : else {
203 17632 : _gcry_mpih_sub_1(wp, up, usize, v);
204 : /* Size can decrease with at most one limb. */
205 17632 : wsize = usize - (wp[usize-1]==0);
206 : }
207 : }
208 :
209 17633 : w->nlimbs = wsize;
210 17633 : w->sign = wsign;
211 17633 : }
212 :
213 : void
214 18655965 : _gcry_mpi_sub(gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v)
215 : {
216 18655965 : gcry_mpi_t vv = mpi_copy (v);
217 18655965 : vv->sign = ! vv->sign;
218 18655965 : mpi_add (w, u, vv);
219 18655965 : mpi_free (vv);
220 18655965 : }
221 :
222 :
223 : void
224 1191 : _gcry_mpi_addm( gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v, gcry_mpi_t m)
225 : {
226 1191 : mpi_add (w, u, v);
227 1191 : mpi_mod (w, w, m);
228 1191 : }
229 :
230 : void
231 46 : _gcry_mpi_subm( gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v, gcry_mpi_t m)
232 : {
233 46 : mpi_sub (w, u, v);
234 46 : mpi_mod (w, w, m);
235 46 : }
|
