schnorrkel/
serdey.rs

1// -*- mode: rust; -*-
2//
3// This file is part of schnorrkel.
4// Copyright (c) 2019 isis lovecruft and Web 3 Foundation
5// See LICENSE for licensing information.
6//
7// Authors:
8// - isis agora lovecruft <isis@patternsinthevoid.net>
9// - Jeff Burdges <jeff@web3.foundation>
10
11//! ### Various and tooling related to serde
12
13#[cfg(feature = "serde")]
14macro_rules! serde_boilerplate { ($t:ty) => {
15impl serde_crate::Serialize for $t {
16    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde_crate::Serializer {
17        let bytes = &self.to_bytes()[..];
18        serde_bytes::Bytes::new(bytes).serialize(serializer)
19    }
20}
21
22impl<'d> serde_crate::Deserialize<'d> for $t {
23    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde_crate::Deserializer<'d> {
24        cfg_if::cfg_if!{
25            if #[cfg(feature = "std")] {
26                let bytes = <std::borrow::Cow<'_, [u8]>>::deserialize(deserializer)?;
27            } else if #[cfg(feature = "alloc")] {
28                let bytes = <alloc::borrow::Cow<'_, [u8]>>::deserialize(deserializer)?;
29            } else {
30                let bytes = <&::serde_bytes::Bytes>::deserialize(deserializer)?;
31            }
32        }
33
34        Self::from_bytes(bytes.as_ref())
35                .map_err(crate::errors::serde_error_from_signature_error)
36    }
37}
38} } // macro_rules! serde_boilerplate
39
40#[cfg(not(feature = "serde"))]
41macro_rules! serde_boilerplate { ($t:ty) => { } }
42
43#[cfg(all(test, feature = "serde"))]
44mod test {
45    use std::vec::Vec;
46
47    use bincode::{serialize, serialized_size, deserialize};
48    use serde_json::{to_value, from_value, to_string, from_str};
49
50    use curve25519_dalek::ristretto::{CompressedRistretto};
51
52    use crate::*;
53
54    static COMPRESSED_PUBLIC_KEY : CompressedRistretto = CompressedRistretto([
55        208, 120, 140, 129, 177, 179, 237, 159,
56        252, 160, 028, 013, 206, 005, 211, 241,
57        192, 218, 001, 097, 130, 241, 020, 169,
58        119, 046, 246, 029, 079, 080, 077, 084]);
59
60    /*
61    static ED25519_PUBLIC_KEY: CompressedEdwardsY = CompressedEdwardsY([
62        130, 039, 155, 015, 062, 076, 188, 063,
63        124, 122, 026, 251, 233, 253, 225, 220,
64        014, 041, 166, 120, 108, 035, 254, 077,
65        160, 083, 172, 058, 219, 042, 086, 120, ]);
66    */
67
68    static ED25519_SECRET_KEY: MiniSecretKey = MiniSecretKey([
69        062, 070, 027, 163, 092, 182, 011, 003,
70        077, 234, 098, 004, 011, 127, 079, 228,
71        243, 187, 150, 073, 201, 137, 076, 022,
72        085, 251, 152, 002, 241, 042, 072, 054, ]);
73
74    /// Ed25519 signature with the above keypair of a blank message.
75    static SIGNATURE_BYTES: [u8; SIGNATURE_LENGTH] = [
76        010, 126, 151, 143, 157, 064, 047, 001,
77        196, 140, 179, 058, 226, 152, 018, 102,
78        160, 123, 080, 016, 210, 086, 196, 028,
79        053, 231, 012, 157, 169, 019, 158, 063,
80        045, 154, 238, 007, 053, 185, 227, 229,
81        079, 108, 213, 080, 124, 252, 084, 167,
82        216, 085, 134, 144, 129, 149, 041, 081,
83        063, 120, 126, 100, 092, 059, 050, 138, ];
84
85
86    #[test]
87    fn serialize_deserialize_signature() {
88        let signature: Signature = Signature::from_bytes(&SIGNATURE_BYTES).unwrap();
89        let encoded_signature: Vec<u8> = serialize(&signature).unwrap();
90        let decoded_signature: Signature = deserialize(&encoded_signature).unwrap();
91
92        assert_eq!(signature, decoded_signature);
93    }
94
95    #[test]
96    fn serialize_deserialize_signature_json() {
97        let signature: Signature = Signature::from_bytes(&SIGNATURE_BYTES).unwrap();
98
99        let encoded_signature = to_value(&signature).unwrap();
100        let decoded_signature: Signature = from_value(encoded_signature).unwrap();
101
102        assert_eq!(signature, decoded_signature);
103
104        let encoded_signature = to_string(&signature).unwrap();
105        let decoded_signature: Signature = from_str(&encoded_signature).unwrap();
106
107        assert_eq!(signature, decoded_signature);
108    }
109
110    #[test]
111    fn serialize_deserialize_public_key() {
112        let public_key = PublicKey::from_compressed(COMPRESSED_PUBLIC_KEY).unwrap();
113        let encoded_public_key: Vec<u8> = serialize(&public_key).unwrap();
114        let decoded_public_key: PublicKey = deserialize(&encoded_public_key).unwrap();
115
116        assert_eq!(public_key, decoded_public_key);
117    }
118
119    #[test]
120    fn serialize_deserialize_public_key_json() {
121        let public_key = PublicKey::from_compressed(COMPRESSED_PUBLIC_KEY).unwrap();
122        let encoded_public_key = to_value(&public_key).unwrap();
123        let decoded_public_key: PublicKey = from_value(encoded_public_key).unwrap();
124
125        assert_eq!(public_key, decoded_public_key);
126
127        let encoded_public_key = to_string(&public_key).unwrap();
128        let decoded_public_key: PublicKey = from_str(&encoded_public_key).unwrap();
129
130        assert_eq!(public_key, decoded_public_key);
131    }
132
133    /*
134    TODO: Actually test serde on real secret key, not just mini one.
135    fn serialize_deserialize_secret_key() {
136        let encoded_secret_key: Vec<u8> = serialize(&SECRET_KEY, Infinite).unwrap();
137        let decoded_secret_key: MiniSecretKey = deserialize(&encoded_secret_key).unwrap();
138
139        for i in 0..64 {
140            assert_eq!(ED25519_SECRET_KEY.0[i], decoded_secret_key.0[i]);
141        }
142    }
143    */
144
145    #[test]
146    fn serialize_deserialize_mini_secret_key() {
147        let encoded_secret_key: Vec<u8> = serialize(&ED25519_SECRET_KEY).unwrap();
148        let decoded_secret_key: MiniSecretKey = deserialize(&encoded_secret_key).unwrap();
149
150        for i in 0..32 {
151            assert_eq!(ED25519_SECRET_KEY.0[i], decoded_secret_key.0[i]);
152        }
153    }
154
155    #[test]
156    fn serialize_deserialize_mini_secret_key_json() {
157        let encoded_secret_key = to_value(&ED25519_SECRET_KEY).unwrap();
158        let decoded_secret_key: MiniSecretKey = from_value(encoded_secret_key).unwrap();
159
160        for i in 0..32 {
161            assert_eq!(ED25519_SECRET_KEY.0[i], decoded_secret_key.0[i]);
162        }
163
164        let encoded_secret_key = to_string(&ED25519_SECRET_KEY).unwrap();
165        let decoded_secret_key: MiniSecretKey = from_str(&encoded_secret_key).unwrap();
166
167        for i in 0..32 {
168            assert_eq!(ED25519_SECRET_KEY.0[i], decoded_secret_key.0[i]);
169        }
170    }
171
172    #[test]
173    fn serialize_public_key_size() {
174        let public_key = PublicKey::from_compressed(COMPRESSED_PUBLIC_KEY).unwrap();
175        assert_eq!(serialized_size(&public_key).unwrap(), 32+8);  // Size specific to bincode==1.0.1
176    }
177
178    #[test]
179    fn serialize_signature_size() {
180        let signature: Signature = Signature::from_bytes(&SIGNATURE_BYTES).unwrap();
181        assert_eq!(serialized_size(&signature).unwrap(), 64+8);  // Size specific to bincode==1.0.1
182    }
183
184    #[test]
185    fn serialize_secret_key_size() {
186        assert_eq!(serialized_size(&ED25519_SECRET_KEY).unwrap(), 32+8);
187        let secret_key = ED25519_SECRET_KEY.expand(ExpansionMode::Ed25519);
188        assert_eq!(serialized_size(&secret_key).unwrap(), 64+8);  // Sizes specific to bincode==1.0.1
189        let secret_key = ED25519_SECRET_KEY.expand(ExpansionMode::Uniform);
190        assert_eq!(serialized_size(&secret_key).unwrap(), 64+8);  // Sizes specific to bincode==1.0.1
191    }
192}
schnorrkel/serdey.rs

schnorrkel/
serdey.rs
