openpgp-card-tools 0.11.11

A tool for inspecting, configuring and using OpenPGP cards
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

// SPDX-FileCopyrightText: 2022 Lars Wirzenius <liw@liw.fi>
// SPDX-License-Identifier: MIT OR Apache-2.0

use serde::Serialize;

use crate::output::OpgpCardError;
use crate::{OutputBuilder, OutputFormat, OutputVariant, OutputVersion};

#[derive(Debug, Default, Serialize)]
pub struct AdminGenerate {
    ident: String,
    algorithm: String,
    public_key: String,
}

impl AdminGenerate {
    pub fn ident(&mut self, ident: String) {
        self.ident = ident;
    }

    pub fn algorithm(&mut self, algorithm: String) {
        self.algorithm = algorithm;
    }

    pub fn public_key(&mut self, key: String) {
        self.public_key = key;
    }

    fn text(&self) -> Result<String, OpgpCardError> {
        // Do not print ident, as the file with the public_key must not contain anything else
        Ok(self.public_key.to_string())
    }

    fn v0(&self) -> Result<AdminGenerateV0, OpgpCardError> {
        Ok(AdminGenerateV0 {
            schema_version: AdminGenerateV0::VERSION,
            ident: self.ident.clone(),
            algorithm: self.algorithm.clone(),
            public_key: self.public_key.clone(),
        })
    }
}

impl OutputBuilder for AdminGenerate {
    type Err = OpgpCardError;

    fn print(&self, format: OutputFormat, version: OutputVersion) -> Result<String, Self::Err> {
        match format {
            OutputFormat::Json => {
                let result = if AdminGenerateV0::VERSION.is_acceptable_for(&version) {
                    self.v0()?.json()
                } else {
                    return Err(Self::Err::UnknownVersion(version));
                };
                result.map_err(Self::Err::SerdeJson)
            }
            OutputFormat::Yaml => {
                let result = if AdminGenerateV0::VERSION.is_acceptable_for(&version) {
                    self.v0()?.yaml()
                } else {
                    return Err(Self::Err::UnknownVersion(version));
                };
                result.map_err(Self::Err::SerdeYaml)
            }
            OutputFormat::Text => Ok(self.text()?),
        }
    }
}

#[derive(Debug, Serialize)]
struct AdminGenerateV0 {
    schema_version: OutputVersion,
    ident: String,
    algorithm: String,
    public_key: String,
}

impl OutputVariant for AdminGenerateV0 {
    const VERSION: OutputVersion = OutputVersion::new(0, 11, 0);
}