feat(chore): add EcdsaPubKey and EcdsaP256Sig types

Signed-off-by: Nicholas Farshidmehr <[email protected]>

Author: definitelynobody

Cargo.toml

@@ -28,6 +28,7 @@ rcrypto = ["rand", "rsa", "sha2", "num-integer", "num-traits"]
 x86_64 = { version = "^0.14.6", default-features = false }
 xsave = { version = "^2.0.0", default-features = false }
 openssl = { version = "^0.10.36", optional = true }
+der = { version = "0.6.0-pre.3", features = ["derive"], optional = false }
 bitflags = "^1.3.2"
 
 # Used by the rcrypto feature (see above).

src/crypto/mod.rs

@@ -11,6 +11,8 @@ pub mod openssl;
 #[cfg(feature = "rcrypto")]
 pub mod rcrypto;
 
+use der::{asn1::UIntBytes, Encodable, Sequence};
+
 /// A fixed-size hash
 pub trait Digest: Sized {
     type Output: AsRef<[u8]>;
@@ -45,6 +47,58 @@ pub struct SigData {
     pub q2: [u8; 384],
 }
 
+/// EC KT-I Public Key, the x-coordinate followed by
+/// the y-coordinate (on the RFC 6090P-256 curve),
+/// 2 x 32 bytes.
+/// A.4, Table 7
+#[derive(Clone, Debug)]
+#[repr(C)]
+pub struct EcdsaPubKey {
+    pub x: [u8; 32],
+    pub y: [u8; 32],
+}
+
+/// ECDSA signature, the r component followed by the
+/// s component, 2 x 32 bytes.
+/// A.4, Table 6
+#[derive(Clone, Debug)]
+#[repr(C)]
+pub struct EcdsaP256Sig {
+    pub r: [u8; 32],
+    pub s: [u8; 32],
+}
+
+impl EcdsaP256Sig {
+    // The size of the buffer the DER encoded signature will occupy.
+    const DER_ENCODED_LEN: usize = 72;
+
+    /// Converts the concatenated signature to a DER signature.
+    ///
+    /// Returns the buffer containing the DER and its length.
+    pub fn to_der(&self) -> Result<([u8; Self::DER_ENCODED_LEN], usize), der::Error> {
+        /// ECDSA-Sig-Value ::= SEQUENCE {
+        ///    r INTEGER,
+        ///    s INTEGER
+        /// }
+        #[derive(Clone, Debug, Sequence)]
+        struct EcdsaSig<'a> {
+            r: UIntBytes<'a>,
+            s: UIntBytes<'a>,
+        }
+
+        let es = EcdsaSig {
+            r: UIntBytes::new(&self.r)?,
+            s: UIntBytes::new(&self.s)?,
+        };
+
+        let mut buffer = [0; Self::DER_ENCODED_LEN];
+        let mut encoder = der::Encoder::new(&mut buffer);
+        es.encode(&mut encoder)?;
+        let len = encoder.finish()?.len();
+        Ok((buffer, len))
+    }
+}
+
 #[cfg(test)]
 #[allow(dead_code)]
 fn selftest<K: PrivateKey, D: Digest<Output = [u8; 32]>>() {