openpgp 0.1.5

Low-level OpenPGP packet operations based on rPGP
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

// SPDX-FileCopyrightText: Heiko Schaefer <heiko@schaefer.name>
// SPDX-License-Identifier: MIT OR Apache-2.0

mod util;

use std::fs::File;
use std::path::PathBuf;

use anyhow::Result;
use clap::Parser;
use pgp::packet::PacketTrait;
use pgp::ser::Serialize;

#[derive(Parser, Debug)]
pub struct Args {
    #[command(subcommand)]
    pub cmd: Command,
}

#[derive(Parser, Debug)]
pub enum Command {
    /// Dump packet information
    Dump(DumpCommand),

    /// Split OpenPGP data into individual packets
    Split(SplitCommand),
}

#[derive(Parser, Debug)]
pub struct SplitCommand {
    /// Input file (stdin if unset)
    pub input: Option<PathBuf>,
}

#[derive(Parser, Debug)]
pub struct DumpCommand {
    /// Input file (stdin if unset)
    pub input: Option<PathBuf>,
}

pub fn dump(input: Option<PathBuf>) -> Result<()> {
    for res in util::parse_packets(input)? {
        match res {
            Ok(p) => println!("{:#?}", p),
            Err(e) => println!("{:#?}", e),
        }
    }

    Ok(())
}

pub fn split(input: Option<PathBuf>) -> Result<()> {
    let prefix = input
        .clone()
        .and_then(|p| {
            p.file_name()
                .and_then(|os_str| os_str.to_str())
                .map(|str| str.to_string())
        })
        .map(|p| format!("{}-", p))
        .unwrap_or("".to_string());

    for (i, res) in util::parse_packets(input)?.enumerate() {
        match res {
            Ok(p) => {
                let filename = format!("{}{:06}-{:?}", prefix, i, p.tag());

                let mut file = File::create_new(filename)?;
                p.to_writer(&mut file)?;
            }
            Err(e) => println!("Error in packet {}: {:#?}", i, e),
        }
    }

    Ok(())
}