Match Debug traits of keys with what the "boring" crate returns

Author: jedisct1

src/algorithms/eddsa.rs

@@ -67,6 +67,12 @@ pub struct Edwards25519KeyPair {
     metadata: Option<KeyMetadata>,
 }
 
+impl std::fmt::Debug for Edwards25519KeyPair {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("PKey").field("algorithm", &"Ed25519").finish()
+    }
+}
+
 impl AsRef<ed25519_compact::KeyPair> for Edwards25519KeyPair {
     fn as_ref(&self) -> &ed25519_compact::KeyPair {
         &self.ed25519_kp
@@ -235,6 +241,12 @@ pub struct Ed25519KeyPair {
     key_id: Option<String>,
 }
 
+impl std::fmt::Debug for Ed25519KeyPair {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("PKey").field("algorithm", &"Ed25519").finish()
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct Ed25519PublicKey {
     pk: Edwards25519PublicKey,

src/algorithms/es256.rs

@@ -74,6 +74,12 @@ pub struct P256KeyPair {
     metadata: Option<KeyMetadata>,
 }
 
+impl std::fmt::Debug for P256KeyPair {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "EcKey")
+    }
+}
+
 impl AsRef<ecdsa::SigningKey> for P256KeyPair {
     fn as_ref(&self) -> &ecdsa::SigningKey {
         &self.p256_sk
@@ -265,6 +271,12 @@ pub struct ES256KeyPair {
     key_id: Option<String>,
 }
 
+impl std::fmt::Debug for ES256KeyPair {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "EcKey")
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct ES256PublicKey {
     pk: P256PublicKey,

src/algorithms/es256k.rs

@@ -73,6 +73,12 @@ pub struct K256KeyPair {
     metadata: Option<KeyMetadata>,
 }
 
+impl std::fmt::Debug for K256KeyPair {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "EcKey")
+    }
+}
+
 impl AsRef<ecdsa::SigningKey> for K256KeyPair {
     fn as_ref(&self) -> &ecdsa::SigningKey {
         &self.k256_sk
@@ -254,6 +260,12 @@ pub struct ES256kKeyPair {
     key_id: Option<String>,
 }
 
+impl std::fmt::Debug for ES256kKeyPair {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "EcKey")
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct ES256kPublicKey {
     pk: K256PublicKey,

src/algorithms/es384.rs

@@ -74,6 +74,12 @@ pub struct P384KeyPair {
     metadata: Option<KeyMetadata>,
 }
 
+impl std::fmt::Debug for P384KeyPair {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "EcKey")
+    }
+}
+
 impl AsRef<ecdsa::SigningKey> for P384KeyPair {
     fn as_ref(&self) -> &ecdsa::SigningKey {
         &self.p384_sk
@@ -265,6 +271,12 @@ pub struct ES384KeyPair {
     key_id: Option<String>,
 }
 
+impl std::fmt::Debug for ES384KeyPair {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "EcKey")
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct ES384PublicKey {
     pk: P384PublicKey,

src/algorithms/hmac.rs

@@ -13,12 +13,18 @@ use crate::jwt_header::*;
 use crate::token::*;
 
 #[doc(hidden)]
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct HMACKey {
     raw_key: Vec<u8>,
     metadata: Option<KeyMetadata>,
 }
 
+impl std::fmt::Debug for HMACKey {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "HMACKey")
+    }
+}
+
 impl Drop for HMACKey {
     fn drop(&mut self) {
         self.raw_key.zeroize();

src/algorithms/rsa.rs

@@ -76,12 +76,18 @@ impl RSAPublicKey {
 }
 
 #[doc(hidden)]
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct RSAKeyPair {
     rsa_sk: Rsa<Private>,
     metadata: Option<KeyMetadata>,
 }
 
+impl std::fmt::Debug for RSAKeyPair {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Rsa")
+    }
+}
+
 impl AsRef<Rsa<Private>> for RSAKeyPair {
     fn as_ref(&self) -> &Rsa<Private> {
         &self.rsa_sk
@@ -255,12 +261,18 @@ pub trait RSAPublicKeyLike {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct RS256KeyPair {
     key_pair: RSAKeyPair,
     key_id: Option<String>,
 }
 
+impl std::fmt::Debug for RS256KeyPair {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Rsa")
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct RS256PublicKey {
     pk: RSAPublicKey,
@@ -417,12 +429,18 @@ impl RS256PublicKey {
 
 //
 
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct RS512KeyPair {
     key_pair: RSAKeyPair,
     key_id: Option<String>,
 }
 
+impl std::fmt::Debug for RS512KeyPair {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Rsa")
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct RS512PublicKey {
     pk: RSAPublicKey,
@@ -579,12 +597,18 @@ impl RS512PublicKey {
 
 //
 
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct RS384KeyPair {
     key_pair: RSAKeyPair,
     key_id: Option<String>,
 }
 
+impl std::fmt::Debug for RS384KeyPair {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Rsa")
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct RS384PublicKey {
     pk: RSAPublicKey,
@@ -741,12 +765,18 @@ impl RS384PublicKey {
 
 //
 
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct PS256KeyPair {
     key_pair: RSAKeyPair,
     key_id: Option<String>,
 }
 
+impl std::fmt::Debug for PS256KeyPair {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Rsa")
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct PS256PublicKey {
     pk: RSAPublicKey,
@@ -895,12 +925,18 @@ impl PS256PublicKey {
 
 //
 
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct PS512KeyPair {
     key_pair: RSAKeyPair,
     key_id: Option<String>,
 }
 
+impl std::fmt::Debug for PS512KeyPair {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Rsa")
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct PS512PublicKey {
     pk: RSAPublicKey,
@@ -1057,12 +1093,18 @@ impl PS512PublicKey {
 
 //
 
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct PS384KeyPair {
     key_pair: RSAKeyPair,
     key_id: Option<String>,
 }
 
+impl std::fmt::Debug for PS384KeyPair {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Rsa")
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct PS384PublicKey {
     pk: RSAPublicKey,