utility_crypto/
signature.rs

1use borsh::{BorshDeserialize, BorshSerialize};
2use ed25519_dalek::ed25519::signature::{Signer, Verifier};
3use once_cell::sync::Lazy;
4use primitive_types::U256;
5use secp256k1::rand::rngs::OsRng;
6use secp256k1::Message;
7use std::convert::AsRef;
8use std::fmt::{Debug, Display, Formatter};
9use std::hash::{Hash, Hasher};
10use std::io::{Error, ErrorKind, Read, Write};
11use std::str::FromStr;
12use rsa::Pkcs1v15Sign;
13use rsa::pkcs8::{EncodePrivateKey, EncodePublicKey, DecodePublicKey, DecodePrivateKey};
14
15pub static SECP256K1: Lazy<secp256k1::Secp256k1<secp256k1::All>> =
16    Lazy::new(secp256k1::Secp256k1::new);
17
18#[derive(Debug, Copy, Clone, serde::Serialize, serde::Deserialize)]
19pub enum KeyType {
20    ED25519 = 0,
21    SECP256K1 = 1,
22    RSA2048 = 2,
23}
24
25impl Display for KeyType {
26    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
27        f.write_str(match self {
28            KeyType::ED25519 => "ed25519",
29            KeyType::SECP256K1 => "secp256k1",
30            KeyType::RSA2048 => "rsa2048",
31        })
32    }
33}
34
35impl FromStr for KeyType {
36    type Err = crate::errors::ParseKeyTypeError;
37
38    fn from_str(value: &str) -> Result<Self, Self::Err> {
39        let lowercase_key_type = value.to_ascii_lowercase();
40        match lowercase_key_type.as_str() {
41            "ed25519" => Ok(KeyType::ED25519),
42            "secp256k1" => Ok(KeyType::SECP256K1),
43            "rsa2048" => Ok(KeyType::RSA2048),
44            _ => Err(Self::Err::UnknownKeyType { unknown_key_type: lowercase_key_type }),
45        }
46    }
47}
48
49impl TryFrom<u8> for KeyType {
50    type Error = crate::errors::ParseKeyTypeError;
51
52    fn try_from(value: u8) -> Result<Self, Self::Error> {
53        match value {
54            0_u8 => Ok(KeyType::ED25519),
55            1_u8 => Ok(KeyType::SECP256K1),
56            2_u8 => Ok(KeyType::RSA2048),
57            unknown_key_type => {
58                Err(Self::Error::UnknownKeyType { unknown_key_type: unknown_key_type.to_string() })
59            }
60        }
61    }
62}
63
64fn split_key_type_data(value: &str) -> Result<(KeyType, &str), crate::errors::ParseKeyTypeError> {
65    if let Some((prefix, key_data)) = value.split_once(':') {
66        Ok((KeyType::from_str(prefix)?, key_data))
67    } else {
68        // If there is no prefix then we Default to ED25519.
69        Ok((KeyType::ED25519, value))
70    }
71}
72
73// RSA
74const RAW_PUBLIC_KEY_RSA_2048_LENGTH: usize = 294;
75#[derive(Clone, Eq, Ord, PartialEq, PartialOrd, derive_more::AsRef, derive_more::From)]
76#[as_ref(forward)]
77pub struct Rsa2048PublicKey([u8; RAW_PUBLIC_KEY_RSA_2048_LENGTH]);
78
79impl TryFrom<&[u8]> for crate::Rsa2048PublicKey {
80    type Error = crate::errors::ParseKeyError;
81
82    fn try_from(data: &[u8]) -> Result<Self, Self::Error> {
83        data.try_into().map(Self).map_err(|_| Self::Error::InvalidLength {
84            expected_length: RAW_PUBLIC_KEY_RSA_2048_LENGTH,
85            received_length: data.len(),
86        })
87    }
88}
89
90impl std::fmt::Debug for crate::Rsa2048PublicKey {
91    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
92        Display::fmt(&Bs58(&self.0), f)
93    }
94}
95
96// SECP256K1
97const PUBLIC_KEY_SECP256K1_LENGTH: usize = 64;
98
99#[derive(Clone, Eq, Ord, PartialEq, PartialOrd, derive_more::AsRef, derive_more::From)]
100#[as_ref(forward)]
101pub struct Secp256K1PublicKey([u8; PUBLIC_KEY_SECP256K1_LENGTH]);
102
103impl TryFrom<&[u8]> for Secp256K1PublicKey {
104    type Error = crate::errors::ParseKeyError;
105
106    fn try_from(data: &[u8]) -> Result<Self, Self::Error> {
107        data.try_into().map(Self).map_err(|_| Self::Error::InvalidLength {
108            expected_length: PUBLIC_KEY_SECP256K1_LENGTH,
109            received_length: data.len(),
110        })
111    }
112}
113
114impl std::fmt::Debug for Secp256K1PublicKey {
115    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
116        Display::fmt(&Bs58(&self.0), f)
117    }
118}
119
120#[derive(Clone, Eq, Ord, PartialEq, PartialOrd, derive_more::AsRef, derive_more::From)]
121#[as_ref(forward)]
122pub struct ED25519PublicKey(pub [u8; ed25519_dalek::PUBLIC_KEY_LENGTH]);
123
124impl TryFrom<&[u8]> for ED25519PublicKey {
125    type Error = crate::errors::ParseKeyError;
126
127    fn try_from(data: &[u8]) -> Result<Self, Self::Error> {
128        data.try_into().map(Self).map_err(|_| Self::Error::InvalidLength {
129            expected_length: ed25519_dalek::PUBLIC_KEY_LENGTH,
130            received_length: data.len(),
131        })
132    }
133}
134
135impl std::fmt::Debug for ED25519PublicKey {
136    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
137        Display::fmt(&Bs58(&self.0), f)
138    }
139}
140
141/// Public key container supporting different curves.
142#[derive(Clone, PartialEq, PartialOrd, Ord, Eq)]
143pub enum PublicKey {
144    /// 256 bit elliptic curve based public-key.
145    ED25519(ED25519PublicKey),
146    /// 512 bit elliptic curve based public-key used in Bitcoin's public-key cryptography.
147    SECP256K1(Secp256K1PublicKey),
148    /// 2048 bit rsa
149    RSA(Rsa2048PublicKey),
150}
151
152impl PublicKey {
153    // `is_empty` always returns false, so there is no point in adding it
154    #[allow(clippy::len_without_is_empty)]
155    pub fn len(&self) -> usize {
156        const ED25519_LEN: usize = ed25519_dalek::PUBLIC_KEY_LENGTH + 1;
157        match self {
158            Self::ED25519(_) => ED25519_LEN,
159            Self::SECP256K1(_) => PUBLIC_KEY_SECP256K1_LENGTH + 1,
160            Self::RSA(_) => RAW_PUBLIC_KEY_RSA_2048_LENGTH + 1,
161        }
162    }
163
164    pub fn empty(key_type: KeyType) -> Self {
165        match key_type {
166            KeyType::ED25519 => {
167                PublicKey::ED25519(ED25519PublicKey([0u8; ed25519_dalek::PUBLIC_KEY_LENGTH]))
168            }
169            KeyType::SECP256K1 => PublicKey::SECP256K1(Secp256K1PublicKey([0u8; PUBLIC_KEY_SECP256K1_LENGTH])),
170            KeyType::RSA2048 => PublicKey::RSA(Rsa2048PublicKey([0u8; RAW_PUBLIC_KEY_RSA_2048_LENGTH])),
171        }
172    }
173
174    pub fn key_type(&self) -> KeyType {
175        match self {
176            Self::ED25519(_) => KeyType::ED25519,
177            Self::SECP256K1(_) => KeyType::SECP256K1,
178            Self::RSA(_) => KeyType::RSA2048,
179        }
180    }
181
182    pub fn key_data(&self) -> &[u8] {
183        match self {
184            Self::ED25519(key) => key.as_ref(),
185            Self::SECP256K1(key) => key.as_ref(),
186            Self::RSA(key) => key.as_ref(),
187        }
188    }
189
190    pub fn unwrap_as_ed25519(&self) -> &ED25519PublicKey {
191        match self {
192            Self::ED25519(key) => key,
193            _ => panic!(),
194        }
195    }
196
197    pub fn unwrap_as_secp256k1(&self) -> &Secp256K1PublicKey {
198        match self {
199            Self::SECP256K1(key) => key,
200            _ => panic!(),
201        }
202    }
203
204    pub fn unwrap_as_rsa2048(&self) -> &Rsa2048PublicKey {
205        match self {
206            Self::RSA(key) => key,
207            _ => panic!(),
208        }
209    }
210}
211
212// This `Hash` implementation is safe since it retains the property
213// `k1 == k2 ⇒ hash(k1) == hash(k2)`.
214impl Hash for PublicKey {
215    fn hash<H: Hasher>(&self, state: &mut H) {
216        match self {
217            PublicKey::ED25519(public_key) => {
218                state.write_u8(0u8);
219                state.write(&public_key.0);
220            }
221            PublicKey::SECP256K1(public_key) => {
222                state.write_u8(1u8);
223                state.write(&public_key.0);
224            }
225            PublicKey::RSA(public_key) => {
226                state.write_u8(2u8);
227                state.write(&public_key.0);
228            }
229        }
230    }
231}
232
233impl Display for PublicKey {
234    fn fmt(&self, fmt: &mut Formatter) -> std::fmt::Result {
235        let (key_type, key_data) = match self {
236            PublicKey::ED25519(public_key) => (KeyType::ED25519, &public_key.0[..]),
237            PublicKey::SECP256K1(public_key) => (KeyType::SECP256K1, &public_key.0[..]),
238            PublicKey::RSA(public_key) => (KeyType::RSA2048, &public_key.0[..]),
239        };
240        write!(fmt, "{}:{}", key_type, Bs58(key_data))
241    }
242}
243
244impl Debug for PublicKey {
245    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
246        Display::fmt(self, f)
247    }
248}
249
250impl BorshSerialize for PublicKey {
251    fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), Error> {
252        match self {
253            PublicKey::ED25519(public_key) => {
254                BorshSerialize::serialize(&0u8, writer)?;
255                writer.write_all(&public_key.0)?;
256            }
257            PublicKey::SECP256K1(public_key) => {
258                BorshSerialize::serialize(&1u8, writer)?;
259                writer.write_all(&public_key.0)?;
260            }
261            PublicKey::RSA(public_key) => {
262                BorshSerialize::serialize(&2u8, writer)?;
263                writer.write_all(&public_key.0)?;
264            }
265        }
266        Ok(())
267    }
268}
269
270impl BorshDeserialize for PublicKey {
271    fn deserialize_reader<R: Read>(rd: &mut R) -> std::io::Result<Self> {
272        let key_type = KeyType::try_from(u8::deserialize_reader(rd)?)
273            .map_err(|err| Error::new(ErrorKind::InvalidData, err.to_string()))?;
274        match key_type {
275            KeyType::ED25519 => {
276                Ok(PublicKey::ED25519(ED25519PublicKey(BorshDeserialize::deserialize_reader(rd)?)))
277            }
278            KeyType::SECP256K1 => Ok(PublicKey::SECP256K1(Secp256K1PublicKey(
279                BorshDeserialize::deserialize_reader(rd)?,
280            ))),
281            KeyType::RSA2048 => Ok(PublicKey::RSA(Rsa2048PublicKey(
282                BorshDeserialize::deserialize_reader(rd)?,
283            ))),
284        }
285    }
286}
287
288impl serde::Serialize for PublicKey {
289    fn serialize<S>(
290        &self,
291        serializer: S,
292    ) -> Result<<S as serde::Serializer>::Ok, <S as serde::Serializer>::Error>
293    where
294        S: serde::Serializer,
295    {
296        serializer.collect_str(self)
297    }
298}
299
300impl<'de> serde::Deserialize<'de> for PublicKey {
301    fn deserialize<D>(deserializer: D) -> Result<Self, <D as serde::Deserializer<'de>>::Error>
302    where
303        D: serde::Deserializer<'de>,
304    {
305        let s = <String as serde::Deserialize>::deserialize(deserializer)?;
306        s.parse()
307            .map_err(|err: crate::errors::ParseKeyError| serde::de::Error::custom(err.to_string()))
308    }
309}
310
311impl FromStr for PublicKey {
312    type Err = crate::errors::ParseKeyError;
313
314    fn from_str(value: &str) -> Result<Self, Self::Err> {
315        let (key_type, key_data) = split_key_type_data(value)?;
316        Ok(match key_type {
317            KeyType::ED25519 => Self::ED25519(ED25519PublicKey(decode_bs58(key_data)?)),
318            KeyType::SECP256K1 => Self::SECP256K1(Secp256K1PublicKey(decode_bs58(key_data)?)),
319            KeyType::RSA2048 => Self::RSA(Rsa2048PublicKey(decode_bs58(key_data)?)),
320        })
321    }
322}
323
324impl From<ED25519PublicKey> for PublicKey {
325    fn from(ed25519: ED25519PublicKey) -> Self {
326        Self::ED25519(ed25519)
327    }
328}
329
330impl From<Secp256K1PublicKey> for PublicKey {
331    fn from(secp256k1: Secp256K1PublicKey) -> Self {
332        Self::SECP256K1(secp256k1)
333    }
334}
335
336impl From<Rsa2048PublicKey> for PublicKey {
337    fn from(rsa2048: Rsa2048PublicKey) -> Self {
338        Self::RSA(rsa2048)
339    }
340}
341
342#[derive(Clone, Eq)]
343// This is actually a keypair, because ed25519_dalek api only has keypair.sign
344// From ed25519_dalek doc: The first SECRET_KEY_LENGTH of bytes is the SecretKey
345// The last PUBLIC_KEY_LENGTH of bytes is the public key, in total it's KEYPAIR_LENGTH
346pub struct ED25519SecretKey(pub [u8; ed25519_dalek::KEYPAIR_LENGTH]);
347
348impl PartialEq for ED25519SecretKey {
349    fn eq(&self, other: &Self) -> bool {
350        self.0[..ed25519_dalek::SECRET_KEY_LENGTH] == other.0[..ed25519_dalek::SECRET_KEY_LENGTH]
351    }
352}
353
354impl std::fmt::Debug for ED25519SecretKey {
355    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
356        Display::fmt(&Bs58(&self.0[..ed25519_dalek::SECRET_KEY_LENGTH]), f)
357    }
358}
359
360
361pub(crate) const PRIVTAE_KEY_DEFAULT_RSA_KEY_BITS: usize = 2048;
362
363/// Secret key container supporting different curves.
364#[derive(Clone, Eq, PartialEq, Debug)]
365pub enum SecretKey {
366    ED25519(ED25519SecretKey),
367    SECP256K1(secp256k1::SecretKey),
368    RSA(rsa::RsaPrivateKey),
369}
370
371impl SecretKey {
372    pub fn key_type(&self) -> KeyType {
373        match self {
374            SecretKey::ED25519(_) => KeyType::ED25519,
375            SecretKey::SECP256K1(_) => KeyType::SECP256K1,
376            SecretKey::RSA(_) => KeyType::RSA2048,
377        }
378    }
379
380    pub fn from_random(key_type: KeyType) -> SecretKey {
381        match key_type {
382            KeyType::ED25519 => {
383                let keypair = ed25519_dalek::SigningKey::generate(&mut OsRng);
384                SecretKey::ED25519(ED25519SecretKey(keypair.to_keypair_bytes()))
385            }
386            KeyType::SECP256K1 => SecretKey::SECP256K1(secp256k1::SecretKey::new(&mut OsRng)),
387            KeyType::RSA2048 => {
388                SecretKey::RSA(rsa::RsaPrivateKey::new(&mut OsRng, PRIVTAE_KEY_DEFAULT_RSA_KEY_BITS).unwrap())
389            }
390        }
391    }
392
393    pub fn sign(&self, data: &[u8]) -> Signature {
394        match &self {
395            SecretKey::ED25519(secret_key) => {
396                let keypair = ed25519_dalek::SigningKey::from_keypair_bytes(&secret_key.0).unwrap();
397                Signature::ED25519(keypair.sign(data))
398            }
399
400            SecretKey::SECP256K1(secret_key) => {
401                let signature = SECP256K1.sign_ecdsa_recoverable(
402                    &secp256k1::Message::from_slice(data).expect("32 bytes"),
403                    secret_key,
404                );
405                let (rec_id, data) = signature.serialize_compact();
406                let mut buf = [0; 65];
407                buf[0..64].copy_from_slice(&data[0..64]);
408                buf[64] = rec_id.to_i32() as u8;
409                Signature::SECP256K1(Secp256K1Signature(buf))
410            }
411            SecretKey::RSA(secret_key) => {
412                let sign_data = secret_key.sign(Pkcs1v15Sign::new_unprefixed(), data).unwrap();
413                Signature::RSA(Rsa2048Signature(<[u8; 256]>::try_from(sign_data.as_slice()).unwrap()))
414            }
415
416        }
417    }
418
419    pub fn public_key(&self) -> PublicKey {
420        match &self {
421            SecretKey::ED25519(secret_key) => PublicKey::ED25519(ED25519PublicKey(
422                secret_key.0[ed25519_dalek::SECRET_KEY_LENGTH..].try_into().unwrap(),
423            )),
424            SecretKey::SECP256K1(secret_key) => {
425                let pk = secp256k1::PublicKey::from_secret_key(&SECP256K1, secret_key);
426                let serialized = pk.serialize_uncompressed();
427                let mut public_key = Secp256K1PublicKey([0; 64]);
428                public_key.0.copy_from_slice(&serialized[1..65]);
429                PublicKey::SECP256K1(public_key)
430            },
431            SecretKey::RSA(secret_key) => {
432                let pk = secret_key.to_public_key();
433                let mut public_key = [0; RAW_PUBLIC_KEY_RSA_2048_LENGTH];
434                public_key.copy_from_slice(&pk.to_public_key_der().unwrap().as_bytes());
435                PublicKey::RSA(Rsa2048PublicKey(public_key))
436            }
437        }
438    }
439
440    pub fn unwrap_as_ed25519(&self) -> &ED25519SecretKey {
441        match self {
442            SecretKey::ED25519(key) => key,
443            _ => panic!(),
444        }
445    }
446}
447
448impl std::fmt::Display for SecretKey {
449    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
450        match self {
451            SecretKey::ED25519(secret_key) => {
452                write!(f, "{}:{}", KeyType::ED25519, Bs58(&secret_key.0[..]))
453            },
454            SecretKey::SECP256K1(secret_key) => {
455                write!(f, "{}:{}", KeyType::SECP256K1, Bs58(&secret_key[..]))
456            },
457            SecretKey::RSA(secret_key) => {
458                // 先将 DER 编码的密钥存储在一个变量中
459                let pkcs8_bytes = secret_key.to_pkcs8_der().unwrap().to_bytes();
460                // 然后获取它的切片
461                write!(f, "{}:{}", KeyType::RSA2048, Bs58(&pkcs8_bytes.as_slice()))
462            },
463        }
464    }
465}
466
467impl FromStr for SecretKey {
468    type Err = crate::errors::ParseKeyError;
469
470    fn from_str(s: &str) -> Result<Self, Self::Err> {
471        let (key_type, key_data) = split_key_type_data(s)?;
472        Ok(match key_type {
473            KeyType::ED25519 => Self::ED25519(ED25519SecretKey(decode_bs58(key_data)?)),
474            KeyType::SECP256K1 => {
475                let data = decode_bs58::<{ secp256k1::constants::SECRET_KEY_SIZE }>(key_data)?;
476                let sk = secp256k1::SecretKey::from_slice(&data)
477                    .map_err(|err| Self::Err::InvalidData { error_message: err.to_string() })?;
478                Self::SECP256K1(sk)
479            },
480            KeyType::RSA2048 => {
481                let sk = rsa::RsaPrivateKey::from_pkcs8_der(&decode_bs58::<1218>(key_data)?)
482                    .map_err(|err| Self::Err::InvalidData { error_message: err.to_string() })?;
483                Self::RSA(sk)
484            }
485        })
486    }
487}
488
489impl serde::Serialize for SecretKey {
490    fn serialize<S>(
491        &self,
492        serializer: S,
493    ) -> Result<<S as serde::Serializer>::Ok, <S as serde::Serializer>::Error>
494    where
495        S: serde::Serializer,
496    {
497        serializer.collect_str(self)
498    }
499}
500
501impl<'de> serde::Deserialize<'de> for SecretKey {
502    fn deserialize<D>(deserializer: D) -> Result<Self, <D as serde::Deserializer<'de>>::Error>
503    where
504        D: serde::Deserializer<'de>,
505    {
506        let s = <String as serde::Deserialize>::deserialize(deserializer)?;
507        Self::from_str(&s).map_err(|err| serde::de::Error::custom(err.to_string()))
508    }
509}
510
511const SECP256K1_N: U256 =
512    U256([0xbfd25e8cd0364141, 0xbaaedce6af48a03b, 0xfffffffffffffffe, 0xffffffffffffffff]);
513
514// Half of SECP256K1_N + 1.
515const SECP256K1_N_HALF_ONE: U256 =
516    U256([0xdfe92f46681b20a1, 0x5d576e7357a4501d, 0xffffffffffffffff, 0x7fffffffffffffff]);
517
518const SECP256K1_SIGNATURE_LENGTH: usize = 65;
519
520#[derive(Clone, Eq, PartialEq, Hash, derive_more::From, derive_more::Into)]
521pub struct Secp256K1Signature([u8; SECP256K1_SIGNATURE_LENGTH]);
522
523impl Secp256K1Signature {
524    pub fn check_signature_values(&self, reject_upper: bool) -> bool {
525        let mut r_bytes = [0u8; 32];
526        r_bytes.copy_from_slice(&self.0[0..32]);
527        let r = U256::from(r_bytes);
528
529        let mut s_bytes = [0u8; 32];
530        s_bytes.copy_from_slice(&self.0[32..64]);
531        let s = U256::from(s_bytes);
532
533        let s_check = if reject_upper {
534            // Reject upper range of s values (ECDSA malleability)
535            SECP256K1_N_HALF_ONE
536        } else {
537            SECP256K1_N
538        };
539
540        r < SECP256K1_N && s < s_check
541    }
542
543    pub fn recover(
544        &self,
545        msg: [u8; 32],
546    ) -> Result<Secp256K1PublicKey, crate::errors::ParseSignatureError> {
547        let recoverable_sig = secp256k1::ecdsa::RecoverableSignature::from_compact(
548            &self.0[0..64],
549            secp256k1::ecdsa::RecoveryId::from_i32(i32::from(self.0[64])).unwrap(),
550        )
551        .map_err(|err| crate::errors::ParseSignatureError::InvalidData {
552            error_message: err.to_string(),
553        })?;
554        let msg = Message::from_slice(&msg).unwrap();
555
556        let res = SECP256K1
557            .recover_ecdsa(&msg, &recoverable_sig)
558            .map_err(|err| crate::errors::ParseSignatureError::InvalidData {
559                error_message: err.to_string(),
560            })?
561            .serialize_uncompressed();
562
563        // Can not fail
564        let pk = Secp256K1PublicKey::try_from(&res[1..65]).unwrap();
565
566        Ok(pk)
567    }
568}
569
570impl TryFrom<&[u8]> for Secp256K1Signature {
571    type Error = crate::errors::ParseSignatureError;
572
573    fn try_from(data: &[u8]) -> Result<Self, Self::Error> {
574        Ok(Self(data.try_into().map_err(|_| Self::Error::InvalidLength {
575            expected_length: 65,
576            received_length: data.len(),
577        })?))
578    }
579}
580
581impl Debug for Secp256K1Signature {
582    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
583        Display::fmt(&Bs58(&self.0), f)
584    }
585}
586
587
588// RSA Signature
589const RSA2048_SIGNATURE_LENGTH: usize = 256;
590
591#[derive(Clone, Eq, PartialEq, Hash, derive_more::From, derive_more::Into)]
592pub struct Rsa2048Signature([u8; RSA2048_SIGNATURE_LENGTH]);
593
594impl TryFrom<&[u8]> for Rsa2048Signature {
595    type Error = crate::errors::ParseSignatureError;
596
597    fn try_from(data: &[u8]) -> Result<Self, Self::Error> {
598        Ok(Self(data.try_into().map_err(|_| Self::Error::InvalidLength {
599            expected_length: RSA2048_SIGNATURE_LENGTH,
600            received_length: data.len(),
601        })?))
602    }
603}
604
605impl Debug for Rsa2048Signature {
606    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
607        Display::fmt(&Bs58(&self.0), f)
608    }
609}
610
611/// Signature container supporting different curves.
612#[derive(Clone, PartialEq, Eq)]
613pub enum Signature {
614    ED25519(ed25519_dalek::Signature),
615    SECP256K1(Secp256K1Signature),
616    RSA(Rsa2048Signature),
617}
618
619// This `Hash` implementation is safe since it retains the property
620// `k1 == k2 ⇒ hash(k1) == hash(k2)`.
621impl Hash for Signature {
622    fn hash<H: Hasher>(&self, state: &mut H) {
623        match self {
624            Signature::ED25519(sig) => sig.to_bytes().hash(state),
625            Signature::SECP256K1(sig) => sig.hash(state),
626            Signature::RSA(sig) => sig.hash(state),
627        };
628    }
629}
630
631impl Signature {
632    /// Construct Signature from key type and raw signature blob
633    pub fn from_parts(
634        signature_type: KeyType,
635        signature_data: &[u8],
636    ) -> Result<Self, crate::errors::ParseSignatureError> {
637        match signature_type {
638            KeyType::ED25519 => Ok(Signature::ED25519(ed25519_dalek::Signature::from_bytes(
639                <&[u8; ed25519_dalek::SIGNATURE_LENGTH]>::try_from(signature_data).map_err(
640                    |err| crate::errors::ParseSignatureError::InvalidData {
641                        error_message: err.to_string(),
642                    },
643                )?,
644            ))),
645            KeyType::SECP256K1 => {
646                Ok(Signature::SECP256K1(Secp256K1Signature::try_from(signature_data).map_err(
647                    |_| crate::errors::ParseSignatureError::InvalidData {
648                        error_message: "invalid Secp256k1 signature length".to_string(),
649                    },
650                )?))
651            }
652            KeyType::RSA2048 => Ok(Signature::RSA(Rsa2048Signature::try_from(signature_data).map_err(
653                |_| crate::errors::ParseSignatureError::InvalidData {
654                    error_message: "invalid RSA2048 signature length".to_string(),
655                },
656            )?)),
657        }
658    }
659
660    /// Verifies that this signature is indeed signs the data with given public key.
661    /// Also if public key doesn't match on the curve returns `false`.
662    pub fn verify(&self, data: &[u8], public_key: &PublicKey) -> bool {
663        match (&self, public_key) {
664            (Signature::ED25519(signature), PublicKey::ED25519(public_key)) => {
665                match ed25519_dalek::VerifyingKey::from_bytes(&public_key.0) {
666                    Err(_) => false,
667                    Ok(public_key) => public_key.verify(data, signature).is_ok(),
668                }
669            }
670            (Signature::SECP256K1(signature), PublicKey::SECP256K1(public_key)) => {
671                let rsig = secp256k1::ecdsa::RecoverableSignature::from_compact(
672                    &signature.0[0..64],
673                    secp256k1::ecdsa::RecoveryId::from_i32(i32::from(signature.0[64])).unwrap(),
674                )
675                .unwrap();
676                let sig = rsig.to_standard();
677                let pdata: [u8; 65] = {
678                    // code borrowed from https://github.com/openethereum/openethereum/blob/98b7c07171cd320f32877dfa5aa528f585dc9a72/ethkey/src/signature.rs#L210
679                    let mut temp = [4u8; 65];
680                    temp[1..65].copy_from_slice(&public_key.0);
681                    temp
682                };
683                SECP256K1
684                    .verify_ecdsa(
685                        &secp256k1::Message::from_slice(data).expect("32 bytes"),
686                        &sig,
687                        &secp256k1::PublicKey::from_slice(&pdata).unwrap(),
688                    )
689                    .is_ok()
690            }
691            (Signature::RSA(signature), PublicKey::RSA(public_key)) => {
692                let pk = rsa::RsaPublicKey::from_public_key_der(&public_key.0).unwrap();
693                match pk.verify(Pkcs1v15Sign::new_unprefixed(), &data, signature.0.as_ref()) {
694                    Ok(_) => true,
695                    Err(_) => false,
696                }
697            }
698
699            _ => false,
700        }
701    }
702
703    pub fn key_type(&self) -> KeyType {
704        match self {
705            Signature::ED25519(_) => KeyType::ED25519,
706            Signature::SECP256K1(_) => KeyType::SECP256K1,
707            Signature::RSA(_) => KeyType::RSA2048,
708        }
709    }
710}
711
712impl Default for Signature {
713    fn default() -> Self {
714        Signature::empty(KeyType::ED25519)
715    }
716}
717
718impl BorshSerialize for Signature {
719    fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), Error> {
720        match self {
721            Signature::ED25519(signature) => {
722                BorshSerialize::serialize(&0u8, writer)?;
723                writer.write_all(&signature.to_bytes())?;
724            }
725            Signature::SECP256K1(signature) => {
726                BorshSerialize::serialize(&1u8, writer)?;
727                writer.write_all(&signature.0)?;
728            }
729            Signature::RSA(signature) => {
730                BorshSerialize::serialize(&2u8, writer)?;
731                writer.write_all(&signature.0)?;
732            }
733        }
734        Ok(())
735    }
736}
737
738impl BorshDeserialize for Signature {
739    fn deserialize_reader<R: Read>(rd: &mut R) -> std::io::Result<Self> {
740        let key_type = KeyType::try_from(u8::deserialize_reader(rd)?)
741            .map_err(|err| Error::new(ErrorKind::InvalidData, err.to_string()))?;
742        match key_type {
743            KeyType::ED25519 => {
744                let array: [u8; ed25519_dalek::SIGNATURE_LENGTH] =
745                    BorshDeserialize::deserialize_reader(rd)?;
746                // Sanity-check that was performed by ed25519-dalek in from_bytes before version 2,
747                // but was removed with version 2. It is not actually any good a check, but we have
748                // it here in case we need to keep backward compatibility. Maybe this check is not
749                // actually required, but please think carefully before removing it.
750                if array[ed25519_dalek::SIGNATURE_LENGTH - 1] & 0b1110_0000 != 0 {
751                    return Err(Error::new(ErrorKind::InvalidData, "signature error"));
752                }
753                Ok(Signature::ED25519(ed25519_dalek::Signature::from_bytes(&array)))
754            }
755            KeyType::SECP256K1 => {
756                let array: [u8; 65] = BorshDeserialize::deserialize_reader(rd)?;
757                Ok(Signature::SECP256K1(Secp256K1Signature(array)))
758            }
759            KeyType::RSA2048 => {
760                let array: [u8; 256] = BorshDeserialize::deserialize_reader(rd)?;
761                Ok(Signature::RSA(Rsa2048Signature(array)))
762            }
763        }
764    }
765}
766
767impl Display for Signature {
768    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
769        let buf;
770        let (key_type, key_data) = match self {
771            Signature::ED25519(signature) => {
772                buf = signature.to_bytes();
773                (KeyType::ED25519, &buf[..])
774            }
775            Signature::SECP256K1(signature) => (KeyType::SECP256K1, &signature.0[..]),
776            Signature::RSA(signature) => (KeyType::RSA2048, &signature.0[..]),
777        };
778        write!(f, "{}:{}", key_type, Bs58(&key_data))
779    }
780}
781
782impl Debug for Signature {
783    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
784        Display::fmt(self, f)
785    }
786}
787
788impl serde::Serialize for Signature {
789    fn serialize<S>(
790        &self,
791        serializer: S,
792    ) -> Result<<S as serde::Serializer>::Ok, <S as serde::Serializer>::Error>
793    where
794        S: serde::Serializer,
795    {
796        serializer.serialize_str(&self.to_string())
797    }
798}
799
800impl FromStr for Signature {
801    type Err = crate::errors::ParseSignatureError;
802
803    fn from_str(value: &str) -> Result<Self, Self::Err> {
804        let (sig_type, sig_data) = split_key_type_data(value)?;
805        Ok(match sig_type {
806            KeyType::ED25519 => {
807                let data = decode_bs58::<{ ed25519_dalek::SIGNATURE_LENGTH }>(sig_data)?;
808                let sig = ed25519_dalek::Signature::from_bytes(&data);
809                Signature::ED25519(sig)
810            }
811            KeyType::SECP256K1 => Signature::SECP256K1(Secp256K1Signature(decode_bs58(sig_data)?)),
812            KeyType::RSA2048 => Signature::RSA(Rsa2048Signature(decode_bs58(sig_data)?)),
813        })
814    }
815}
816
817impl<'de> serde::Deserialize<'de> for Signature {
818    fn deserialize<D>(deserializer: D) -> Result<Self, <D as serde::Deserializer<'de>>::Error>
819    where
820        D: serde::Deserializer<'de>,
821    {
822        let s = <String as serde::Deserialize>::deserialize(deserializer)?;
823        s.parse().map_err(|err: crate::errors::ParseSignatureError| {
824            serde::de::Error::custom(err.to_string())
825        })
826    }
827}
828
829/// Helper struct which provides Display implementation for bytes slice
830/// encoding them using base58.
831// TODO(mina86): Get rid of it once bs58 has this feature.  There’s currently PR
832// for that: https://github.com/Nullus157/bs58-rs/pull/97
833struct Bs58<'a>(&'a [u8]);
834
835impl<'a> core::fmt::Display for Bs58<'a> {
836    fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
837        debug_assert!(self.0.len() <= 1218);
838        // The largest buffer we’re ever encoding is 65-byte long.  Base58
839        // increases size of the value by less than 40%.  96-byte buffer is
840        // therefore enough to fit the largest value we’re ever encoding.
841        let mut buf = [0u8; 2048];
842        let len = bs58::encode(self.0).into(&mut buf[..]).unwrap();
843        let output = &buf[..len];
844        // SAFETY: we know that alphabet can only include ASCII characters
845        // thus our result is an ASCII string.
846        fmt.write_str(unsafe { std::str::from_utf8_unchecked(output) })
847    }
848}
849
850/// Helper which decodes fixed-length base58-encoded data.
851///
852/// If the encoded string decodes into a buffer of different length than `N`,
853/// returns error.  Similarly returns error if decoding fails.
854fn decode_bs58<const N: usize>(encoded: &str) -> Result<[u8; N], DecodeBs58Error> {
855    let mut buffer = [0u8; N];
856    decode_bs58_impl(&mut buffer[..], encoded)?;
857    Ok(buffer)
858}
859
860fn decode_bs58_impl(dst: &mut [u8], encoded: &str) -> Result<(), DecodeBs58Error> {
861    let expected = dst.len();
862    match bs58::decode(encoded).into(dst) {
863        Ok(received) if received == expected => Ok(()),
864        Ok(received) => Err(DecodeBs58Error::BadLength { expected, received }),
865        Err(bs58::decode::Error::BufferTooSmall) => {
866            Err(DecodeBs58Error::BadLength { expected, received: expected.saturating_add(1) })
867        }
868        Err(err) => Err(DecodeBs58Error::BadData(err.to_string())),
869    }
870}
871
872enum DecodeBs58Error {
873    BadLength { expected: usize, received: usize },
874    BadData(String),
875}
876
877impl std::convert::From<DecodeBs58Error> for crate::errors::ParseKeyError {
878    fn from(err: DecodeBs58Error) -> Self {
879        match err {
880            DecodeBs58Error::BadLength { expected, received } => {
881                crate::errors::ParseKeyError::InvalidLength {
882                    expected_length: expected,
883                    received_length: received,
884                }
885            }
886            DecodeBs58Error::BadData(error_message) => Self::InvalidData { error_message },
887        }
888    }
889}
890
891impl std::convert::From<DecodeBs58Error> for crate::errors::ParseSignatureError {
892    fn from(err: DecodeBs58Error) -> Self {
893        match err {
894            DecodeBs58Error::BadLength { expected, received } => {
895                Self::InvalidLength { expected_length: expected, received_length: received }
896            }
897            DecodeBs58Error::BadData(error_message) => Self::InvalidData { error_message },
898        }
899    }
900}
901
902#[cfg(test)]
903mod tests {
904    use super::*;
905
906    #[test]
907    fn test_sign_verify() {
908        for key_type in [KeyType::ED25519, KeyType::SECP256K1, KeyType::RSA2048] {
909            let secret_key = SecretKey::from_random(key_type);
910            let public_key = secret_key.public_key();
911            use sha2::Digest;
912            let data = sha2::Sha256::digest(b"123").to_vec();
913            let signature = secret_key.sign(&data);
914            assert!(signature.verify(&data, &public_key));
915        }
916    }
917
918    #[test]
919    fn test_json_serialize_ed25519() {
920        let sk = SecretKey::from_seed(KeyType::ED25519, "test");
921        let pk = sk.public_key();
922        let expected = "\"ed25519:DcA2MzgpJbrUATQLLceocVckhhAqrkingax4oJ9kZ847\"";
923        assert_eq!(serde_json::to_string(&pk).unwrap(), expected);
924        assert_eq!(pk, serde_json::from_str(expected).unwrap());
925        assert_eq!(
926            pk,
927            serde_json::from_str("\"DcA2MzgpJbrUATQLLceocVckhhAqrkingax4oJ9kZ847\"").unwrap()
928        );
929        let pk2: PublicKey = pk.to_string().parse().unwrap();
930        assert_eq!(pk, pk2);
931
932        let expected = "\"ed25519:3KyUuch8pYP47krBq4DosFEVBMR5wDTMQ8AThzM8kAEcBQEpsPdYTZ2FPX5ZnSoLrerjwg66hwwJaW1wHzprd5k3\"";
933        assert_eq!(serde_json::to_string(&sk).unwrap(), expected);
934        assert_eq!(sk, serde_json::from_str(expected).unwrap());
935
936        let signature = sk.sign(b"123");
937        let expected = "\"ed25519:3s1dvZdQtcAjBksMHFrysqvF63wnyMHPA4owNQmCJZ2EBakZEKdtMsLqrHdKWQjJbSRN6kRknN2WdwSBLWGCokXj\"";
938        assert_eq!(serde_json::to_string(&signature).unwrap(), expected);
939        assert_eq!(signature, serde_json::from_str(expected).unwrap());
940        let signature_str: String = signature.to_string();
941        let signature2: Signature = signature_str.parse().unwrap();
942        assert_eq!(signature, signature2);
943    }
944
945    #[test]
946    fn test_json_serialize_secp256k1() {
947        use sha2::Digest;
948        let data = sha2::Sha256::digest(b"123").to_vec();
949
950        let sk = SecretKey::from_seed(KeyType::SECP256K1, "test");
951        let pk = sk.public_key();
952        let expected = "\"secp256k1:5ftgm7wYK5gtVqq1kxMGy7gSudkrfYCbpsjL6sH1nwx2oj5NR2JktohjzB6fbEhhRERQpiwJcpwnQjxtoX3GS3cQ\"";
953        assert_eq!(serde_json::to_string(&pk).unwrap(), expected);
954        assert_eq!(pk, serde_json::from_str(expected).unwrap());
955        let pk2: PublicKey = pk.to_string().parse().unwrap();
956        assert_eq!(pk, pk2);
957
958        let expected = "\"secp256k1:X4ETFKtQkSGVoZEnkn7bZ3LyajJaK2b3eweXaKmynGx\"";
959        assert_eq!(serde_json::to_string(&sk).unwrap(), expected);
960        assert_eq!(sk, serde_json::from_str(expected).unwrap());
961
962        let signature = sk.sign(&data);
963        let expected = "\"secp256k1:5N5CB9H1dmB9yraLGCo4ZCQTcF24zj4v2NT14MHdH3aVhRoRXrX3AhprHr2w6iXNBZDmjMS1Ntzjzq8Bv6iBvwth6\"";
964        assert_eq!(serde_json::to_string(&signature).unwrap(), expected);
965        assert_eq!(signature, serde_json::from_str(expected).unwrap());
966        let signature_str: String = signature.to_string();
967        let signature2: Signature = signature_str.parse().unwrap();
968        assert_eq!(signature, signature2);
969    }
970
971    #[test]
972    fn test_json_serialize_rsa2048() {
973        use sha2::Digest;
974        let data = sha2::Sha256::digest(b"123").to_vec();
975
976        let sk = SecretKey::from_seed(KeyType::RSA2048, "test");
977        let pk = sk.public_key();
978        let expected = "\"rsa2048:2TuPVgMCHJy5atawrsADEzjP7MCVbyyCA89UW6Wvjp9HrBuhZpGCRvEqExjN4wDfrT97k75BySeWiWgDoRmWBCVMQzCNFWQcfVmzeeZJFnVVceSziJsciYeCEeJGzjQnWBj4PEESKNgdKGWrQyUckRvknPQE3v7GVp9tXRPL81nLAgNm29E4SQ3u6ZV3DzJTCnnsoW75H8vdMMRY3zNzpTWKjEkMYA9qow6nnpS9asJ3HqXshDh3ookoAqzYgVwYmh2CDYFyw3cdwzimFFTYv3STud6erWxiMogeqP2XNnUyFYPKRWrhrrY966QDk4mEz1JgvBN9U4Vh5tsJGZLrZQPpt1owEjrGuCB6iqZQFwKxxjmNTcCZXZZn2WbdYVnSXGFR68uAjtPmHktzwS\"";
979        assert_eq!(serde_json::to_string(&pk).unwrap(), expected);
980        assert_eq!(pk, serde_json::from_str(expected).unwrap());
981        let pk2: PublicKey = pk.to_string().parse().unwrap();
982        assert_eq!(pk, pk2);
983
984        let expected = "\"rsa2048:riiewRJm2wpE3rWTs1ikUc83so8ZXMX8vp9dUTnRgMC8GyfLr99MgiVFAbK3mdNq6mGY5dNdUfn3anQVSqFHL4sPbZD4w7QBx5Dzj4MzqJ8LjqmiKxE64G9tNDjfzkyYdinPssorC9yab7EhBMe24m3dMSnwHBJHQsXXaGibBtJUBcgPCbwYerZjfJB7TjMrj7WF1A2Q9SNdLUMYNX5CuKbWnpmrgFdkUzR1rZjrcgzSyUs4LrWwPBy2uA8PjJLwRabvoPpSr6hTMoHjeGMnQsLbVxKs7SC5aucdXru6ox9jJeD9Jackd5HKjAmobBaKiR1i9f7EsoxfsmibsqML8B5fFuHCRzMT6Ea5oEETevn4H5uBszJtrPJQpM5kwNogcNchHhK8GG2FZDGY5bsZuJEvzrWeuK7XR1ef1JmAmCtSqQNLe42CkqvBun8Cwj61Gf2rkvU2He1Wc6Lg81CwQKLUZTFRDXkdmaJEjAdweXhcksbMhajDp1D5mHtL3LY3FvxvgZpHxVq4gnKQTQenCvmgoH6JAJNQK5pmP68hMaJ4EZ45LgCzfzNs5eYYq3jqUQHGY7mvKi7E4ZFkY8fmgk5VQWcTyb3WeiqXzSYB79c2cR4XSUgmXiaFnLUYM1kqaNzeUhiprCTC43k9MhX5kMw3VRcg2RzrdnofHetPn75MPeR4g9i4kooZyRRkEvdg4YAWL6rhYQ5vV99cbQvTZSAzYTasiHfUKLkB76yoXJiok57tAjbz9XBGgWeqGRF8UFFcMDw8KJqrrEA4E1FhYEEYNR84kuU4ZwnnJakBCXf1UoYC7RKJEiWtcBqcL3Epcp3x6d4qxLij3M1pCDeFPZPYyMqYPvM8yB6GfMVwcycJSxWjK7cxmVRPF9WT3HyVNqFHA4o1aXHJ9LGMgDdVCUSk1QfEC1kLxMMFZMVY6RK6ycUPmotJxbJgBL9SAFypzNg63tipocAXucqaJ3NQrA5ujLnV4GhrmwF9Eo6T7FH9qgqsKZV1FN7m83TtXUuRqSDMdpDLLNotcC4MQ6nFH46R73ct8CE4ibn6j4dtPMMJrEuWQqAE8tqpvGJoxifvVfwmtJMvozTTu69DgXn38MHZL2f3K25M7iW4yWiZjve4b7AFXhnaaKQuCwoZ6CNf31X2STT29wFvw6HMZNZt4WdXMxUrgP5mkM8r2Fio8iEQUbSfhrAj3SuZXDV3xiRYRXb45cL7umoZ446YctmQuyHzaRfP8yLsy3Y7Bn8GGTj4bbzPNhT4r4QHitobymKScePdFTms4P8HNogebkBf4K7QrNSJxA4EVRgf9aP4KejHUfhq9v7pLGsfXv3rGaxRZnCNrgTYY215e8FoJcx8mQGvykCRejto8Gghp1gw5n5eC3ddMUiYqphteoYfuhVYfiweMDSiRrajko4JAxuXpvHRVeTwSypPYUkiazcog7z8bgPSq1FNS8Vnqhyx4oSj5rBGXTK8y7MR9zPB8yN78DacxPBBLfUcMvVan4GueCi2wxq9KL8XMj8DvDccBBotc8c1jftgaYdLqESVqpiKj3ZSu8Ui3SpdhELMFzk22kwRXN2p9nK78u94Gpp44J9upyiNpHsLbkB3kpT4vtvxa8P9H1YhMqVRB2k9EhVHUwATRVb3uoznRqXVnXmE8cq\"";
985        assert_eq!(serde_json::to_string(&sk).unwrap(), expected);
986        assert_eq!(sk, serde_json::from_str(expected).unwrap());
987
988        let signature = sk.sign(&data);
989        let expected = "\"rsa2048:9UXu2UtEzfgJWw5goaHcjAueJcRkwNS9VPHsF1Re2MR8p7WcA9Q77DTPAMWXkDnEsaebWFwrQHqqk8jAZfLsZDTBmDQ28XNsPgsx3wJkwrujYT5o99Zf6J1SbFK3umfzgo26BNWGLD44nrqhFJDwy1UdXqQPMKGKs7P56g2dqbEe3daoVze6UrhHQAdLbEXN9BQJBkNz254MLey7pzbAforMfoqy2S3RdvgFRQuXdgHbsXSHJEemmQEVpMiMvDW5Hz4vVMx3XaLkLLUQfqpT9Tom6NbGsNfPn7M1Ge1xXEFs25Zcqv3e7mq5Ps8pXovCexeznHJz5VSkDGY2h2r6tpACjDM2LW\"";
990        assert_eq!(serde_json::to_string(&signature).unwrap(), expected);
991        assert_eq!(signature, serde_json::from_str(expected).unwrap());
992        let signature_str: String = signature.to_string();
993        let signature2: Signature = signature_str.parse().unwrap();
994        assert_eq!(signature, signature2);
995    }
996
997    #[test]
998    fn test_borsh_serialization() {
999        use sha2::Digest;
1000        let data = sha2::Sha256::digest(b"123").to_vec();
1001        for key_type in [KeyType::ED25519, KeyType::SECP256K1, KeyType::RSA2048] {
1002            let sk = SecretKey::from_seed(key_type, "test");
1003            let pk = sk.public_key();
1004            let bytes = borsh::to_vec(&pk).unwrap();
1005            assert_eq!(PublicKey::try_from_slice(&bytes).unwrap(), pk);
1006
1007            let signature = sk.sign(&data);
1008            let bytes = borsh::to_vec(&signature).unwrap();
1009            assert_eq!(Signature::try_from_slice(&bytes).unwrap(), signature);
1010
1011            assert!(PublicKey::try_from_slice(&[0]).is_err());
1012            assert!(Signature::try_from_slice(&[0]).is_err());
1013        }
1014    }
1015
1016    #[test]
1017    fn test_invalid_data() {
1018        let invalid = "\"secp256k1:2xVqteU8PWhadHTv99TGh3bSf\"";
1019        assert!(serde_json::from_str::<PublicKey>(invalid).is_err());
1020        assert!(serde_json::from_str::<SecretKey>(invalid).is_err());
1021        assert!(serde_json::from_str::<Signature>(invalid).is_err());
1022    }
1023
1024    #[test]
1025    fn test_invalid_rsa_data() {
1026        let invalid = "\"rsa2048:riiewRJm2wpE3rWTs1ikUc83so8ZXMX8vp9dUTnRgMC8GyfLr99MgiVFAbK3mdNq6mGY5dNdUfn3anQVSqFHL4sPbZD4w7QBx5Dzj4MzqJ8LjqmiKxE64G9tNDjfzkyYdinPssorC9yab7EhBMe24m3dMSnwHBJHQsXXaGibBtJUBcgPCbwYerZjfJB7TjMrj7WF1A2Q9SNdLUMYNX5CuKbWnpmrgFdkUzR1rZjrcgzSyUs4LrWwPBy2uA8PjJLwRabvoPpSr6hTMoHjeGMnQsLbVxKs7SC5aucdXru6ox9jJeD9Jackd5HKjAmobBaKiR1i9f7EsoxfsmibsqML8B5fFuHCRzMT6Ea5oEETevn4H5uBszJtrPJQpM5kwNogcNchHhK8GG2FZDGY5bsZuJEvzrWeuK7XR1ef1JmAmCtSqQNLe42CkqvBun8Cwj61Gf2rkvU2He1Wc6Lg81CwQKLUZTFRDXkdmaJEjAdweXhcksbMhajDp1D5mHtL3LY3FvxvgZpHxVq4gnKQTQenCvmgoH6JAJNQK5pmP68hMaJ4EZ45LgCzfzNs5eYYq3jqUQHGY7mvKi7E4ZFkY8fmgk5VQWcTyb3WeiqXzSYB79c2cR4XSUgmXiaFnLUYM1kqaNzeUhiprCTC43k9MhX5kMw3VRcg2RzrdnofHetPn75MPeR4g9i4kooZyRRkEvdg4YAWL6rhYQ5vV99cbQvTZSAzYTasiHfUKLkB76yoXJiok57tAjbz9XBGgWeqGRF8UFFcMDw8KJqrrEA4E1FhYEEYNR84kuU4ZwnnJakBCXf1UoYC7RKJEiWtcBqcL3Epcp3x6d4qxLij3M1pCDeFPZPYyMqYPvM8yB6GfMVwcycJSxWjK7cxmVRPF9WT3HyVNqFHA4o1aXHJ9LGMgDdVCUSk1QfEC1kLxMMFZMVY6RK6ycUPmotJxbJgBL9SAFypzNg63tipocAXucqaJ3NQrA5ujLnV4GhrmwF9Eo6T7FH9qgqsKZV1FN7m83TtXUuRqSDMdpDLLNotcC4MQ6nFH46R73ct8CE4ibn6j4dtPMMJrEuWQqAE8tqpvGJoxifvVfwmtJMvozTTu69DgXn38MHZL2f3K25M7iW4yWiZjve4b7AFXhnaaKQuCwoZ6CNf31X2STT29wFvw6HMZNZt4WdXMxUrgP5mkM8r2Fio8iEQUbSfhrAj3SuZXDV3xiRYRXb45cL7umoZ446YctmQuyHzaRfP8yLsy3Y7Bn8GGTj4bbzPNhT4r4QHitobymKScePdFTms4P8HNogebkBf4K7QrNSJxA4EVRgf9aP4KejHUfhq9v7pLGsfXv3rGaxRZnCNrgTYY215e8FoJcx8mQGvykCRejto8Gghp1gw5n5eC3ddMUiYqphteoYfuhVYfiweMDSiRrajko4JAxuXpvHRVeTwSypPYUkiazcog7z8bgPSq1FNS8Vnqhyx4oSj5rBGXTK8y7MR9zPB8yN78DacxPBBLfUcMvVan4GueCi2wxq9KL8XMj8DvDccBBotc8c1jftgaYdLqESVqpiKj3ZSu8Ui3SpdhELMFzk22kwRXN2p9nK78u94Gpp44J9upyiNpHsLbkB3kpT4vtvxa8P9H1YhMqVRB2k9EhVHUwATRVb3uoznRqXVnXmE8cq\"";
1027        assert!(serde_json::from_str::<PublicKey>(invalid).is_err());
1028        assert!(serde_json::from_str::<SecretKey>(invalid).is_ok());
1029        assert!(serde_json::from_str::<Signature>(invalid).is_err());
1030    }
1031}
utility_crypto/signature.rs

utility_crypto/
signature.rs
