test: generate key with signing capable subkey, check embedded signature

hko-s · hko-s · commit e4cc899c609d · 2025-05-26T12:56:37.000+02:00
diff --git a/src/composed/key/builder.rs b/src/composed/key/builder.rs
@@ -1328,6 +1328,80 @@ mod tests {
         signed_key2.verify().expect("invalid public key");
     }
 
+    #[test]
+    fn signing_capable_subkey() {
+        let _ = pretty_env_logger::try_init();
+
+        let mut rng = ChaCha8Rng::seed_from_u64(0);
+
+        let key_params = SecretKeyParamsBuilder::default()
+            .version(KeyVersion::V6)
+            .key_type(KeyType::Ed25519)
+            .can_certify(true)
+            .subkey(
+                SubkeyParamsBuilder::default()
+                    .version(KeyVersion::V6)
+                    .key_type(KeyType::Ed25519)
+                    .can_sign(true)
+                    .build()
+                    .unwrap(),
+            )
+            .build()
+            .unwrap();
+
+        let secret_key = key_params
+            .generate(&mut rng)
+            .expect("failed to generate secret key");
+
+        let signed_secret_key = secret_key
+            .sign(&mut rng, &"".into())
+            .expect("failed to sign key");
+
+        // The signing capable subkey should have an embedded signature
+        let subkey = signed_secret_key
+            .secret_subkeys
+            .first()
+            .expect("signing subkey");
+        let embedded = subkey
+            .signatures
+            .first()
+            .expect("binding signature")
+            .embedded_signature();
+        assert!(embedded.is_some());
+
+        embedded
+            .unwrap()
+            .verify_backwards_key_binding(
+                &subkey.key.public_key(),
+                &signed_secret_key.primary_key.public_key(),
+            )
+            .expect("verify ok");
+
+        let public_key = signed_secret_key.public_key();
+
+        let signed_public_key = public_key
+            .sign(
+                &mut rng,
+                &*signed_secret_key,
+                &*signed_secret_key.public_key(),
+                &"".into(),
+            )
+            .expect("failed to sign public key");
+
+        // The signing capable subkey should have an embedded signature
+        assert!(signed_public_key
+            .public_subkeys
+            .first()
+            .expect("signing subkey")
+            .signatures
+            .first()
+            .expect("binding signature")
+            .embedded_signature()
+            .is_some());
+
+        signed_public_key.verify().expect("invalid public key");
+    }
+
     #[test]
     fn test_cert_metadata_gen_v4_v4() {
         let mut rng = ChaCha8Rng::seed_from_u64(0);
