Primality testing

libindy-crypto/src/bn/openssl.rs

@@ -401,6 +401,34 @@ mod tests {
         assert!(end > random_prime);
     }
 
+    #[test]
+    fn is_prime_works() {
+        let primes:Vec<u64> = vec![2, 23, 31, 42885908609, 24473809133, 47055833459];
+        for pr in primes {
+            let num = BigNumber::from_dec(&pr.to_string()).unwrap();
+            assert!(num.is_prime(None).unwrap());
+        }
+        let num = BigNumber::from_dec("36").unwrap();
+        assert!(!num.is_prime(None).unwrap());
+
+        let mut n128 = BigNumber::new().unwrap();
+        BigNumRef::generate_prime(&mut n128.openssl_bn, 128, false, None, None).unwrap();
+        assert!(n128.is_prime(None).unwrap());
+        let mut n256 = BigNumber::new().unwrap();
+        BigNumRef::generate_prime(&mut n256.openssl_bn, 256, false, None, None).unwrap();
+        assert!(n256.is_prime(None).unwrap());
+
+        let vec1 = vec![9, 252, 51, 8, 129]; // big endian representation of 42885908609
+        let v1 = BigNumber::from_bytes(&vec1).unwrap();
+        assert!(v1.is_prime(None).unwrap());
+        let vec2 = vec![129, 8, 51, 252, 9]; // little endian representation of 42885908609
+        let v2 = BigNumber::from_bytes(&vec2).unwrap();
+        assert!(!v2.is_prime(None).unwrap());
+        let vec3 = vec![1, 153, 25]; // big endian representation of 104729
+        let v3 = BigNumber::from_bytes(&vec3).unwrap();
+        assert!(v3.is_prime(None).unwrap());
+    }
+
     #[cfg(feature = "serialization")]
     #[derive(Serialize, Deserialize)]
     struct Test {

libindy-crypto/src/ffi/bn.rs

@@ -0,0 +1,78 @@
+use bn::BigNumber;
+
+use ffi::ErrorCode;
+use errors::ToErrorCode;
+use std::slice;
+
+#[no_mangle]
+pub extern fn indy_crypto_primality_check(big_endian_number: *const u8,
+                                          size_in_bytes: usize,
+                                          is_prime: *mut bool) -> ErrorCode {
+    trace!("indy_crypto_primality_check: >>> big_endian_number: {:?}, size_in_bytes: {:?}, is_prime: {:?}", big_endian_number, size_in_bytes, is_prime);
+    println!("before {:?}", big_endian_number);
+    check_useful_c_byte_array!(big_endian_number, size_in_bytes, ErrorCode::CommonInvalidParam1, ErrorCode::CommonInvalidParam2);
+    check_useful_c_ptr!(is_prime, ErrorCode::CommonInvalidParam3);
+
+    trace!("indy_crypto_primality_check: big_endian_number: {:?}, size_in_bytes: {:?}, is_prime: {:?}", big_endian_number, size_in_bytes, is_prime);
+
+    println!("after {:?}", big_endian_number);
+    let res = match BigNumber::from_bytes(&big_endian_number) {
+        Ok(big_number) => {
+            match big_number.is_prime(None) {
+                Ok(valid) => {
+                    println!("{:?}", big_number);
+                    println!("to bytes {:?}", big_number.to_bytes());
+                    trace!("indy_crypto_primality_check: big_endian_number: {:?}", big_number);
+                    unsafe { *is_prime = valid; }
+                    ErrorCode::Success
+                }
+                Err(err) => err.to_error_code()
+            }
+
+        }
+        Err(err) => err.to_error_code()
+    };
+
+    trace!("indy_crypto_primality_check: <<< res: {:?}", res);
+    res
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn indy_crypto_primality_check_works() {
+        let number1 = vec![29];
+        let mut valid = false;
+        let err_code = indy_crypto_primality_check(number1.as_ptr(),1, &mut valid);
+        assert_eq!(err_code, ErrorCode::Success);
+        assert!(valid);
+
+        let number2 = vec![1, 153, 25]; // number 104729
+        let err_code = indy_crypto_primality_check(number2.as_ptr(), 3,&mut valid);
+        assert_eq!(err_code, ErrorCode::Success);
+        assert!(valid);
+
+        let number3 = vec![9, 252, 51, 8, 129];   // number 42885908609
+        let err_code = indy_crypto_primality_check(number3.as_ptr(),5, &mut valid);
+        assert_eq!(err_code, ErrorCode::Success);
+        assert!(valid);
+
+        let number4 = [116, 9, 191, 244, 10];   // number 47055833460
+        let err_code = indy_crypto_primality_check(number4.as_ptr(),5, &mut valid);
+        assert_eq!(err_code, ErrorCode::Success);
+        assert!(!valid);
+
+        let number6 = [204, 248, 234, 50, 24, 50, 123, 244, 109, 76, 16, 66, 12, 245, 54, 77];   // number 272454950813783527414999934504692692557
+        let err_code = indy_crypto_primality_check(number6.as_ptr(),16, &mut valid);
+        assert_eq!(err_code, ErrorCode::Success);
+        assert!(valid);
+
+//        let number5 = vec![175, 151, 131, 108, 102, 141, 162, 107, 99, 34, 90, 210, 161, 21, 95, 135, 74, 195, 151, 217, 185, 90, 220, 50, 204, 96, 223, 214, 10, 240, 182, 15].as_ptr();   // number 79422449460098942399106282402512198969536520971550757303162642879618420356623
+        let number5 = vec![175, 151, 131, 108, 102, 141, 162, 107, 99, 34, 90, 210, 161, 21, 95, 135, 74, 195, 151, 217, 185, 90, 220, 50, 204, 96, 223, 214, 10, 240, 182, 15];   // number 79422449460098942399106282402512198969536520971550757303162642879618420356623
+        let err_code = indy_crypto_primality_check(number5.as_ptr(),32, &mut valid);
+        assert_eq!(err_code, ErrorCode::Success);
+        assert!(valid);
+    }
+}

libindy-crypto/src/ffi/mod.rs

@@ -1,5 +1,6 @@
 pub mod cl;
 pub mod bls;
+pub mod bn;
 
 use env_logger;
 

libindy-crypto/src/utils/ctypes.rs

@@ -120,4 +120,4 @@ macro_rules! check_useful_c_str {
             return $e
         }
     }
