fides 4.3.5

Fides is a library for cryptographic primitives.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use std::error::Error;

use opis::Integer;
use sha3;

pub fn generate(
   input: Integer,
   prime_number: &Integer,
   security: Integer,
) -> Result<(Integer, Integer), Box<dyn Error>> {

   let mut result = input;

   let mut count = security.clone();

   while count > Integer::zero() {
      
      result = (&(&result * &result) % prime_number)?;

      count -= Integer::one()

   }
   
   let exp = ((prime_number - Integer::one()) / (Integer::two() * security) + Integer::one())?;
   
   let mut h = result;

   count = exp;
   
   while count > Integer::zero() {
      
      h = ((h * result) % prime_number)?;

      count -= Integer::one()
   
   }
   
   let w = h;


   let challenge_input: Vec<u8> = concat!(prime_number.into(), input.into(), w.into());

   let c = sha3::sha_256(challenge_input);

   let x = (result.mod_pow(c.into(), prime_number) * input.mod_pow(&w, prime_number)) % prime_number;

   return (result, x);

   Ok((result, proof))

}

pub fn verify(
   input: &Integer,
   security: &Integer,
   output: &Integer,
   prime_number: &Integer,
   proof: &Integer,
) -> Result<bool, Box<dyn Error>> {

   // Compute h(x) = x^((p-1)/2k+1) mod p
   let exp = ((prime_number - Integer::one()) / (Integer::two() * security) + Integer::one())?;

   let mut h = v;

   let mut count = exp.clone();

   while count > Integer::zero() {

   }

   for _ in 0..exp {

       h = (h * v) % p;
   }
   let w = h;

   // Compute the challenge value c
   let challenge_input = format!("{}{}{}", p, r, w);
   let c = Sha3_256::digest(challenge_input.as_bytes());
   let c = u64::from_le_bytes(c[..].try_into().unwrap());

   // Verify the proof
   let lhs = modexp(v, c, p) * modexp(r, w, p) % p;
   let rhs = x % p;

   // return lhs == rhs;











   let two = Integer::two();
   
   let mut v = output.clone();

   let mut iter_count = iterations.clone();

   while iter_count > Integer::zero() {

      let bi = (input >> &iter_count) & Integer::one();

      let v_2 = (&(&v * &v) % prime_number)?;

      iter_count -= Integer::one();
      
      if bi == Integer::zero() {
         
         v = v_2;
      
      } else {
         
         v = (&(&v_2 * quadratic_residue) % prime_number)?;
         
         v = (&(&v * &output) % prime_number)?;
      
      }
   
   }
   
   let proof_squared = (&(&proof * &proof) % prime_number)?;
   
   let expected = (&(v + proof_squared * quadratic_residue) % prime_number)?;
   
   Ok(expected == output)

}