ope 0.1.1

This is an Order-preserving encryption (OPE) lib inspired by cryptdb's ope implementation.
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

use alloc::string::ToString;

use crate::hgd::hgd;
use crate::prng::{BlockCipher, Prng};
use crate::utils::{hmac, sha};
use crate::{OpeError, OpeKey};

struct OpeDomainRange
{
	d: u64,
	r_lo: u64,
	r_hi: u64,
}

impl OpeDomainRange
{
	pub fn new(d: u64, r_lo: u64, r_hi: u64) -> Self
	{
		Self {
			d,
			r_lo,
			r_hi,
		}
	}
}

fn domain_gap(ndomain: u64, nrange: u64, rgap: u64, prng: &mut impl Prng) -> Result<u64, OpeError>
{
	hgd(rgap, ndomain, nrange - ndomain, prng)
}

pub struct Ope<'a>
{
	key: &'a OpeKey,
	pbits: u64,
	cbits: u64,
}

impl<'a> Ope<'a>
{
	pub fn new(key: &'a OpeKey, plainbits: u64, cipherbits: u64) -> Self
	{
		Self {
			key,
			pbits: plainbits,
			cbits: cipherbits,
		}
	}

	fn lazy_sample(&self, d_lo: u64, d_hi: u64, r_lo: u64, r_hi: u64, plaintext: u64, prng: &mut BlockCipher) -> Result<OpeDomainRange, OpeError>
	{
		let ndomain = d_hi - d_lo + 1;
		let nrange = r_hi - r_lo + 1;

		if nrange < ndomain {
			return Err(OpeError::OpeRange);
		}

		if ndomain == 1 {
			return Ok(OpeDomainRange::new(d_lo, r_lo, r_hi));
		}

		/*
		 * Deterministically reset the PRNG counter, regardless of
		 * whether we had to use it for HGD or not in previous round.
		 */
		let s = d_lo.to_string() + "/" + &d_hi.to_string() + "/" + &r_lo.to_string() + "/" + &r_hi.to_string();
		let v = hmac(s.as_bytes(), self.key);
		prng.set_ctr(v);

		let rgap = nrange / 2;

		//TODO make cache
		let dgap = domain_gap(ndomain, nrange, nrange / 2, prng)?;

		if plaintext < (d_lo + dgap) {
			self.lazy_sample(d_lo, d_lo + dgap - 1, r_lo, r_lo + rgap - 1, plaintext, prng)
		} else {
			self.lazy_sample(d_lo + dgap, d_hi, r_lo + rgap, r_hi, plaintext, prng)
		}
	}

	fn search(&self, plaintext: u64) -> Result<OpeDomainRange, OpeError>
	{
		self.lazy_sample(
			0,
			self.pbits, //1 << self.pbits
			0,
			self.cbits, //1 << self.cbits
			plaintext,
			&mut BlockCipher::new(self.key),
		)
	}

	pub fn encrypt(&self, ptext: u64) -> Result<u64, OpeError>
	{
		let dr = self.search(ptext)?;

		let v = sha(ptext.to_string().as_bytes());

		let mut aesrand = BlockCipher::new(self.key);
		aesrand.set_ctr(v);

		let nrange = dr.r_hi - dr.r_lo + 1;

		Ok(dr.r_lo + aesrand.rand_int_mod(nrange))
	}

	pub fn decrypt(&self, ctext: u64) -> Result<u64, OpeError>
	{
		let dr = self.search(ctext)?;

		Ok(dr.d)
	}
}