Ready to get PKCS7 envelopped data len

src/asn_parsing.rs

@@ -4,11 +4,16 @@ use anyhow::Context;
 use tempfile::NamedTempFile;
 
 #[derive(Debug, Default)]
-pub struct SCEPEnvelopedPayload {
+pub struct SCEPRequest {
     cn: String,
     alt_name: String,
 }
 
+#[derive(Debug, Default)]
+pub struct SCEPResponse {
+
+}
+
 /// Parse asn1 content
 fn parse_asn1(openssl: &str, req: &[u8]) -> anyhow::Result<String> {
     let mut tmpfile: NamedTempFile = NamedTempFile::new()?;
@@ -27,13 +32,13 @@ fn parse_asn1(openssl: &str, req: &[u8]) -> anyhow::Result<String> {
 }
 
 /// Decode SCEP request
-pub fn decode_request(openssl: &str, req: &[u8]) -> anyhow::Result<SCEPEnvelopedPayload> {
+pub fn decode_request(openssl: &str, req: &[u8]) -> anyhow::Result<SCEPRequest> {
     let output = parse_asn1(openssl, req)?;
     let output = output.trim().replace('\r', "");
     log::debug!("ASN1 request output: {output}");
     let lines = output.split('\n').collect::<Vec<&str>>();
 
-    let mut res = SCEPEnvelopedPayload::default();
+    let mut res = SCEPRequest::default();
 
     for (num, line) in lines.iter().enumerate() {
         // Extract common name
@@ -60,6 +65,45 @@ pub fn decode_request(openssl: &str, req: &[u8]) -> anyhow::Result<SCEPEnveloped
         }
     }
 
+    Ok(res)
+}
+
+/// Decode SCEP response
+pub fn decode_response(openssl: &str, res: &[u8]) -> anyhow::Result<SCEPResponse> {
+    let output = parse_asn1(openssl, res)?;
+    let output = output.trim().replace('\r', "");
+    log::debug!("ASN1 response output: {output}");
+    let lines = output.split('\n').collect::<Vec<&str>>();
+
+    let mut byte_string = String::new();
+
+    // Extract PKCS7 payload
+    let mut extracting = false;
+    for (num, line) in lines.iter().enumerate() {
+        // Wait for payload
+        if !extracting {
+            if !line.contains(":pkcs7-data") {
+                extracting = true;
+            }
+            continue;
+        }
+
+        if line.contains("EOC") {
+            break;
+        }
+
+        if !line.contains("[HEX DUMP]:") {
+            continue;
+        }
+
+        byte_string.push_str(&line.split_once("[HEX DUMP]:").unwrap().1);
+    }
+
+    let mut res = SCEPResponse::default();
+    let pkcs7_data = hex::decode(byte_string.trim()).context("Decode PKCS7")?;
+
+    let pkcs7_decoded = parse_asn1(openssl, &pkcs7_data)?;
+    println!("{}", pkcs7_decoded);
 
     Ok(res)
 }

src/main.rs

@@ -4,7 +4,7 @@ use url::Url;
 use base64::prelude::*;
 use base64::engine::general_purpose::URL_SAFE as BASE64_URL_URL_SAFE;
 use colored::Colorize;
-use scep_req_parser::asn_parsing::decode_request;
+use scep_req_parser::asn_parsing::{decode_request, decode_response};
 use scep_req_parser::http_decoder::{parse_request, parse_response};
 
 /// Simple SCEP parser program
@@ -85,7 +85,9 @@ fn main() {
 
     if op == Operation::PKIOperation  {
         let req = decode_request(&args.openssl_command, request.body()).expect("Failed to decode request!");
+        let res = decode_response(&args.openssl_command, response.body()).expect("Failed to decode response!");
         println!("{req:?}");
+        println!("{res:?}");
     }
 
 }