-}
+}

wrappers/python/indy_crypto/__init__.py

@@ -1 +1 @@
-from indy_crypto.error import IndyCryptoError
+from indy_crypto.error import IndyCryptoError

wrappers/python/indy_crypto/big_number.py

@@ -0,0 +1,32 @@
+import logging
+import math
+from ctypes import c_bool, byref, c_int8
+
+from .lib import do_call
+
+
+class BigNumber:
+    @staticmethod
+    def is_prime(number) -> bool:
+        logger = logging.getLogger(__name__)
+        logger.debug(
+            "BigNumber::is_prime: >>> number: %r", number)
+
+        if not isinstance(number, int) or number < 1:
+            raise ValueError('Need a positive integer, not {}', number)
+
+        int_array = list(
+            number.to_bytes(math.ceil(number.bit_length() / 8),
+                            'big') or b'\0')
+        logger.debug("BigNumber::is_prime: <<< array is: %r", int_array)
+        array_size = len(int_array)
+        pointer = (c_int8 * array_size)(*int_array)
+        valid = c_bool()
+        do_call('indy_crypto_primality_check',
+                pointer,
+                array_size,
+                byref(valid))
+
+        res = valid
+        logger.debug("BigNumber::is_prime: <<< res: %r", res)
+        return res

wrappers/python/tests/conftest.py

@@ -1,3 +1,3 @@
 import logging
 
-logging.basicConfig(level=logging.DEBUG)
+logging.basicConfig(level=logging.DEBUG)

wrappers/python/tests/test_primality.py

@@ -0,0 +1,33 @@
+import pytest
+
+from indy_crypto.big_number import BigNumber
+
+
+def test_bad_input():
+    for n in [-90, 0, 2.2, 91.0]:
+        with pytest.raises(ValueError):
+            assert BigNumber.is_prime(n)
+
+
+def test_check_primes():
+    for number in [2, 23, 31, 263, 104729, 42885908609, 24473809133, 47055833459]:
+        assert BigNumber.is_prime(number), number
+
+
+def test_check_non_primes():
+    for number in [24, 42885908610, 24473809134, 47055833460]:
+        assert not BigNumber.is_prime(number), number
+
+
+def test_big_primes():
+    big_primes_256bit = [
+        79422449460098942399106282402512198969536520971550757303162642879618420356623,
+        111239814848601840476117025037343156956140807592049293111743976116251852031961,
+        110807377343103593013767585056169865297439509005813309754958294117148328724967
+    ]
+    for number in big_primes_256bit:
+        assert BigNumber.is_prime(number), number
+
+    for number in big_primes_256bit:
+        # Since each prime is odd, prime+1 will not be prime
+        assert not BigNumber.is_prime(number+1), number