libpep 0.12.0

Library for polymorphic encryption and pseudonymization
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
134
135
136
137
138
139
140
141
142
143
144

use super::super::group_elements::{GroupElement, G};
use crate::arithmetic::py::PyScalarNonZero;
use derive_more::{Deref, From, Into};
use pyo3::prelude::*;
use pyo3::types::{PyAny, PyBytes};
use pyo3::Py;

/// Element on a group. Can not be converted to a scalar. Supports addition and subtraction. Multiplication by a scalar is supported.
/// We use ristretto points to discard unsafe points and safely use the group operations in higher level protocols without any other cryptographic assumptions.
#[derive(Copy, Clone, Eq, PartialEq, Debug, From, Into, Deref)]
#[pyclass(name = "GroupElement", from_py_object)]
pub struct PyGroupElement(pub(crate) GroupElement);

#[pymethods]
impl PyGroupElement {
    /// Encodes the group element as a 32-byte array.
    #[pyo3(name = "to_bytes")]
    fn encode(&self, py: Python) -> Py<PyAny> {
        PyBytes::new(py, &self.0.to_bytes()).into()
    }

    /// Decodes a group element from a 32-byte array.
    #[staticmethod]
    #[pyo3(name = "from_bytes")]
    fn decode(bytes: &[u8]) -> PyResult<Option<PyGroupElement>> {
        Ok(GroupElement::from_slice(bytes).map(PyGroupElement))
    }

    /// Generates a random group element.
    #[staticmethod]
    #[pyo3(name = "random")]
    fn random() -> PyGroupElement {
        GroupElement::random(&mut rand::rng()).into()
    }

    /// Decodes a group element from a 64-byte hash.
    #[staticmethod]
    #[pyo3(name = "from_hash")]
    fn from_hash(v: &[u8]) -> PyResult<PyGroupElement> {
        if v.len() != 64 {
            return Err(pyo3::exceptions::PyValueError::new_err(
                "Hash must be 64 bytes",
            ));
        }
        let mut arr = [0u8; 64];
        arr.copy_from_slice(v);
        Ok(GroupElement::from_hash(&arr).into())
    }

    /// Decodes a group element from a hexadecimal string of 64 characters.
    #[staticmethod]
    #[pyo3(name = "from_hex")]
    fn from_hex(hex: &str) -> Option<PyGroupElement> {
        GroupElement::from_hex(hex).map(PyGroupElement)
    }

    /// Encodes the group element as a hexadecimal string of 64 characters.
    #[pyo3(name = "to_hex")]
    fn as_hex(&self) -> String {
        self.0.to_hex()
    }

    /// Decode from a byte array of length 16 using lizard encoding.
    #[staticmethod]
    #[pyo3(name = "from_lizard")]
    fn from_lizard(data: &[u8]) -> PyResult<Self> {
        if data.len() != 16 {
            return Err(pyo3::exceptions::PyValueError::new_err(
                "Data must be 16 bytes",
            ));
        }
        let mut arr = [0u8; 16];
        arr.copy_from_slice(data);
        Ok(Self(GroupElement::from_lizard(&arr)))
    }

    /// Encode as a byte array of length 16 using lizard encoding.
    /// Returns `None` if the point is not a valid lizard encoding of a 16-byte value.
    #[pyo3(name = "to_lizard")]
    fn encode_lizard(&self, py: Python) -> Option<Py<PyAny>> {
        self.0.to_lizard().map(|x| PyBytes::new(py, &x).into())
    }

    /// Returns the identity element of the group.
    #[staticmethod]
    #[pyo3(name = "identity")]
    fn identity() -> PyGroupElement {
        GroupElement::identity().into()
    }

    /// Returns the generator of the group.
    #[staticmethod]
    #[pyo3(name = "generator")]
    fn generator() -> PyGroupElement {
        G.into()
    }

    /// Adds two group elements.
    #[pyo3(name = "add")]
    fn add(&self, other: &PyGroupElement) -> PyGroupElement {
        PyGroupElement(self.0 + other.0)
    }

    /// Subtracts two group elements.
    #[pyo3(name = "sub")]
    fn sub(&self, other: &PyGroupElement) -> PyGroupElement {
        PyGroupElement(self.0 - other.0)
    }

    /// Multiplies a group element by a scalar.
    #[pyo3(name = "mul")]
    fn mul(&self, other: &PyScalarNonZero) -> PyGroupElement {
        (other.0 * self.0).into() // Only possible if the scalar is non-zero
    }

    fn __add__(&self, other: &PyGroupElement) -> PyGroupElement {
        self.add(other)
    }

    fn __sub__(&self, other: &PyGroupElement) -> PyGroupElement {
        self.sub(other)
    }

    fn __mul__(&self, other: &PyScalarNonZero) -> PyGroupElement {
        self.mul(other)
    }

    fn __repr__(&self) -> String {
        format!("GroupElement({})", self.as_hex())
    }

    fn __str__(&self) -> String {
        self.as_hex()
    }

    fn __eq__(&self, other: &PyGroupElement) -> bool {
        self.0 == other.0
    }
}

pub fn register(m: &Bound<'_, PyModule>) -> PyResult<()> {
    m.add_class::<PyGroupElement>()?;
    Ok(())
}