chore: checkpoint before Python removal

vendor/ed25519/tests/examples/pkcs8-v1.pem

@@ -0,0 +1,3 @@
+-----BEGIN PRIVATE KEY-----
+MC4CAQAwBQYDK2VwBCIEINTuctv5E1hK1bbY8fdp+K06/nwoy/HU++CXqI9EdVhC
+-----END PRIVATE KEY-----

vendor/ed25519/tests/examples/pkcs8-v2.pem

@@ -0,0 +1,5 @@
+-----BEGIN PRIVATE KEY-----
+MHICAQEwBQYDK2VwBCIEINTuctv5E1hK1bbY8fdp+K06/nwoy/HU++CXqI9EdVhC
+oB8wHQYKKoZIhvcNAQkJFDEPDA1DdXJkbGUgQ2hhaXJzgSEAGb9ECWmEzf6FQbrB
+Z9w7lshQhqowtrbLDFw4rXAxZuE=
+-----END PRIVATE KEY------

vendor/ed25519/tests/examples/pubkey.pem

@@ -0,0 +1,3 @@
+-----BEGIN PUBLIC KEY-----
+MCowBQYDK2VwAyEAGb9ECWmEzf6FQbrBZ9w7lshQhqowtrbLDFw4rXAxZuE=
+-----END PUBLIC KEY-----

vendor/ed25519/tests/hex.rs

@@ -0,0 +1,50 @@
+//! Hexadecimal display/serialization tests.
+
+use ed25519::Signature;
+use hex_literal::hex;
+use std::str::FromStr;
+
+/// Test 1 signature from RFC 8032 § 7.1
+/// <https://datatracker.ietf.org/doc/html/rfc8032#section-7.1>
+const TEST_1_SIGNATURE: [u8; Signature::BYTE_SIZE] = hex!(
+    "e5564300c360ac729086e2cc806e828a
+     84877f1eb8e5d974d873e06522490155
+     5fb8821590a33bacc61e39701cf9b46b
+     d25bf5f0595bbe24655141438e7a100b"
+);
+
+#[test]
+fn display() {
+    let sig = Signature::from_bytes(&TEST_1_SIGNATURE);
+    assert_eq!(sig.to_string(), "E5564300C360AC729086E2CC806E828A84877F1EB8E5D974D873E065224901555FB8821590A33BACC61E39701CF9B46BD25BF5F0595BBE24655141438E7A100B")
+}
+
+#[test]
+fn lower_hex() {
+    let sig = Signature::from_bytes(&TEST_1_SIGNATURE);
+    assert_eq!(format!("{:x}", sig), "e5564300c360ac729086e2cc806e828a84877f1eb8e5d974d873e065224901555fb8821590a33bacc61e39701cf9b46bd25bf5f0595bbe24655141438e7a100b")
+}
+
+#[test]
+fn upper_hex() {
+    let sig = Signature::from_bytes(&TEST_1_SIGNATURE);
+    assert_eq!(format!("{:X}", sig), "E5564300C360AC729086E2CC806E828A84877F1EB8E5D974D873E065224901555FB8821590A33BACC61E39701CF9B46BD25BF5F0595BBE24655141438E7A100B")
+}
+
+#[test]
+fn from_str_lower() {
+    let sig = Signature::from_str("e5564300c360ac729086e2cc806e828a84877f1eb8e5d974d873e065224901555fb8821590a33bacc61e39701cf9b46bd25bf5f0595bbe24655141438e7a100b").unwrap();
+    assert_eq!(sig.to_bytes(), TEST_1_SIGNATURE);
+}
+
+#[test]
+fn from_str_upper() {
+    let sig = Signature::from_str("E5564300C360AC729086E2CC806E828A84877F1EB8E5D974D873E065224901555FB8821590A33BACC61E39701CF9B46BD25BF5F0595BBE24655141438E7A100B").unwrap();
+    assert_eq!(sig.to_bytes(), TEST_1_SIGNATURE);
+}
+
+#[test]
+fn from_str_rejects_mixed_case() {
+    let result = Signature::from_str("E5564300c360ac729086e2cc806e828a84877f1eb8e5d974d873e065224901555fb8821590a33bacc61e39701cf9b46bd25bf5f0595bbe24655141438e7a100b");
+    assert!(result.is_err());
+}

vendor/ed25519/tests/pkcs8.rs

