Add private key file parsing and generation

src/lib.rs

@@ -3,3 +3,4 @@ pub use self::args::Args;
 pub mod args;
 pub mod commands;
 pub mod error;
+pub mod utils;

src/utils/mod.rs

@@ -0,0 +1 @@
+pub mod private_key_file_parser;

src/utils/private_key_file_parser.rs

@@ -0,0 +1,291 @@
+use crate::error::Error;
+use domain::base::iana::SecAlg;
+use domain::utils::base64;
+use std::slice::Iter;
+
+macro_rules! parse_next_line {
+    ($lines:ident, $match_text:expr) => {
+        if let Some(line) = $lines.next() {
+            if !line.starts_with($match_text) {
+                return Err(Error::from(concat!(
+                    "expected line starting with ",
+                    $match_text
+                )));
+            }
+
+            if let Some((_, m)) = line.split_once(' ') {
+                m
+            } else {
+                return Err(Error::from("malformed line"));
+            }
+        } else {
+            return Err(Error::from("expected more private key data"));
+        }
+    };
+}
+
+#[derive(Default, Debug)]
+pub struct RsaKeyData {
+    algorithm_id: u8,
+    modulus: Vec<u8>,
+    public_exponent: Vec<u8>,
+    private_exponent: Vec<u8>,
+    prime1: Vec<u8>,
+    prime2: Vec<u8>,
+    exponent1: Vec<u8>,
+    exponent2: Vec<u8>,
+    coefficient: Vec<u8>,
+}
+
+impl RsaKeyData {
+    fn parse_lines(algorithm: u8, lines: &mut Iter<&str>) -> Result<RsaKeyData, Error> {
+        let modulus = parse_next_line!(lines, "Modulus: ");
+        let public_exponent = parse_next_line!(lines, "PublicExponent: ");
+        let private_exponent = parse_next_line!(lines, "PrivateExponent: ");
+        let prime1 = parse_next_line!(lines, "Prime1: ");
+        let prime2 = parse_next_line!(lines, "Prime2: ");
+        let exponent1 = parse_next_line!(lines, "Exponent1: ");
+        let exponent2 = parse_next_line!(lines, "Exponent2: ");
+        let coefficient = parse_next_line!(lines, "Coefficient: ");
+
+        Ok(RsaKeyData {
+            algorithm_id: algorithm,
+            modulus: base64::decode(modulus).expect("failed decoding base64 data"),
+            public_exponent: base64::decode(public_exponent).expect("failed decoding base64 data"),
+            private_exponent: base64::decode(private_exponent)
+                .expect("failed decoding base64 data"),
+            prime1: base64::decode(prime1).expect("failed decoding base64 data"),
+            prime2: base64::decode(prime2).expect("failed decoding base64 data"),
+            exponent1: base64::decode(exponent1).expect("failed decoding base64 data"),
+            exponent2: base64::decode(exponent2).expect("failed decoding base64 data"),
+            coefficient: base64::decode(coefficient).expect("failed decoding base64 data"),
+        })
+    }
+}
+
+#[derive(Default, Debug)]
+pub struct EcKeyData {
+    algorithm_id: u8,
+    private_key: Vec<u8>,
+}
+
+impl EcKeyData {
+    fn parse_lines(algorithm: u8, lines: &mut Iter<&str>) -> Result<EcKeyData, Error> {
+        let private_key = parse_next_line!(lines, "PrivateKey: ");
+
+        Ok(EcKeyData {
+            algorithm_id: algorithm,
+            private_key: base64::decode(private_key).expect("failed decoding base64 data"),
+        })
+    }
+}
+
+#[derive(Default, Debug)]
+pub struct HmacKeyData {
+    algorithm_id: u8,
+    key: Vec<u8>,
+}
+
+impl HmacKeyData {
+    fn parse_lines(algorithm: u8, lines: &mut Iter<&str>) -> Result<HmacKeyData, Error> {
+        let key = parse_next_line!(lines, "Key: ");
+
+        Ok(HmacKeyData {
+            algorithm_id: algorithm,
+            key: base64::decode(key).expect("failed decoding base64 data"),
+        })
+    }
+}
+
+#[derive(Default, Debug)]
+pub struct DsaKeyData {
+    algorithm_id: u8,
+    prime: Vec<u8>,
+    subprime: Vec<u8>,
+    base: Vec<u8>,
+    private_value: Vec<u8>,
+    public_value: Vec<u8>,
+}
+
+impl DsaKeyData {
+    fn parse_lines(algorithm: u8, lines: &mut Iter<&str>) -> Result<DsaKeyData, Error> {
+        let prime = parse_next_line!(lines, "Prime(p): ");
+        let subprime = parse_next_line!(lines, "Subprime(q): ");
+        let base = parse_next_line!(lines, "Base(g): ");
+        let private_value = parse_next_line!(lines, "Private_value(x): ");
+        let public_value = parse_next_line!(lines, "Public_value(y): ");
+
+        Ok(DsaKeyData {
+            algorithm_id: algorithm,
+            prime: base64::decode(prime).expect("failed decoding base64 data"),
+            subprime: base64::decode(subprime).expect("failed decoding base64 data"),
+            base: base64::decode(base).expect("failed decoding base64 data"),
+            private_value: base64::decode(private_value).expect("failed decoding base64 data"),
+            public_value: base64::decode(public_value).expect("failed decoding base64 data"),
+        })
+    }
+}
+
+#[derive(Debug)]
+pub enum KeyData {
+    Rsa(RsaKeyData),
+    Ec(EcKeyData),
+    Hmac(HmacKeyData),
+    Dsa(DsaKeyData),
+}
+
+pub fn gen_private_key_file_text(key: KeyData) -> Result<String, Error> {
+    match key {
+        KeyData::Rsa(rsa) => Ok(format!(
+            "Private-key-format: v1.2
+Algorithm: {alg_id} ({alg_name})
+Modulus: {modulus}
+PublicExponent: {pub_exp}
+PrivateExponent: {priv_exp}
+Prime1: {prime1}
+Prime2: {prime2}
+Exponent1: {exp1}
+Exponent2: {exp2}
+Coefficient: {coeff}\n",
+            alg_id = rsa.algorithm_id,
+            alg_name = SecAlg::from_int(rsa.algorithm_id),
+            modulus = base64::encode_string(&rsa.modulus),
+            pub_exp = base64::encode_string(&rsa.public_exponent),
+            priv_exp = base64::encode_string(&rsa.private_exponent),
+            prime1 = base64::encode_string(&rsa.prime1),
+            prime2 = base64::encode_string(&rsa.prime2),
+            exp1 = base64::encode_string(&rsa.exponent1),
+            exp2 = base64::encode_string(&rsa.exponent2),
+            coeff = base64::encode_string(&rsa.coefficient),
+        )),
+        KeyData::Ec(ec) => Ok(format!(
+            "Private-key-format: v1.2
+Algorithm: {alg_id} ({alg_name})
+PrivateKey: {key}\n",
+            alg_id = ec.algorithm_id,
+            alg_name = SecAlg::from_int(ec.algorithm_id),
+            key = base64::encode_string(&ec.private_key),
+        )),
+        KeyData::Hmac(hmac) => Ok(format!(
+            "Private-key-format: v1.2
+Algorithm: {alg_id} ({alg_name})
+Key: {key}\n",
+            alg_id = hmac.algorithm_id,
+            alg_name = match hmac.algorithm_id {
+            157 => "HMAC_MD5",
+            158 => "HMAC_SHA1",
+            159 => "HMAC_SHA256",
+            161 => "HMAC_SHA1",
+            162 => "HMAC_SHA224",
+            163 => "HMAC_SHA256",
+            164 => "HMAC_SHA384",
+            165 => "HMAC_SHA512",
+            _ => return Err(Error::from("unknown hmac algorithm"))
+            },
+            key = base64::encode_string(&hmac.key),
+        )),
+        KeyData::Dsa(dsa) => Ok(format!(
+            "Private-key-format: v1.2
+Algorithm: {alg_id} ({alg_name})
+Prime(p): {p}
+Subprime(q): {q}
+Base(g): {g}
+Private_value(x): {x}
+Public_value(y): {y}\n",
+            alg_id = dsa.algorithm_id,
+            alg_name = SecAlg::from_int(dsa.algorithm_id),
+            p = base64::encode_string(&dsa.prime),
+            q = base64::encode_string(&dsa.subprime),
+            g = base64::encode_string(&dsa.base),
+            x = base64::encode_string(&dsa.private_value),
+            y = base64::encode_string(&dsa.public_value),
+        )),
+    }
+}
+
+pub fn parse_private_key_file(mut lines: Iter<&str>) -> Result<KeyData, Error> {
+    // File format in ABNF (no data validity encoded here)
+
+    // KEYFILE      = HEADER ALGORITHM KEY_SPECIFIC
+    // HEADER       = %s"Private-key-format: v" DIGIT "." DIGIT LF
+    // ALGORITHM    = %s"Algorithm: " 1*3DIGIT *1( " (" ALG_NAME ")" ) LF
+    // KEY_SPECIFIC = RSA / EDDSA / HMAC / DSA
+    //
+    // RSA   = MODULUS PUBLIC_EXPONENT PRIVATE_EXPONENT PRIME1 PRIME2 EXPONENT1 EXPONENT2 COEFFICIENT
+    // DSA   = PRIME SUBPRIME BASE PRIVATE_VALUE PUBLIC_VALUE
+    // EDDSA = %s"PrivateKey: " BASE64_DATA
+    // HMAC  = %s"Key: " BASE64_DATA
+    //
+    // PRIME            = %s"Prime(p): "         BASE64_DATA LF
+    // SUBPRIME         = %s"Subprime(q): "      BASE64_DATA LF
+    // BASE             = %s"Base(g): "          BASE64_DATA LF
+    // PRIVATE_VALUE    = %s"Private_value(x): " BASE64_DATA LF
+    // PUBLIC_VALUE     = %s"Public_value(y): "  BASE64_DATA LF
+    //
+    // MODULUS          = %s"Modulus: "          BASE64_DATA LF
+    // PUBLIC_EXPONENT  = %s"PublicExponent: "   BASE64_DATA LF
+    // PRIVATE_EXPONENT = %s"PrivateExponent: "  BASE64_DATA LF
+    // PRIME1           = %s"Prim1: "            BASE64_DATA LF
+    // PRIME2           = %s"Prime2: "           BASE64_DATA LF
+    // EXPONENT1        = %s"Exponent1: "        BASE64_DATA LF
+    // EXPONENT2        = %s"Exponent2: "        BASE64_DATA LF
+    // COEFFICIENT      = %s"Coefficient: "      BASE64_DATA LF
+    //
+    // BASE64_DATA = *(ALPHA / DIGIT / "/" / "+")
+
+    let mut algorithm = 0;
+
+    if let Some(line) = lines.next() {
+        if !line.starts_with("Private-key-format: v1.") {
+            return Err(Error::from(
+                "expected private key format version (v1.x) specifier",
+            ));
+        }
+    };
+
+    if let Some(line) = lines.next() {
+        if !line.starts_with("Algorithm: ") {
+            return Err(Error::from("expected algorithm specifier"));
+        }
+
+        // "Algorithm: 123 (NAMEXYZ)"
+        let mut parts = line.split(' ');
+        parts.next(); // "Algorithm:"
+        if let Some(alg) = parts.next() {
+            algorithm = alg.parse()?;
+        } else {
+            return Err(Error::from("expected algorithm identifier number"));
+        }
+    };
+
+    match SecAlg::from_int(algorithm) {
+        SecAlg::RSAMD5
+        | SecAlg::RSASHA1
+        | SecAlg::RSASHA1_NSEC3_SHA1
+        | SecAlg::RSASHA256
+        | SecAlg::RSASHA512 => Ok(KeyData::Rsa(RsaKeyData::parse_lines(
+            algorithm, &mut lines,
+        )?)),
+        SecAlg::DSA | SecAlg::DSA_NSEC3_SHA1 => Ok(KeyData::Dsa(DsaKeyData::parse_lines(
+            algorithm, &mut lines,
+        )?)),
+        SecAlg::ECDSAP256SHA256 | SecAlg::ECDSAP384SHA384 | SecAlg::ED25519 | SecAlg::ED448 => {
+            Ok(KeyData::Ec(EcKeyData::parse_lines(algorithm, &mut lines)?))
+        }
+
+        /* might be a hmac algorithm */
+        _ => match algorithm {
+            157 /* HMAC_MD5 */
+            | 158 /* HMAC_SHA1 */
+            | 159 /* HMAC_SHA256 */
+            | 161 /* HMAC_SHA1 */
+            | 162 /* HMAC_SHA224 */
+            | 163 /* HMAC_SHA256 */
+            | 164 /* HMAC_SHA384 */
+            | 165 /* HMAC_SHA512 */
+            => Ok(KeyData::Hmac(HmacKeyData::parse_lines(algorithm, &mut lines)?)),
+            /* unknown algorithm number */
+            _ => Err(Error::from("unsupported algorithm")),
+        },
+    }
+}