m2 0.0.0

Set of Unix tools to work with m2dirs
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

mod html;
mod pgp;

use std::{
    error::Error,
    io::{Read, Write, stdin, stdout},
};

use clap::Parser;
use html::generate_html;
use m2::Message;
use mail_builder::{
    MessageBuilder,
    headers::content_type::ContentType,
    mime::{BodyPart, MimePart},
};

#[derive(Debug, Parser)]
#[command(name = "m2proc", author, version)]
pub struct Args {
    /// PGP/MIME-sign email using gpg
    #[arg(long, default_value_t = false)]
    sign: bool,
    /// Don't create a multipart email with generated HTML
    #[arg(long, default_value_t = false)]
    no_html: bool,
}

pub fn preprocess<R: Read, W: Write>(
    mut r: R,
    w: W,
    sign: bool,
    gen_html: bool,
) -> Result<(), Box<dyn Error>> {
    let msg = Message::from_reader(&mut r)?;
    let mut builder = msg.builder();

    if gen_html {
        builder = multipart_html(builder);
    }

    if sign {
        builder = sign_builder(builder)?;
    }

    Ok(builder.write_to(w)?)
}

pub fn multipart_html(mut builder: MessageBuilder) -> MessageBuilder {
    let plain_ctype = ContentType::new("text/plain")
        .attribute("charset", "utf-8")
        .attribute("format", "flowed");
    let html_ctype = ContentType::new("text/html").attribute("charset", "utf-8");

    if let Some(ref mut body) = builder.body {
        let plain_body: String = match &body.contents {
            BodyPart::Text(s) => s.to_string(),
            _ => "".to_string(),
        };

        let html_body = generate_html(plain_body.clone());
        builder.headers.append(&mut body.headers);
        builder = builder.body(MimePart::new(
            "multipart/alternative",
            vec![
                MimePart::new(plain_ctype.clone(), plain_body),
                MimePart::new(html_ctype.clone(), html_body),
            ],
        ));
    }

    builder
}

pub fn sign_builder(msg_builder: MessageBuilder) -> Result<MessageBuilder, Box<dyn Error>> {
    let body = msg_builder.clone().body.ok_or("no body to sign")?;

    let mut mail_bytes = Vec::new();
    body.clone().write_part(&mut mail_bytes)?;

    let mut signature = Vec::<u8>::new();
    pgp::sign(mail_bytes.trim_ascii(), &mut signature)?;

    // NOTE: We are trusting that the output of `gpg --armor` is valid UTF-8
    let signature = MimePart::new(
        "application/pgp-signature",
        String::from_utf8_lossy(&signature).into_owned(),
    )
    .transfer_encoding("7bit")
    .attachment("signature.asc");

    let content_type = ContentType {
        c_type: "multipart/signed".into(),
        attributes: vec![
            ("micalg".into(), "pgp-sha1".into()),
            ("protocol".into(), "application/pgp-signature".into()),
        ],
    };

    Ok(msg_builder.body(MimePart::new(content_type, vec![body, signature])))
}

pub fn main() {
    let args = Args::parse();
    if let Err(e) = preprocess(stdin(), stdout(), args.sign, !args.no_html) {
        eprintln!("{e}");
    }
}