@@ -0,0 +1,86 @@
+//! PKCS#8 private key tests
+
+#![cfg(feature = "pkcs8")]
+
+use ed25519::pkcs8::{DecodePrivateKey, DecodePublicKey, KeypairBytes, PublicKeyBytes};
+use hex_literal::hex;
+
+#[cfg(feature = "alloc")]
+use ed25519::pkcs8::{EncodePrivateKey, EncodePublicKey};
+
+/// Ed25519 PKCS#8 v1 private key encoded as ASN.1 DER.
+const PKCS8_V1_DER: &[u8] = include_bytes!("examples/pkcs8-v1.der");
+
+/// Ed25519 PKCS#8 v2 private key + public key encoded as ASN.1 DER.
+const PKCS8_V2_DER: &[u8] = include_bytes!("examples/pkcs8-v2.der");
+
+/// Ed25519 SubjectPublicKeyInfo encoded as ASN.1 DER.
+const PUBLIC_KEY_DER: &[u8] = include_bytes!("examples/pubkey.der");
+
+#[test]
+fn decode_pkcs8_v1() {
+    let keypair = KeypairBytes::from_pkcs8_der(PKCS8_V1_DER).unwrap();
+
+    // Extracted with:
+    // $ openssl asn1parse -inform der -in tests/examples/pkcs8-v1.der
+    assert_eq!(
+        keypair.secret_key,
+        &hex!("D4EE72DBF913584AD5B6D8F1F769F8AD3AFE7C28CBF1D4FBE097A88F44755842")[..]
+    );
+
+    assert_eq!(keypair.public_key, None);
+}
+
+#[test]
+fn decode_pkcs8_v2() {
+    let keypair = KeypairBytes::from_pkcs8_der(PKCS8_V2_DER).unwrap();
+
+    // Extracted with:
+    // $ openssl asn1parse -inform der -in tests/examples/pkcs8-v2.der
+    assert_eq!(
+        keypair.secret_key,
+        &hex!("D4EE72DBF913584AD5B6D8F1F769F8AD3AFE7C28CBF1D4FBE097A88F44755842")[..]
+    );
+
+    assert_eq!(
+        keypair.public_key.unwrap().0,
+        hex!("19BF44096984CDFE8541BAC167DC3B96C85086AA30B6B6CB0C5C38AD703166E1")
+    );
+}
+
+#[test]
+fn decode_public_key() {
+    let public_key = PublicKeyBytes::from_public_key_der(PUBLIC_KEY_DER).unwrap();
+
+    // Extracted with:
+    // $ openssl pkey -inform der -in tests/examples/pkcs8-v1.der -pubout -text
+    assert_eq!(
+        public_key.as_ref(),
+        &hex!("19BF44096984CDFE8541BAC167DC3B96C85086AA30B6B6CB0C5C38AD703166E1")
+    );
+}
+
+#[cfg(feature = "alloc")]
+#[test]
+fn encode_pkcs8_v1() {
+    let pk = KeypairBytes::from_pkcs8_der(PKCS8_V1_DER).unwrap();
+    let pk_der = pk.to_pkcs8_der().unwrap();
+    assert_eq!(pk_der.as_bytes(), PKCS8_V1_DER);
+}
+
+#[cfg(feature = "alloc")]
+#[test]
+fn encode_pkcs8_v2() {
+    let pk = KeypairBytes::from_pkcs8_der(PKCS8_V2_DER).unwrap();
+    let pk2 = KeypairBytes::from_pkcs8_der(pk.to_pkcs8_der().unwrap().as_bytes()).unwrap();
+    assert_eq!(pk.secret_key, pk2.secret_key);
+    assert_eq!(pk.public_key, pk2.public_key);
+}
+
+#[cfg(feature = "alloc")]
+#[test]
+fn encode_public_key() {
+    let pk = PublicKeyBytes::from_public_key_der(PUBLIC_KEY_DER).unwrap();
+    let pk_der = pk.to_public_key_der().unwrap();
+    assert_eq!(pk_der.as_ref(), PUBLIC_KEY_DER);
+}

vendor/ed25519/tests/serde.rs

@@ -0,0 +1,62 @@
+//! Tests for serde serializers/deserializers
+
+#![cfg(feature = "serde")]
+
+use ed25519::{Signature, SignatureBytes};
+use hex_literal::hex;
+
+const EXAMPLE_SIGNATURE: SignatureBytes = hex!(
+    "3f3e3d3c3b3a393837363534333231302f2e2d2c2b2a29282726252423222120"
+    "1f1e1d1c1b1a191817161514131211100f0e0d0c0b0a09080706050403020100"
+);
+
+#[test]
+fn test_serialize() {
+    let signature = Signature::try_from(&EXAMPLE_SIGNATURE[..]).unwrap();
+    dbg!(&signature);
+    let encoded_signature: Vec<u8> = bincode::serialize(&signature).unwrap();
+    assert_eq!(&EXAMPLE_SIGNATURE[..], &encoded_signature[..]);
+}
+
+#[test]
+fn test_deserialize() {
+    let signature = bincode::deserialize::<Signature>(&EXAMPLE_SIGNATURE).unwrap();
+    assert_eq!(EXAMPLE_SIGNATURE, signature.to_bytes());
+}
+
+#[cfg(feature = "serde_bytes")]
+#[test]
+fn test_serialize_bytes() {
+    use bincode::Options;
+
+    let signature = Signature::try_from(&EXAMPLE_SIGNATURE[..]).unwrap();
+
+    let mut encoded_signature = Vec::new();
+    let options = bincode::DefaultOptions::new()
+        .with_fixint_encoding()
+        .allow_trailing_bytes();
+    let mut serializer = bincode::Serializer::new(&mut encoded_signature, options);
+    serde_bytes::serialize(&signature, &mut serializer).unwrap();
+
+    let mut expected = Vec::from(Signature::BYTE_SIZE.to_le_bytes());
+    expected.extend(&EXAMPLE_SIGNATURE[..]);
+    assert_eq!(&expected[..], &encoded_signature[..]);
+}
+
+#[cfg(feature = "serde_bytes")]
+#[test]
+fn test_deserialize_bytes() {
+    use bincode::Options;
+
+    let mut encoded_signature = Vec::from(Signature::BYTE_SIZE.to_le_bytes());
+    encoded_signature.extend(&EXAMPLE_SIGNATURE[..]);
+
+    let options = bincode::DefaultOptions::new()
+        .with_fixint_encoding()
+        .allow_trailing_bytes();
+    let mut deserializer = bincode::de::Deserializer::from_slice(&encoded_signature[..], options);
+
+    let signature: Signature = serde_bytes::deserialize(&mut deserializer).unwrap();
+
+    assert_eq!(EXAMPLE_SIGNATURE, signature.to_bytes());
+}