Browse Source

Reject 2FA verification tokens issued for another provider

The Email and Duo claims only have optional fields, so a userVerificationToken minted for another
provider deserialized into them and was accepted. Each provider's claims now reject unknown fields,
with a test that every token only parses as its own provider.

Also fix the email 2FA login in the Playwright user setup, which used an undefined `mailBuffer`.
pull/7563/head
Daniel García 1 month ago
parent
commit
7658a0bc4f
No known key found for this signature in database GPG Key ID: FC8A7D14C3CD543A
  1. 2
      playwright/tests/setups/user.ts
  2. 56
      src/auth/two_factor.rs

2
playwright/tests/setups/user.ts

@ -69,7 +69,7 @@ export async function logUser(
timestamp = timestamp + (totp.period - (Math.floor(timestamp / 1000) % totp.period) + 1) * 1000; timestamp = timestamp + (totp.period - (Math.floor(timestamp / 1000) % totp.period) + 1) * 1000;
code = totp.generate({timestamp}); code = totp.generate({timestamp});
} else if( options.mail2fa ){ } else if( options.mail2fa ){
code = await retrieveEmailCode(test, page, mailBuffer); code = await retrieveEmailCode(test, page, options.mailBuffer);
} }
await page.getByLabel(/Verification code/).fill(code); await page.getByLabel(/Verification code/).fill(code);

56
src/auth/two_factor.rs

@ -28,24 +28,28 @@ pub struct TwoFactorClaims<T> {
} }
#[derive(Serialize, Deserialize)] #[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AuthenticatorClaims { pub struct AuthenticatorClaims {
#[serde(rename = "authenticator_key")] #[serde(rename = "authenticator_key")]
pub key: String, pub key: String,
} }
#[derive(Serialize, Deserialize)] #[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct DuoClaims { pub struct DuoClaims {
#[serde(rename = "duo_data")] #[serde(rename = "duo_data")]
pub data: Option<DuoData>, pub data: Option<DuoData>,
} }
#[derive(Serialize, Deserialize)] #[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct WebauthnClaims { pub struct WebauthnClaims {
#[serde(rename = "webauthn_keys")] #[serde(rename = "webauthn_keys")]
pub keys: Vec<i32>, pub keys: Vec<i32>,
} }
#[derive(Serialize, Deserialize)] #[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct YubikeyClaims { pub struct YubikeyClaims {
#[serde(rename = "yubi_keys")] #[serde(rename = "yubi_keys")]
pub keys: Vec<String>, pub keys: Vec<String>,
@ -100,6 +104,7 @@ impl DuoData {
} }
#[derive(Serialize, Deserialize)] #[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct EmailClaims { pub struct EmailClaims {
pub email: Option<String>, pub email: Option<String>,
} }
@ -223,3 +228,54 @@ pub fn validate_yubikey(token: &str, user_id: &UserId, keys: &Vec<String>, enabl
} }
Ok(()) Ok(())
} }
#[cfg(test)]
mod tests {
use super::*;
use serde_json::{Value, from_value, to_value};
fn token<T: Serialize>(claims: T) -> Value {
to_value(TwoFactorClaims {
nbf: 0,
exp: 0,
iss: String::new(),
sub: UserId::from(String::from("4ff0f0a4-0aa4-4c1d-9d43-1f2bd4d5e8b1")),
enabled: false,
claims,
})
.unwrap()
}
#[test]
fn claims_only_parse_as_their_own_provider() {
let tokens = [
token(AuthenticatorClaims {
key: String::from("JBSWY3DPEHPK3PXP"),
}),
token(DuoClaims {
data: None,
}),
token(WebauthnClaims {
keys: vec![1],
}),
token(YubikeyClaims {
keys: Vec::new(),
}),
token(EmailClaims {
email: None,
}),
];
for (issued, token) in tokens.iter().enumerate() {
let parsed = [
from_value::<TwoFactorClaims<AuthenticatorClaims>>(token.clone()).is_ok(),
from_value::<TwoFactorClaims<DuoClaims>>(token.clone()).is_ok(),
from_value::<TwoFactorClaims<WebauthnClaims>>(token.clone()).is_ok(),
from_value::<TwoFactorClaims<YubikeyClaims>>(token.clone()).is_ok(),
from_value::<TwoFactorClaims<EmailClaims>>(token.clone()).is_ok(),
];
for (checked, ok) in parsed.into_iter().enumerate() {
assert_eq!(ok, issued == checked, "token {issued} parsed as {checked}");
}
}
}
}

Loading…
Cancel
Save