provekit-spongefish 0.1.0

An implementation of the Fiat--Shamir transformation from Duplex Sponges.
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

//! secp256k1 (k256) codec implementations
use k256::{
    elliptic_curve::{
        bigint::U512,
        ff::Field,
        sec1::{FromEncodedPoint, ToEncodedPoint},
    },
    AffinePoint, ProjectivePoint, Scalar,
};

use crate::{
    codecs::{Decoding, Encoding},
    error::VerificationError,
    io::NargDeserialize,
    VerificationResult,
};

// Make k256 Scalar a valid Unit type
impl crate::Unit for Scalar {
    const ZERO: Self = <Scalar as Field>::ZERO;
}

// Implement Decoding for k256 Scalar
impl Decoding<[u8]> for Scalar {
    type Repr = super::Array64;

    fn decode(buf: Self::Repr) -> Self {
        use k256::elliptic_curve::{bigint::Encoding, ops::Reduce};
        Scalar::reduce(U512::from_le_bytes(buf.0))
    }
}

// Implement Deserialize for k256 Scalar
impl NargDeserialize for Scalar {
    fn deserialize_from_narg(buf: &mut &[u8]) -> VerificationResult<Self> {
        if buf.len() < 32 {
            return Err(VerificationError);
        }
        let mut repr = [0u8; 32];
        repr.copy_from_slice(&buf[..32]);
        *buf = &buf[32..];

        use k256::elliptic_curve::ff::PrimeField;
        repr.reverse();
        Option::from(Scalar::from_repr(repr.into())).ok_or(VerificationError)
    }
}

// Implement Deserialize for ProjectivePoint
impl NargDeserialize for ProjectivePoint {
    fn deserialize_from_narg(buf: &mut &[u8]) -> VerificationResult<Self> {
        // Compressed points are 33 bytes
        if buf.len() < 33 {
            return Err(VerificationError);
        }

        use k256::EncodedPoint;
        let encoded = EncodedPoint::from_bytes(&buf[..33]).map_err(|_| VerificationError)?;
        *buf = &buf[33..];
        Option::from(ProjectivePoint::from_encoded_point(&encoded)).ok_or(VerificationError)
    }
}

// Implement Encoding for k256 Scalar
impl Encoding<[u8]> for Scalar {
    fn encode(&self) -> impl AsRef<[u8]> {
        let mut bytes = self.to_bytes();
        bytes.reverse();
        bytes
    }
}

// Implement Encoding for ProjectivePoint
impl Encoding<[u8]> for ProjectivePoint {
    fn encode(&self) -> impl AsRef<[u8]> {
        self.to_affine().to_encoded_point(true)
    }
}

impl Encoding<[u8]> for AffinePoint {
    fn encode(&self) -> impl AsRef<[u8]> {
        self.to_encoded_point(true)
    }
}

#[cfg(test)]
mod tests {
    use alloc::vec::Vec;

    use super::*;
    use crate::io::NargSerialize;

    #[test]
    fn test_scalar_serialize_deserialize() {
        let scalar = Scalar::random(&mut rand::thread_rng());

        let mut buf = Vec::new();
        scalar.serialize_into_narg(&mut buf);

        let mut buf_slice = &buf[..];
        let deserialized = Scalar::deserialize_from_narg(&mut buf_slice).unwrap();
        assert_eq!(scalar, deserialized);
    }

    #[test]
    fn test_point_serialize_deserialize() {
        use k256::elliptic_curve::Group;

        let point = ProjectivePoint::random(&mut rand::thread_rng());

        let mut buf = Vec::new();
        point.serialize_into_narg(&mut buf);

        let mut buf_slice = &buf[..];
        let deserialized = ProjectivePoint::deserialize_from_narg(&mut buf_slice).unwrap();
        assert_eq!(point, deserialized);
    }

    #[test]
    fn test_scalar_encoding() {
        let scalar = Scalar::random(&mut rand::thread_rng());

        let encoded = scalar.encode();
        let encoded_bytes = encoded.as_ref();

        let mut buf_slice = encoded_bytes;
        let deserialized = Scalar::deserialize_from_narg(&mut buf_slice).unwrap();
        assert_eq!(scalar, deserialized);
    }

    #[test]
    fn test_decoding() {
        let buf = super::super::Array64::default();
        let scalar = Scalar::decode(buf);
        assert_eq!(scalar, Scalar::ZERO);
    }
}