pgp 0.9.0

OpenPGP implementation in Rust
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
142
143
144

use chrono::{DateTime, TimeZone, Utc};
use nom::{be_u16, be_u32, be_u8};
use num_traits::FromPrimitive;

use crate::crypto::ecc_curve::ecc_curve_from_oid;
use crate::crypto::{HashAlgorithm, PublicKeyAlgorithm, SymmetricKeyAlgorithm};
use crate::types::{mpi, KeyVersion, Mpi, MpiRef, PublicParams};

#[inline]
fn to_owned(mref: MpiRef<'_>) -> Mpi {
    mref.to_owned()
}

// Ref: https://tools.ietf.org/html/rfc6637#section-9
#[rustfmt::skip]
named!(ecdsa<PublicParams>, do_parse!(
    // a one-octet size of the following field
         len: be_u8
    // octets representing a curve OID
    >> curve: map_opt!(take!(len), ecc_curve_from_oid)
    // MPI of an EC point representing a public key
    >>   p: mpi
    >> (PublicParams::ECDSA {
        curve,
        p: p.to_owned(),
    })
));

// https://tools.ietf.org/html/draft-koch-eddsa-for-openpgp-00#section-4
#[rustfmt::skip]
named!(eddsa<PublicParams>, do_parse!(
    // a one-octet size of the following field
         len: be_u8
    // octets representing a curve OID
    >> curve: map_opt!(take!(len), ecc_curve_from_oid)
    // MPI of an EC point representing a public key
    >>   q: mpi
    >> (PublicParams::EdDSA {
        curve,
        q: q.to_owned(),
    })
));

// Ref: https://tools.ietf.org/html/rfc6637#section-9
#[rustfmt::skip]
named!(ecdh<PublicParams>, do_parse!(
    // a one-octet size of the following field
          len: be_u8
    // octets representing a curve OID
    >>  curve: map_opt!(take!(len), ecc_curve_from_oid)
    // MPI of an EC point representing a public key
    >>    p: mpi
    // a one-octet size of the following fields
    >> _len2: be_u8
    // a one-octet value 01, reserved for future extensions
    >>       tag!(&[1][..])
    // a one-octet hash function ID used with a KDF
    >> hash: map_opt!(be_u8, HashAlgorithm::from_u8)
    // a one-octet algorithm ID for the symmetric algorithm used to wrap
    // the symmetric key used for the message encryption
    >>  alg_sym: map_opt!(be_u8, SymmetricKeyAlgorithm::from_u8)
    >> (PublicParams::ECDH {
        curve,
        p: p.to_owned(),
        hash,
        alg_sym,
    })
));

#[rustfmt::skip]
named!(elgamal<PublicParams>, do_parse!(
    // MPI of Elgamal prime p
        p: map!(mpi, to_owned)
    // MPI of Elgamal group generator g
    >> g: map!(mpi, to_owned)
    // MPI of Elgamal public key value y (= g**x mod p where x is secret)
    >> y: map!(mpi, to_owned)
    >> (PublicParams::Elgamal{ p, g, y })
));

#[rustfmt::skip]
named!(dsa<PublicParams>, do_parse!(
       p: map!(mpi, to_owned)
    >> q: map!(mpi, to_owned)
    >> g: map!(mpi, to_owned)
    >> y: map!(mpi, to_owned)
    >> (PublicParams::DSA { p, q, g, y })
));

#[rustfmt::skip]
named!(rsa<PublicParams>, do_parse!(
       n: map!(mpi, to_owned)
    >> e: map!(mpi, to_owned)
    >> (PublicParams::RSA { n, e })
));

// Parse the fields of a public key.
named_args!(pub parse_pub_fields(typ: PublicKeyAlgorithm) <PublicParams>, switch!(
    value!(typ),
    PublicKeyAlgorithm::RSA        |
    PublicKeyAlgorithm::RSAEncrypt |
    PublicKeyAlgorithm::RSASign    => call!(rsa)     |
    PublicKeyAlgorithm::DSA        => call!(dsa)     |
    PublicKeyAlgorithm::ECDSA      => call!(ecdsa)   |
    PublicKeyAlgorithm::ECDH       => call!(ecdh)    |
    PublicKeyAlgorithm::Elgamal    |
    PublicKeyAlgorithm::ElgamalSign => call!(elgamal) |
    PublicKeyAlgorithm::EdDSA       => call!(eddsa)
    // &PublicKeyAlgorithm::DiffieHellman =>
));

named_args!(new_public_key_parser<'a>(key_ver: &'a KeyVersion) <(KeyVersion, PublicKeyAlgorithm, DateTime<Utc>, Option<u16>, PublicParams)>, do_parse!(
       created_at: map!(be_u32, |v| Utc.timestamp(i64::from(v), 0))
    >>        alg: map_opt!(be_u8, PublicKeyAlgorithm::from_u8)
    >>     params: call!(parse_pub_fields, alg)
    >> (*key_ver, alg, created_at, None, params)
));

named_args!(old_public_key_parser<'a>(key_ver: &'a KeyVersion) <(KeyVersion, PublicKeyAlgorithm, DateTime<Utc>, Option<u16>, PublicParams)>, do_parse!(
        created_at: map!(be_u32, |v| Utc.timestamp(i64::from(v), 0))
    >>         exp: be_u16
    >>         alg: map_opt!(be_u8, PublicKeyAlgorithm::from_u8)
    >>      params: call!(parse_pub_fields, alg)
    >> (*key_ver, alg, created_at, Some(exp), params)
));

// Parse a public key packet (Tag 6)
// Ref: https://tools.ietf.org/html/rfc4880.html#section-5.5.1.1
#[rustfmt::skip]
named!(pub parse<(KeyVersion, PublicKeyAlgorithm, DateTime<Utc>, Option<u16>, PublicParams)>, do_parse!(
       key_ver: map_opt!(be_u8, KeyVersion::from_u8)
    >>     key: switch!(value!(&key_ver),
                        &KeyVersion::V2 => call!(
                            old_public_key_parser, &key_ver
                        ) |
                        &KeyVersion::V3 => call!(
                            old_public_key_parser, &key_ver
                        ) |
                        &KeyVersion::V4 => call!(
                            new_public_key_parser, &key_ver
                        )
        )
    >> (key)
));