sui_crypto/
simple.rs

1use crate::SignatureError;
2use signature::Verifier;
3use sui_sdk_types::SimpleSignature;
4use sui_sdk_types::UserSignature;
5
6pub struct SimpleVerifier;
7
8impl Verifier<SimpleSignature> for SimpleVerifier {
9    #[allow(unused_variables)]
10    fn verify(&self, message: &[u8], signature: &SimpleSignature) -> Result<(), SignatureError> {
11        match signature {
12            #[cfg(feature = "ed25519")]
13            SimpleSignature::Ed25519 {
14                signature,
15                public_key,
16            } => {
17                let verifying_key = crate::ed25519::Ed25519VerifyingKey::new(public_key)?;
18                verifying_key.verify(message, signature)
19            }
20            #[cfg(not(feature = "ed25519"))]
21            SimpleSignature::Ed25519 { .. } => Err(SignatureError::from_source(
22                "support for ed25519 is not enabled",
23            )),
24
25            #[cfg(feature = "secp256k1")]
26            SimpleSignature::Secp256k1 {
27                signature,
28                public_key,
29            } => {
30                let verifying_key = crate::secp256k1::Secp256k1VerifyingKey::new(public_key)?;
31                verifying_key.verify(message, signature)
32            }
33            #[cfg(not(feature = "secp256k1"))]
34            SimpleSignature::Secp256k1 { .. } => Err(SignatureError::from_source(
35                "support for secp256k1 is not enabled",
36            )),
37
38            #[cfg(feature = "secp256r1")]
39            SimpleSignature::Secp256r1 {
40                signature,
41                public_key,
42            } => {
43                let verifying_key = crate::secp256r1::Secp256r1VerifyingKey::new(public_key)?;
44                verifying_key.verify(message, signature)
45            }
46            #[cfg(not(feature = "secp256r1"))]
47            SimpleSignature::Secp256r1 { .. } => Err(SignatureError::from_source(
48                "support for secp256r1 is not enabled",
49            )),
50        }
51    }
52}
53
54impl Verifier<UserSignature> for SimpleVerifier {
55    fn verify(&self, message: &[u8], signature: &UserSignature) -> Result<(), SignatureError> {
56        let UserSignature::Simple(signature) = signature else {
57            return Err(SignatureError::from_source("not a simple signature"));
58        };
59
60        <Self as Verifier<SimpleSignature>>::verify(self, message, signature)
61    }
62}
63
64#[cfg(any(feature = "ed25519", feature = "secp256r1", feature = "secp256k1",))]
65#[cfg_attr(
66    doc_cfg,
67    doc(cfg(any(feature = "ed25519", feature = "secp256r1", feature = "secp256k1",)))
68)]
69#[rustfmt::skip]
70pub use keypair::{SimpleKeypair, SimpleVerifiyingKey};
71
72#[cfg(any(feature = "ed25519", feature = "secp256r1", feature = "secp256k1",))]
73#[cfg_attr(
74    doc_cfg,
75    doc(cfg(any(feature = "ed25519", feature = "secp256r1", feature = "secp256k1",)))
76)]
77mod keypair {
78    use crate::SignatureError;
79    use signature::Signer;
80    use signature::Verifier;
81    use sui_sdk_types::MultisigMemberPublicKey;
82    use sui_sdk_types::SignatureScheme;
83    use sui_sdk_types::SimpleSignature;
84    use sui_sdk_types::UserSignature;
85
86    #[derive(Debug, Clone)]
87    pub struct SimpleKeypair {
88        inner: InnerKeypair,
89    }
90
91    #[derive(Debug, Clone)]
92    enum InnerKeypair {
93        #[cfg(feature = "ed25519")]
94        Ed25519(crate::ed25519::Ed25519PrivateKey),
95        #[cfg(feature = "secp256k1")]
96        Secp256k1(crate::secp256k1::Secp256k1PrivateKey),
97        #[cfg(feature = "secp256r1")]
98        Secp256r1(crate::secp256r1::Secp256r1PrivateKey),
99    }
100
101    impl SimpleKeypair {
102        pub fn scheme(&self) -> SignatureScheme {
103            match &self.inner {
104                #[cfg(feature = "ed25519")]
105                InnerKeypair::Ed25519(private_key) => private_key.scheme(),
106                #[cfg(feature = "secp256k1")]
107                InnerKeypair::Secp256k1(private_key) => private_key.scheme(),
108                #[cfg(feature = "secp256r1")]
109                InnerKeypair::Secp256r1(private_key) => private_key.scheme(),
110            }
111        }
112
113        pub fn verifying_key(&self) -> SimpleVerifiyingKey {
114            let verifying_key = match &self.inner {
115                #[cfg(feature = "ed25519")]
116                InnerKeypair::Ed25519(private_key) => {
117                    InnerVerifyingKey::Ed25519(private_key.verifying_key())
118                }
119                #[cfg(feature = "secp256k1")]
120                InnerKeypair::Secp256k1(private_key) => {
121                    InnerVerifyingKey::Secp256k1(private_key.verifying_key())
122                }
123                #[cfg(feature = "secp256r1")]
124                InnerKeypair::Secp256r1(private_key) => {
125                    InnerVerifyingKey::Secp256r1(private_key.verifying_key())
126                }
127            };
128
129            SimpleVerifiyingKey {
130                inner: verifying_key,
131            }
132        }
133
134        pub fn public_key(&self) -> MultisigMemberPublicKey {
135            self.verifying_key().public_key()
136        }
137
138        #[cfg(feature = "pem")]
139        #[cfg_attr(doc_cfg, doc(cfg(feature = "pem")))]
140        /// Deserialize PKCS#8 private key from ASN.1 DER-encoded data (binary format).
141        pub fn from_der(bytes: &[u8]) -> Result<Self, SignatureError> {
142            let private_key =
143                pkcs8::PrivateKeyInfo::try_from(bytes).map_err(SignatureError::from_source)?;
144
145            match private_key
146                .algorithm
147                .oids()
148                .map_err(SignatureError::from_source)?
149            {
150                #[cfg(feature = "ed25519")]
151                (ed25519_dalek::pkcs8::ALGORITHM_OID, None) => private_key
152                    .try_into()
153                    .map(crate::ed25519::Ed25519PrivateKey::from_dalek)
154                    .map(InnerKeypair::Ed25519)
155                    .map_err(SignatureError::from_source),
156
157                #[cfg(feature = "secp256r1")]
158                (
159                    p256::elliptic_curve::ALGORITHM_OID,
160                    Some(<p256::NistP256 as pkcs8::AssociatedOid>::OID),
161                ) => private_key
162                    .try_into()
163                    .map(crate::secp256r1::Secp256r1PrivateKey::from_p256)
164                    .map(InnerKeypair::Secp256r1)
165                    .map_err(SignatureError::from_source),
166
167                #[cfg(feature = "secp256k1")]
168                (
169                    k256::elliptic_curve::ALGORITHM_OID,
170                    Some(<k256::Secp256k1 as pkcs8::AssociatedOid>::OID),
171                ) => private_key
172                    .try_into()
173                    .map(crate::secp256k1::Secp256k1PrivateKey::from_k256)
174                    .map(InnerKeypair::Secp256k1)
175                    .map_err(SignatureError::from_source),
176
177                _ => Err(SignatureError::from_source(
178                    "unsupported or invalid private key type",
179                )),
180            }
181            .map(|inner| Self { inner })
182        }
183
184        #[cfg(feature = "pem")]
185        #[cfg_attr(doc_cfg, doc(cfg(feature = "pem")))]
186        /// Serialize this private key as DER-encoded PKCS#8
187        pub fn to_der(&self) -> Result<Vec<u8>, SignatureError> {
188            match &self.inner {
189                #[cfg(feature = "ed25519")]
190                InnerKeypair::Ed25519(private_key) => private_key.to_der(),
191                #[cfg(feature = "secp256k1")]
192                InnerKeypair::Secp256k1(private_key) => private_key.to_der(),
193                #[cfg(feature = "secp256r1")]
194                InnerKeypair::Secp256r1(private_key) => private_key.to_der(),
195            }
196        }
197
198        #[cfg(feature = "pem")]
199        #[cfg_attr(doc_cfg, doc(cfg(feature = "pem")))]
200        /// Deserialize PKCS#8-encoded private key from PEM.
201        pub fn from_pem(s: &str) -> Result<Self, SignatureError> {
202            use pkcs8::der::pem::PemLabel;
203
204            let (label, doc) =
205                pkcs8::SecretDocument::from_pem(s).map_err(SignatureError::from_source)?;
206            pkcs8::PrivateKeyInfo::validate_pem_label(label)
207                .map_err(SignatureError::from_source)?;
208            Self::from_der(doc.as_bytes())
209        }
210
211        #[cfg(feature = "pem")]
212        #[cfg_attr(doc_cfg, doc(cfg(feature = "pem")))]
213        /// Serialize this private key as DER-encoded PKCS#8
214        pub fn to_pem(&self) -> Result<String, SignatureError> {
215            match &self.inner {
216                #[cfg(feature = "ed25519")]
217                InnerKeypair::Ed25519(private_key) => private_key.to_pem(),
218                #[cfg(feature = "secp256k1")]
219                InnerKeypair::Secp256k1(private_key) => private_key.to_pem(),
220                #[cfg(feature = "secp256r1")]
221                InnerKeypair::Secp256r1(private_key) => private_key.to_pem(),
222            }
223        }
224    }
225
226    impl Signer<SimpleSignature> for SimpleKeypair {
227        fn try_sign(&self, message: &[u8]) -> Result<SimpleSignature, SignatureError> {
228            match &self.inner {
229                #[cfg(feature = "ed25519")]
230                InnerKeypair::Ed25519(private_key) => private_key.try_sign(message),
231                #[cfg(feature = "secp256k1")]
232                InnerKeypair::Secp256k1(private_key) => private_key.try_sign(message),
233                #[cfg(feature = "secp256r1")]
234                InnerKeypair::Secp256r1(private_key) => private_key.try_sign(message),
235            }
236        }
237    }
238
239    impl Signer<UserSignature> for SimpleKeypair {
240        fn try_sign(&self, msg: &[u8]) -> Result<UserSignature, SignatureError> {
241            <Self as Signer<SimpleSignature>>::try_sign(self, msg).map(UserSignature::Simple)
242        }
243    }
244
245    #[cfg(feature = "ed25519")]
246    #[cfg_attr(doc_cfg, doc(cfg(feature = "ed25519")))]
247    impl From<crate::ed25519::Ed25519PrivateKey> for SimpleKeypair {
248        fn from(private_key: crate::ed25519::Ed25519PrivateKey) -> Self {
249            Self {
250                inner: InnerKeypair::Ed25519(private_key),
251            }
252        }
253    }
254
255    #[cfg(feature = "secp256r1")]
256    #[cfg_attr(doc_cfg, doc(cfg(feature = "secp256r1")))]
257    impl From<crate::secp256r1::Secp256r1PrivateKey> for SimpleKeypair {
258        fn from(private_key: crate::secp256r1::Secp256r1PrivateKey) -> Self {
259            Self {
260                inner: InnerKeypair::Secp256r1(private_key),
261            }
262        }
263    }
264
265    #[cfg(feature = "secp256k1")]
266    #[cfg_attr(doc_cfg, doc(cfg(feature = "secp256k1")))]
267    impl From<crate::secp256k1::Secp256k1PrivateKey> for SimpleKeypair {
268        fn from(private_key: crate::secp256k1::Secp256k1PrivateKey) -> Self {
269            Self {
270                inner: InnerKeypair::Secp256k1(private_key),
271            }
272        }
273    }
274
275    #[derive(Debug, Clone, Eq, PartialEq)]
276    pub struct SimpleVerifiyingKey {
277        inner: InnerVerifyingKey,
278    }
279
280    #[derive(Debug, Clone, Eq, PartialEq)]
281    enum InnerVerifyingKey {
282        #[cfg(feature = "ed25519")]
283        Ed25519(crate::ed25519::Ed25519VerifyingKey),
284        #[cfg(feature = "secp256k1")]
285        Secp256k1(crate::secp256k1::Secp256k1VerifyingKey),
286        #[cfg(feature = "secp256r1")]
287        Secp256r1(crate::secp256r1::Secp256r1VerifyingKey),
288    }
289
290    impl SimpleVerifiyingKey {
291        pub fn scheme(&self) -> SignatureScheme {
292            match &self.inner {
293                #[cfg(feature = "ed25519")]
294                InnerVerifyingKey::Ed25519(verifying_key) => verifying_key.public_key().scheme(),
295                #[cfg(feature = "secp256k1")]
296                InnerVerifyingKey::Secp256k1(verifying_key) => verifying_key.public_key().scheme(),
297                #[cfg(feature = "secp256r1")]
298                InnerVerifyingKey::Secp256r1(verifying_key) => verifying_key.public_key().scheme(),
299            }
300        }
301
302        pub fn public_key(&self) -> MultisigMemberPublicKey {
303            match &self.inner {
304                #[cfg(feature = "ed25519")]
305                InnerVerifyingKey::Ed25519(verifying_key) => {
306                    MultisigMemberPublicKey::Ed25519(verifying_key.public_key())
307                }
308                #[cfg(feature = "secp256k1")]
309                InnerVerifyingKey::Secp256k1(verifying_key) => {
310                    MultisigMemberPublicKey::Secp256k1(verifying_key.public_key())
311                }
312                #[cfg(feature = "secp256r1")]
313                InnerVerifyingKey::Secp256r1(verifying_key) => {
314                    MultisigMemberPublicKey::Secp256r1(verifying_key.public_key())
315                }
316            }
317        }
318
319        #[cfg(feature = "pem")]
320        #[cfg_attr(doc_cfg, doc(cfg(feature = "pem")))]
321        /// Deserialize public key from ASN.1 DER-encoded data (binary format).
322        pub fn from_der(bytes: &[u8]) -> Result<Self, SignatureError> {
323            let public_key = pkcs8::SubjectPublicKeyInfoRef::try_from(bytes)
324                .map_err(SignatureError::from_source)?;
325
326            match public_key
327                .algorithm
328                .oids()
329                .map_err(SignatureError::from_source)?
330            {
331                #[cfg(feature = "ed25519")]
332                (ed25519_dalek::pkcs8::ALGORITHM_OID, None) => public_key
333                    .try_into()
334                    .map(crate::ed25519::Ed25519VerifyingKey::from_dalek)
335                    .map(InnerVerifyingKey::Ed25519)
336                    .map_err(SignatureError::from_source),
337
338                #[cfg(feature = "secp256r1")]
339                (
340                    p256::elliptic_curve::ALGORITHM_OID,
341                    Some(<p256::NistP256 as pkcs8::AssociatedOid>::OID),
342                ) => public_key
343                    .try_into()
344                    .map(crate::secp256r1::Secp256r1VerifyingKey::from_p256)
345                    .map(InnerVerifyingKey::Secp256r1)
346                    .map_err(SignatureError::from_source),
347
348                #[cfg(feature = "secp256k1")]
349                (
350                    k256::elliptic_curve::ALGORITHM_OID,
351                    Some(<k256::Secp256k1 as pkcs8::AssociatedOid>::OID),
352                ) => public_key
353                    .try_into()
354                    .map(crate::secp256k1::Secp256k1VerifyingKey::from_k256)
355                    .map(InnerVerifyingKey::Secp256k1)
356                    .map_err(SignatureError::from_source),
357
358                _ => Err(SignatureError::from_source(
359                    "unsupported or invalid public key type",
360                )),
361            }
362            .map(|inner| Self { inner })
363        }
364
365        #[cfg(feature = "pem")]
366        #[cfg_attr(doc_cfg, doc(cfg(feature = "pem")))]
367        /// Serialize this public key as DER-encoded data
368        pub fn to_der(&self) -> Result<Vec<u8>, SignatureError> {
369            match &self.inner {
370                #[cfg(feature = "ed25519")]
371                InnerVerifyingKey::Ed25519(verifying_key) => verifying_key.to_der(),
372                #[cfg(feature = "secp256k1")]
373                InnerVerifyingKey::Secp256k1(verifying_key) => verifying_key.to_der(),
374                #[cfg(feature = "secp256r1")]
375                InnerVerifyingKey::Secp256r1(verifying_key) => verifying_key.to_der(),
376            }
377        }
378
379        #[cfg(feature = "pem")]
380        #[cfg_attr(doc_cfg, doc(cfg(feature = "pem")))]
381        /// Deserialize public key from PEM.
382        pub fn from_pem(s: &str) -> Result<Self, SignatureError> {
383            use pkcs8::der::pem::PemLabel;
384
385            let (label, doc) = pkcs8::Document::from_pem(s).map_err(SignatureError::from_source)?;
386            pkcs8::SubjectPublicKeyInfoRef::validate_pem_label(label)
387                .map_err(SignatureError::from_source)?;
388            Self::from_der(doc.as_bytes())
389        }
390
391        #[cfg(feature = "pem")]
392        #[cfg_attr(doc_cfg, doc(cfg(feature = "pem")))]
393        /// Serialize this public key as PEM
394        pub fn to_pem(&self) -> Result<String, SignatureError> {
395            match &self.inner {
396                #[cfg(feature = "ed25519")]
397                InnerVerifyingKey::Ed25519(verifying_key) => verifying_key.to_pem(),
398                #[cfg(feature = "secp256k1")]
399                InnerVerifyingKey::Secp256k1(verifying_key) => verifying_key.to_pem(),
400                #[cfg(feature = "secp256r1")]
401                InnerVerifyingKey::Secp256r1(verifying_key) => verifying_key.to_pem(),
402            }
403        }
404    }
405
406    impl Verifier<SimpleSignature> for SimpleVerifiyingKey {
407        fn verify(
408            &self,
409            message: &[u8],
410            signature: &SimpleSignature,
411        ) -> Result<(), SignatureError> {
412            match &self.inner {
413                #[cfg(feature = "ed25519")]
414                InnerVerifyingKey::Ed25519(verifying_key) => {
415                    verifying_key.verify(message, signature)
416                }
417                #[cfg(feature = "secp256k1")]
418                InnerVerifyingKey::Secp256k1(verifying_key) => {
419                    verifying_key.verify(message, signature)
420                }
421                #[cfg(feature = "secp256r1")]
422                InnerVerifyingKey::Secp256r1(verifying_key) => {
423                    verifying_key.verify(message, signature)
424                }
425            }
426        }
427    }
428
429    impl Verifier<UserSignature> for SimpleVerifiyingKey {
430        fn verify(&self, message: &[u8], signature: &UserSignature) -> Result<(), SignatureError> {
431            let UserSignature::Simple(signature) = signature else {
432                return Err(SignatureError::from_source("not a simple signature"));
433            };
434
435            <Self as Verifier<SimpleSignature>>::verify(self, message, signature)
436        }
437    }
438
439    #[cfg(feature = "ed25519")]
440    #[cfg_attr(doc_cfg, doc(cfg(feature = "ed25519")))]
441    impl From<crate::ed25519::Ed25519VerifyingKey> for SimpleVerifiyingKey {
442        fn from(verifying_key: crate::ed25519::Ed25519VerifyingKey) -> Self {
443            Self {
444                inner: InnerVerifyingKey::Ed25519(verifying_key),
445            }
446        }
447    }
448
449    #[cfg(feature = "secp256r1")]
450    #[cfg_attr(doc_cfg, doc(cfg(feature = "secp256r1")))]
451    impl From<crate::secp256r1::Secp256r1VerifyingKey> for SimpleVerifiyingKey {
452        fn from(verifying_key: crate::secp256r1::Secp256r1VerifyingKey) -> Self {
453            Self {
454                inner: InnerVerifyingKey::Secp256r1(verifying_key),
455            }
456        }
457    }
458
459    #[cfg(feature = "secp256k1")]
460    #[cfg_attr(doc_cfg, doc(cfg(feature = "secp256k1")))]
461    impl From<crate::secp256k1::Secp256k1VerifyingKey> for SimpleVerifiyingKey {
462        fn from(verifying_key: crate::secp256k1::Secp256k1VerifyingKey) -> Self {
463            Self {
464                inner: InnerVerifyingKey::Secp256k1(verifying_key),
465            }
466        }
467    }
468}
469
470#[cfg(test)]
471mod test {
472    use super::*;
473    use crate::ed25519::Ed25519PrivateKey;
474    use crate::ed25519::Ed25519VerifyingKey;
475    use crate::secp256k1::Secp256k1PrivateKey;
476    use crate::secp256k1::Secp256k1VerifyingKey;
477    use crate::secp256r1::Secp256r1PrivateKey;
478    use crate::secp256r1::Secp256r1VerifyingKey;
479    use test_strategy::proptest;
480
481    #[cfg(target_arch = "wasm32")]
482    use wasm_bindgen_test::wasm_bindgen_test as test;
483
484    #[proptest]
485    fn ed25519_pem_der(signer: Ed25519PrivateKey) {
486        //
487        // Private Key
488        //
489        let public_key = signer.public_key();
490        let ed25519_der = signer.to_der().unwrap();
491        let ed25519_pem = signer.to_pem().unwrap();
492
493        // der and pem round-trip
494        let from_der = Ed25519PrivateKey::from_der(&ed25519_der).unwrap();
495        assert_eq!(from_der.public_key(), public_key);
496        let from_pem = Ed25519PrivateKey::from_pem(&ed25519_pem).unwrap();
497        assert_eq!(from_pem.public_key(), public_key);
498
499        // der and pem bytes don't convert to secp256r1 or secp256k1
500        Secp256r1PrivateKey::from_der(&ed25519_der).unwrap_err();
501        Secp256r1PrivateKey::from_pem(&ed25519_pem).unwrap_err();
502        Secp256k1PrivateKey::from_der(&ed25519_der).unwrap_err();
503        Secp256k1PrivateKey::from_pem(&ed25519_pem).unwrap_err();
504
505        // SimpleKeypair parses
506        let keypair_from_der = SimpleKeypair::from_der(&ed25519_der).unwrap();
507        assert_eq!(ed25519_der, keypair_from_der.to_der().unwrap());
508        let keypair_from_pem = SimpleKeypair::from_pem(&ed25519_pem).unwrap();
509        assert_eq!(ed25519_pem, keypair_from_pem.to_pem().unwrap());
510
511        //
512        // Verifying Key
513        //
514        let verifying_key = signer.verifying_key();
515        let der = verifying_key.to_der().unwrap();
516        let pem = verifying_key.to_pem().unwrap();
517
518        // der and pem round-trip
519        let from_der = Ed25519VerifyingKey::from_der(&der).unwrap();
520        assert_eq!(from_der.public_key(), public_key);
521        let from_pem = Ed25519VerifyingKey::from_pem(&pem).unwrap();
522        assert_eq!(from_pem.public_key(), public_key);
523
524        // der and pem bytes don't convert to secp256r1 or secp256k1
525        Secp256r1VerifyingKey::from_der(&der).unwrap_err();
526        Secp256r1VerifyingKey::from_pem(&pem).unwrap_err();
527        Secp256k1VerifyingKey::from_der(&der).unwrap_err();
528        Secp256k1VerifyingKey::from_pem(&pem).unwrap_err();
529
530        // SimpleKeypair parses
531        let from_der = SimpleVerifiyingKey::from_der(&der).unwrap();
532        assert_eq!(der, from_der.to_der().unwrap());
533        let from_pem = SimpleVerifiyingKey::from_pem(&pem).unwrap();
534        assert_eq!(pem, from_pem.to_pem().unwrap());
535    }
536
537    #[proptest]
538    fn secp256r1_pem_der(signer: Secp256r1PrivateKey) {
539        //
540        // Private Key
541        //
542        let public_key = signer.public_key();
543        let secp256r1_der = signer.to_der().unwrap();
544        let secp256r1_pem = signer.to_pem().unwrap();
545
546        // der and pem round-trip
547        let from_der = Secp256r1PrivateKey::from_der(&secp256r1_der).unwrap();
548        assert_eq!(from_der.public_key(), public_key);
549        let from_pem = Secp256r1PrivateKey::from_pem(&secp256r1_pem).unwrap();
550        assert_eq!(from_pem.public_key(), public_key);
551
552        // der and pem bytes don't convert to ed25519 or secp256k1
553        Ed25519PrivateKey::from_der(&secp256r1_der).unwrap_err();
554        Ed25519PrivateKey::from_pem(&secp256r1_pem).unwrap_err();
555        Secp256k1PrivateKey::from_der(&secp256r1_der).unwrap_err();
556        Secp256k1PrivateKey::from_pem(&secp256r1_pem).unwrap_err();
557
558        // SimpleKeypair parses
559        let keypair_from_der = SimpleKeypair::from_der(&secp256r1_der).unwrap();
560        assert_eq!(secp256r1_der, keypair_from_der.to_der().unwrap());
561        let keypair_from_pem = SimpleKeypair::from_pem(&secp256r1_pem).unwrap();
562        assert_eq!(secp256r1_pem, keypair_from_pem.to_pem().unwrap());
563
564        //
565        // Verifying Key
566        //
567        let verifying_key = signer.verifying_key();
568        let der = verifying_key.to_der().unwrap();
569        let pem = verifying_key.to_pem().unwrap();
570
571        // der and pem round-trip
572        let from_der = Secp256r1VerifyingKey::from_der(&der).unwrap();
573        assert_eq!(from_der.public_key(), public_key);
574        let from_pem = Secp256r1VerifyingKey::from_pem(&pem).unwrap();
575        assert_eq!(from_pem.public_key(), public_key);
576
577        // der and pem bytes don't convert to ed25519 or secp256k1
578        Ed25519VerifyingKey::from_der(&der).unwrap_err();
579        Ed25519VerifyingKey::from_pem(&pem).unwrap_err();
580        Secp256k1VerifyingKey::from_der(&der).unwrap_err();
581        Secp256k1VerifyingKey::from_pem(&pem).unwrap_err();
582
583        // SimpleKeypair parses
584        let from_der = SimpleVerifiyingKey::from_der(&der).unwrap();
585        assert_eq!(der, from_der.to_der().unwrap());
586        let from_pem = SimpleVerifiyingKey::from_pem(&pem).unwrap();
587        assert_eq!(pem, from_pem.to_pem().unwrap());
588    }
589
590    #[proptest]
591    fn secp256k1_pem_der(signer: Secp256k1PrivateKey) {
592        //
593        // Private Key
594        //
595        let public_key = signer.public_key();
596        let secp256k1_der = signer.to_der().unwrap();
597        let secp256k1_pem = signer.to_pem().unwrap();
598
599        // der and pem round-trip
600        let from_der = Secp256k1PrivateKey::from_der(&secp256k1_der).unwrap();
601        assert_eq!(from_der.public_key(), public_key);
602        let from_pem = Secp256k1PrivateKey::from_pem(&secp256k1_pem).unwrap();
603        assert_eq!(from_pem.public_key(), public_key);
604
605        // der and pem bytes don't convert to secp256r1 or ed25519
606        Ed25519PrivateKey::from_der(&secp256k1_der).unwrap_err();
607        Ed25519PrivateKey::from_pem(&secp256k1_pem).unwrap_err();
608        Secp256r1PrivateKey::from_der(&secp256k1_der).unwrap_err();
609        Secp256r1PrivateKey::from_pem(&secp256k1_pem).unwrap_err();
610
611        // SimpleKeypair parses
612        let keypair_from_der = SimpleKeypair::from_der(&secp256k1_der).unwrap();
613        assert_eq!(secp256k1_der, keypair_from_der.to_der().unwrap());
614        let keypair_from_pem = SimpleKeypair::from_pem(&secp256k1_pem).unwrap();
615        assert_eq!(secp256k1_pem, keypair_from_pem.to_pem().unwrap());
616
617        //
618        // Verifying Key
619        //
620        let verifying_key = signer.verifying_key();
621        let der = verifying_key.to_der().unwrap();
622        let pem = verifying_key.to_pem().unwrap();
623
624        // der and pem round-trip
625        let from_der = Secp256k1VerifyingKey::from_der(&der).unwrap();
626        assert_eq!(from_der.public_key(), public_key);
627        let from_pem = Secp256k1VerifyingKey::from_pem(&pem).unwrap();
628        assert_eq!(from_pem.public_key(), public_key);
629
630        // der and pem bytes don't convert to ed25519 or secp256r1
631        Ed25519VerifyingKey::from_der(&der).unwrap_err();
632        Ed25519VerifyingKey::from_pem(&pem).unwrap_err();
633        Secp256r1VerifyingKey::from_der(&der).unwrap_err();
634        Secp256r1VerifyingKey::from_pem(&pem).unwrap_err();
635
636        // SimpleKeypair parses
637        let from_der = SimpleVerifiyingKey::from_der(&der).unwrap();
638        assert_eq!(der, from_der.to_der().unwrap());
639        let from_pem = SimpleVerifiyingKey::from_pem(&pem).unwrap();
640        assert_eq!(pem, from_pem.to_pem().unwrap());
641    }
642}
sui_crypto/simple.rs

sui_crypto/
simple.rs
