use std::collections::BTreeMap;
use std::sync::Arc;
use fiki::{
sign_request, sign_response, verify_request, verify_response, Authorities, Error,
ExpectedKeyid, Key, Kind, MaxAge, Minimum, Request, Resolver, SignOptions, VerifyOptions,
REQUEST_MINIMUM, RESPONSE_MINIMUM,
};
type Outcome = Result<(), Box<dyn std::error::Error>>;
const URL: &str = "https://keria.example.com/identifiers";
const BODY: &[u8] = br#"{"name": "alice"}"#;
const CONTROLLER: &str = "ELLKuZrOw7_eNOyM2TXu5j2YHnEyHnpM1iTUKf4Dxgtx";
const AGENT: &str = "EIhwv8kMnCY92GevqHtBlMT8cQD96m3XkNav--Ti-4Q6";
fn seeded(first: u8) -> Key {
Key::from_seed(&(first..first + 32).collect::<Vec<_>>()).unwrap()
}
fn current_key(key: &Key) -> [u8; 32] {
*fiki::verifying_key(&key.aid()).unwrap().as_bytes()
}
fn main() -> Outcome {
plain()?;
let controller = seeded(2);
let agent = seeded(3);
let table = BTreeMap::from([
(CONTROLLER.to_string(), current_key(&controller)),
(AGENT.to_string(), current_key(&agent)),
]);
let headers = keri_request(&controller)?;
keri_verify(&headers, &table)?;
let request = Request {
method: "POST".into(),
url: URL.into(),
headers: headers.clone(),
body: Some(BODY.to_vec()),
};
let response = keri_response(&agent, &request)?;
keri_verify_response(&response, &request, &table)?;
refusals(&controller, &headers, &table)?;
println!("rust guide samples: OK");
Ok(())
}
fn plain() -> Outcome {
let seed: Vec<u8> = (0u8..32).collect();
let key = Key::from_seed(&seed)?;
println!("{}", key.aid());
let url = "https://api.example.com/things?limit=1";
let body = br#"{"hello": "world"}"#;
let headers = sign_request(
&key,
"POST",
url,
&BTreeMap::new(),
&SignOptions {
body: Some(body.to_vec()),
..Default::default()
},
)?;
let verdict = verify_request(
"POST",
url,
&headers,
&VerifyOptions {
max_age: MaxAge::seconds(300),
body: Some(body.to_vec()),
authorities: Authorities::served(["api.example.com"]),
..Default::default()
},
)?;
assert_eq!(verdict.aid, key.aid());
Ok(())
}
fn keri_request(controller: &Key) -> Result<BTreeMap<String, String>, Error> {
let key = controller;
let headers = sign_request(
key,
"POST",
"https://keria.example.com/identifiers",
&BTreeMap::new(),
&SignOptions {
body: Some(br#"{"name": "alice"}"#.to_vec()),
keyid: Some("ELLKuZrOw7_eNOyM2TXu5j2YHnEyHnpM1iTUKf4Dxgtx".into()),
minimum: Some(REQUEST_MINIMUM.map(String::from).to_vec()),
..Default::default()
},
)?;
Ok(headers)
}
fn keri_verify(headers: &BTreeMap<String, String>, table: &BTreeMap<String, [u8; 32]>) -> Outcome {
let key_state = table.clone();
let body = BODY;
let resolve: Resolver = Arc::new(move |keyid: &str| Ok(key_state.get(keyid).copied()));
let verdict = verify_request(
"POST",
"https://keria.example.com/identifiers",
headers,
&VerifyOptions {
max_age: MaxAge::seconds(300),
body: Some(body.to_vec()),
resolve: Some(resolve),
minimum: Minimum::of(REQUEST_MINIMUM),
authorities: Authorities::served(["keria.example.com"]),
..Default::default()
},
)?;
assert_eq!(verdict.aid, "ELLKuZrOw7_eNOyM2TXu5j2YHnEyHnpM1iTUKf4Dxgtx");
Ok(())
}
fn keri_response(agent: &Key, request: &Request) -> Result<BTreeMap<String, String>, Error> {
let request = request.clone();
let response_headers = sign_response(
agent,
200,
Some(&request),
&BTreeMap::new(),
&SignOptions {
body: Some(br#"{"done": true}"#.to_vec()),
keyid: Some("EIhwv8kMnCY92GevqHtBlMT8cQD96m3XkNav--Ti-4Q6".into()),
minimum: Some(RESPONSE_MINIMUM.map(String::from).to_vec()),
..Default::default()
},
)?;
Ok(response_headers)
}
fn keri_verify_response(
response_headers: &BTreeMap<String, String>,
request: &Request,
table: &BTreeMap<String, [u8; 32]>,
) -> Outcome {
let key_state = table.clone();
let resolve: Resolver = Arc::new(move |keyid: &str| Ok(key_state.get(keyid).copied()));
let verdict = verify_response(
200,
response_headers,
Some(request),
&VerifyOptions {
max_age: MaxAge::seconds(300),
body: Some(br#"{"done": true}"#.to_vec()),
resolve: Some(resolve),
expected_keyid: ExpectedKeyid::is("EIhwv8kMnCY92GevqHtBlMT8cQD96m3XkNav--Ti-4Q6"),
minimum: Minimum::of(RESPONSE_MINIMUM),
..Default::default()
},
)?;
assert_eq!(
verdict.keyid.as_deref(),
Some("EIhwv8kMnCY92GevqHtBlMT8cQD96m3XkNav--Ti-4Q6")
);
Ok(())
}
fn refusals(
controller: &Key,
headers: &BTreeMap<String, String>,
table: &BTreeMap<String, [u8; 32]>,
) -> Outcome {
let key_state = table.clone();
let opts = |resolve: Resolver| VerifyOptions {
max_age: MaxAge::seconds(300),
body: Some(BODY.to_vec()),
resolve: Some(resolve),
minimum: Minimum::of(REQUEST_MINIMUM),
authorities: Authorities::served(["keria.example.com"]),
..Default::default()
};
let verify = |headers: &BTreeMap<String, String>, opts: &VerifyOptions| {
verify_request("POST", URL, headers, opts)
};
let known: Resolver = Arc::new(move |keyid: &str| Ok(key_state.get(keyid).copied()));
let nobody: Resolver = Arc::new(|_: &str| Ok(None));
let group: Resolver = Arc::new(|keyid: &str| {
Err(Error::detailed(
Kind::UnsupportedSigner,
"This AID's key state has no single key that satisfies its threshold.",
keyid,
))
});
let narrow = sign_request(
controller,
"POST",
URL,
&BTreeMap::new(),
&SignOptions {
body: Some(BODY.to_vec()),
covered: Some(vec![
"@method".into(),
"@path".into(),
"content-digest".into(),
]),
keyid: Some(CONTROLLER.into()),
..Default::default()
},
)?;
let mut doubled = headers.clone();
let input = doubled["Signature-Input"].replacen("\"@path\"", "\"@path\" \"@path\"", 1);
doubled.insert("Signature-Input".into(), input);
let below = VerifyOptions {
minimum: Minimum::of(["@method"]),
..opts(known.clone())
};
let any_signer = VerifyOptions {
expected_keyid: ExpectedKeyid::Unchecked,
max_age: MaxAge::Unchecked,
..Default::default()
};
let results = [
verify(headers, &opts(nobody)), verify(headers, &opts(group)), verify(&narrow, &opts(known.clone())), verify(&doubled, &opts(known.clone())), verify_response(401, &BTreeMap::new(), None, &any_signer), verify(headers, &below), ];
let mut seen = Vec::new();
for result in results {
let err = result.unwrap_err();
match err.kind {
Kind::UnknownKey => {} Kind::UnsupportedSigner => {} Kind::InsufficientCoverage => {} Kind::DuplicateComponent => {} Kind::Unauthenticated => {} Kind::InvalidArgument => {} _ => {} }
seen.push(err.kind);
}
assert_eq!(
seen,
[
Kind::UnknownKey,
Kind::UnsupportedSigner,
Kind::InsufficientCoverage,
Kind::DuplicateComponent,
Kind::Unauthenticated,
Kind::InvalidArgument,
]
);
Ok(())
}