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

sui_crypto/
simple.rs
