use super::test_support::{self as stub, MetaOptions, IDP_ENTITY, REALM, REPLY};
use crate::error::WsFedError;
use crate::httpclient::is_loopback_host;
use crate::relying_party::RelyingParty;
use crate::ssf::{ReceiverOptions, SignalsLog, SignalsReceiver};
use std::io::{Read, Write};
use std::net::{TcpListener, TcpStream};
use std::path::Path;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
use std::thread;
use std::time::Duration;
const REFUSED: &str = "is refused: plain http is allowed only to a loopback host";
struct Quiet;
impl SignalsLog for Quiet {
fn info(&self, _: &str) {}
fn warn(&self, _: &str) {}
fn error(&self, _: &str) {}
}
struct Stub { port: u16, hits: Arc<AtomicUsize> }
fn stub_server() -> Stub {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let port = listener.local_addr().unwrap().port();
let hits = Arc::new(AtomicUsize::new(0));
let counted = hits.clone();
let metadata = stub::idp_metadata(&MetaOptions::default());
thread::spawn(move || {
for stream in listener.incoming() {
let Ok(mut stream) = stream else { continue };
counted.fetch_add(1, Ordering::SeqCst);
let path = request_path(&mut stream);
let reply = match path.as_str() {
"/md" => format!("HTTP/1.1 200 OK\r\ncontent-type: application/samlmetadata+xml\r\ncontent-length: {}\r\nconnection: close\r\n\r\n{metadata}", metadata.len()),
"/away" => "HTTP/1.1 302 Found\r\nlocation: http://example.com/md\r\ncontent-length: 0\r\nconnection: close\r\n\r\n".to_string(),
_ => "HTTP/1.1 404 Not Found\r\ncontent-length: 0\r\nconnection: close\r\n\r\n".to_string(),
};
let _ = stream.write_all(reply.as_bytes());
}
});
Stub { port, hits }
}
fn request_path(stream: &mut TcpStream) -> String {
let mut head = Vec::new();
let mut byte = [0u8; 1];
while !head.ends_with(b"\r\n\r\n") {
match stream.read(&mut byte) {
Ok(1) => head.push(byte[0]),
_ => break,
}
}
let text = String::from_utf8_lossy(&head);
text.split_whitespace().nth(1).unwrap_or("").split('?').next().unwrap_or("").to_string()
}
fn party(metadata_url: &str) -> Result<RelyingParty, WsFedError> {
let config = serde_json::json!({
"realm": REALM,
"replyUrl": REPLY,
"privateKey": stub::rp_key(),
"certificate": stub::rp_cert(),
"idpMetadata": metadata_url,
});
RelyingParty::create(config.as_object().unwrap(), Path::new("."))
}
fn receiver(transmitter: &str) -> Result<(), WsFedError> {
let options = ReceiverOptions { log: Some(Arc::new(Quiet)), ..ReceiverOptions::default() };
let receiver = SignalsReceiver::new(transmitter, Arc::new(|_, _| Ok(())), options)?;
receiver.start()
}
fn refused(result: Result<(), WsFedError>, code: &str, shown: &str) -> WsFedError {
let err = result.expect_err("the fetch was not refused");
assert_eq!(err.code, code, "{}", err.message);
assert!(err.message.starts_with(&format!("{shown} {REFUSED}")), "{}", err.message);
assert!(!err.message.contains("s3cret"), "{}", err.message);
for part in ["/md", "/ssf", "federationmetadata", "token="] {
assert!(!err.message.contains(part), "{}", err.message);
}
err
}
#[test]
fn refuses_plain_http_metadata_off_loopback() {
refused(party("http://example.com/federationmetadata.xml?token=s3cret").map(|_| ()), "metadata", "http://example.com");
}
#[test]
fn refuses_a_plain_http_transmitter_off_loopback() {
refused(receiver("http://example.com/ssf"), "ssf", "http://example.com");
}
#[test]
fn refuses_before_connecting() {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let plain = format!("http://0.0.0.0:{}", listener.local_addr().unwrap().port());
refused(party(&format!("{plain}/md")).map(|_| ()), "metadata", &plain);
refused(receiver(&plain), "ssf", &plain);
listener.set_nonblocking(true).unwrap();
thread::sleep(Duration::from_millis(300));
assert!(listener.accept().is_err(), "a refused fetch opened a connection");
}
#[test]
fn userinfo_is_never_loopback_and_never_shown() {
let stub = stub_server();
let origin = format!("127.0.0.1:{}", stub.port);
let err = refused(party(&format!("http://alice:s3cret@{origin}/md")).map(|_| ()), "metadata", &format!("http://{origin}"));
assert!(!err.message.contains("alice"), "{}", err.message);
refused(party("http://localhost:80@example.com/md").map(|_| ()), "metadata", "http://example.com");
refused(receiver(&format!("http://alice:s3cret@{origin}/ssf")), "ssf", &format!("http://{origin}"));
assert_eq!(stub.hits.load(Ordering::SeqCst), 0);
}
#[test]
fn refuses_whitespace_and_control_characters() {
let stub = stub_server();
for url in [
format!("http://127.0.0.1:{} @example.com/md", stub.port),
format!("http://127.0.0.1:{}/m\td", stub.port),
format!("http://127.0.0.1:{}\u{0}@example.com/md", stub.port),
"https://example.com/m\nd".to_string(),
] {
let err = party(&url).map(|_| ()).expect_err("a URL with whitespace was fetched");
assert_eq!(err.code, "metadata");
assert!(err.message.contains("whitespace or a control character"), "{}", err.message);
}
let err = receiver(&format!("http://127.0.0.1:{}/s sf", stub.port)).expect_err("a URL with whitespace was fetched");
assert_eq!(err.code, "ssf");
assert_eq!(stub.hits.load(Ordering::SeqCst), 0);
}
#[test]
fn a_redirect_is_not_followed() {
let stub = stub_server();
let err = party(&format!("http://127.0.0.1:{}/away", stub.port)).map(|_| ()).expect_err("the redirect was followed");
assert_eq!(err.code, "metadata");
assert!(err.message.contains("answered HTTP 302"), "{}", err.message);
}
#[test]
fn plain_http_to_loopback_still_works() {
let stub = stub_server();
for host in ["127.0.0.1", "localhost"] {
let rp = party(&format!("http://{host}:{}/md", stub.port)).unwrap();
assert_eq!(rp.idp.as_ref().unwrap().entity_id, IDP_ENTITY);
let before = stub.hits.load(Ordering::SeqCst);
let err = receiver(&format!("http://{host}:{}/ssf", stub.port)).expect_err("the stub has no transmitter");
assert_eq!(err.code, "ssf");
assert!(!err.message.contains(REFUSED), "{}", err.message);
assert!(stub.hits.load(Ordering::SeqCst) > before, "the transmitter on {host} was not reached");
}
assert!(is_loopback_host(&url::Host::parse("[::1]").unwrap()));
assert!(is_loopback_host(&url::Host::parse("127.200.0.9").unwrap()));
assert!(!is_loopback_host(&url::Host::parse("127.0.0.1.example.com").unwrap()));
assert!(!is_loopback_host(&url::Host::parse("0.0.0.0").unwrap()));
}
#[test]
fn https_to_an_unreachable_host_is_a_connection_error_not_this_refusal() {
let closed = TcpListener::bind("127.0.0.1:0").unwrap().local_addr().unwrap().port();
let https = format!("https://127.0.0.1:{closed}");
for err in [party(&format!("{https}/md")).map(|_| ()).unwrap_err(), receiver(&https).unwrap_err()] {
assert!(!err.message.contains(REFUSED), "{}", err.message);
assert!(err.message.starts_with(&https), "{}", err.message);
}
}