1
0
Fork 0
mirror of https://github.com/actix/actix-web.git synced 2024-11-23 01:51:11 +00:00
actix-web/actix-http/tests/test_openssl.rs

449 lines
15 KiB
Rust
Raw Normal View History

2019-11-19 12:54:19 +00:00
#![cfg(feature = "openssl")]
#![allow(clippy::uninlined_format_args)]
2021-02-07 03:54:58 +00:00
extern crate tls_openssl as openssl;
use std::{convert::Infallible, io, time::Duration};
2019-11-19 12:54:19 +00:00
2021-04-13 10:16:12 +00:00
use actix_http::{
2021-12-04 19:40:47 +00:00
body::{BodyStream, BoxBody, SizedStream},
error::PayloadError,
header::{self, HeaderValue},
Error, HttpService, Method, Request, Response, StatusCode, TlsAcceptorConfig, Version,
2021-04-13 10:16:12 +00:00
};
use actix_http_test::test_server;
use actix_service::{fn_service, ServiceFactoryExt};
2021-04-01 14:26:13 +00:00
use actix_utils::future::{err, ok, ready};
use bytes::{Bytes, BytesMut};
use derive_more::{Display, Error};
2021-03-11 03:48:38 +00:00
use futures_core::Stream;
use futures_util::{stream::once, StreamExt as _};
use openssl::{
pkey::PKey,
ssl::{SslAcceptor, SslMethod},
x509::X509,
};
2019-11-19 12:54:19 +00:00
async fn load_body<S>(stream: S) -> Result<BytesMut, PayloadError>
where
S: Stream<Item = Result<Bytes, PayloadError>>,
{
let body = stream
.map(|res| match res {
Ok(chunk) => chunk,
Err(_) => panic!(),
})
.fold(BytesMut::new(), move |mut body, chunk| {
body.extend_from_slice(&chunk);
ready(body)
})
.await;
Ok(body)
}
fn tls_config() -> SslAcceptor {
let cert = rcgen::generate_simple_self_signed(vec!["localhost".to_owned()]).unwrap();
let cert_file = cert.serialize_pem().unwrap();
let key_file = cert.serialize_private_key_pem();
let cert = X509::from_pem(cert_file.as_bytes()).unwrap();
let key = PKey::private_key_from_pem(key_file.as_bytes()).unwrap();
2019-11-19 12:54:19 +00:00
let mut builder = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
builder.set_certificate(&cert).unwrap();
builder.set_private_key(&key).unwrap();
2019-11-19 12:54:19 +00:00
builder.set_alpn_select_callback(|_, protos| {
const H2: &[u8] = b"\x02h2";
if protos.windows(3).any(|window| window == H2) {
Ok(b"h2")
} else {
Err(openssl::ssl::AlpnError::NOACK)
2019-11-19 12:54:19 +00:00
}
});
builder.set_alpn_protos(b"\x02h2").unwrap();
2019-12-02 11:33:11 +00:00
builder.build()
2019-11-19 12:54:19 +00:00
}
2019-11-26 05:25:50 +00:00
#[actix_rt::test]
2022-02-01 14:15:30 +00:00
async fn h2() -> io::Result<()> {
2019-12-12 17:08:38 +00:00
let srv = test_server(move || {
2019-12-02 11:33:11 +00:00
HttpService::build()
.h2(|_| ok::<_, Error>(Response::ok()))
.openssl(tls_config())
2019-12-02 11:33:11 +00:00
.map_err(|_| ())
2020-03-08 07:42:45 +00:00
})
.await;
2019-11-26 05:25:50 +00:00
let response = srv.sget("/").send().await.unwrap();
assert!(response.status().is_success());
Ok(())
2019-11-19 12:54:19 +00:00
}
2019-11-26 05:25:50 +00:00
#[actix_rt::test]
2022-02-01 14:15:30 +00:00
async fn h2_1() -> io::Result<()> {
2019-12-12 17:08:38 +00:00
let srv = test_server(move || {
2019-12-02 11:33:11 +00:00
HttpService::build()
.finish(|req: Request| {
assert!(req.peer_addr().is_some());
assert_eq!(req.version(), Version::HTTP_2);
ok::<_, Error>(Response::ok())
2019-12-02 11:33:11 +00:00
})
.openssl_with_config(
tls_config(),
TlsAcceptorConfig::default().handshake_timeout(Duration::from_secs(5)),
)
2019-12-02 11:33:11 +00:00
.map_err(|_| ())
2020-03-08 07:42:45 +00:00
})
.await;
2019-11-26 05:25:50 +00:00
let response = srv.sget("/").send().await.unwrap();
assert!(response.status().is_success());
Ok(())
2019-11-19 12:54:19 +00:00
}
2019-11-26 05:25:50 +00:00
#[actix_rt::test]
2022-02-01 14:15:30 +00:00
async fn h2_body() -> io::Result<()> {
let data = "HELLOWORLD".to_owned().repeat(64 * 1024); // 640 KiB
2019-12-12 17:08:38 +00:00
let mut srv = test_server(move || {
2019-12-02 11:33:11 +00:00
HttpService::build()
2020-02-27 02:10:55 +00:00
.h2(|mut req: Request<_>| async move {
let body = load_body(req.take_payload()).await?;
Ok::<_, Error>(Response::ok().set_body(body))
2019-12-02 11:33:11 +00:00
})
.openssl(tls_config())
2019-12-02 11:33:11 +00:00
.map_err(|_| ())
2020-03-08 07:42:45 +00:00
})
.await;
2019-11-26 05:25:50 +00:00
let response = srv.sget("/").send_body(data.clone()).await.unwrap();
assert!(response.status().is_success());
let body = srv.load_body(response).await.unwrap();
assert_eq!(&body, data.as_bytes());
Ok(())
2019-11-19 12:54:19 +00:00
}
2019-11-26 05:25:50 +00:00
#[actix_rt::test]
2022-02-01 14:15:30 +00:00
async fn h2_content_length() {
2019-12-12 17:08:38 +00:00
let srv = test_server(move || {
2019-12-02 11:33:11 +00:00
HttpService::build()
.h2(|req: Request| {
2021-03-04 13:27:54 +00:00
let idx: usize = req.uri().path()[1..].parse().unwrap();
2019-12-02 11:33:11 +00:00
let statuses = [
StatusCode::CONTINUE,
2021-03-04 13:27:54 +00:00
StatusCode::NO_CONTENT,
2019-12-02 11:33:11 +00:00
StatusCode::OK,
StatusCode::NOT_FOUND,
];
2021-06-17 16:57:58 +00:00
ok::<_, Infallible>(Response::new(statuses[idx]))
2019-12-02 11:33:11 +00:00
})
.openssl(tls_config())
2019-12-02 11:33:11 +00:00
.map_err(|_| ())
2020-03-08 07:42:45 +00:00
})
.await;
2019-11-19 12:54:19 +00:00
2021-11-15 04:03:33 +00:00
static VALUE: HeaderValue = HeaderValue::from_static("0");
2019-11-26 05:25:50 +00:00
{
2021-11-15 04:03:33 +00:00
let req = srv.request(Method::HEAD, srv.surl("/0")).send();
req.await.expect_err("should timeout on recv 1xx frame");
2021-03-04 13:27:54 +00:00
2021-11-15 04:03:33 +00:00
let req = srv.request(Method::GET, srv.surl("/0")).send();
req.await.expect_err("should timeout on recv 1xx frame");
2019-11-26 05:25:50 +00:00
2021-11-15 04:03:33 +00:00
let req = srv.request(Method::GET, srv.surl("/1")).send();
let response = req.await.unwrap();
assert!(response.headers().get("content-length").is_none());
2019-11-26 05:25:50 +00:00
2021-03-04 13:27:54 +00:00
for &i in &[2, 3] {
2019-11-26 05:25:50 +00:00
let req = srv
.request(Method::GET, srv.surl(&format!("/{}", i)))
.send();
let response = req.await.unwrap();
2021-11-15 04:03:33 +00:00
assert_eq!(response.headers().get("content-length"), Some(&VALUE));
2019-11-19 12:54:19 +00:00
}
2019-11-26 05:25:50 +00:00
}
2019-11-19 12:54:19 +00:00
}
2019-11-26 05:25:50 +00:00
#[actix_rt::test]
2022-02-01 14:15:30 +00:00
async fn h2_headers() {
2019-11-26 05:25:50 +00:00
let data = STR.repeat(10);
let data2 = data.clone();
2019-11-19 12:54:19 +00:00
2019-12-12 17:08:38 +00:00
let mut srv = test_server(move || {
2019-11-26 05:25:50 +00:00
let data = data.clone();
2021-12-08 06:01:11 +00:00
HttpService::build()
.h2(move |_| {
let mut builder = Response::build(StatusCode::OK);
for idx in 0..90 {
builder.insert_header(
2021-01-15 02:11:10 +00:00
(format!("X-TEST-{}", idx).as_str(),
2019-11-19 12:54:19 +00:00
"TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST \
TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST ",
2021-01-15 02:11:10 +00:00
));
2021-12-08 06:01:11 +00:00
}
ok::<_, Infallible>(builder.body(data.clone()))
})
.openssl(tls_config())
2021-12-08 06:01:11 +00:00
.map_err(|_| ())
})
.await;
2019-11-19 12:54:19 +00:00
2019-11-26 05:25:50 +00:00
let response = srv.sget("/").send().await.unwrap();
assert!(response.status().is_success());
2019-11-19 12:54:19 +00:00
2019-11-26 05:25:50 +00:00
// read response
let bytes = srv.load_body(response).await.unwrap();
assert_eq!(bytes, Bytes::from(data2));
2019-11-19 12:54:19 +00:00
}
const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World";
2019-11-26 05:25:50 +00:00
#[actix_rt::test]
2022-02-01 14:15:30 +00:00
async fn h2_body2() {
2019-12-12 17:08:38 +00:00
let mut srv = test_server(move || {
2019-12-02 11:33:11 +00:00
HttpService::build()
2021-06-17 16:57:58 +00:00
.h2(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
.openssl(tls_config())
2019-12-02 11:33:11 +00:00
.map_err(|_| ())
2020-03-08 07:42:45 +00:00
})
.await;
2019-11-26 05:25:50 +00:00
let response = srv.sget("/").send().await.unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.load_body(response).await.unwrap();
assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
2019-11-19 12:54:19 +00:00
}
2019-11-26 05:25:50 +00:00
#[actix_rt::test]
2022-02-01 14:15:30 +00:00
async fn h2_head_empty() {
2019-12-12 17:08:38 +00:00
let mut srv = test_server(move || {
2019-12-02 11:33:11 +00:00
HttpService::build()
2021-06-17 16:57:58 +00:00
.finish(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
.openssl(tls_config())
2019-12-02 11:33:11 +00:00
.map_err(|_| ())
2020-03-08 07:42:45 +00:00
})
.await;
2019-11-26 05:25:50 +00:00
let response = srv.shead("/").send().await.unwrap();
assert!(response.status().is_success());
assert_eq!(response.version(), Version::HTTP_2);
2019-11-19 12:54:19 +00:00
2019-11-26 05:25:50 +00:00
{
let len = response.headers().get(header::CONTENT_LENGTH).unwrap();
assert_eq!(format!("{}", STR.len()), len.to_str().unwrap());
}
// read response
let bytes = srv.load_body(response).await.unwrap();
assert!(bytes.is_empty());
2019-11-19 12:54:19 +00:00
}
2019-11-26 05:25:50 +00:00
#[actix_rt::test]
2022-02-01 14:15:30 +00:00
async fn h2_head_binary() {
2019-12-12 17:08:38 +00:00
let mut srv = test_server(move || {
2019-12-02 11:33:11 +00:00
HttpService::build()
2021-06-17 16:57:58 +00:00
.h2(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
.openssl(tls_config())
2019-12-02 11:33:11 +00:00
.map_err(|_| ())
2020-03-08 07:42:45 +00:00
})
.await;
2019-11-19 12:54:19 +00:00
2019-11-26 05:25:50 +00:00
let response = srv.shead("/").send().await.unwrap();
assert!(response.status().is_success());
2019-11-19 12:54:19 +00:00
2019-11-26 05:25:50 +00:00
{
let len = response.headers().get(header::CONTENT_LENGTH).unwrap();
assert_eq!(format!("{}", STR.len()), len.to_str().unwrap());
}
2019-11-19 12:54:19 +00:00
2019-11-26 05:25:50 +00:00
// read response
let bytes = srv.load_body(response).await.unwrap();
assert!(bytes.is_empty());
2019-11-19 12:54:19 +00:00
}
2019-11-26 05:25:50 +00:00
#[actix_rt::test]
2022-02-01 14:15:30 +00:00
async fn h2_head_binary2() {
2019-12-12 17:08:38 +00:00
let srv = test_server(move || {
2019-12-02 11:33:11 +00:00
HttpService::build()
2021-06-17 16:57:58 +00:00
.h2(|_| ok::<_, Infallible>(Response::ok().set_body(STR)))
.openssl(tls_config())
2019-12-02 11:33:11 +00:00
.map_err(|_| ())
2020-03-08 07:42:45 +00:00
})
.await;
2019-11-26 05:25:50 +00:00
let response = srv.shead("/").send().await.unwrap();
assert!(response.status().is_success());
{
let len = response.headers().get(header::CONTENT_LENGTH).unwrap();
assert_eq!(format!("{}", STR.len()), len.to_str().unwrap());
}
2019-11-19 12:54:19 +00:00
}
2019-11-26 05:25:50 +00:00
#[actix_rt::test]
2022-02-01 14:15:30 +00:00
async fn h2_body_length() {
2019-12-12 17:08:38 +00:00
let mut srv = test_server(move || {
2019-12-02 11:33:11 +00:00
HttpService::build()
2021-06-17 16:57:58 +00:00
.h2(|_| async {
2021-12-08 06:01:11 +00:00
let body =
once(async { Ok::<_, Infallible>(Bytes::from_static(STR.as_ref())) });
2021-06-17 16:57:58 +00:00
Ok::<_, Infallible>(
Response::ok().set_body(SizedStream::new(STR.len() as u64, body)),
2019-12-02 11:33:11 +00:00
)
})
.openssl(tls_config())
2019-12-02 11:33:11 +00:00
.map_err(|_| ())
2020-03-08 07:42:45 +00:00
})
.await;
2019-11-26 05:25:50 +00:00
let response = srv.sget("/").send().await.unwrap();
assert!(response.status().is_success());
// read response
let bytes = srv.load_body(response).await.unwrap();
assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
2019-11-19 12:54:19 +00:00
}
2019-11-26 05:25:50 +00:00
#[actix_rt::test]
2022-02-01 14:15:30 +00:00
async fn h2_body_chunked_explicit() {
2019-12-12 17:08:38 +00:00
let mut srv = test_server(move || {
2019-12-02 11:33:11 +00:00
HttpService::build()
.h2(|_| {
let body = once(ok::<_, Error>(Bytes::from_static(STR.as_ref())));
2021-06-17 16:57:58 +00:00
ok::<_, Infallible>(
Response::build(StatusCode::OK)
2021-01-15 02:11:10 +00:00
.insert_header((header::TRANSFER_ENCODING, "chunked"))
2021-12-04 19:40:47 +00:00
.body(BodyStream::new(body)),
2019-12-02 11:33:11 +00:00
)
})
.openssl(tls_config())
2019-12-02 11:33:11 +00:00
.map_err(|_| ())
2020-03-08 07:42:45 +00:00
})
.await;
2019-11-19 12:54:19 +00:00
2019-11-26 05:25:50 +00:00
let response = srv.sget("/").send().await.unwrap();
assert!(response.status().is_success());
assert!(!response.headers().contains_key(header::TRANSFER_ENCODING));
2019-11-19 12:54:19 +00:00
2019-11-26 05:25:50 +00:00
// read response
let bytes = srv.load_body(response).await.unwrap();
2019-11-19 12:54:19 +00:00
2019-11-26 05:25:50 +00:00
// decode
assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
2019-11-19 12:54:19 +00:00
}
2019-11-26 05:25:50 +00:00
#[actix_rt::test]
2022-02-01 14:15:30 +00:00
async fn h2_response_http_error_handling() {
2019-12-12 17:08:38 +00:00
let mut srv = test_server(move || {
2019-12-02 11:33:11 +00:00
HttpService::build()
2019-12-08 13:25:24 +00:00
.h2(fn_service(|_| {
2019-12-02 11:33:11 +00:00
let broken_header = Bytes::from_static(b"\0\0\0");
2021-06-17 16:57:58 +00:00
ok::<_, Infallible>(
Response::build(StatusCode::OK)
2021-01-15 02:11:10 +00:00
.insert_header((header::CONTENT_TYPE, broken_header))
2019-12-02 11:33:11 +00:00
.body(STR),
)
}))
.openssl(tls_config())
2019-12-02 11:33:11 +00:00
.map_err(|_| ())
2020-03-08 07:42:45 +00:00
})
.await;
2019-11-19 12:54:19 +00:00
2019-11-26 05:25:50 +00:00
let response = srv.sget("/").send().await.unwrap();
assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
2019-11-19 12:54:19 +00:00
2019-11-26 05:25:50 +00:00
// read response
let bytes = srv.load_body(response).await.unwrap();
2021-06-17 16:57:58 +00:00
assert_eq!(
bytes,
Bytes::from_static(b"error processing HTTP: failed to parse header value")
);
2019-11-19 12:54:19 +00:00
}
#[derive(Debug, Display, Error)]
#[display(fmt = "error")]
struct BadRequest;
2021-12-04 19:40:47 +00:00
impl From<BadRequest> for Response<BoxBody> {
2021-06-17 16:57:58 +00:00
fn from(err: BadRequest) -> Self {
2021-12-04 19:40:47 +00:00
Response::build(StatusCode::BAD_REQUEST)
.body(err.to_string())
.map_into_boxed_body()
}
}
2019-11-26 05:25:50 +00:00
#[actix_rt::test]
2022-02-01 14:15:30 +00:00
async fn h2_service_error() {
2019-12-12 17:08:38 +00:00
let mut srv = test_server(move || {
2019-12-02 11:33:11 +00:00
HttpService::build()
2021-12-04 19:40:47 +00:00
.h2(|_| err::<Response<BoxBody>, _>(BadRequest))
.openssl(tls_config())
2019-12-02 11:33:11 +00:00
.map_err(|_| ())
2020-03-08 07:42:45 +00:00
})
.await;
2019-11-26 05:25:50 +00:00
let response = srv.sget("/").send().await.unwrap();
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
// read response
let bytes = srv.load_body(response).await.unwrap();
assert_eq!(bytes, Bytes::from_static(b"error"));
2019-11-19 12:54:19 +00:00
}
2019-11-26 05:25:50 +00:00
#[actix_rt::test]
2022-02-01 14:15:30 +00:00
async fn h2_on_connect() {
2019-12-12 17:08:38 +00:00
let srv = test_server(move || {
2019-12-02 11:33:11 +00:00
HttpService::build()
.on_connect_ext(|_, data| {
data.insert(20isize);
})
2019-12-02 11:33:11 +00:00
.h2(|req: Request| {
assert!(req.conn_data::<isize>().is_some());
2021-06-17 16:57:58 +00:00
ok::<_, Infallible>(Response::ok())
2019-12-02 11:33:11 +00:00
})
.openssl(tls_config())
2019-12-02 11:33:11 +00:00
.map_err(|_| ())
2020-03-08 07:42:45 +00:00
})
.await;
2019-11-26 05:25:50 +00:00
let response = srv.sget("/").send().await.unwrap();
assert!(response.status().is_success());
2019-11-19 12:54:19 +00:00
}