use arrayvec::ArrayVec;
#[allow(missing_docs)]
#[derive(Copy, Clone)]
pub enum Token {
E,
S,
EE,
ES,
SE,
SS,
PSK,
}
use self::Token::*;
#[derive(Clone)]
pub struct HandshakePattern {
pre_i: ArrayVec<Token, 4>,
pre_r: ArrayVec<Token, 4>,
msg_patterns: ArrayVec<ArrayVec<Token, 8>, 8>,
name: &'static str,
}
impl HandshakePattern {
pub fn new(
pre_i: &[Token],
pre_r: &[Token],
msg_patterns: &[&[Token]],
name: &'static str,
) -> Self {
HandshakePattern {
pre_i: pre_i.iter().cloned().collect(),
pre_r: pre_r.iter().cloned().collect(),
msg_patterns: msg_patterns
.iter()
.map(|p| p.iter().cloned().collect())
.collect(),
name,
}
}
pub fn get_pre_i(&self) -> &[Token] {
&self.pre_i
}
pub fn get_pre_r(&self) -> &[Token] {
&self.pre_r
}
pub fn get_message_pattern(&self, i: usize) -> &[Token] {
&self.msg_patterns[i]
}
pub fn get_message_patterns_len(&self) -> usize {
self.msg_patterns.len()
}
pub fn get_name(&self) -> &'static str {
self.name
}
pub fn has_psk(&self) -> bool {
self.msg_patterns.iter().any(|m| {
m.iter().any(|m| match m {
Token::PSK => true,
_ => false,
})
})
}
pub fn is_one_way(&self) -> bool {
self.msg_patterns.len() == 1
}
fn with_psks(&self, poses: &[usize], new_name: &'static str) -> HandshakePattern {
let mut new_msg_patterns = self.msg_patterns.clone();
for pos in poses {
if *pos == 0usize {
new_msg_patterns[0].insert(0, PSK);
} else {
new_msg_patterns[pos - 1].push(PSK);
}
}
HandshakePattern {
pre_i: self.pre_i.clone(),
pre_r: self.pre_r.clone(),
msg_patterns: new_msg_patterns,
name: new_name,
}
}
}
macro_rules! vec {
() => {
ArrayVec::new()
};
( $( $x:expr ),* ) => {
{
let mut temp_vec = ArrayVec::new();
$(
temp_vec.push($x);
)*
temp_vec
}
};
}
pub fn noise_n() -> HandshakePattern {
HandshakePattern {
pre_i: vec![],
pre_r: vec![S],
msg_patterns: vec![vec![E, ES]],
name: "N",
}
}
pub fn noise_k() -> HandshakePattern {
HandshakePattern {
pre_i: vec![S],
pre_r: vec![S],
msg_patterns: vec![vec![E, ES, SS]],
name: "K",
}
}
pub fn noise_x() -> HandshakePattern {
HandshakePattern {
pre_i: vec![],
pre_r: vec![S],
msg_patterns: vec![vec![E, ES, S, SS]],
name: "X",
}
}
pub fn noise_nn() -> HandshakePattern {
HandshakePattern {
pre_i: vec![],
pre_r: vec![],
msg_patterns: vec![vec![E], vec![E, EE]],
name: "NN",
}
}
pub fn noise_nk() -> HandshakePattern {
HandshakePattern {
pre_i: vec![],
pre_r: vec![S],
msg_patterns: vec![vec![E, ES], vec![E, EE]],
name: "NK",
}
}
pub fn noise_nx() -> HandshakePattern {
HandshakePattern {
pre_i: vec![],
pre_r: vec![],
msg_patterns: vec![vec![E], vec![E, EE, S, ES]],
name: "NX",
}
}
pub fn noise_xn() -> HandshakePattern {
HandshakePattern {
pre_i: vec![],
pre_r: vec![],
msg_patterns: vec![vec![E], vec![E, EE], vec![S, SE]],
name: "XN",
}
}
pub fn noise_xk() -> HandshakePattern {
HandshakePattern {
pre_i: vec![],
pre_r: vec![S],
msg_patterns: vec![vec![E, ES], vec![E, EE], vec![S, SE]],
name: "XK",
}
}
pub fn noise_xx() -> HandshakePattern {
HandshakePattern {
pre_i: vec![],
pre_r: vec![],
msg_patterns: vec![vec![E], vec![E, EE, S, ES], vec![S, SE]],
name: "XX",
}
}
pub fn noise_kn() -> HandshakePattern {
HandshakePattern {
pre_i: vec![S],
pre_r: vec![],
msg_patterns: vec![vec![E], vec![E, EE, SE]],
name: "KN",
}
}
pub fn noise_kk() -> HandshakePattern {
HandshakePattern {
pre_i: vec![S],
pre_r: vec![S],
msg_patterns: vec![vec![E, ES, SS], vec![E, EE, SE]],
name: "KK",
}
}
pub fn noise_kx() -> HandshakePattern {
HandshakePattern {
pre_i: vec![S],
pre_r: vec![],
msg_patterns: vec![vec![E], vec![E, EE, SE, S, ES]],
name: "KX",
}
}
pub fn noise_in() -> HandshakePattern {
HandshakePattern {
pre_i: vec![],
pre_r: vec![],
msg_patterns: vec![vec![E, S], vec![E, EE, SE]],
name: "IN",
}
}
pub fn noise_ik() -> HandshakePattern {
HandshakePattern {
pre_i: vec![],
pre_r: vec![S],
msg_patterns: vec![vec![E, ES, S, SS], vec![E, EE, SE]],
name: "IK",
}
}
pub fn noise_ix() -> HandshakePattern {
HandshakePattern {
pre_i: vec![],
pre_r: vec![],
msg_patterns: vec![vec![E, S], vec![E, EE, SE, S, ES]],
name: "IX",
}
}
pub fn noise_xx_fallback() -> HandshakePattern {
HandshakePattern {
pre_i: vec![],
pre_r: vec![E],
msg_patterns: vec![vec![E, EE, S, SE], vec![S, ES]],
name: "XXfallback",
}
}
pub fn noise_n_psk0() -> HandshakePattern {
noise_n().with_psks(&[0], "Npsk0")
}
pub fn noise_k_psk0() -> HandshakePattern {
noise_k().with_psks(&[0], "Kpsk0")
}
pub fn noise_x_psk1() -> HandshakePattern {
noise_x().with_psks(&[1], "Xpsk1")
}
pub fn noise_nn_psk0() -> HandshakePattern {
noise_nn().with_psks(&[0], "NNpsk0")
}
pub fn noise_nn_psk2() -> HandshakePattern {
noise_nn().with_psks(&[2], "NNpsk2")
}
pub fn noise_nk_psk0() -> HandshakePattern {
noise_nk().with_psks(&[0], "NKpsk0")
}
pub fn noise_nk_psk2() -> HandshakePattern {
noise_nk().with_psks(&[2], "NKpsk2")
}
pub fn noise_nx_psk2() -> HandshakePattern {
noise_nx().with_psks(&[2], "NXpsk2")
}
pub fn noise_xn_psk3() -> HandshakePattern {
noise_xn().with_psks(&[3], "XNpsk3")
}
pub fn noise_xk_psk3() -> HandshakePattern {
noise_xk().with_psks(&[3], "XKpsk3")
}
pub fn noise_xx_psk3() -> HandshakePattern {
noise_xx().with_psks(&[3], "XXpsk3")
}
pub fn noise_kn_psk0() -> HandshakePattern {
noise_kn().with_psks(&[0], "KNpsk0")
}
pub fn noise_kn_psk2() -> HandshakePattern {
noise_kn().with_psks(&[2], "KNpsk2")
}
pub fn noise_kk_psk0() -> HandshakePattern {
noise_kk().with_psks(&[0], "KKpsk0")
}
pub fn noise_kk_psk2() -> HandshakePattern {
noise_kk().with_psks(&[2], "KKpsk2")
}
pub fn noise_kx_psk2() -> HandshakePattern {
noise_kx().with_psks(&[2], "KXpsk2")
}
pub fn noise_in_psk1() -> HandshakePattern {
noise_in().with_psks(&[1], "INpsk1")
}
pub fn noise_in_psk2() -> HandshakePattern {
noise_in().with_psks(&[2], "INpsk2")
}
pub fn noise_ik_psk1() -> HandshakePattern {
noise_ik().with_psks(&[1], "IKpsk1")
}
pub fn noise_ik_psk2() -> HandshakePattern {
noise_ik().with_psks(&[2], "IKpsk2")
}
pub fn noise_ix_psk2() -> HandshakePattern {
noise_ix().with_psks(&[2], "IXpsk2")
}
pub fn noise_nn_psk0_psk2() -> HandshakePattern {
noise_nn().with_psks(&[0, 2], "NNpsk0+psk2")
}
pub fn noise_nx_psk0_psk1_psk2() -> HandshakePattern {
noise_nx().with_psks(&[0, 1, 2], "NXpsk0+psk1+psk2")
}
pub fn noise_xn_psk1_psk3() -> HandshakePattern {
noise_xn().with_psks(&[1, 3], "XNpsk1+psk3")
}
pub fn noise_xk_psk0_psk3() -> HandshakePattern {
noise_xk().with_psks(&[0, 3], "XKpsk0+psk3")
}
pub fn noise_kn_psk1_psk2() -> HandshakePattern {
noise_kn().with_psks(&[1, 2], "KNpsk1+psk2")
}
pub fn noise_kk_psk0_psk2() -> HandshakePattern {
noise_kk().with_psks(&[0, 2], "KKpsk0+psk2")
}
pub fn noise_in_psk1_psk2() -> HandshakePattern {
noise_in().with_psks(&[1, 2], "INpsk1+psk2")
}
pub fn noise_ik_psk0_psk2() -> HandshakePattern {
noise_ik().with_psks(&[0, 2], "IKpsk0+psk2")
}
pub fn noise_ix_psk0_psk2() -> HandshakePattern {
noise_ix().with_psks(&[0, 2], "IXpsk0+psk2")
}
pub fn noise_xx_psk0_psk1() -> HandshakePattern {
noise_xx().with_psks(&[0, 1], "XXpsk0+psk1")
}
pub fn noise_xx_psk0_psk2() -> HandshakePattern {
noise_xx().with_psks(&[0, 2], "XXpsk0+psk2")
}
pub fn noise_xx_psk0_psk3() -> HandshakePattern {
noise_xx().with_psks(&[0, 3], "XXpsk0+psk3")
}
pub fn noise_xx_psk0_psk1_psk2_psk3() -> HandshakePattern {
noise_xx().with_psks(&[0, 1, 2, 3], "XXpsk0+psk1+psk2+psk3")
}