mirror of
https://github.com/yuezk/GlobalProtect-openconnect.git
synced 2026-11-18 22:16:18 -05:00
224 lines
7.0 KiB
Rust
224 lines
7.0 KiB
Rust
use std::fmt;
|
|
|
|
use ::base64::{Engine, engine::general_purpose};
|
|
use serde::{Deserialize, Serialize};
|
|
use uuid::Uuid;
|
|
use zeroize::Zeroizing;
|
|
|
|
use crate::device_anchor::DeviceAnchor;
|
|
use crate::utils::base64;
|
|
|
|
use super::{MAX_CREDENTIAL_FRAME, MAX_PRODUCT_VERSION, TransportError};
|
|
|
|
pub struct SessionCredential {
|
|
service_instance_id: Uuid,
|
|
session_id: Uuid,
|
|
secret: Zeroizing<[u8; 32]>,
|
|
product_version: String,
|
|
device_anchor: Option<DeviceAnchor>,
|
|
}
|
|
|
|
impl SessionCredential {
|
|
pub fn generate(service_instance_id: Uuid, product_version: &str) -> Result<Self, TransportError> {
|
|
if product_version.is_empty() || product_version.len() > MAX_PRODUCT_VERSION {
|
|
return Err(TransportError::InvalidCredential);
|
|
}
|
|
|
|
let mut secret = Zeroizing::new([0_u8; 32]);
|
|
getrandom::fill(secret.as_mut()).map_err(|_| TransportError::InvalidState)?;
|
|
|
|
Ok(Self {
|
|
service_instance_id,
|
|
session_id: Uuid::new_v4(),
|
|
secret,
|
|
product_version: product_version.to_owned(),
|
|
device_anchor: None,
|
|
})
|
|
}
|
|
|
|
pub fn service_instance_id(&self) -> Uuid {
|
|
self.service_instance_id
|
|
}
|
|
|
|
pub fn session_id(&self) -> Uuid {
|
|
self.session_id
|
|
}
|
|
|
|
pub fn secret(&self) -> &[u8; 32] {
|
|
&self.secret
|
|
}
|
|
|
|
pub fn product_version(&self) -> &str {
|
|
&self.product_version
|
|
}
|
|
|
|
pub fn with_device_anchor(mut self, anchor: DeviceAnchor) -> Result<Self, TransportError> {
|
|
if !anchor.validate() {
|
|
return Err(TransportError::InvalidCredential);
|
|
}
|
|
self.device_anchor = Some(anchor);
|
|
Ok(self)
|
|
}
|
|
|
|
pub fn device_anchor(&self) -> Option<&DeviceAnchor> {
|
|
self.device_anchor.as_ref()
|
|
}
|
|
|
|
pub fn encode_frame(&self) -> Result<Zeroizing<Vec<u8>>, TransportError> {
|
|
let encoded_secret = Zeroizing::new(base64::encode(self.secret()));
|
|
let dto = CredentialDtoRef {
|
|
service_instance_id: self.service_instance_id,
|
|
session_id: self.session_id,
|
|
secret: encoded_secret.as_str(),
|
|
product_version: &self.product_version,
|
|
device_anchor: self.device_anchor.as_ref(),
|
|
};
|
|
let payload = Zeroizing::new(serde_json::to_vec(&dto)?);
|
|
|
|
if payload.len() + 2 > MAX_CREDENTIAL_FRAME || payload.len() > u16::MAX as usize {
|
|
return Err(TransportError::MessageTooLarge);
|
|
}
|
|
|
|
let mut frame = Zeroizing::new(Vec::with_capacity(payload.len() + 2));
|
|
frame.extend_from_slice(&(payload.len() as u16).to_be_bytes());
|
|
frame.extend_from_slice(&payload);
|
|
Ok(frame)
|
|
}
|
|
|
|
pub fn decode_frame(frame: &[u8]) -> Result<Self, TransportError> {
|
|
if frame.len() < 2 || frame.len() > MAX_CREDENTIAL_FRAME {
|
|
return Err(TransportError::InvalidCredential);
|
|
}
|
|
|
|
let payload_len = u16::from_be_bytes([frame[0], frame[1]]) as usize;
|
|
if payload_len == 0 || payload_len + 2 != frame.len() {
|
|
return Err(TransportError::InvalidCredential);
|
|
}
|
|
|
|
let dto: CredentialDto = serde_json::from_slice(&frame[2..]).map_err(|_| TransportError::InvalidCredential)?;
|
|
let CredentialDto {
|
|
service_instance_id,
|
|
session_id,
|
|
secret,
|
|
product_version,
|
|
device_anchor,
|
|
} = dto;
|
|
let encoded_secret = secret;
|
|
if device_anchor.as_ref().is_some_and(|anchor| !anchor.validate()) {
|
|
return Err(TransportError::InvalidCredential);
|
|
}
|
|
if product_version.is_empty() || product_version.len() > MAX_PRODUCT_VERSION {
|
|
return Err(TransportError::InvalidCredential);
|
|
}
|
|
|
|
let mut secret = Zeroizing::new([0_u8; 32]);
|
|
let decoded_len = general_purpose::STANDARD
|
|
.decode_slice(encoded_secret.as_bytes(), secret.as_mut())
|
|
.map_err(|_| TransportError::InvalidCredential)?;
|
|
if decoded_len != secret.len() {
|
|
return Err(TransportError::InvalidCredential);
|
|
}
|
|
|
|
Ok(Self {
|
|
service_instance_id,
|
|
session_id,
|
|
secret,
|
|
product_version,
|
|
device_anchor,
|
|
})
|
|
}
|
|
}
|
|
|
|
impl fmt::Debug for SessionCredential {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
f.debug_struct("SessionCredential")
|
|
.field("service_instance_id", &self.service_instance_id)
|
|
.field("session_id", &self.session_id)
|
|
.field("secret", &"[REDACTED]")
|
|
.field("product_version", &self.product_version)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
struct CredentialDtoRef<'a> {
|
|
service_instance_id: Uuid,
|
|
session_id: Uuid,
|
|
secret: &'a str,
|
|
product_version: &'a str,
|
|
device_anchor: Option<&'a DeviceAnchor>,
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
struct CredentialDto {
|
|
service_instance_id: Uuid,
|
|
session_id: Uuid,
|
|
secret: Zeroizing<String>,
|
|
product_version: String,
|
|
device_anchor: Option<DeviceAnchor>,
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn credential_round_trips_without_debugging_secret() {
|
|
let credential = SessionCredential::generate(Uuid::new_v4(), "2.6.4").unwrap();
|
|
let frame = credential.encode_frame().unwrap();
|
|
let decoded = SessionCredential::decode_frame(&frame).unwrap();
|
|
|
|
assert_eq!(decoded.service_instance_id(), credential.service_instance_id());
|
|
assert_eq!(decoded.session_id(), credential.session_id());
|
|
assert_eq!(decoded.secret(), credential.secret());
|
|
assert_eq!(decoded.product_version(), credential.product_version());
|
|
assert!(!format!("{credential:?}").contains(&base64::encode(credential.secret())));
|
|
}
|
|
|
|
#[test]
|
|
fn credential_rejects_malformed_lengths() {
|
|
assert!(SessionCredential::decode_frame(&[]).is_err());
|
|
assert!(SessionCredential::decode_frame(&[0, 0]).is_err());
|
|
assert!(SessionCredential::decode_frame(&[0, 2, b'{']).is_err());
|
|
assert!(SessionCredential::decode_frame(&vec![0; MAX_CREDENTIAL_FRAME + 1]).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn credential_round_trips_a_validated_device_anchor() {
|
|
let anchor = DeviceAnchor {
|
|
hardware_id: general_purpose::URL_SAFE_NO_PAD.encode([1_u8; 32]),
|
|
source: crate::device_anchor::AnchorSource::UnixMac,
|
|
};
|
|
let credential = SessionCredential::generate(Uuid::new_v4(), "2.6.5")
|
|
.unwrap()
|
|
.with_device_anchor(anchor.clone())
|
|
.unwrap();
|
|
let frame = credential.encode_frame().unwrap();
|
|
let payload: serde_json::Value = serde_json::from_slice(&frame[2..]).unwrap();
|
|
assert_eq!(payload["device_anchor"]["source"], 1);
|
|
let decoded = SessionCredential::decode_frame(&frame).unwrap();
|
|
assert_eq!(decoded.device_anchor(), Some(&anchor));
|
|
}
|
|
|
|
#[test]
|
|
fn credential_rejects_reserved_and_unknown_anchor_sources() {
|
|
let credential = SessionCredential::generate(Uuid::new_v4(), "2.6.5").unwrap();
|
|
let frame = credential.encode_frame().unwrap();
|
|
let mut payload: serde_json::Value = serde_json::from_slice(&frame[2..]).unwrap();
|
|
let hardware_id = general_purpose::URL_SAFE_NO_PAD.encode([1_u8; 32]);
|
|
|
|
for source in [0, 4] {
|
|
payload["device_anchor"] = serde_json::json!({
|
|
"hardware_id": hardware_id,
|
|
"source": source
|
|
});
|
|
let bytes = serde_json::to_vec(&payload).unwrap();
|
|
let mut invalid_frame = (bytes.len() as u16).to_be_bytes().to_vec();
|
|
invalid_frame.extend_from_slice(&bytes);
|
|
assert!(SessionCredential::decode_frame(&invalid_frame).is_err());
|
|
}
|
|
}
|
|
}
|