// -*- mode: Rust; -*-
use crate::Error;
use crate::packet::Signature;
use crate::packet::UserID;
use crate::packet::UserAttribute;
use crate::packet::{key, Key};
use crate::packet::Unknown;
use crate::Packet;
use crate::cert::prelude::*;
use crate::cert::parser::low_level::lexer;
use crate::cert::parser::low_level::lexer::{Token, Component};
use crate::cert::ComponentBundles;
use crate::cert::bundle::{
PrimaryKeyBundle,
SubkeyBundle,
UserIDBundle,
UserAttributeBundle,
UnknownBundle,
};
use lalrpop_util::ParseError;
grammar;
// The parser is used in two ways: it can either be used to check
// whether a sequence of packets forms a Cert, or to build a Cert from a
// sequence of packets. In the former case, we only need the packet
// tags; in the latter case, we also need the packets. To handle both
// situations, the token includes the tag and an optional packet.
// When invoking the parser, it is essential, that either *all* tokens
// have no packet, or they all have a packet; mixing the two types of
// tokens will result in a crash.
pub Cert: Option<Cert> = {
<p:Primary> <c:OptionalComponents> =>? {
match p {
Some((Packet::PublicKey(_), _))
| Some((Packet::SecretKey(_), _)) => {
let (key, sigs) = match p {
Some((Packet::PublicKey(key), sigs)) => (key, sigs),
Some((Packet::SecretKey(key), sigs)) => (key.into(), sigs),
_ => unreachable!(),
};
let c = c.unwrap();
let mut cert = Cert {
primary: PrimaryKeyBundle {
component: key,
self_signatures: vec![],
certifications: sigs,
self_revocations: vec![],
other_revocations: vec![],
},
subkeys: ComponentBundles::new(),
userids: ComponentBundles::new(),
user_attributes: ComponentBundles::new(),
unknowns: ComponentBundles::new(),
bad: vec![],
};
for c in c.into_iter() {
match c {
Component::SubkeyBundle(b) =>
cert.subkeys.push(b),
Component::UserIDBundle(b) =>
cert.userids.push(b),
Component::UserAttributeBundle(b) =>
cert.user_attributes.push(b),
Component::UnknownBundle(b) =>
cert.unknowns.push(b),
}
}
Ok(Some(cert))
}
Some((Packet::Unknown(unknown), _sigs)) => {
Err(ParseError::User {
error: Error::UnsupportedCert(format!(
"Unsupported primary key: Unparsable {} ({:?}).",
unknown.tag(), unknown).into())
})
}
None => {
// Just validating a message...
assert!(c.is_none() || c.unwrap().len() == 0);
Ok(None)
}
Some((pkt, _)) =>
unreachable!("Expected key or unknown packet, got {:?}", pkt),
}
}
};
Primary: Option<(Packet, Vec<Signature>)> = {
<pk:PrimaryKey> <sigs:OptionalSignatures> => {
if let Some(pk) = pk {
Some((pk, sigs.unwrap()))
} else {
// Just validating a message...
assert!(sigs.is_none() || sigs.unwrap().len() == 0);
None
}
}
}
PrimaryKey: Option<Packet> = {
<t:PUBLIC_KEY> => t.into(),
<t:SECRET_KEY> => t.into(),
};
OptionalSignatures: Option<Vec<Signature>> = {
=> Some(vec![]),
<sigs:OptionalSignatures> <sig:SIGNATURE> => {
match sig {
Token::Signature(Some(Packet::Signature(sig))) => {
assert!(sigs.is_some());
let mut sigs = sigs.unwrap();
sigs.push(sig);
Some(sigs)
}
Token::Signature(Some(Packet::Unknown(_sig))) => {
// Ignore unsupported / bad signatures.
assert!(sigs.is_some());
sigs
}
// Just validating a message...
Token::Signature(None) => return None,
tok => unreachable!("Expected signature token, got {:?}", tok),
}
},
// A trust packet can go wherever a signature can go, but they
// are ignored.
<OptionalSignatures> TRUST,
}
OptionalComponents: Option<Vec<Component>> = {
=> Some(vec![]),
<cs:OptionalComponents> <c:Component> => {
if let Some(c) = c {
let mut cs = cs.unwrap();
cs.push(c);
Some(cs)
} else {
// Just validating a message...
None
}
},
}
Component: Option<Component> = {
<key:Subkey> <sigs:OptionalSignatures> => {
match key {
Some(key) => {
let sigs = sigs.unwrap();
Some(Component::SubkeyBundle(SubkeyBundle {
component: key,
self_signatures: vec![],
certifications: sigs,
self_revocations: vec![],
other_revocations: vec![],
}))
},
// Just validating a message...
None => None,
}
},
<u:UserID> <sigs:OptionalSignatures> => {
match u {
Some(u) => {
let sigs = sigs.unwrap();
Some(Component::UserIDBundle(UserIDBundle {
component: u,
self_signatures: vec![],
certifications: sigs,
self_revocations: vec![],
other_revocations: vec![],
}))
},
// Just validating a message...
None => None,
}
},
<u:UserAttribute> <sigs:OptionalSignatures> => {
match u {
Some(u) => {
let sigs = sigs.unwrap();
Some(Component::UserAttributeBundle(UserAttributeBundle {
component: u,
self_signatures: vec![],
certifications: sigs,
self_revocations: vec![],
other_revocations: vec![],
}))
},
// Just validating a message...
None => None,
}
},
<u:Unknown> <sigs:OptionalSignatures> => {
match u {
Some(u) => {
let sigs = sigs.unwrap();
Some(Component::UnknownBundle(UnknownBundle {
component: u,
self_signatures: vec![],
certifications: sigs,
self_revocations: vec![],
other_revocations: vec![],
}))
},
// Just validating a message...
None => None,
}
},
}
Subkey: Option<Key<key::PublicParts, key::SubordinateRole>> = {
<t:PUBLIC_SUBKEY> => {
match t.into() {
Some(Packet::PublicSubkey(key)) => Some(key),
// Just validating a message...
None => None,
Some(pkt) =>
unreachable!("Expected public subkey packet, got {:?}", pkt),
}
},
<t:SECRET_SUBKEY> => {
match t.into() {
Some(Packet::SecretSubkey(key)) => Some(key.parts_into_public()),
// Just validating a message...
None => None,
Some(pkt) =>
unreachable!("Expected secret subkey packet, got {:?}", pkt),
}
},
}
UserID: Option<UserID> = {
<t:USERID> => {
match t.into() {
Some(Packet::UserID(u)) => Some(u),
// Just validating a message...
None => None,
Some(pkt) =>
unreachable!("Expected user id packet, got {:?}", pkt),
}
},
}
UserAttribute: Option<UserAttribute> = {
<t:USER_ATTRIBUTE> => {
match t.into() {
Some(Packet::UserAttribute(u)) => Some(u),
// Just validating a message...
None => None,
Some(pkt) =>
unreachable!("Expected user attribute packet, got {:?}", pkt),
}
},
}
Unknown: Option<Unknown> = {
<t:UNKNOWN> => {
match t.into() {
Some(Packet::Unknown(u)) => Some(u),
// Just validating a message...
None => None,
Some(pkt) =>
unreachable!("Expected unknown packet, got {:?}", pkt),
}
},
}
extern {
type Location = usize;
type Error = Error;
enum lexer::Token {
PUBLIC_KEY => lexer::Token::PublicKey(_),
SECRET_KEY => lexer::Token::SecretKey(_),
PUBLIC_SUBKEY => lexer::Token::PublicSubkey(_),
SECRET_SUBKEY => lexer::Token::SecretSubkey(_),
USERID => lexer::Token::UserID(_),
USER_ATTRIBUTE => lexer::Token::UserAttribute(_),
SIGNATURE => lexer::Token::Signature(_),
TRUST => lexer::Token::Trust(_),
UNKNOWN => lexer::Token::Unknown(_, _),
}
}