certeef 0.1.3

A small certificate manager
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use std::process::{Command,Stdio};
use std::str;
use chrono::NaiveDateTime;
use std::fs;
use serde_json::{json,Value};

// This is the main library for certeef
pub fn check_expiration_date_of(url: &str) -> u32 {
    let openssl_output_first = Command::new("openssl")
                            .arg("s_client")
                            .arg("-connect")
                            .arg(format!("{}:443",url))
                            .arg("-servername")
                            .arg(url)
                            .stdout(Stdio::piped())
                            .spawn()
                            .unwrap();

    let openssl_output_second = Command::new("openssl")
                            .arg("x509")
                            .arg("-noout")
                            .arg("-dates")
                            .stdin(Stdio::from(openssl_output_first.stdout.unwrap())) // Pipe through.
                            .stdout(Stdio::piped())
                            .spawn()
                            .unwrap();
    let output = openssl_output_second.wait_with_output().unwrap();
    let openssl_stdout = str::from_utf8(&output.stdout).unwrap();
    let criteria = "notAfter=";
    let not_after_index = openssl_stdout.find(criteria).expect("failed to find notAfter=");

    let not_after = &openssl_stdout[not_after_index+criteria.len()..];
    let end_index = not_after.find("\n").expect("failed to find end of notAfter");
    let not_after = &not_after[..end_index];

    return calculate_days_until_expiry(not_after);

}
// 
fn calculate_days_until_expiry(not_after: &str) -> u32 {

    let format_str = "%b %d %H:%M:%S %Y %Z";

    let parsed_date = NaiveDateTime::parse_from_str(not_after, format_str);
    match parsed_date {
        Ok(date_time) => println!("Parsed date: {:?}", date_time),
        Err(e) => println!("Error: {:?}", e),
    }

    let now = chrono::Utc::now();
    let expiry_duration = parsed_date.unwrap().timestamp() - now.timestamp();
    let days_until_expiry = (expiry_duration / (24 * 60 * 60)) as u32;
    
    return days_until_expiry;
}

pub fn generate_self_signed_certificate() -> std::io::Result<Value> {
    let get_self_signed_cert = Command::new("openssl")
        .args(&[
            "req",
            "-x509",
            "-newkey",
            "rsa:4096",
            "-keyout",
            "key.pem",
            "-out",
            "cert.pem",
            "-days",
            "365",
            "-nodes",
            "-subj",
            "/CN=localhost",
        ]).stdout(Stdio::piped())
        .spawn()
        .unwrap();

    let output = get_self_signed_cert.wait_with_output().unwrap();

    if output.status.success() {
        let cert = fs::read_to_string("cert.pem")?;
        let key = fs::read_to_string("key.pem")?;
        let data = json!({
            "certificate": cert,
            "key": key,
        });
        println!("certificate: {}", data["certificate"]);
        Ok(data)
    } else {
        Err(std::io::Error::new(std::io::ErrorKind::Other, String::from_utf8_lossy(&output.stderr).to_string()))
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_check_expiration_date_of() {
        let url = "www.github.com";
        let result = check_expiration_date_of(url);
        assert!(result > 0);
    }   

#[cfg(test)]
mod tests {
    // Note this useful idiom: importing names from outer (for mod tests) scope.
    use super::*;
    use serde_json::Value;

    #[test]
    fn test_good_date_calculate_days_until_expiry() {
        assert_eq!(calculate_days_until_expiry("Jan 01 00:00:01 2099 GMT"), 27419);
    }

    #[test]
    fn test_bad_date_calculate_days_until_expiry() {
        assert_ne!(calculate_days_until_expiry("Jul 26 23:59:59 2024 GMT"), 40);
    }

    #[test]
    fn test_generate_self_signed_certificate() {
        let result = generate_self_signed_certificate();

        match result {
            Ok(json_string) => {
                let parsed: Value = json_string;
                let certificate = parsed["certificate"].as_str().unwrap();
                let key = parsed["key"].as_str().unwrap();
                assert!(certificate.contains("BEGIN CERTIFICATE"));
                assert!(key.contains("BEGIN PRIVATE KEY"));

                println!("Certificate: {}", certificate);
                println!("Key: {}", key);

            }
            Err(e) => eprintln!("Failed to generate certificate: {}", e),
        }
    }
}

}