use crate::fingerprint::akamai_h2::{
AkamaiH2Fingerprint, AkamaiH2ParseError, H2Priority, H2Setting, PseudoHeader,
};
use crate::http::session_coherence::H2Profile;
pub const H2_CLIENT_PREFACE: &[u8] = b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n";
const FRAME_HEADERS: u8 = 0x1;
const FRAME_PRIORITY: u8 = 0x2;
const FRAME_SETTINGS: u8 = 0x4;
const FRAME_WINDOW_UPDATE: u8 = 0x8;
const FLAG_END_STREAM: u8 = 0x1;
const FLAG_END_HEADERS: u8 = 0x4;
const FLAG_ACK: u8 = 0x1;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum WireEmitError {
Model(AkamaiH2ParseError),
}
impl core::fmt::Display for WireEmitError {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
Self::Model(e) => write!(f, "persona Akamai model does not parse: {e:?}"),
}
}
}
impl std::error::Error for WireEmitError {}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum WireParseError {
BadPreface,
Truncated,
BadSettings,
BadPriority,
UnsupportedHpack,
NoHeaders,
}
impl core::fmt::Display for WireParseError {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
let s = match self {
Self::BadPreface => "not an HTTP/2 client preface",
Self::Truncated => "frame ran past end of buffer (truncated)",
Self::BadSettings => "SETTINGS payload not a multiple of 6 bytes",
Self::BadPriority => "PRIORITY payload not 5 bytes",
Self::UnsupportedHpack => "unsupported HPACK representation in HEADERS",
Self::NoHeaders => "opening ended before any HEADERS frame",
};
f.write_str(s)
}
}
impl std::error::Error for WireParseError {}
pub fn encode_client_opening_for_profile(
profile: &H2Profile,
authority: &str,
path: &str,
) -> Result<Vec<u8>, WireEmitError> {
let fp =
AkamaiH2Fingerprint::parse(&profile.akamai_fingerprint()).map_err(WireEmitError::Model)?;
Ok(encode_client_opening(&fp, authority, path))
}
#[must_use]
pub fn encode_client_opening(fp: &AkamaiH2Fingerprint, authority: &str, path: &str) -> Vec<u8> {
let mut out = Vec::with_capacity(64);
out.extend_from_slice(H2_CLIENT_PREFACE);
let mut settings = Vec::with_capacity(fp.settings.len() * 6);
for s in &fp.settings {
settings.extend_from_slice(&s.id.to_be_bytes());
settings.extend_from_slice(&s.value.to_be_bytes());
}
push_frame(&mut out, FRAME_SETTINGS, 0, 0, &settings);
if fp.window_update != 0 {
push_frame(
&mut out,
FRAME_WINDOW_UPDATE,
0,
0,
&fp.window_update.to_be_bytes(),
);
}
for p in &fp.priorities {
let mut payload = Vec::with_capacity(5);
let dep = (p.dependent & 0x7fff_ffff) | ((u32::from(p.exclusive) & 1) << 31);
payload.extend_from_slice(&dep.to_be_bytes());
payload.push(p.weight as u8);
push_frame(&mut out, FRAME_PRIORITY, 0, p.stream_id, &payload);
}
let mut block = Vec::with_capacity(32);
for ph in &fp.pseudo_header_order {
push_pseudo_header(&mut block, *ph, authority, path);
}
push_frame(
&mut out,
FRAME_HEADERS,
FLAG_END_HEADERS | FLAG_END_STREAM,
1,
&block,
);
out
}
pub fn parse_client_akamai(bytes: &[u8]) -> Result<String, WireParseError> {
if bytes.len() < H2_CLIENT_PREFACE.len()
|| &bytes[..H2_CLIENT_PREFACE.len()] != H2_CLIENT_PREFACE
{
return Err(WireParseError::BadPreface);
}
let mut pos = H2_CLIENT_PREFACE.len();
let mut settings: Vec<H2Setting> = Vec::new();
let mut window_update: u32 = 0;
let mut priorities: Vec<H2Priority> = Vec::new();
let mut pseudo_header_order: Option<Vec<PseudoHeader>> = None;
while pos + 9 <= bytes.len() {
let len = (usize::from(bytes[pos]) << 16)
| (usize::from(bytes[pos + 1]) << 8)
| usize::from(bytes[pos + 2]);
let ftype = bytes[pos + 3];
let flags = bytes[pos + 4];
let stream = u32::from_be_bytes([
bytes[pos + 5],
bytes[pos + 6],
bytes[pos + 7],
bytes[pos + 8],
]) & 0x7fff_ffff;
let body_start = pos + 9;
let body_end = body_start
.checked_add(len)
.ok_or(WireParseError::Truncated)?;
if body_end > bytes.len() {
return Err(WireParseError::Truncated);
}
let payload = &bytes[body_start..body_end];
match ftype {
FRAME_SETTINGS if flags & FLAG_ACK == 0 => {
if !payload.len().is_multiple_of(6) {
return Err(WireParseError::BadSettings);
}
for chunk in payload.chunks_exact(6) {
let id = u16::from_be_bytes([chunk[0], chunk[1]]);
let value = u32::from_be_bytes([chunk[2], chunk[3], chunk[4], chunk[5]]);
settings.push(H2Setting { id, value });
}
}
FRAME_WINDOW_UPDATE if stream == 0 => {
if payload.len() != 4 {
return Err(WireParseError::Truncated);
}
if window_update == 0 {
window_update =
u32::from_be_bytes([payload[0], payload[1], payload[2], payload[3]])
& 0x7fff_ffff;
}
}
FRAME_PRIORITY => {
if payload.len() != 5 {
return Err(WireParseError::BadPriority);
}
let raw = u32::from_be_bytes([payload[0], payload[1], payload[2], payload[3]]);
priorities.push(H2Priority {
stream_id: stream,
exclusive: u8::from(raw & 0x8000_0000 != 0),
dependent: raw & 0x7fff_ffff,
weight: u16::from(payload[4]),
});
}
FRAME_HEADERS => {
pseudo_header_order = Some(decode_pseudo_header_order(payload)?);
break; }
_ => {}
}
pos = body_end;
}
let Some(pseudo_header_order) = pseudo_header_order else {
return Err(WireParseError::NoHeaders);
};
Ok(AkamaiH2Fingerprint {
settings,
window_update,
priorities,
pseudo_header_order,
}
.to_canonical())
}
pub fn capture_client_opening(
bytes: &[u8],
) -> Result<crate::http::session_coherence::WireCapture, WireParseError> {
Ok(crate::http::session_coherence::WireCapture {
akamai_fingerprint: Some(parse_client_akamai(bytes)?),
..Default::default()
})
}
fn push_frame(out: &mut Vec<u8>, ftype: u8, flags: u8, stream: u32, payload: &[u8]) {
let len = payload.len();
out.push((len >> 16) as u8);
out.push((len >> 8) as u8);
out.push(len as u8);
out.push(ftype);
out.push(flags);
out.extend_from_slice(&(stream & 0x7fff_ffff).to_be_bytes());
out.extend_from_slice(payload);
}
fn push_pseudo_header(block: &mut Vec<u8>, ph: PseudoHeader, authority: &str, path: &str) {
match ph {
PseudoHeader::Method => block.push(0x80 | 2), PseudoHeader::Scheme => block.push(0x80 | 7), PseudoHeader::Path => {
if path == "/" {
block.push(0x80 | 4); } else {
block.push(0x04);
push_hpack_string(block, path.as_bytes());
}
}
PseudoHeader::Authority => {
block.push(0x41);
push_hpack_string(block, authority.as_bytes());
}
}
}
fn push_hpack_string(out: &mut Vec<u8>, s: &[u8]) {
push_hpack_int(out, s.len(), 7, 0x00);
out.extend_from_slice(s);
}
fn push_hpack_int(out: &mut Vec<u8>, value: usize, prefix_bits: u32, first_byte_flags: u8) {
let mask = (1usize << prefix_bits) - 1;
if value < mask {
out.push(first_byte_flags | value as u8);
return;
}
out.push(first_byte_flags | mask as u8);
let mut rem = value - mask;
loop {
let mut byte = (rem & 0x7f) as u8;
rem >>= 7;
if rem > 0 {
byte |= 0x80;
}
out.push(byte);
if rem == 0 {
break;
}
}
}
fn decode_pseudo_header_order(block: &[u8]) -> Result<Vec<PseudoHeader>, WireParseError> {
let mut order = Vec::new();
let mut i = 0usize;
while i < block.len() {
let b = block[i];
let name = if b & 0x80 != 0 {
let idx = read_hpack_int(block, &mut i, 7)?;
static_index_name(idx)
} else if b & 0xc0 == 0x40 {
let idx = read_hpack_int(block, &mut i, 6)?;
let name = literal_name(block, &mut i, idx)?;
skip_hpack_string(block, &mut i)?; name
} else if b & 0xe0 == 0x20 {
read_hpack_int(block, &mut i, 5)?;
None
} else {
let idx = read_hpack_int(block, &mut i, 4)?;
let name = literal_name(block, &mut i, idx)?;
skip_hpack_string(block, &mut i)?; name
};
if let Some(ps) = name.and_then(pseudo_from_name) {
order.push(ps);
}
}
Ok(order)
}
fn literal_name(block: &[u8], i: &mut usize, idx: usize) -> Result<Option<String>, WireParseError> {
if idx == 0 {
return read_hpack_string(block, i);
}
Ok(static_index_name(idx))
}
fn static_index_name(idx: usize) -> Option<String> {
match idx {
1 => Some(":authority".into()),
2 | 3 => Some(":method".into()),
4 | 5 => Some(":path".into()),
6 | 7 => Some(":scheme".into()),
_ => None,
}
}
fn pseudo_from_name(name: String) -> Option<PseudoHeader> {
match name.as_str() {
":method" => Some(PseudoHeader::Method),
":path" => Some(PseudoHeader::Path),
":authority" => Some(PseudoHeader::Authority),
":scheme" => Some(PseudoHeader::Scheme),
_ => None,
}
}
fn read_hpack_string(block: &[u8], i: &mut usize) -> Result<Option<String>, WireParseError> {
if *i >= block.len() {
return Err(WireParseError::Truncated);
}
let huffman = block[*i] & 0x80 != 0;
let len = read_hpack_int(block, i, 7)?;
let end = i.checked_add(len).ok_or(WireParseError::Truncated)?;
if end > block.len() {
return Err(WireParseError::Truncated);
}
if huffman {
return Err(WireParseError::UnsupportedHpack);
}
let s = core::str::from_utf8(&block[*i..end])
.map_err(|_| WireParseError::UnsupportedHpack)?
.to_string();
*i = end;
Ok(Some(s))
}
fn skip_hpack_string(block: &[u8], i: &mut usize) -> Result<(), WireParseError> {
if *i >= block.len() {
return Err(WireParseError::Truncated);
}
let len = read_hpack_int(block, i, 7)?;
let end = i.checked_add(len).ok_or(WireParseError::Truncated)?;
if end > block.len() {
return Err(WireParseError::Truncated);
}
*i = end;
Ok(())
}
fn read_hpack_int(block: &[u8], i: &mut usize, prefix_bits: u32) -> Result<usize, WireParseError> {
if *i >= block.len() {
return Err(WireParseError::Truncated);
}
let mask = (1usize << prefix_bits) - 1;
let mut value = usize::from(block[*i]) & mask;
*i += 1;
if value < mask {
return Ok(value);
}
let mut shift = 0u32;
loop {
if *i >= block.len() {
return Err(WireParseError::Truncated);
}
let byte = block[*i];
*i += 1;
value = value
.checked_add((usize::from(byte & 0x7f)) << shift)
.ok_or(WireParseError::Truncated)?;
shift += 7;
if byte & 0x80 == 0 {
break;
}
}
Ok(value)
}
#[cfg(test)]
#[path = "wire_emit/tests.rs"]
mod tests;