use crate::crypto::{
Confirmation, HASH_LEN_BYTES, PUBLIC_KEY_SIZE_BYTES, Spake2pProver, Spake2pVerifier,
Spake2pVerifierData, context as spake_context, ct_eq,
};
use crate::error::{Error, ErrorCode, Result, bail};
use crate::msg::SessionId;
use crate::session::EstablishedKeys;
use crate::tlv::{ContainerKind, Tag, TlvReader, TlvWriter, Value, set_once};
use super::SessionParams;
use super::status::{SecureChannelCode, StatusReport};
pub const RANDOM_LEN: usize = 32;
pub const PASSCODE_ID_COMMISSIONING: u16 = 0;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PbkdfParameters {
pub iterations: u32,
pub salt: heapless::Vec<u8, { crate::crypto::PBKDF_SALT_MAX_BYTES }>,
}
impl PbkdfParameters {
pub fn new(iterations: u32, salt: &[u8]) -> Result<Self> {
if !(crate::crypto::PBKDF_ITERATIONS_MIN..=crate::crypto::PBKDF_ITERATIONS_MAX)
.contains(&iterations)
{
bail!(InvalidArgument)
}
let Ok(salt) = heapless::Vec::from_slice(salt) else {
bail!(InvalidArgument)
};
if salt.len() < crate::crypto::PBKDF_SALT_MIN_BYTES {
bail!(InvalidArgument)
}
Ok(Self { iterations, salt })
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PbkdfParamRequest {
pub initiator_random: [u8; RANDOM_LEN],
pub initiator_session_id: SessionId,
pub passcode_id: u16,
pub has_pbkdf_parameters: bool,
pub session_params: Option<SessionParams>,
}
impl PbkdfParamRequest {
pub fn encode(&self, out: &mut [u8]) -> Result<usize> {
let mut w = TlvWriter::new(out);
w.start_structure(Tag::Anonymous)?;
w.octets(Tag::Context(1), &self.initiator_random)?;
w.unsigned(Tag::Context(2), u64::from(self.initiator_session_id.0))?;
w.unsigned(Tag::Context(3), u64::from(self.passcode_id))?;
w.bool(Tag::Context(4), self.has_pbkdf_parameters)?;
if let Some(params) = &self.session_params {
params.encode(&mut w, Tag::Context(5))?;
}
w.end_container()?;
Ok(w.finish()?.len())
}
pub fn decode(buf: &[u8]) -> Result<Self> {
let mut fields = Fields::new(buf)?;
let mut out = Self {
initiator_random: [0; RANDOM_LEN],
initiator_session_id: SessionId(0),
passcode_id: PASSCODE_ID_COMMISSIONING,
has_pbkdf_parameters: false,
session_params: None,
};
let mut seen_random = false;
while let Some((tag, element)) = fields.next()? {
match tag {
1 => {
let bytes = element.octets()?;
let Ok(arr) = <[u8; RANDOM_LEN]>::try_from(bytes) else {
bail!(InvalidArgument)
};
out.initiator_random = arr;
seen_random = true;
}
2 => out.initiator_session_id = SessionId(u16_of(element.unsigned()?)?),
3 => out.passcode_id = u16_of(element.unsigned()?)?,
4 => out.has_pbkdf_parameters = element.bool()?,
5 => out.session_params = Some(SessionParams::decode(&mut fields)?),
_ => fields.skip(&element)?,
}
}
if !seen_random {
bail!(TlvNotFound)
}
Ok(out)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PbkdfParamResponse {
pub initiator_random: [u8; RANDOM_LEN],
pub responder_random: [u8; RANDOM_LEN],
pub responder_session_id: SessionId,
pub pbkdf_parameters: Option<PbkdfParameters>,
pub session_params: Option<SessionParams>,
}
impl PbkdfParamResponse {
pub fn encode(&self, out: &mut [u8]) -> Result<usize> {
let mut w = TlvWriter::new(out);
w.start_structure(Tag::Anonymous)?;
w.octets(Tag::Context(1), &self.initiator_random)?;
w.octets(Tag::Context(2), &self.responder_random)?;
w.unsigned(Tag::Context(3), u64::from(self.responder_session_id.0))?;
w.start_structure(Tag::Context(4))?;
if let Some(params) = &self.pbkdf_parameters {
w.unsigned(Tag::Context(1), u64::from(params.iterations))?;
w.octets(Tag::Context(2), ¶ms.salt)?;
}
w.end_container()?;
if let Some(params) = &self.session_params {
params.encode(&mut w, Tag::Context(5))?;
}
w.end_container()?;
Ok(w.finish()?.len())
}
pub fn decode(buf: &[u8]) -> Result<Self> {
let mut fields = Fields::new(buf)?;
let mut out = Self {
initiator_random: [0; RANDOM_LEN],
responder_random: [0; RANDOM_LEN],
responder_session_id: SessionId(0),
pbkdf_parameters: None,
session_params: None,
};
while let Some((tag, element)) = fields.next()? {
match tag {
1 => out.initiator_random = random_of(&element)?,
2 => out.responder_random = random_of(&element)?,
3 => out.responder_session_id = SessionId(u16_of(element.unsigned()?)?),
4 => out.pbkdf_parameters = decode_pbkdf_parameters(&mut fields, &element)?,
5 => out.session_params = Some(SessionParams::decode(&mut fields)?),
_ => fields.skip(&element)?,
}
}
Ok(out)
}
}
fn decode_pbkdf_parameters(
fields: &mut Fields<'_>,
element: &crate::tlv::Element<'_>,
) -> Result<Option<PbkdfParameters>> {
if element.value.container() != Some(ContainerKind::Structure) {
bail!(TlvWrongType)
}
let (iterations, salt) = fields.nested(|fields| {
let mut iterations = None;
let mut salt: Option<heapless::Vec<u8, { crate::crypto::PBKDF_SALT_MAX_BYTES }>> = None;
while let Some((tag, inner)) = fields.next()? {
match tag {
1 => set_once(&mut iterations, u32_of(inner.unsigned()?)?)?,
2 => {
let Ok(v) = heapless::Vec::from_slice(inner.octets()?) else {
bail!(InvalidArgument)
};
set_once(&mut salt, v)?;
}
_ => fields.skip(&inner)?,
}
}
Ok((iterations, salt))
})?;
match (iterations, salt) {
(Some(iterations), Some(salt)) => Ok(Some(PbkdfParameters::new(iterations, &salt)?)),
(None, None) => Ok(None),
_ => Err(Error::new(ErrorCode::InvalidArgument)),
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Pake1 {
pub pa: [u8; PUBLIC_KEY_SIZE_BYTES],
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Pake2 {
pub pb: [u8; PUBLIC_KEY_SIZE_BYTES],
pub cb: Confirmation,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Pake3 {
pub ca: Confirmation,
}
impl Pake1 {
pub fn encode(&self, out: &mut [u8]) -> Result<usize> {
let mut w = TlvWriter::new(out);
w.start_structure(Tag::Anonymous)?;
w.octets(Tag::Context(1), &self.pa)?;
w.end_container()?;
Ok(w.finish()?.len())
}
pub fn decode(buf: &[u8]) -> Result<Self> {
let mut fields = Fields::new(buf)?;
let mut pa = None;
while let Some((tag, element)) = fields.next()? {
match tag {
1 => pa = Some(point_of(&element)?),
_ => fields.skip(&element)?,
}
}
Ok(Self {
pa: pa.ok_or(Error::new(ErrorCode::TlvNotFound))?,
})
}
}
impl Pake2 {
pub fn encode(&self, out: &mut [u8]) -> Result<usize> {
let mut w = TlvWriter::new(out);
w.start_structure(Tag::Anonymous)?;
w.octets(Tag::Context(1), &self.pb)?;
w.octets(Tag::Context(2), &self.cb)?;
w.end_container()?;
Ok(w.finish()?.len())
}
pub fn decode(buf: &[u8]) -> Result<Self> {
let mut fields = Fields::new(buf)?;
let (mut pb, mut cb) = (None, None);
while let Some((tag, element)) = fields.next()? {
match tag {
1 => pb = Some(point_of(&element)?),
2 => cb = Some(confirmation_of(&element)?),
_ => fields.skip(&element)?,
}
}
Ok(Self {
pb: pb.ok_or(Error::new(ErrorCode::TlvNotFound))?,
cb: cb.ok_or(Error::new(ErrorCode::TlvNotFound))?,
})
}
}
impl Pake3 {
pub fn encode(&self, out: &mut [u8]) -> Result<usize> {
let mut w = TlvWriter::new(out);
w.start_structure(Tag::Anonymous)?;
w.octets(Tag::Context(1), &self.ca)?;
w.end_container()?;
Ok(w.finish()?.len())
}
pub fn decode(buf: &[u8]) -> Result<Self> {
let mut fields = Fields::new(buf)?;
let mut ca = None;
while let Some((tag, element)) = fields.next()? {
match tag {
1 => ca = Some(confirmation_of(&element)?),
_ => fields.skip(&element)?,
}
}
Ok(Self {
ca: ca.ok_or(Error::new(ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone)]
pub struct ResponderConfig {
pub verifier: Spake2pVerifierData,
pub parameters: PbkdfParameters,
pub session_params: Option<SessionParams>,
}
#[derive(Debug)]
pub struct PaseResponder {
config: ResponderConfig,
local_session_id: SessionId,
peer_session_id: SessionId,
request_bytes: heapless::Vec<u8, 256>,
response_bytes: heapless::Vec<u8, 256>,
verifier: Option<Spake2pVerifier>,
expected_ca: Option<Confirmation>,
keys: Option<EstablishedKeys>,
state: State,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum State {
AwaitingRequest,
AwaitingPake1,
AwaitingPake3,
Established,
Failed,
}
impl PaseResponder {
#[must_use]
pub fn new(config: ResponderConfig, local_session_id: SessionId) -> Self {
Self {
config,
local_session_id,
peer_session_id: SessionId(0),
request_bytes: heapless::Vec::new(),
response_bytes: heapless::Vec::new(),
verifier: None,
expected_ca: None,
keys: None,
state: State::AwaitingRequest,
}
}
#[must_use]
pub const fn local_session_id(&self) -> SessionId {
self.local_session_id
}
#[must_use]
pub const fn peer_session_id(&self) -> SessionId {
self.peer_session_id
}
pub fn on_pbkdf_param_request(
&mut self,
payload: &[u8],
responder_random: &[u8; RANDOM_LEN],
out: &mut [u8],
) -> Result<usize> {
if self.state != State::AwaitingRequest {
self.state = State::Failed;
bail!(InvalidState)
}
let request = PbkdfParamRequest::decode(payload)?;
if request.passcode_id != PASSCODE_ID_COMMISSIONING {
self.state = State::Failed;
bail!(InvalidArgument)
}
self.peer_session_id = request.initiator_session_id;
let response = PbkdfParamResponse {
initiator_random: request.initiator_random,
responder_random: *responder_random,
responder_session_id: self.local_session_id,
pbkdf_parameters: if request.has_pbkdf_parameters {
None
} else {
Some(self.config.parameters.clone())
},
session_params: self.config.session_params,
};
let n = response.encode(out)?;
self.request_bytes = copy_of(payload)?;
self.response_bytes = copy_of(out.get(..n).unwrap_or(&[]))?;
self.state = State::AwaitingPake1;
Ok(n)
}
pub fn on_pake1(
&mut self,
payload: &[u8],
responder_ephemeral: &[u8; 32],
out: &mut [u8],
) -> Result<usize> {
if self.state != State::AwaitingPake1 {
self.state = State::Failed;
bail!(InvalidState)
}
let pake1 = Pake1::decode(payload)?;
let verifier = Spake2pVerifier::new(&self.config.verifier, responder_ephemeral)?;
let context = spake_context(&self.request_bytes, &self.response_bytes);
let (ca, cb, ke) = verifier.finish(&pake1.pa, &context)?;
let n = Pake2 {
pb: *verifier.pb(),
cb,
}
.encode(out)?;
self.keys = Some(EstablishedKeys::derive(ke.as_bytes(), &[])?);
self.expected_ca = Some(ca);
self.verifier = Some(verifier);
self.state = State::AwaitingPake3;
Ok(n)
}
pub fn on_pake3(&mut self, payload: &[u8], out: &mut [u8]) -> Result<(usize, EstablishedKeys)> {
if self.state != State::AwaitingPake3 {
self.state = State::Failed;
bail!(InvalidState)
}
let pake3 = Pake3::decode(payload)?;
let Some(expected) = self.expected_ca else {
self.state = State::Failed;
bail!(InvalidState)
};
if !ct_eq(&pake3.ca, &expected) {
self.state = State::Failed;
bail!(IntegrityCheckFailed)
}
let Some(keys) = self.keys.clone() else {
self.state = State::Failed;
bail!(InvalidState)
};
let n = StatusReport::secure_channel(SecureChannelCode::SessionEstablishmentSuccess)
.encode(out)?;
self.state = State::Established;
Ok((n, keys))
}
#[must_use]
pub const fn is_established(&self) -> bool {
matches!(self.state, State::Established)
}
#[must_use]
pub const fn is_failed(&self) -> bool {
matches!(self.state, State::Failed)
}
}
#[derive(Debug)]
pub struct PaseInitiator {
passcode: u32,
local_session_id: SessionId,
peer_session_id: SessionId,
known_parameters: Option<PbkdfParameters>,
session_params: Option<SessionParams>,
initiator_random: [u8; RANDOM_LEN],
request_bytes: heapless::Vec<u8, 256>,
response_bytes: heapless::Vec<u8, 256>,
prover: Option<Spake2pProver>,
expected_cb: Option<Confirmation>,
ca: Option<Confirmation>,
keys: Option<EstablishedKeys>,
state: State,
}
impl PaseInitiator {
#[must_use]
pub fn new(
passcode: u32,
local_session_id: SessionId,
known_parameters: Option<PbkdfParameters>,
session_params: Option<SessionParams>,
) -> Self {
Self {
passcode,
local_session_id,
peer_session_id: SessionId(0),
known_parameters,
session_params,
initiator_random: [0; RANDOM_LEN],
request_bytes: heapless::Vec::new(),
response_bytes: heapless::Vec::new(),
prover: None,
expected_cb: None,
ca: None,
keys: None,
state: State::AwaitingRequest,
}
}
#[must_use]
pub const fn local_session_id(&self) -> SessionId {
self.local_session_id
}
#[must_use]
pub const fn peer_session_id(&self) -> SessionId {
self.peer_session_id
}
pub fn start(&mut self, initiator_random: &[u8; RANDOM_LEN], out: &mut [u8]) -> Result<usize> {
if self.state != State::AwaitingRequest {
bail!(InvalidState)
}
let request = PbkdfParamRequest {
initiator_random: *initiator_random,
initiator_session_id: self.local_session_id,
passcode_id: PASSCODE_ID_COMMISSIONING,
has_pbkdf_parameters: self.known_parameters.is_some(),
session_params: self.session_params,
};
let n = request.encode(out)?;
self.initiator_random = *initiator_random;
self.request_bytes = copy_of(out.get(..n).unwrap_or(&[]))?;
self.state = State::AwaitingPake1;
Ok(n)
}
pub fn on_pbkdf_param_response(
&mut self,
payload: &[u8],
initiator_ephemeral: &[u8; 32],
out: &mut [u8],
) -> Result<usize> {
if self.state != State::AwaitingPake1 {
self.state = State::Failed;
bail!(InvalidState)
}
let response = PbkdfParamResponse::decode(payload)?;
if !ct_eq(&response.initiator_random, &self.initiator_random) {
self.state = State::Failed;
bail!(InvalidArgument)
}
self.peer_session_id = response.responder_session_id;
let parameters = match (&self.known_parameters, &response.pbkdf_parameters) {
(Some(known), None) => known.clone(),
(None, Some(sent)) => sent.clone(),
(Some(known), Some(_)) => {
known.clone()
}
(None, None) => {
self.state = State::Failed;
bail!(InvalidArgument)
}
};
let prover = Spake2pProver::new(
self.passcode,
¶meters.salt,
parameters.iterations,
initiator_ephemeral,
)?;
let n = Pake1 { pa: *prover.pa() }.encode(out)?;
self.response_bytes = copy_of(payload)?;
self.prover = Some(prover);
self.state = State::AwaitingPake3;
Ok(n)
}
pub fn on_pake2(&mut self, payload: &[u8], out: &mut [u8]) -> Result<usize> {
if self.state != State::AwaitingPake3 {
self.state = State::Failed;
bail!(InvalidState)
}
let pake2 = Pake2::decode(payload)?;
let Some(prover) = &self.prover else {
self.state = State::Failed;
bail!(InvalidState)
};
let context = spake_context(&self.request_bytes, &self.response_bytes);
let (ca, cb, ke) = prover.finish(&pake2.pb, &context)?;
if !ct_eq(&pake2.cb, &cb) {
self.state = State::Failed;
bail!(IntegrityCheckFailed)
}
let n = Pake3 { ca }.encode(out)?;
self.keys = Some(EstablishedKeys::derive(ke.as_bytes(), &[])?);
self.expected_cb = Some(cb);
self.ca = Some(ca);
self.state = State::Established;
Ok(n)
}
pub fn on_pake_finished(&mut self, payload: &[u8]) -> Result<EstablishedKeys> {
if self.state != State::Established {
bail!(InvalidState)
}
let report = StatusReport::decode(payload)?;
if !report.is_success()
|| report.secure_channel_code() != Some(SecureChannelCode::SessionEstablishmentSuccess)
{
self.state = State::Failed;
bail!(InvalidState)
}
self.keys.clone().ok_or(Error::new(ErrorCode::InvalidState))
}
#[must_use]
pub const fn is_established(&self) -> bool {
matches!(self.state, State::Established)
}
#[must_use]
pub const fn is_failed(&self) -> bool {
matches!(self.state, State::Failed)
}
}
pub(crate) struct Fields<'a> {
reader: TlvReader<'a>,
depth: usize,
}
impl<'a> Fields<'a> {
pub(crate) fn new(buf: &'a [u8]) -> Result<Self> {
let mut reader = TlvReader::new(buf);
let Some(first) = reader.next_element()? else {
bail!(TlvTruncated)
};
if first.value.container() != Some(ContainerKind::Structure) {
bail!(TlvWrongType)
}
Ok(Self { reader, depth: 1 })
}
pub(crate) fn next(&mut self) -> Result<Option<(u8, crate::tlv::Element<'a>)>> {
let Some(element) = self.reader.next_element()? else {
return Ok(None);
};
if matches!(element.value, Value::EndOfContainer) {
if self.reader.depth() < self.depth {
return Ok(None);
}
return self.next();
}
let Some(tag) = element.tag.context() else {
bail!(TlvInvalidTag)
};
Ok(Some((tag, element)))
}
pub(crate) fn nested<T>(&mut self, f: impl FnOnce(&mut Self) -> Result<T>) -> Result<T> {
self.depth = self.depth.saturating_add(1);
let out = f(self);
self.depth = self.depth.saturating_sub(1);
out
}
pub(crate) fn skip(&mut self, element: &crate::tlv::Element<'a>) -> Result<()> {
self.reader.skip_value(element)
}
}
fn copy_of<const N: usize>(bytes: &[u8]) -> Result<heapless::Vec<u8, N>> {
heapless::Vec::from_slice(bytes).map_err(|_| Error::new(ErrorCode::NoSpace))
}
fn u16_of(value: u64) -> Result<u16> {
u16::try_from(value).map_err(|_| Error::new(ErrorCode::TlvOutOfRange))
}
fn u32_of(value: u64) -> Result<u32> {
u32::try_from(value).map_err(|_| Error::new(ErrorCode::TlvOutOfRange))
}
fn random_of(element: &crate::tlv::Element<'_>) -> Result<[u8; RANDOM_LEN]> {
<[u8; RANDOM_LEN]>::try_from(element.octets()?)
.map_err(|_| Error::new(ErrorCode::InvalidArgument))
}
fn point_of(element: &crate::tlv::Element<'_>) -> Result<[u8; PUBLIC_KEY_SIZE_BYTES]> {
<[u8; PUBLIC_KEY_SIZE_BYTES]>::try_from(element.octets()?)
.map_err(|_| Error::new(ErrorCode::InvalidArgument))
}
fn confirmation_of(element: &crate::tlv::Element<'_>) -> Result<Confirmation> {
<[u8; HASH_LEN_BYTES]>::try_from(element.octets()?)
.map_err(|_| Error::new(ErrorCode::InvalidArgument))
}
#[cfg(test)]
mod tests {
use super::*;
fn parameters() -> PbkdfParameters {
PbkdfParameters::new(1_000, b"SPAKE2P Key Salt").expect("parameters")
}
fn round_trip<T, E, D>(value: &T, encode: E, decode: D)
where
T: core::fmt::Debug + PartialEq,
E: Fn(&T, &mut [u8]) -> Result<usize>,
D: Fn(&[u8]) -> Result<T>,
{
let mut buf = [0u8; 512];
let n = encode(value, &mut buf).expect("encode");
let decoded = decode(&buf[..n]).expect("decode");
assert_eq!(&decoded, value);
for cut in 0..n {
let _ = decode(&buf[..cut]);
}
}
#[test]
fn pbkdf_param_request_round_trips() {
round_trip(
&PbkdfParamRequest {
initiator_random: [0xAB; RANDOM_LEN],
initiator_session_id: SessionId(0x1234),
passcode_id: PASSCODE_ID_COMMISSIONING,
has_pbkdf_parameters: true,
session_params: None,
},
|v, b| v.encode(b),
PbkdfParamRequest::decode,
);
round_trip(
&PbkdfParamRequest {
initiator_random: [0x01; RANDOM_LEN],
initiator_session_id: SessionId(1),
passcode_id: PASSCODE_ID_COMMISSIONING,
has_pbkdf_parameters: false,
session_params: Some(SessionParams::announce(
&crate::exchange::MrpParams::default(),
)),
},
|v, b| v.encode(b),
PbkdfParamRequest::decode,
);
}
#[test]
fn pbkdf_param_response_round_trips_with_and_without_parameters() {
round_trip(
&PbkdfParamResponse {
initiator_random: [0x11; RANDOM_LEN],
responder_random: [0x22; RANDOM_LEN],
responder_session_id: SessionId(7),
pbkdf_parameters: Some(parameters()),
session_params: None,
},
|v, b| v.encode(b),
PbkdfParamResponse::decode,
);
round_trip(
&PbkdfParamResponse {
initiator_random: [0x11; RANDOM_LEN],
responder_random: [0x22; RANDOM_LEN],
responder_session_id: SessionId(7),
pbkdf_parameters: None,
session_params: None,
},
|v, b| v.encode(b),
PbkdfParamResponse::decode,
);
}
#[test]
fn the_pake_messages_round_trip() {
round_trip(
&Pake1 {
pa: [0x04; PUBLIC_KEY_SIZE_BYTES],
},
|v, b| v.encode(b),
Pake1::decode,
);
round_trip(
&Pake2 {
pb: [0x04; PUBLIC_KEY_SIZE_BYTES],
cb: [0x77; HASH_LEN_BYTES],
},
|v, b| v.encode(b),
Pake2::decode,
);
round_trip(
&Pake3 {
ca: [0x88; HASH_LEN_BYTES],
},
|v, b| v.encode(b),
Pake3::decode,
);
}
#[test]
fn unknown_context_tags_are_skipped() {
let mut buf = [0u8; 256];
let mut w = TlvWriter::new(&mut buf);
w.start_structure(Tag::Anonymous).expect("open");
w.octets(Tag::Context(1), &[0xAB; RANDOM_LEN])
.expect("random");
w.unsigned(Tag::Context(2), 9).expect("session");
w.unsigned(Tag::Context(3), 0).expect("passcode id");
w.bool(Tag::Context(4), true).expect("flag");
w.unsigned(Tag::Context(99), 1234).expect("unknown scalar");
w.start_structure(Tag::Context(100)).expect("open");
w.unsigned(Tag::Context(1), 1).expect("inner");
w.start_array(Tag::Context(2)).expect("array");
w.unsigned(Tag::Anonymous, 2).expect("item");
w.end_container().expect("close array");
w.end_container().expect("close struct");
w.end_container().expect("close");
let n = w.finish().expect("finish").len();
let decoded = PbkdfParamRequest::decode(&buf[..n]).expect("decode");
assert_eq!(decoded.initiator_session_id, SessionId(9));
assert!(decoded.has_pbkdf_parameters);
}
#[test]
fn a_missing_mandatory_field_is_refused() {
let mut buf = [0u8; 64];
let mut w = TlvWriter::new(&mut buf);
w.start_structure(Tag::Anonymous).expect("open");
w.unsigned(Tag::Context(2), 1).expect("session");
w.end_container().expect("close");
let n = w.finish().expect("finish").len();
assert_eq!(
PbkdfParamRequest::decode(&buf[..n]).unwrap_err().code(),
ErrorCode::TlvNotFound
);
}
#[test]
fn pbkdf_parameters_enforce_section_3_9() {
assert!(PbkdfParameters::new(999, b"0123456789abcdef").is_err());
assert!(PbkdfParameters::new(100_001, b"0123456789abcdef").is_err());
assert!(PbkdfParameters::new(1_000, b"tooshort").is_err());
assert!(PbkdfParameters::new(1_000, &[0u8; 33]).is_err());
assert!(PbkdfParameters::new(1_000, &[0u8; 16]).is_ok());
assert!(PbkdfParameters::new(100_000, &[0u8; 32]).is_ok());
}
#[test]
fn half_a_parameter_set_is_refused() {
for (iterations, salt) in [(Some(1_000u32), None), (None, Some(&[0u8; 16]))] {
let mut buf = [0u8; 256];
let mut w = TlvWriter::new(&mut buf);
w.start_structure(Tag::Anonymous).expect("open");
w.octets(Tag::Context(1), &[0x11; RANDOM_LEN]).expect("r1");
w.octets(Tag::Context(2), &[0x22; RANDOM_LEN]).expect("r2");
w.unsigned(Tag::Context(3), 1).expect("session");
w.start_structure(Tag::Context(4)).expect("params");
if let Some(i) = iterations {
w.unsigned(Tag::Context(1), u64::from(i)).expect("iters");
}
if let Some(s) = salt {
w.octets(Tag::Context(2), s).expect("salt");
}
w.end_container().expect("close params");
w.end_container().expect("close");
let n = w.finish().expect("finish").len();
assert!(
PbkdfParamResponse::decode(&buf[..n]).is_err(),
"iterations={iterations:?} salt={:?}",
salt.map(|s| s.len())
);
}
}
#[test]
fn a_nonzero_passcode_id_is_refused() {
let verifier = Spake2pVerifierData::from_passcode(20_202_021, b"SPAKE2P Key Salt", 1_000)
.expect("verifier");
let mut device = PaseResponder::new(
ResponderConfig {
verifier,
parameters: parameters(),
session_params: None,
},
SessionId(1),
);
let mut buf = [0u8; 256];
let n = PbkdfParamRequest {
initiator_random: [0; RANDOM_LEN],
initiator_session_id: SessionId(2),
passcode_id: 1,
has_pbkdf_parameters: true,
session_params: None,
}
.encode(&mut buf)
.expect("encode");
let mut out = [0u8; 256];
assert_eq!(
device
.on_pbkdf_param_request(&buf[..n], &[0; RANDOM_LEN], &mut out)
.unwrap_err()
.code(),
ErrorCode::InvalidArgument
);
assert!(device.is_failed());
}
#[test]
fn messages_must_arrive_in_order() {
let verifier = Spake2pVerifierData::from_passcode(20_202_021, b"SPAKE2P Key Salt", 1_000)
.expect("verifier");
let mut device = PaseResponder::new(
ResponderConfig {
verifier,
parameters: parameters(),
session_params: None,
},
SessionId(1),
);
let mut out = [0u8; 256];
let mut pake1 = [0u8; 256];
let n = Pake1 {
pa: [0x04; PUBLIC_KEY_SIZE_BYTES],
}
.encode(&mut pake1)
.expect("encode");
assert_eq!(
device
.on_pake1(&pake1[..n], &[1; 32], &mut out)
.unwrap_err()
.code(),
ErrorCode::InvalidState
);
}
#[test]
fn session_params_clamp_what_a_peer_sends() {
let hostile = SessionParams {
idle_interval_ms: u32::MAX,
active_interval_ms: u32::MAX,
active_threshold_ms: u16::MAX,
..SessionParams::legacy_peer()
};
let mrp = hostile.to_mrp();
assert_eq!(mrp.idle_interval.as_millis(), 3_600_000);
assert_eq!(mrp.active_interval.as_millis(), 3_600_000);
assert_eq!(mrp.active_threshold.as_millis(), 65_535);
}
#[test]
fn absent_session_params_take_the_defaults() {
let peer = SessionParams::legacy_peer();
assert_eq!(peer.to_mrp(), crate::exchange::MrpParams::default());
assert_eq!(peer.data_model_revision, 16);
assert_eq!(peer.interaction_model_revision, 10);
assert_eq!(peer.max_paths_per_invoke, 1);
assert!(peer.supported_transports.is_empty());
}
}
#[cfg(test)]
mod nesting_tests {
use super::*;
use crate::sc::SessionParams;
#[test]
fn a_pbkdf_param_response_keeps_the_session_params_after_its_nested_parameter_set() {
let parameters = PbkdfParameters::new(1_000, b"SPAKE2P Key Salt").expect("parameters");
let response = PbkdfParamResponse {
initiator_random: [1; RANDOM_LEN],
responder_random: [2; RANDOM_LEN],
responder_session_id: SessionId(0x4321),
pbkdf_parameters: Some(parameters.clone()),
session_params: Some(SessionParams {
idle_interval_ms: 1234,
active_interval_ms: 567,
active_threshold_ms: 8901,
..SessionParams::legacy_peer()
}),
};
let mut buf = [0u8; 256];
let len = response.encode(&mut buf).expect("encode");
let mut round = [0u8; 256];
round[..len].copy_from_slice(buf.get(..len).expect("in range"));
let decoded =
PbkdfParamResponse::decode(round.get(..len).expect("in range")).expect("decode");
assert_eq!(decoded.pbkdf_parameters, response.pbkdf_parameters);
assert_eq!(
decoded.session_params, response.session_params,
"the session params come after a nested structure"
);
assert_eq!(decoded.responder_session_id, SessionId(0x4321));
}
#[test]
fn a_duplicate_tag_inside_the_parameter_set_is_refused() {
let mut buf = [0u8; 256];
let mut w = TlvWriter::new(&mut buf);
w.start_structure(Tag::Anonymous).expect("start");
w.octets(Tag::Context(1), &[1u8; RANDOM_LEN])
.expect("random");
w.octets(Tag::Context(2), &[2u8; RANDOM_LEN])
.expect("random");
w.unsigned(Tag::Context(3), 1).expect("session id");
w.start_structure(Tag::Context(4)).expect("parameters");
w.unsigned(Tag::Context(1), 1_000).expect("iterations");
w.unsigned(Tag::Context(1), 2_000)
.expect("a second iterations");
w.octets(Tag::Context(2), b"SPAKE2P Key Salt")
.expect("salt");
w.end_container().expect("end parameters");
w.end_container().expect("end");
let len = w.finish().expect("finish").len();
let mut round = [0u8; 256];
round[..len].copy_from_slice(buf.get(..len).expect("in range"));
assert_eq!(
PbkdfParamResponse::decode(round.get(..len).expect("in range"))
.map(|_| ())
.unwrap_err()
.code(),
ErrorCode::TlvDuplicateTag
);
}
}