unc_crypto/
signature.rs

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

unc_crypto/
signature.rs
