indy_crypto/bn/
openssl.rs

1use errors::prelude::*;
2
3use int_traits::IntTraits;
4
5use openssl::bn::{BigNum, BigNumRef, BigNumContext, MsbOption};
6use openssl::hash::{hash, MessageDigest, Hasher};
7use openssl::error::ErrorStack;
8
9#[cfg(feature = "serialization")]
10use serde::ser::{Serialize, Serializer, Error as SError};
11
12#[cfg(feature = "serialization")]
13use serde::de::{Deserialize, Deserializer, Visitor, Error as DError};
14
15use std::fmt;
16use std::cmp::Ord;
17use std::cmp::Ordering;
18
19pub struct BigNumberContext {
20    openssl_bn_context: BigNumContext
21}
22
23#[derive(Debug)]
24pub struct BigNumber {
25    openssl_bn: BigNum
26}
27
28impl BigNumber {
29    pub fn new_context() -> IndyCryptoResult<BigNumberContext> {
30        let ctx = BigNumContext::new()?;
31        Ok(BigNumberContext {
32            openssl_bn_context: ctx
33        })
34    }
35
36    pub fn new() -> IndyCryptoResult<BigNumber> {
37        let bn = BigNum::new()?;
38        Ok(BigNumber {
39            openssl_bn: bn
40        })
41    }
42
43    pub fn generate_prime(size: usize) -> IndyCryptoResult<BigNumber> {
44        let mut bn = BigNumber::new()?;
45        BigNumRef::generate_prime(&mut bn.openssl_bn, size as i32, false, None, None)?;
46        Ok(bn)
47    }
48
49    pub fn generate_safe_prime(size: usize) -> IndyCryptoResult<BigNumber> {
50        let mut bn = BigNumber::new()?;
51        BigNumRef::generate_prime(&mut bn.openssl_bn, (size + 1) as i32, true, None, None)?;
52        Ok(bn)
53    }
54
55    pub fn generate_prime_in_range(start: &BigNumber, end: &BigNumber) -> IndyCryptoResult<BigNumber> {
56        let mut prime;
57        let mut iteration = 0;
58        let mut bn_ctx = BigNumber::new_context()?;
59        let sub = end.sub(start)?;
60
61        loop {
62            prime = sub.rand_range()?;
63            prime = prime.add(start)?;
64
65            if prime.is_prime(Some(&mut bn_ctx))? {
66                debug!("Found prime in {} iteration", iteration);
67                break;
68            }
69            iteration += 1;
70        }
71
72        Ok(prime)
73    }
74
75    pub fn is_prime(&self, ctx: Option<&mut BigNumberContext>) -> IndyCryptoResult<bool> {
76        let prime_len = self.to_dec()?.len();
77        let checks = prime_len.log2() as i32;
78        match ctx {
79            Some(context) => Ok(self.openssl_bn.is_prime(checks, &mut context.openssl_bn_context)?),
80            None => {
81                let mut ctx = BigNumber::new_context()?;
82                Ok(self.openssl_bn.is_prime(checks, &mut ctx.openssl_bn_context)?)
83            }
84        }
85    }
86
87    pub fn is_safe_prime(&self, ctx: Option<&mut BigNumberContext>) -> IndyCryptoResult<bool> {
88
89        match ctx {
90            Some(c) => {
91                // according to https://eprint.iacr.org/2003/186.pdf
92                // a safe prime is congruent to 2 mod 3
93
94                // a safe prime satisfies (p-1)/2 is prime. Since a
95                // prime is odd, We just need to divide by 2
96                Ok(
97                    self.modulus(&BigNumber::from_u32(3)?, Some(c))? == BigNumber::from_u32(2)? &&
98                    self.is_prime(Some(c))? &&
99                    self.rshift1()?.is_prime(Some(c))?
100                )
101            },
102            None => {
103                let mut context = BigNumber::new_context()?;
104                self.is_safe_prime(Some(&mut context))
105            }
106        }
107    }
108
109    pub fn rand(size: usize) -> IndyCryptoResult<BigNumber> {
110        let mut bn = BigNumber::new()?;
111        BigNumRef::rand(&mut bn.openssl_bn, size as i32, MsbOption::MAYBE_ZERO, false)?;
112        Ok(bn)
113    }
114
115    pub fn rand_range(&self) -> IndyCryptoResult<BigNumber> {
116        let mut bn = BigNumber::new()?;
117        BigNumRef::rand_range(&self.openssl_bn, &mut bn.openssl_bn)?;
118        Ok(bn)
119    }
120
121    pub fn num_bits(&self) -> IndyCryptoResult<i32> {
122        Ok(self.openssl_bn.num_bits())
123    }
124
125    pub fn is_bit_set(&self, n: i32) -> IndyCryptoResult<bool> {
126        Ok(self.openssl_bn.is_bit_set(n))
127    }
128
129    pub fn set_bit(&mut self, n: i32) -> IndyCryptoResult<&mut BigNumber> {
130        BigNumRef::set_bit(&mut self.openssl_bn, n)?;
131        Ok(self)
132    }
133
134    pub fn from_u32(n: usize) -> IndyCryptoResult<BigNumber> {
135        let bn = BigNum::from_u32(n as u32)?;
136        Ok(BigNumber {
137            openssl_bn: bn
138        })
139    }
140
141    pub fn from_dec(dec: &str) -> IndyCryptoResult<BigNumber> {
142        let bn = BigNum::from_dec_str(dec)?;
143        Ok(BigNumber {
144            openssl_bn: bn
145        })
146    }
147
148    pub fn from_hex(hex: &str) -> IndyCryptoResult<BigNumber> {
149        let bn = BigNum::from_hex_str(hex)?;
150        Ok(BigNumber {
151            openssl_bn: bn
152        })
153    }
154
155    pub fn from_bytes(bytes: &[u8]) -> IndyCryptoResult<BigNumber> {
156        let bn = BigNum::from_slice(bytes)?;
157        Ok(BigNumber {
158            openssl_bn: bn
159        })
160    }
161
162    pub fn to_dec(&self) -> IndyCryptoResult<String> {
163        let result = self.openssl_bn.to_dec_str()?;
164        Ok(result.to_string())
165    }
166
167    pub fn to_hex(&self) -> IndyCryptoResult<String> {
168        let result = self.openssl_bn.to_hex_str()?;
169        Ok(result.to_string())
170    }
171
172    pub fn to_bytes(&self) -> IndyCryptoResult<Vec<u8>> {
173        Ok(self.openssl_bn.to_vec())
174    }
175
176    pub fn hash(data: &[u8]) -> IndyCryptoResult<Vec<u8>> {
177        Ok(hash(MessageDigest::sha256(), data)?.to_vec())
178    }
179
180    pub fn add(&self, a: &BigNumber) -> IndyCryptoResult<BigNumber> {
181        let mut bn = BigNumber::new()?;
182        BigNumRef::checked_add(&mut bn.openssl_bn, &self.openssl_bn, &a.openssl_bn)?;
183        Ok(bn)
184    }
185
186    pub fn sub(&self, a: &BigNumber) -> IndyCryptoResult<BigNumber> {
187        let mut bn = BigNumber::new()?;
188        BigNumRef::checked_sub(&mut bn.openssl_bn, &self.openssl_bn, &a.openssl_bn)?;
189        Ok(bn)
190    }
191
192    pub fn sqr(&self, ctx: Option<&mut BigNumberContext>) -> IndyCryptoResult<BigNumber> {
193        let mut bn = BigNumber::new()?;
194        match ctx {
195            Some(context) => BigNumRef::sqr(&mut bn.openssl_bn, &self.openssl_bn, &mut context.openssl_bn_context)?,
196            None => {
197                let mut ctx = BigNumber::new_context()?;
198                BigNumRef::sqr(&mut bn.openssl_bn, &self.openssl_bn, &mut ctx.openssl_bn_context)?;
199            }
200        }
201        Ok(bn)
202    }
203
204    pub fn mul(&self, a: &BigNumber, ctx: Option<&mut BigNumberContext>) -> IndyCryptoResult<BigNumber> {
205        let mut bn = BigNumber::new()?;
206        match ctx {
207            Some(context) => BigNumRef::checked_mul(&mut bn.openssl_bn, &self.openssl_bn, &a.openssl_bn, &mut context.openssl_bn_context)?,
208            None => {
209                let mut ctx = BigNumber::new_context()?;
210                BigNumRef::checked_mul(&mut bn.openssl_bn, &self.openssl_bn, &a.openssl_bn, &mut ctx.openssl_bn_context)?;
211            }
212        }
213        Ok(bn)
214    }
215
216    pub fn mod_mul(&self, a: &BigNumber, n: &BigNumber, ctx: Option<&mut BigNumberContext>) -> IndyCryptoResult<BigNumber> {
217        let mut bn = BigNumber::new()?;
218        match ctx {
219            Some(context) => BigNumRef::mod_mul(&mut bn.openssl_bn, &self.openssl_bn, &a.openssl_bn, &n.openssl_bn, &mut context.openssl_bn_context)?,
220            None => {
221                let mut ctx = BigNumber::new_context()?;
222                BigNumRef::mod_mul(&mut bn.openssl_bn, &self.openssl_bn, &a.openssl_bn, &n.openssl_bn, &mut ctx.openssl_bn_context)?;
223            }
224        }
225        Ok(bn)
226    }
227
228    pub fn mod_sub(&self, a: &BigNumber, n: &BigNumber, ctx: Option<&mut BigNumberContext>) -> IndyCryptoResult<BigNumber> {
229        let mut bn = BigNumber::new()?;
230        match ctx {
231            Some(context) => BigNumRef::mod_sub(&mut bn.openssl_bn, &self.openssl_bn, &a.openssl_bn, &n.openssl_bn, &mut context.openssl_bn_context)?,
232            None => {
233                let mut ctx = BigNumber::new_context()?;
234                BigNumRef::mod_sub(&mut bn.openssl_bn, &self.openssl_bn, &a.openssl_bn, &n.openssl_bn, &mut ctx.openssl_bn_context)?;
235            }
236        }
237        Ok(bn)
238    }
239
240    pub fn div(&self, a: &BigNumber, ctx: Option<&mut BigNumberContext>) -> IndyCryptoResult<BigNumber> {
241        let mut bn = BigNumber::new()?;
242        match ctx {
243            Some(context) => BigNumRef::checked_div(&mut bn.openssl_bn, &self.openssl_bn, &a.openssl_bn, &mut context.openssl_bn_context)?,
244            None => {
245                let mut ctx = BigNumber::new_context()?;
246                BigNumRef::checked_div(&mut bn.openssl_bn, &self.openssl_bn, &a.openssl_bn, &mut ctx.openssl_bn_context)?;
247            }
248        }
249        Ok(bn)
250    }
251
252    pub fn add_word(&mut self, w: u32) -> IndyCryptoResult<&mut BigNumber> {
253        BigNumRef::add_word(&mut self.openssl_bn, w)?;
254        Ok(self)
255    }
256
257    pub fn sub_word(&mut self, w: u32) -> IndyCryptoResult<&mut BigNumber> {
258        BigNumRef::sub_word(&mut self.openssl_bn, w)?;
259        Ok(self)
260    }
261
262    pub fn mul_word(&mut self, w: u32) -> IndyCryptoResult<&mut BigNumber> {
263        BigNumRef::mul_word(&mut self.openssl_bn, w)?;
264        Ok(self)
265    }
266
267    pub fn div_word(&mut self, w: u32) -> IndyCryptoResult<&mut BigNumber> {
268        BigNumRef::div_word(&mut self.openssl_bn, w)?;
269        Ok(self)
270    }
271
272    pub fn mod_exp(&self, a: &BigNumber, b: &BigNumber, ctx: Option<&mut BigNumberContext>) -> IndyCryptoResult<BigNumber> {
273        match ctx {
274            Some(context) => self._mod_exp(a, b, context),
275            None => {
276                let mut ctx = BigNumber::new_context()?;
277                self._mod_exp(a, b, &mut ctx)
278            }
279        }
280    }
281
282    fn _mod_exp(&self, a: &BigNumber, b: &BigNumber, ctx: &mut BigNumberContext) -> IndyCryptoResult<BigNumber> {
283        let mut bn = BigNumber::new()?;
284
285        if a.openssl_bn.is_negative() {
286            BigNumRef::mod_exp(&mut bn.openssl_bn, &self.inverse(b, Some(ctx))?.openssl_bn, &a.set_negative(false)?.openssl_bn, &b.openssl_bn, &mut ctx.openssl_bn_context)?;
287        } else {
288            BigNumRef::mod_exp(&mut bn.openssl_bn, &self.openssl_bn, &a.openssl_bn, &b.openssl_bn, &mut ctx.openssl_bn_context)?;
289        };
290        Ok(bn)
291    }
292
293    pub fn modulus(&self, a: &BigNumber, ctx: Option<&mut BigNumberContext>) -> IndyCryptoResult<BigNumber> {
294        let mut bn = BigNumber::new()?;
295        match ctx {
296            Some(context) => BigNumRef::nnmod(&mut bn.openssl_bn, &self.openssl_bn, &a.openssl_bn, &mut context.openssl_bn_context)?,
297            None => {
298                let mut ctx = BigNumber::new_context()?;
299                BigNumRef::nnmod(&mut bn.openssl_bn, &self.openssl_bn, &a.openssl_bn, &mut ctx.openssl_bn_context)?;
300            }
301        }
302        Ok(bn)
303    }
304
305    pub fn exp(&self, a: &BigNumber, ctx: Option<&mut BigNumberContext>) -> IndyCryptoResult<BigNumber> {
306        let mut bn = BigNumber::new()?;
307        match ctx {
308            Some(context) => BigNumRef::exp(&mut bn.openssl_bn, &self.openssl_bn, &a.openssl_bn, &mut context.openssl_bn_context)?,
309            None => {
310                let mut ctx = BigNumber::new_context()?;
311                BigNumRef::exp(&mut bn.openssl_bn, &self.openssl_bn, &a.openssl_bn, &mut ctx.openssl_bn_context)?;
312            }
313        }
314        Ok(bn)
315    }
316
317    pub fn inverse(&self, n: &BigNumber, ctx: Option<&mut BigNumberContext>) -> IndyCryptoResult<BigNumber> {
318        let mut bn = BigNumber::new()?;
319        match ctx {
320            Some(context) => BigNumRef::mod_inverse(&mut bn.openssl_bn, &self.openssl_bn, &n.openssl_bn, &mut context.openssl_bn_context)?,
321            None => {
322                let mut ctx = BigNumber::new_context()?;
323                BigNumRef::mod_inverse(&mut bn.openssl_bn, &self.openssl_bn, &n.openssl_bn, &mut ctx.openssl_bn_context)?;
324            }
325        }
326        Ok(bn)
327    }
328
329    pub fn set_negative(&self, negative: bool) -> IndyCryptoResult<BigNumber> {
330        let mut bn = BigNum::from_slice(&self.openssl_bn.to_vec())?;
331        bn.set_negative(negative);
332        Ok(BigNumber {
333            openssl_bn: bn
334        })
335    }
336
337    pub fn is_negative(&self) -> bool {
338        self.openssl_bn.is_negative()
339    }
340
341    pub fn increment(&self) -> IndyCryptoResult<BigNumber> {
342        let mut bn = BigNum::from_slice(&self.openssl_bn.to_vec())?;
343        bn.add_word(1)?;
344        Ok(BigNumber {
345            openssl_bn: bn
346        })
347    }
348
349    pub fn decrement(&self) -> IndyCryptoResult<BigNumber> {
350        let mut bn = BigNum::from_slice(&self.openssl_bn.to_vec())?;
351        bn.sub_word(1)?;
352        Ok(BigNumber {
353            openssl_bn: bn
354        })
355    }
356
357    pub fn lshift1(&self) -> IndyCryptoResult<BigNumber> {
358        let mut bn = BigNumber::new()?;
359        BigNumRef::lshift1(&mut bn.openssl_bn, &self.openssl_bn)?;
360        Ok(bn)
361    }
362
363    pub fn rshift1(&self) -> IndyCryptoResult<BigNumber> {
364        let mut bn = BigNumber::new()?;
365        BigNumRef::rshift1(&mut bn.openssl_bn, &self.openssl_bn)?;
366        Ok(bn)
367    }
368
369    pub fn rshift(&self, n: i32) -> IndyCryptoResult<BigNumber> {
370        let mut bn = BigNumber::new()?;
371        BigNumRef::rshift(&mut bn.openssl_bn, &self.openssl_bn, n)?;
372        Ok(bn)
373    }
374
375    pub fn mod_div(&self, b: &BigNumber, p: &BigNumber, ctx: Option<&mut BigNumberContext>) -> IndyCryptoResult<BigNumber> {
376        //(a * (1/b mod p) mod p)
377        match ctx {
378            Some(mut context) => self._mod_div(b, p, &mut context),
379            None => {
380                let mut context = BigNumber::new_context()?;
381                self._mod_div(b, p, &mut context)
382            }
383        }
384    }
385
386    ///(a * (1/b mod p) mod p)
387    fn _mod_div(&self, b: &BigNumber, p: &BigNumber, ctx: &mut BigNumberContext)-> IndyCryptoResult<BigNumber> {
388        let mut bn = BigNumber::new()?;
389        BigNumRef::mod_mul(&mut bn.openssl_bn, &self.openssl_bn,
390                           &b.inverse(p, Some(ctx))?.openssl_bn,
391                           &p.openssl_bn, &mut ctx.openssl_bn_context)?;
392        Ok(bn)
393    }
394
395    pub fn random_qr(n: &BigNumber) -> IndyCryptoResult<BigNumber> {
396        let qr = n
397            .rand_range()?
398            .sqr(None)?
399            .modulus(&n, None)?;
400        Ok(qr)
401    }
402
403    pub fn clone(&self) -> IndyCryptoResult<BigNumber> {
404        let mut openssl_bn = BigNum::from_slice(&self.openssl_bn.to_vec()[..])?;
405        openssl_bn.set_negative(self.is_negative());
406        Ok(BigNumber {
407            openssl_bn
408        })
409    }
410
411    pub fn hash_array(nums: &Vec<Vec<u8>>) -> IndyCryptoResult<Vec<u8>> {
412        let mut sha256 = Hasher::new(MessageDigest::sha256())?;
413
414        for num in nums.iter() {
415            sha256.update(&num)?;
416        }
417
418        Ok(sha256.finish()?.to_vec())
419    }
420}
421
422impl Ord for BigNumber {
423    fn cmp(&self, other: &BigNumber) -> Ordering {
424        self.openssl_bn.cmp(&other.openssl_bn)
425    }
426}
427
428impl Eq for BigNumber {}
429
430impl PartialOrd for BigNumber {
431    fn partial_cmp(&self, other: &BigNumber) -> Option<Ordering> {
432        Some(self.cmp(other))
433    }
434}
435
436impl PartialEq for BigNumber {
437    fn eq(&self, other: &BigNumber) -> bool {
438        self.openssl_bn == other.openssl_bn
439    }
440}
441
442#[cfg(feature = "serialization")]
443impl Serialize for BigNumber {
444    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
445        serializer.serialize_newtype_struct("BigNumber", &self.to_dec().map_err(SError::custom)?)
446    }
447}
448
449#[cfg(feature = "serialization")]
450impl<'a> Deserialize<'a> for BigNumber {
451    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'a> {
452        struct BigNumberVisitor;
453
454        impl<'a> Visitor<'a> for BigNumberVisitor {
455            type Value = BigNumber;
456
457            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
458                formatter.write_str("expected BigNumber")
459            }
460
461            fn visit_str<E>(self, value: &str) -> Result<BigNumber, E>
462                where E: DError
463            {
464                Ok(BigNumber::from_dec(value).map_err(DError::custom)?)
465            }
466        }
467
468        deserializer.deserialize_str(BigNumberVisitor)
469    }
470}
471
472impl From<ErrorStack> for IndyCryptoError {
473    fn from(err: ErrorStack) -> Self {
474        // TODO: FIXME: Analyze ErrorStack and split invalid structure errors from other errors
475        err.to_indy(IndyCryptoErrorKind::InvalidState, "Internal OpenSSL error")
476    }
477}
478
479impl Default for BigNumber {
480    fn default() -> BigNumber {
481        BigNumber::from_u32(0).unwrap()
482    }
483}
484
485// Constants that are used throughout the code, so avoiding recomputation.
486lazy_static! {
487    pub static ref BIGNUMBER_1: BigNumber = BigNumber::from_u32(1).unwrap();
488    pub static ref BIGNUMBER_2: BigNumber = BigNumber::from_u32(2).unwrap();
489}
490
491#[cfg(test)]
492mod tests {
493    use super::*;
494
495    use serde_json;
496
497    const RANGE_LEFT: usize = 592;
498    const RANGE_RIGHT: usize = 592;
499
500    #[test]
501    #[ignore] //TODO check
502    fn generate_prime_in_range_works() {
503        let start = BigNumber::rand(RANGE_LEFT).unwrap();
504        let end = BigNumber::rand(RANGE_RIGHT).unwrap();
505        let random_prime = BigNumber::generate_prime_in_range(&start, &end).unwrap();
506        assert!(start < random_prime);
507        assert!(end > random_prime);
508    }
509
510    #[test]
511    fn is_prime_works() {
512        let primes:Vec<u64> = vec![2, 23, 31, 42885908609, 24473809133, 47055833459];
513        for pr in primes {
514            let num = BigNumber::from_dec(&pr.to_string()).unwrap();
515            assert!(num.is_prime(None).unwrap());
516        }
517        let num = BigNumber::from_dec("36").unwrap();
518        assert!(!num.is_prime(None).unwrap());
519
520        let mut n128 = BigNumber::new().unwrap();
521        BigNumRef::generate_prime(&mut n128.openssl_bn, 128, false, None, None).unwrap();
522        assert!(n128.is_prime(None).unwrap());
523        let mut n256 = BigNumber::new().unwrap();
524        BigNumRef::generate_prime(&mut n256.openssl_bn, 256, false, None, None).unwrap();
525        assert!(n256.is_prime(None).unwrap());
526
527        let vec1 = vec![9, 252, 51, 8, 129]; // big endian representation of 42885908609
528        let v1 = BigNumber::from_bytes(&vec1).unwrap();
529        assert!(v1.is_prime(None).unwrap());
530        let vec2 = vec![129, 8, 51, 252, 9]; // little endian representation of 42885908609
531        let v2 = BigNumber::from_bytes(&vec2).unwrap();
532        assert!(!v2.is_prime(None).unwrap());
533        let vec3 = vec![1, 153, 25]; // big endian representation of 104729
534        let v3 = BigNumber::from_bytes(&vec3).unwrap();
535        assert!(v3.is_prime(None).unwrap());
536    }
537
538    #[test]
539    fn test_modular_exponentiation() {
540        let base = BigNumber::from_dec("12714671911903680502393098440562958150461307840092575886187217264492970515611166458444182780904860535776274190597528985988632488194981204988199325501696648896748368401254829974173258613724800116424602180755019588176641580062215499750550535543002990347313784260314641340394494547935943176226649412526659864646068220114536172189443925908781755710141006387091748541976715633668919725277837668568166444731358541327097786024076841158424402136565558677098853060675674958695935207345864359540948421232816012865873346545455513695413921957708811080877422273777355768568166638843699798663264533662595755767287970642902713301649").unwrap();
541        let exp = BigNumber::from_dec("13991423645225256679625502829143442357836305738777175327623021076136862973228390317258480888217725740262243618881809894688804251512223982403225288178492105393953431042196371492402144120299046493467608097411259757604892535967240041988260332063962457178993277482991886508015739613530825229685281072180891075265116698114782553748364913010741387964956740720544998915158970813171997488129859542399633104746793770216517872705889857552727967921847493285577238").unwrap();
542        let modulus = BigNumber::from_dec("991272771610724400277702356109350334773782112020672787325464582894874455338156617087078683660308327009158085342465983713825070967004447592080649030930737560915527173820649490032274245863850782844569456999473516497618489127293328524608584652323593452247534656999363158875176879817952982494174728640545484193154314433925648566686738628413929222467005197087738850212963801663981588243042912430590088435419451359859770426041670326127890520192033283832465411962274045956439947646966560440910244870464709982605844468449227905039953511431640780483761563845223213570597106855699997837768334871601402132694515676785338799407204529154456178837013845488372635042715003769626150545960460800980936426723680755798495767188398126674428244764038147226578038085253616108968402209263400729503458144370189359160926796812468410806201905992347006546335038212090539118675048292666041345556742530041533878341459110515497642054583635133581316796089099043782055893003258788369004899742992039315008110063759802733045648131896557338576682560236591353394201381103042167106112201578883917022695113857967398885475101031596068885337186646296664517159150904935112836318654117577507707562065113238913343761942585545093919444150946120523831367132144754209388110483749").unwrap();
543        let n = base.mod_exp(&exp, &modulus, None).unwrap();
544        assert_eq!(n, BigNumber::from_dec("156669382818249607878298589043381544147555658222157929549484054385620519150887267126359684884641035264854247223281407349108771361611707714806192334779156374961296686821846487267487447347213829476609283133961216115764596907219173912888367998704856300105745961091899745329082513615681466199188236178266479183520370119131067362815102553237342546358580424556049196548520326206809677290296313839918774603549816182657993044271509706055893922152644469350618465711055733369291523796837304622919600074130968607301641438272377350795631212741686475924538423333008944556761300787668873766797549942827958501053262330421256183088509761636226277739400954175538503984519144969688787730088704522060486181427528150632576628856946041322195818246199503927686629821338146828603690778689292695518745939007886131151503766930229761608131819298276772877945842806872426029069949874062579870088710097070526608376602732627661781899595747063793310401032556802468649888104062151213860356554306295111191704764944574687548637446778783560586599000631975868701382113259027374431129732911012887214749014288413818636520182416636289308770657630129067046301651835893708731812616847614495049523221056260334965662875649480493232265453415256612460815802528012166114764216881").unwrap());
545
546        let base = BigNumber::from_u32(6).unwrap();
547        let exp = BigNumber::from_u32(5).unwrap().set_negative(true).unwrap();
548        let modulus = BigNumber::from_u32(13).unwrap();
549        assert_eq!(BigNumber::from_u32(7).unwrap(), base.mod_exp(&exp, &modulus, None).unwrap());
550    }
551
552    #[test]
553    #[ignore]
554    fn is_safe_prime_works() {
555        let prime1 = BigNumber::generate_safe_prime(256).unwrap();
556        let prime2 = BigNumber::generate_safe_prime(1024).unwrap();
557        assert!(prime1.is_safe_prime(None).unwrap());
558        assert!(prime2.is_safe_prime(None).unwrap());
559    }
560
561    #[test]
562    #[ignore] //TODO Expensive test, only run to generate public params
563    fn is_safe_prime_works_for_large_prime() {
564        let prime = BigNumber::generate_safe_prime(4096).unwrap();
565        assert!(prime.is_safe_prime(None).unwrap());
566    }
567
568    #[test]
569    fn decrement_works() {
570        let num = BigNumber::from_u32(1000).unwrap();
571        assert_eq!(num.decrement().unwrap(), num.sub(&BIGNUMBER_1).unwrap());
572    }
573
574    #[test]
575    fn increment_works() {
576        let num = BigNumber::from_u32(1000).unwrap();
577        assert_eq!(num.increment().unwrap(), num.add(&BIGNUMBER_1).unwrap());
578    }
579
580    #[test]
581    fn rshift1_works() {
582        let num = BigNumber::from_u32(1000).unwrap();
583        assert_eq!(num.rshift1().unwrap(), BigNumber::from_u32(500).unwrap());
584    }
585
586    #[test]
587    fn rshift_works() {
588        let num = BigNumber::from_u32(1024).unwrap();
589        assert_eq!(num.rshift(1).unwrap(), BigNumber::from_u32(512).unwrap());
590        assert_eq!(num.rshift(2).unwrap(), BigNumber::from_u32(256).unwrap());
591        assert_eq!(num.rshift(3).unwrap(), BigNumber::from_u32(128).unwrap());
592        assert_eq!(num.rshift(4).unwrap(), BigNumber::from_u32(64).unwrap());
593    }
594
595    #[test]
596    fn lshift1_works() {
597        let num = BigNumber::from_u32(1000).unwrap();
598        assert_eq!(num.lshift1().unwrap(), BigNumber::from_u32(2000).unwrap());
599    }
600
601    #[test]
602    fn clone_negative_works() {
603        let num = BigNumber::from_dec("-1").unwrap();
604        let num_cloned = num.clone().unwrap();
605        assert_eq!(num, num_cloned);
606    }
607
608    #[cfg(feature = "serialization")]
609    #[derive(Serialize, Deserialize)]
610    struct Test {
611        field: BigNumber
612    }
613
614    #[cfg(feature = "serialization")]
615    #[test]
616    fn serialize_works() {
617        let s = Test { field: BigNumber::from_dec("1").unwrap() };
618        let serialized = serde_json::to_string(&s);
619
620        assert!(serialized.is_ok());
621        assert_eq!("{\"field\":\"1\"}", serialized.unwrap());
622    }
623
624    #[cfg(feature = "serialization")]
625    #[test]
626    fn deserialize_works() {
627        let s = "{\"field\":\"1\"}";
628        let bn: Result<Test, _> = serde_json::from_str(&s);
629
630        assert!(bn.is_ok());
631        assert_eq!("1", bn.unwrap().field.to_dec().unwrap());
632    }
633}
indy_crypto/bn/openssl.rs

indy_crypto/bn/
openssl.rs
