ate_crypto/utils/
b64.rs

1#![allow(unused_imports)]
2use std::convert::TryInto;
3
4use serde::{de::Deserializer, Serializer};
5use serde::{Deserialize, Serialize};
6use tracing::{debug, error, info, instrument, span, trace, warn, Level};
7
8pub fn vec_serialize<S>(data: &Vec<u8>, serializer: S) -> Result<S::Ok, S::Error>
9where
10    S: Serializer,
11{
12    if std::any::type_name::<S>().contains("serde_json") {
13        serializer.serialize_str(&base64::encode(&data[..]))
14    } else {
15        <Vec<u8>>::serialize(data, serializer)
16    }
17}
18
19pub fn vec_deserialize<'a, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
20where
21    D: Deserializer<'a>,
22{
23    if std::any::type_name::<D>().contains("serde_json") {
24        use serde::de::Error;
25        let ret = String::deserialize(deserializer).and_then(|string| {
26            base64::decode(&string).map_err(|err| Error::custom(err.to_string()))
27        })?;
28        Ok(ret)
29    } else {
30        <Vec<u8>>::deserialize(deserializer)
31    }
32}
33
34pub fn b16_serialize<S>(data: &[u8; 16], serializer: S) -> Result<S::Ok, S::Error>
35where
36    S: Serializer,
37{
38    if std::any::type_name::<S>().contains("serde_json") {
39        serializer.serialize_str(&base64::encode(&data[..]))
40    } else {
41        <[u8; 16]>::serialize(data, serializer)
42    }
43}
44
45pub fn b16_deserialize<'a, D>(deserializer: D) -> Result<[u8; 16], D::Error>
46where
47    D: Deserializer<'a>,
48{
49    if std::any::type_name::<D>().contains("serde_json") {
50        use serde::de::Error;
51        let ret = String::deserialize(deserializer).and_then(|string| {
52            base64::decode(&string).map_err(|err| Error::custom(err.to_string()))
53        })?;
54        ret.try_into().map_err(|e: Vec<u8>| {
55            Error::custom(format!("expected 16 bytes but found {}", e.len()).as_str())
56        })
57    } else {
58        <[u8; 16]>::deserialize(deserializer)
59    }
60}
61
62pub fn b24_serialize<S>(data: &[u8; 24], serializer: S) -> Result<S::Ok, S::Error>
63where
64    S: Serializer,
65{
66    if std::any::type_name::<S>().contains("serde_json") {
67        serializer.serialize_str(&base64::encode(&data[..]))
68    } else {
69        <[u8; 24]>::serialize(data, serializer)
70    }
71}
72
73pub fn b24_deserialize<'a, D>(deserializer: D) -> Result<[u8; 24], D::Error>
74where
75    D: Deserializer<'a>,
76{
77    if std::any::type_name::<D>().contains("serde_json") {
78        use serde::de::Error;
79        let ret = String::deserialize(deserializer).and_then(|string| {
80            base64::decode(&string).map_err(|err| Error::custom(err.to_string()))
81        })?;
82        ret.try_into().map_err(|e: Vec<u8>| {
83            Error::custom(format!("expected 24 bytes but found {}", e.len()).as_str())
84        })
85    } else {
86        <[u8; 24]>::deserialize(deserializer)
87    }
88}
89
90pub fn b32_serialize<S>(data: &[u8; 32], serializer: S) -> Result<S::Ok, S::Error>
91where
92    S: Serializer,
93{
94    if std::any::type_name::<S>().contains("serde_json") {
95        serializer.serialize_str(&base64::encode(&data[..]))
96    } else {
97        <[u8; 32]>::serialize(data, serializer)
98    }
99}
100
101pub fn b32_deserialize<'a, D>(deserializer: D) -> Result<[u8; 32], D::Error>
102where
103    D: Deserializer<'a>,
104{
105    if std::any::type_name::<D>().contains("serde_json") {
106        use serde::de::Error;
107        let ret = String::deserialize(deserializer).and_then(|string| {
108            base64::decode(&string).map_err(|err| Error::custom(err.to_string()))
109        })?;
110        ret.try_into().map_err(|e: Vec<u8>| {
111            Error::custom(format!("expected 32 bytes but found {}", e.len()).as_str())
112        })
113    } else {
114        <[u8; 32]>::deserialize(deserializer)
115    }
116}
117
118#[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
119struct TestClass {
120    pub header: String,
121    #[serde(serialize_with = "vec_serialize", deserialize_with = "vec_deserialize")]
122    pub my_bytes: Vec<u8>,
123    #[serde(serialize_with = "b16_serialize", deserialize_with = "b16_deserialize")]
124    pub my_b1: [u8; 16],
125    #[serde(serialize_with = "b24_serialize", deserialize_with = "b24_deserialize")]
126    pub my_b2: [u8; 24],
127    #[serde(serialize_with = "b32_serialize", deserialize_with = "b32_deserialize")]
128    pub my_b3: [u8; 32],
129}
130
131#[test]
132fn test_b64() {
133    crate::utils::bootstrap_test_env();
134
135    let plain = TestClass {
136        header: "ate".to_string(),
137        my_bytes: vec![
138            112u8, 84u8, 99u8, 210u8, 55u8, 201u8, 202u8, 203u8, 204u8, 205u8, 206u8, 207u8,
139        ],
140        my_b1: [
141            1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8, 9u8, 10u8, 11u8, 12u8, 13u8, 14u8, 15u8, 16u8,
142        ],
143        my_b2: [
144            1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8, 9u8, 10u8, 11u8, 12u8, 13u8, 14u8, 15u8, 16u8,
145            1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8,
146        ],
147        my_b3: [
148            1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8, 9u8, 10u8, 11u8, 12u8, 13u8, 14u8, 15u8, 16u8,
149            1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8, 9u8, 10u8, 11u8, 12u8, 13u8, 14u8, 15u8, 16u8,
150        ],
151    };
152
153    let cipher = bincode::serialize(&plain).unwrap();
154    trace!("{:?}", cipher);
155    let test: TestClass = bincode::deserialize(&cipher[..]).unwrap();
156    assert_eq!(test, plain);
157
158    let cipher = rmp_serde::to_vec(&plain).unwrap();
159    trace!("{:?}", cipher);
160    let test: TestClass = rmp_serde::from_read_ref(&cipher[..]).unwrap();
161    assert_eq!(test, plain);
162
163    let cipher = serde_json::to_string_pretty(&plain).unwrap();
164    trace!("{}", cipher);
165    let test: TestClass = serde_json::from_str(&cipher).unwrap();
166    assert_eq!(test, plain);
167}
ate_crypto/utils/b64.rs

ate_crypto/utils/
b64.rs
