From 927cadde6ee9d7c16da8c2426dcdfc5c0d24d762 Mon Sep 17 00:00:00 2001 From: Alex Tiernan-Berry Date: Sun, 22 Nov 2026 10:38:53 +0000 Subject: [PATCH 1/5] clazel-ipc spec: 7.16's FetchScript, UpdateUrl, ScriptResponse, ScriptBody, ScriptEnd, ScriptFailed Contracts first (CLAUDE.md rule 3): the schema rows, tokens and parser. The codec, lemmas, examples and mutations follow. Co-Authored-By: Claude Opus 5.5 --- crates/clazel-ipc/src/message/spec.rs | 121 +++++++++++++++++++++++++- 1 file changed, 120 insertions(+), 1 deletion(-) diff --git a/crates/clazel-ipc/src/message/spec.rs b/crates/clazel-ipc/src/message/spec.rs index 559a0eeb6..c8ff1f32f 100644 --- a/crates/clazel-ipc/src/message/spec.rs +++ b/crates/clazel-ipc/src/message/spec.rs @@ -22,6 +22,8 @@ //! | 10 | renderer to kernel | `Display` | title (text), text (text), links (array of text) | //! | 11 | renderer to kernel | `Title` | title (text) | //! | 14 | renderer to kernel | `FetchStyle` | request (unsigned), url (text) | +//! | 16 | renderer to kernel | `FetchScript` | request (unsigned), url (text) | +//! | 17 | renderer to kernel | `UpdateUrl` | replace (bool), url (text) | //! | 15 | GPU process to kernel | `FrameReady` | buffer (unsigned), width (unsigned), height (unsigned) | //! | 18 | GPU process to kernel | `GpuReady` | software (bool) | //! | 19 | GPU process to kernel | `GpuRefused` | | @@ -39,6 +41,10 @@ //! | 112 | kernel to renderer | `StyleEnd` | request (unsigned) | //! | 113 | kernel to renderer | `StyleFailed` | request (unsigned) | //! | 114 | kernel to GPU process | `GpuViewport` | width (unsigned), height (unsigned), scale (unsigned) | +//! | 115 | kernel to renderer | `ScriptResponse` | request (unsigned), content type (bytes) | +//! | 116 | kernel to renderer | `ScriptBody` | request (unsigned), bytes (bytes, at most [`max_script_chunk`]) | +//! | 117 | kernel to renderer | `ScriptEnd` | request (unsigned) | +//! | 118 | kernel to renderer | `ScriptFailed` | request (unsigned) | //! //! `StorageLengthValue` is not in the plan's list, which has no reply for //! `StorageLength`; the schema needs one. @@ -78,6 +84,20 @@ //! `StyleFailed`, each naming that `request`. The request id is the //! renderer's own number for its fetch, not an identity: it names nobody. //! +//! Phase 7 item 7.16 adds the script fetch and the URL update. +//! `FetchScript` has 5.19's request shape: a committed renderer asks the +//! kernel to fetch `url` (resolved against its committed URL) under +//! `request`, an id the renderer chose, and the kernel answers with +//! `ScriptResponse`, zero or more `ScriptBody` and `ScriptEnd`, or with +//! `ScriptFailed`, each naming that `request`, exactly as it does for +//! `FetchStyle` (the two differ only in their tags, so that a renderer never +//! reads a script's bytes as a sheet's). `UpdateUrl` is `pushState` (`replace` +//! false) and `replaceState` (`replace` true): it names the URL the renderer +//! wants its document to have, as written (resolved by the kernel against +//! the committed URL, as `Navigate`'s is), and the kernel decides whether the +//! address bar changes. The tags 16 and 17 are the first free ones below 100; +//! 115 to 118 follow 114. +//! //! Two rules are part of the schema's spec ([`message_fields`], and //! `lemmas::lemma_no_identity_fields`): //! - **No message carries a claimed identity.** No origin, renderer id, tab @@ -242,6 +262,46 @@ pub enum Message { /// The renderer's id for the fetch. request: u64, }, + /// Renderer to kernel: fetch a script (item 7.16), with 5.19's request + /// shape. + FetchScript { + /// The renderer's id for this fetch. + request: u64, + /// The script's URL, as the document wrote it. + url: Seq, + }, + /// Renderer to kernel: `history.pushState` or `history.replaceState` + /// (item 7.16). + UpdateUrl { + /// Whether it is `replaceState` (`pushState` otherwise). + replace: bool, + /// The URL the document asks to have, as the script wrote it. + url: Seq, + }, + /// Kernel to renderer: the script's response arrived (item 7.16). + ScriptResponse { + /// The renderer's id for the fetch. + request: u64, + /// The response's combined `Content-Type` field value, or empty. + content_type: Seq, + }, + /// Kernel to renderer: the next part of the script's body. + ScriptBody { + /// The renderer's id for the fetch. + request: u64, + /// The octets. + bytes: Seq, + }, + /// Kernel to renderer: the script's body is complete. + ScriptEnd { + /// The renderer's id for the fetch. + request: u64, + }, + /// Kernel to renderer: the script fetch failed (or was refused). + ScriptFailed { + /// The renderer's id for the fetch. + request: u64, + }, /// Kernel to renderer: a document is committed; its body follows in /// `Body` frames, then `BodyEnd`. Commit { @@ -332,6 +392,16 @@ pub open spec fn max_style_chunk() -> nat { (crate::frame::spec::MAX_FRAME - 17) as nat } +/// The most octets one `ScriptBody` carries: `MAX_FRAME` minus the rest of +/// its payload, which is the array's head (1 octet), the tag 116 (2 octets), +/// the request id (at most 9 octets) and the byte string's head (at most 5 +/// octets below 2^32), so that every `ScriptBody` of at most this many octets +/// fits one frame (item 7.16). That is [`max_style_chunk`] (a `StyleBody`'s +/// payload has the same shape, with the tag 111 in place of 116). +pub open spec fn max_script_chunk() -> nat { + max_style_chunk() +} + /// Whether `m` is sent by a renderer to the kernel. pub open spec fn is_from_renderer(m: Message) -> bool { match m { @@ -344,6 +414,8 @@ pub open spec fn is_from_renderer(m: Message) -> bool { | Message::StorageKey { .. } | Message::StorageLength | Message::Navigate { .. } + | Message::FetchScript { .. } + | Message::UpdateUrl { .. } | Message::Display { .. } | Message::Title { .. } | Message::FetchStyle { .. } => true, @@ -411,8 +483,11 @@ pub enum Field { Delta, /// A key code. KeyCode, - /// The renderer's own id for a style sheet fetch (item 5.19). + /// The renderer's own id for a style sheet or script fetch (items 5.19 + /// and 7.16). Request, + /// Whether a URL update replaces the current history entry (item 7.16). + Replace, /// A claimed origin. No message has one. Origin, /// A renderer id. No message has one. @@ -459,6 +534,12 @@ pub open spec fn message_fields(m: Message) -> Seq { Message::StyleBody { .. } => seq![Field::Request, Field::BodyBytes], Message::StyleEnd { .. } => seq![Field::Request], Message::StyleFailed { .. } => seq![Field::Request], + Message::FetchScript { .. } => seq![Field::Request, Field::Url], + Message::UpdateUrl { .. } => seq![Field::Replace, Field::Url], + Message::ScriptResponse { .. } => seq![Field::Request, Field::ContentType], + Message::ScriptBody { .. } => seq![Field::Request, Field::BodyBytes], + Message::ScriptEnd { .. } => seq![Field::Request], + Message::ScriptFailed { .. } => seq![Field::Request], } } @@ -534,6 +615,12 @@ pub open spec fn message_tokens(m: Message) -> Seq { Message::StyleBody { request, bytes } => seq![Token::Array(3), Token::Uint(111), Token::Uint(request), Token::Bytes(bytes)], Message::StyleEnd { request } => seq![Token::Array(2), Token::Uint(112), Token::Uint(request)], Message::StyleFailed { request } => seq![Token::Array(2), Token::Uint(113), Token::Uint(request)], + Message::FetchScript { request, url } => seq![Token::Array(3), Token::Uint(16), Token::Uint(request), Token::Text(url)], + Message::UpdateUrl { replace, url } => seq![Token::Array(3), Token::Uint(17), Token::Bool(replace), Token::Text(url)], + Message::ScriptResponse { request, content_type } => seq![Token::Array(3), Token::Uint(115), Token::Uint(request), Token::Bytes(content_type)], + Message::ScriptBody { request, bytes } => seq![Token::Array(3), Token::Uint(116), Token::Uint(request), Token::Bytes(bytes)], + Message::ScriptEnd { request } => seq![Token::Array(2), Token::Uint(117), Token::Uint(request)], + Message::ScriptFailed { request } => seq![Token::Array(2), Token::Uint(118), Token::Uint(request)], } } @@ -583,6 +670,20 @@ pub open spec fn parse_fields(tag: u64, f: Seq) -> Option { _ => None, } } else { None } + } else if tag == 16 { + if f.len() == 2 { + match (f[0], f[1]) { + (Token::Uint(r), Token::Text(u)) => Some(Message::FetchScript { request: r, url: u }), + _ => None, + } + } else { None } + } else if tag == 17 { + if f.len() == 2 { + match (f[0], f[1]) { + (Token::Bool(b), Token::Text(u)) => Some(Message::UpdateUrl { replace: b, url: u }), + _ => None, + } + } else { None } } else if tag == 18 { if f.len() == 1 { match f[0] { Token::Bool(b) => Some(Message::GpuReady { software: b }), _ => None } } else { None } } else if tag == 19 { @@ -647,6 +748,24 @@ pub open spec fn parse_fields(tag: u64, f: Seq) -> Option { if f.len() == 1 { match f[0] { Token::Uint(r) => Some(Message::StyleEnd { request: r }), _ => None } } else { None } } else if tag == 113 { if f.len() == 1 { match f[0] { Token::Uint(r) => Some(Message::StyleFailed { request: r }), _ => None } } else { None } + } else if tag == 115 { + if f.len() == 2 { + match (f[0], f[1]) { + (Token::Uint(r), Token::Bytes(c)) => Some(Message::ScriptResponse { request: r, content_type: c }), + _ => None, + } + } else { None } + } else if tag == 116 { + if f.len() == 2 { + match (f[0], f[1]) { + (Token::Uint(r), Token::Bytes(b)) => Some(Message::ScriptBody { request: r, bytes: b }), + _ => None, + } + } else { None } + } else if tag == 117 { + if f.len() == 1 { match f[0] { Token::Uint(r) => Some(Message::ScriptEnd { request: r }), _ => None } } else { None } + } else if tag == 118 { + if f.len() == 1 { match f[0] { Token::Uint(r) => Some(Message::ScriptFailed { request: r }), _ => None } } else { None } } else if tag == 114 { if f.len() == 3 { match (f[0], f[1], f[2]) { From 2290542359b4a12005e6c464f8f4b7766a9fedac Mon Sep 17 00:00:00 2001 From: Alex Tiernan-Berry Date: Sun, 22 Nov 2026 10:48:08 +0000 Subject: [PATCH 2/5] clazel-ipc: codec, lemmas, examples, tests and mutations for 7.16's messages lemma_script_body_fits_frame: a ScriptBody of at most max_script_chunk octets, whatever its request id, fits one frame. Co-Authored-By: Claude Opus 5.5 --- crates/clazel-ipc/mutations.json | 104 ++++++++++++++++++++++ crates/clazel-ipc/src/message/codec.rs | 101 +++++++++++++++++++++ crates/clazel-ipc/src/message/examples.rs | 29 ++++++ crates/clazel-ipc/src/message/lemmas.rs | 46 ++++++++++ crates/clazel-ipc/tests/messages.rs | 41 +++++++++ 5 files changed, 321 insertions(+) diff --git a/crates/clazel-ipc/mutations.json b/crates/clazel-ipc/mutations.json index 5d7da39ce..cfe2394c1 100644 --- a/crates/clazel-ipc/mutations.json +++ b/crates/clazel-ipc/mutations.json @@ -1273,6 +1273,110 @@ "lemma": "lemma_max_style_chunk()", "witness": "max_style_chunk() != 1048559nat" } + }, + { + "id": "msg-fetch-script-tag", + "file": "src/message/spec.rs", + "find": "Message::FetchScript { request, url } => seq![Token::Array(3), Token::Uint(16),", + "replace": "Message::FetchScript { request, url } => seq![Token::Array(3), Token::Uint(20),", + "expect": "killed", + "reason": "FetchScript is written with tag 20, which nothing reads: lemma_decode_encode_message is false.", + "certificate": { + "file": "src/message/lemmas.rs", + "lemma": "lemma_decode_encode_message(Message::FetchScript { request: 1, url: seq![0x61u8] })", + "witness": "message_ok(Message::FetchScript { request: 1, url: seq![0x61u8] }) && decode_message(encode_message(Message::FetchScript { request: 1, url: seq![0x61u8] })) != Some(Message::FetchScript { request: 1, url: seq![0x61u8] })" + } + }, + { + "id": "msg-script-body-request-dropped", + "file": "src/message/spec.rs", + "find": "Token::Uint(116), Token::Uint(request), Token::Bytes(bytes)]", + "replace": "Token::Uint(116), Token::Uint(0), Token::Bytes(bytes)]", + "expect": "killed", + "reason": "A ScriptBody loses its request id: the renderer would add the bytes to another fetch's script. lemma_decode_encode_message is false.", + "certificate": { + "file": "src/message/lemmas.rs", + "lemma": "lemma_decode_encode_message(Message::ScriptBody { request: 2, bytes: seq![0x61u8] })", + "witness": "message_ok(Message::ScriptBody { request: 2, bytes: seq![0x61u8] }) && decode_message(encode_message(Message::ScriptBody { request: 2, bytes: seq![0x61u8] })) != Some(Message::ScriptBody { request: 2, bytes: seq![0x61u8] })" + } + }, + { + "id": "msg-script-failed-parse-tag", + "file": "src/message/spec.rs", + "find": "} else if tag == 118 {", + "replace": "} else if tag == 119 {", + "expect": "killed", + "reason": "The parser reads ScriptFailed under tag 119: lemma_decode_encode_message is false.", + "certificate": { + "file": "src/message/lemmas.rs", + "lemma": "lemma_decode_encode_message(Message::ScriptFailed { request: 3 })", + "witness": "message_ok(Message::ScriptFailed { request: 3 }) && decode_message(encode_message(Message::ScriptFailed { request: 3 })) != Some(Message::ScriptFailed { request: 3 })" + } + }, + { + "id": "msg-update-url-replace-flipped", + "file": "src/message/spec.rs", + "find": "Token::Uint(17), Token::Bool(replace), Token::Text(url)]", + "replace": "Token::Uint(17), Token::Bool(!replace), Token::Text(url)]", + "expect": "killed", + "reason": "The replace flag is flipped on the wire: a pushState would be read as replaceState (and the reverse). lemma_decode_encode_message is false.", + "certificate": { + "file": "src/message/lemmas.rs", + "lemma": "lemma_decode_encode_message(Message::UpdateUrl { replace: true, url: seq![0x61u8] })", + "witness": "message_ok(Message::UpdateUrl { replace: true, url: seq![0x61u8] }) && decode_message(encode_message(Message::UpdateUrl { replace: true, url: seq![0x61u8] })) != Some(Message::UpdateUrl { replace: true, url: seq![0x61u8] })" + } + }, + { + "id": "dir-update-url-not-renderer", + "file": "src/message/spec.rs", + "find": " | Message::UpdateUrl { .. }\n | Message::Display { .. }", + "replace": " | Message::Display { .. }", + "expect": "killed", + "reason": "UpdateUrl is not counted as a renderer message: the kernel would refuse it, so lemma_example_script is false.", + "certificate": { + "file": "src/message/lemmas.rs", + "lemma": "super::examples::lemma_example_script()", + "witness": "decode_renderer_message(seq![0x83u8, 0x11, 0xF5, 0x62, 0x2F, 0x61]) is None" + } + }, + { + "id": "dir-fetch-script-not-renderer", + "file": "src/message/spec.rs", + "find": " | Message::FetchScript { .. }\n | Message::UpdateUrl { .. }", + "replace": " | Message::UpdateUrl { .. }", + "expect": "killed", + "reason": "FetchScript is not counted as a renderer message: the kernel would refuse it, so lemma_example_script is false.", + "certificate": { + "file": "src/message/lemmas.rs", + "lemma": "super::examples::lemma_example_script()", + "witness": "decode_renderer_message(seq![0x83u8, 0x10, 0x01, 0x64, 0x73, 0x2E, 0x6A, 0x73]) is None" + } + }, + { + "id": "dir-script-body-from-renderer", + "file": "src/message/spec.rs", + "find": " | Message::FetchStyle { .. } => true,\n _ => false,", + "replace": " | Message::FetchStyle { .. }\n | Message::ScriptBody { .. } => true,\n _ => false,", + "expect": "killed", + "reason": "A renderer may send ScriptBody, a kernel-to-renderer message: lemma_example_script (the kernel's decoder refuses it) is false.", + "certificate": { + "file": "src/message/lemmas.rs", + "lemma": "super::examples::lemma_example_script()", + "witness": "decode_renderer_message(seq![0x83u8, 0x18, 0x74, 0x01, 0x41, 0x61]) is Some" + } + }, + { + "id": "msg-max-script-chunk", + "file": "src/message/spec.rs", + "find": "pub open spec fn max_script_chunk() -> nat {\n max_style_chunk()\n}", + "replace": "pub open spec fn max_script_chunk() -> nat {\n max_style_chunk() + 1\n}", + "expect": "killed", + "reason": "The largest ScriptBody (with a 9-octet request id) is one octet too long for a frame. lemma_script_body_fits_frame is false for it, but a certificate on a 1 MiB input is too large to evaluate; the certificate is lemma_max_script_chunk, which ties the codec's MAX_SCRIPT_CHUNK (1_048_559, the size a_largest_script_body_fits_one_frame checks on the real code) to the spec.", + "certificate": { + "file": "src/message/codec.rs", + "lemma": "lemma_max_script_chunk()", + "witness": "max_script_chunk() != 1048559nat" + } } ] } diff --git a/crates/clazel-ipc/src/message/codec.rs b/crates/clazel-ipc/src/message/codec.rs index e01023964..661905510 100644 --- a/crates/clazel-ipc/src/message/codec.rs +++ b/crates/clazel-ipc/src/message/codec.rs @@ -111,6 +111,44 @@ pub enum Msg { /// The renderer's id for the fetch. request: u64, }, + /// Renderer to kernel: fetch a script (item 7.16). + FetchScript { + /// The renderer's id for this fetch. + request: u64, + /// The script's URL, as the document wrote it. + url: Vec, + }, + /// Renderer to kernel: `pushState` or `replaceState` (item 7.16). + UpdateUrl { + /// Whether it is `replaceState`. + replace: bool, + /// The URL, as the script wrote it. + url: Vec, + }, + /// Kernel to renderer: the script's response arrived. + ScriptResponse { + /// The renderer's id for the fetch. + request: u64, + /// The response's combined `Content-Type` field value, or empty. + content_type: Vec, + }, + /// Kernel to renderer: the next part of the script's body. + ScriptBody { + /// The renderer's id for the fetch. + request: u64, + /// The octets. + bytes: Vec, + }, + /// Kernel to renderer: the script's body is complete. + ScriptEnd { + /// The renderer's id for the fetch. + request: u64, + }, + /// Kernel to renderer: the script fetch failed (or was refused). + ScriptFailed { + /// The renderer's id for the fetch. + request: u64, + }, /// Kernel to renderer: a document is committed; its body follows in /// `Body` frames, then `BodyEnd`. Commit { @@ -205,6 +243,17 @@ pub proof fn lemma_max_style_chunk() { } +/// [`max_script_chunk`]: the most octets one `ScriptBody` carries, +/// `MAX_FRAME` minus 17 (item 7.16). +pub const MAX_SCRIPT_CHUNK: usize = 1_048_559; + +/// [`MAX_SCRIPT_CHUNK`] is the spec's [`max_script_chunk`]. +pub proof fn lemma_max_script_chunk() + ensures + MAX_SCRIPT_CHUNK as nat == max_script_chunk(), +{ +} + /// The view of a list of strings. pub open spec fn strings_view(v: Seq>) -> Seq> { v.map_values(|s: Vec| s@) @@ -259,6 +308,12 @@ impl View for Msg { Msg::StyleBody { request, bytes } => Message::StyleBody { request: *request, bytes: bytes@ }, Msg::StyleEnd { request } => Message::StyleEnd { request: *request }, Msg::StyleFailed { request } => Message::StyleFailed { request: *request }, + Msg::FetchScript { request, url } => Message::FetchScript { request: *request, url: url@ }, + Msg::UpdateUrl { replace, url } => Message::UpdateUrl { replace: *replace, url: url@ }, + Msg::ScriptResponse { request, content_type } => Message::ScriptResponse { request: *request, content_type: content_type@ }, + Msg::ScriptBody { request, bytes } => Message::ScriptBody { request: *request, bytes: bytes@ }, + Msg::ScriptEnd { request } => Message::ScriptEnd { request: *request }, + Msg::ScriptFailed { request } => Message::ScriptFailed { request: *request }, } } } @@ -405,6 +460,20 @@ fn parse_fields(tag: u64, toks: &[Tok]) -> (r: Option) _ => None, } } else { None } + } else if tag == 16 { + if k == 2 { + match (uint_at(toks, 2), text_at(toks, 3)) { + (Some(a), Some(b)) => Some(Msg::FetchScript { request: a, url: b }), + _ => None, + } + } else { None } + } else if tag == 17 { + if k == 2 { + match (bool_at(toks, 2), text_at(toks, 3)) { + (Some(a), Some(b)) => Some(Msg::UpdateUrl { replace: a, url: b }), + _ => None, + } + } else { None } } else if tag == 15 { if k == 3 { match (uint_at(toks, 2), uint_at(toks, 3), uint_at(toks, 4)) { @@ -498,6 +567,30 @@ fn parse_fields(tag: u64, toks: &[Tok]) -> (r: Option) let a = uint_at(toks, 2)?; Some(Msg::StyleFailed { request: a }) } else { None } + } else if tag == 115 { + if k == 2 { + match (uint_at(toks, 2), bytes_at(toks, 3)) { + (Some(a), Some(b)) => Some(Msg::ScriptResponse { request: a, content_type: b }), + _ => None, + } + } else { None } + } else if tag == 116 { + if k == 2 { + match (uint_at(toks, 2), bytes_at(toks, 3)) { + (Some(a), Some(b)) => Some(Msg::ScriptBody { request: a, bytes: b }), + _ => None, + } + } else { None } + } else if tag == 117 { + if k == 1 { + let a = uint_at(toks, 2)?; + Some(Msg::ScriptEnd { request: a }) + } else { None } + } else if tag == 118 { + if k == 1 { + let a = uint_at(toks, 2)?; + Some(Msg::ScriptFailed { request: a }) + } else { None } } else if tag == 114 { if k == 3 { match (uint_at(toks, 2), uint_at(toks, 3), uint_at(toks, 4)) { @@ -652,6 +745,8 @@ pub fn is_from_renderer(m: &Msg) -> (r: bool) | Msg::Display { .. } | Msg::Title { .. } | Msg::FetchStyle { .. } + | Msg::FetchScript { .. } + | Msg::UpdateUrl { .. } ) } @@ -847,6 +942,12 @@ fn message_tokens(m: &Msg) -> (t: Vec) Msg::StyleBody { request, bytes } => toks4(Tok::Array(3), Tok::Uint(111), Tok::Uint(*request), Tok::Bytes(copy(bytes.as_slice()))), Msg::StyleEnd { request } => toks3(Tok::Array(2), Tok::Uint(112), Tok::Uint(*request)), Msg::StyleFailed { request } => toks3(Tok::Array(2), Tok::Uint(113), Tok::Uint(*request)), + Msg::FetchScript { request, url } => toks4(Tok::Array(3), Tok::Uint(16), Tok::Uint(*request), Tok::Text(copy(url.as_slice()))), + Msg::UpdateUrl { replace, url } => toks4(Tok::Array(3), Tok::Uint(17), Tok::Bool(*replace), Tok::Text(copy(url.as_slice()))), + Msg::ScriptResponse { request, content_type } => toks4(Tok::Array(3), Tok::Uint(115), Tok::Uint(*request), Tok::Bytes(copy(content_type.as_slice()))), + Msg::ScriptBody { request, bytes } => toks4(Tok::Array(3), Tok::Uint(116), Tok::Uint(*request), Tok::Bytes(copy(bytes.as_slice()))), + Msg::ScriptEnd { request } => toks3(Tok::Array(2), Tok::Uint(117), Tok::Uint(*request)), + Msg::ScriptFailed { request } => toks3(Tok::Array(2), Tok::Uint(118), Tok::Uint(*request)), } } diff --git a/crates/clazel-ipc/src/message/examples.rs b/crates/clazel-ipc/src/message/examples.rs index efb9f03f0..e2c0f3668 100644 --- a/crates/clazel-ipc/src/message/examples.rs +++ b/crates/clazel-ipc/src/message/examples.rs @@ -358,4 +358,33 @@ pub proof fn lemma_example_style() assert(decode_renderer_message(seq![0x82u8, 0x18, 0x70, 0x01]) is None) by (compute_only); } +/// `FetchScript(1, "s.js")` is `[16, 1, "s.js"]` and `UpdateUrl(true, "/a")` +/// is `[17, true, "/a"]`, both from a renderer only; `ScriptResponse(1, +/// h'74')` is `[115, 1, h'74']`, `ScriptBody(1, h'61')` `[116, 1, h'61']`, +/// `ScriptEnd(1)` `[117, 1]` and `ScriptFailed(1)` `[118, 1]` (item 7.16). +pub proof fn lemma_example_script() + ensures + decode_renderer_message(seq![0x83u8, 0x10, 0x01, 0x64, 0x73, 0x2E, 0x6A, 0x73]) == Some(Message::FetchScript { request: 1, url: seq![0x73u8, 0x2E, 0x6A, 0x73] }), + encode_message(Message::FetchScript { request: 1, url: seq![0x73u8, 0x2E, 0x6A, 0x73] }) == seq![0x83u8, 0x10, 0x01, 0x64, 0x73, 0x2E, 0x6A, 0x73], + decode_renderer_message(seq![0x83u8, 0x11, 0xF5, 0x62, 0x2F, 0x61]) == Some(Message::UpdateUrl { replace: true, url: seq![0x2Fu8, 0x61] }), + encode_message(Message::UpdateUrl { replace: false, url: seq![0x2Fu8, 0x61] }) == seq![0x83u8, 0x11, 0xF4, 0x62, 0x2F, 0x61], + decode_message(seq![0x83u8, 0x18, 0x73, 0x01, 0x41, 0x74]) == Some(Message::ScriptResponse { request: 1, content_type: seq![0x74u8] }), + decode_message(seq![0x83u8, 0x18, 0x74, 0x01, 0x41, 0x61]) == Some(Message::ScriptBody { request: 1, bytes: seq![0x61u8] }), + decode_message(seq![0x82u8, 0x18, 0x75, 0x01]) == Some(Message::ScriptEnd { request: 1 }), + decode_message(seq![0x82u8, 0x18, 0x76, 0x01]) == Some(Message::ScriptFailed { request: 1 }), + decode_renderer_message(seq![0x82u8, 0x18, 0x75, 0x01]) is None, + decode_renderer_message(seq![0x83u8, 0x18, 0x74, 0x01, 0x41, 0x61]) is None, +{ + assert(decode_renderer_message(seq![0x83u8, 0x10, 0x01, 0x64, 0x73, 0x2E, 0x6A, 0x73]) == Some(Message::FetchScript { request: 1, url: seq![0x73u8, 0x2E, 0x6A, 0x73] })) by (compute_only); + assert(encode_message(Message::FetchScript { request: 1, url: seq![0x73u8, 0x2E, 0x6A, 0x73] }) == seq![0x83u8, 0x10, 0x01, 0x64, 0x73, 0x2E, 0x6A, 0x73]) by (compute_only); + assert(decode_renderer_message(seq![0x83u8, 0x11, 0xF5, 0x62, 0x2F, 0x61]) == Some(Message::UpdateUrl { replace: true, url: seq![0x2Fu8, 0x61] })) by (compute_only); + assert(encode_message(Message::UpdateUrl { replace: false, url: seq![0x2Fu8, 0x61] }) == seq![0x83u8, 0x11, 0xF4, 0x62, 0x2F, 0x61]) by (compute_only); + assert(decode_message(seq![0x83u8, 0x18, 0x73, 0x01, 0x41, 0x74]) == Some(Message::ScriptResponse { request: 1, content_type: seq![0x74u8] })) by (compute_only); + assert(decode_message(seq![0x83u8, 0x18, 0x74, 0x01, 0x41, 0x61]) == Some(Message::ScriptBody { request: 1, bytes: seq![0x61u8] })) by (compute_only); + assert(decode_message(seq![0x82u8, 0x18, 0x75, 0x01]) == Some(Message::ScriptEnd { request: 1 })) by (compute_only); + assert(decode_message(seq![0x82u8, 0x18, 0x76, 0x01]) == Some(Message::ScriptFailed { request: 1 })) by (compute_only); + assert(decode_renderer_message(seq![0x82u8, 0x18, 0x75, 0x01]) is None) by (compute_only); + assert(decode_renderer_message(seq![0x83u8, 0x18, 0x74, 0x01, 0x41, 0x61]) is None) by (compute_only); +} + } // verus! diff --git a/crates/clazel-ipc/src/message/lemmas.rs b/crates/clazel-ipc/src/message/lemmas.rs index 698f3e7b5..a055c4c9b 100644 --- a/crates/clazel-ipc/src/message/lemmas.rs +++ b/crates/clazel-ipc/src/message/lemmas.rs @@ -234,6 +234,46 @@ pub proof fn lemma_style_body_fits_frame(request: u64, bytes: Seq) assert(crate::cbor::spec::encode_head(2, bytes.len()).len() <= 5); } +/// A `ScriptBody` of at most [`max_script_chunk`] octets can be sent, and its +/// bytes fit one frame (item 7.16), whatever its request id. +pub proof fn lemma_script_body_fits_frame(request: u64, bytes: Seq) + requires + bytes.len() <= max_script_chunk(), + ensures + message_ok(Message::ScriptBody { request, bytes }), + crate::frame::spec::payload_ok(encode_message(Message::ScriptBody { request, bytes })), +{ + let t = seq![Token::Array(3), Token::Uint(116), Token::Uint(request), Token::Bytes(bytes)]; + let rest = seq![Token::Uint(request), Token::Bytes(bytes)]; + assert(t =~= seq![Token::Array(3), Token::Uint(116)] + rest); + lemma_items_head(3, 116, rest); + lemma_items_step(rest, 2); + assert(rest[0] == Token::Uint(request)); + assert(rest.drop_first() =~= seq![Token::Bytes(bytes)]); + lemma_items_step(seq![Token::Bytes(bytes)], 1); + assert(seq![Token::Bytes(bytes)][0] == Token::Bytes(bytes)); + assert(seq![Token::Bytes(bytes)].drop_first() =~= Seq::::empty()); + assert(crate::cbor::spec::token_ok(Token::Bytes(bytes))); + assert(crate::cbor::spec::token_ok(Token::Uint(request))); + assert(crate::cbor::spec::is_items(Seq::::empty(), 0)); + reveal_with_fuel(crate::cbor::spec::encode, 5); + assert(t.drop_first() =~= seq![Token::Uint(116), Token::Uint(request), Token::Bytes(bytes)]); + assert(t.drop_first().drop_first() =~= rest); + assert(t.drop_first().drop_first().drop_first() =~= seq![Token::Bytes(bytes)]); + assert(t.drop_first().drop_first().drop_first().drop_first() =~= Seq::::empty()); + crate::cbor::lemmas::lemma_be_bytes_len(116, 1); + crate::cbor::lemmas::lemma_be_bytes_len(request as nat, 1); + crate::cbor::lemmas::lemma_be_bytes_len(request as nat, 2); + crate::cbor::lemmas::lemma_be_bytes_len(request as nat, 4); + crate::cbor::lemmas::lemma_be_bytes_len(request as nat, 8); + crate::cbor::lemmas::lemma_be_bytes_len(bytes.len(), 1); + crate::cbor::lemmas::lemma_be_bytes_len(bytes.len(), 2); + crate::cbor::lemmas::lemma_be_bytes_len(bytes.len(), 4); + assert(crate::cbor::spec::encode(Seq::::empty()) == Seq::::empty()); + assert(crate::cbor::spec::encode_head(0, request as nat).len() <= 9); + assert(crate::cbor::spec::encode_head(2, bytes.len()).len() <= 5); +} + /// The tokens of a sendable message parse back to it. pub proof fn lemma_parse_message_tokens(m: Message) requires @@ -290,6 +330,12 @@ pub proof fn lemma_parse_message_tokens(m: Message) Message::StyleBody { request, bytes } => { assert(t.subrange(2, 4) =~= seq![Token::Uint(request), Token::Bytes(bytes)]); }, Message::StyleEnd { request } => { assert(t.subrange(2, 3) =~= seq![Token::Uint(request)]); }, Message::StyleFailed { request } => { assert(t.subrange(2, 3) =~= seq![Token::Uint(request)]); }, + Message::FetchScript { request, url } => { assert(t.subrange(2, 4) =~= seq![Token::Uint(request), Token::Text(url)]); }, + Message::UpdateUrl { replace, url } => { assert(t.subrange(2, 4) =~= seq![Token::Bool(replace), Token::Text(url)]); }, + Message::ScriptResponse { request, content_type } => { assert(t.subrange(2, 4) =~= seq![Token::Uint(request), Token::Bytes(content_type)]); }, + Message::ScriptBody { request, bytes } => { assert(t.subrange(2, 4) =~= seq![Token::Uint(request), Token::Bytes(bytes)]); }, + Message::ScriptEnd { request } => { assert(t.subrange(2, 3) =~= seq![Token::Uint(request)]); }, + Message::ScriptFailed { request } => { assert(t.subrange(2, 3) =~= seq![Token::Uint(request)]); }, } } diff --git a/crates/clazel-ipc/tests/messages.rs b/crates/clazel-ipc/tests/messages.rs index 9b19eb1cd..4b7086c28 100644 --- a/crates/clazel-ipc/tests/messages.rs +++ b/crates/clazel-ipc/tests/messages.rs @@ -127,6 +127,28 @@ fn all() -> Vec { }, Msg::StyleEnd { request: 7 }, Msg::StyleFailed { request: 0 }, + Msg::FetchScript { + request: 9, + url: t("app.js?v=2"), + }, + Msg::UpdateUrl { + replace: false, + url: t("/a/b?c#d"), + }, + Msg::UpdateUrl { + replace: true, + url: t(""), + }, + Msg::ScriptResponse { + request: u64::MAX, + content_type: t("text/javascript"), + }, + Msg::ScriptBody { + request: 9, + bytes: vec![0x00, 0xFF], + }, + Msg::ScriptEnd { request: 9 }, + Msg::ScriptFailed { request: 0 }, ] } @@ -147,6 +169,23 @@ fn a_largest_style_body_fits_one_frame() { assert!(encode_framed(&over).is_none()); } +#[test] +fn a_largest_script_body_fits_one_frame() { + use clazel_ipc::message::codec::MAX_SCRIPT_CHUNK; + let m = Msg::ScriptBody { + request: u64::MAX, + bytes: vec![0x5A; MAX_SCRIPT_CHUNK], + }; + let frame = encode_framed(&m).unwrap_or_default(); + assert_eq!(frame.len(), MAX_FRAME + 4); + assert_eq!(decode_framed(&frame), Some(m_clone(&m))); + let over = Msg::ScriptBody { + request: u64::MAX, + bytes: vec![0x5A; MAX_SCRIPT_CHUNK + 1], + }; + assert!(encode_framed(&over).is_none()); +} + #[test] fn every_message_round_trips_through_a_frame() { for m in all() { @@ -181,6 +220,8 @@ fn the_kernel_decoder_takes_only_renderer_messages() { | Msg::Display { .. } | Msg::Title { .. } | Msg::FetchStyle { .. } + | Msg::FetchScript { .. } + | Msg::UpdateUrl { .. } ); assert_eq!( decode_renderer_message(&bytes).is_some(), From 7ac82d4096876ee2cb5c671ee84ab52d20f58776 Mon Sep 17 00:00:00 2001 From: Alex Tiernan-Berry Date: Sun, 22 Nov 2026 10:49:43 +0000 Subject: [PATCH 3/5] clazel-kernel spec: 7.16's FetchScript, and theorem_script_fetch_shape's statement Contracts first (CLAUDE.md rule 3): fetch_sub (fetch_style's function with a script flag), the Script* frames, the sub-fetch's script flag, and the statement of theorem_script_fetch_shape. The proofs and the exec kernel follow. Co-Authored-By: Claude Opus 5.5 --- crates/clazel-kernel/src/spec.rs | 121 +++++++++++++++++++++---- crates/clazel-kernel/src/statements.rs | 69 +++++++++++++- 2 files changed, 168 insertions(+), 22 deletions(-) diff --git a/crates/clazel-kernel/src/spec.rs b/crates/clazel-kernel/src/spec.rs index 799781f49..85b73156a 100644 --- a/crates/clazel-kernel/src/spec.rs +++ b/crates/clazel-kernel/src/spec.rs @@ -422,6 +422,27 @@ //! partition key (the renderer's domain): its connections are its tab's, //! keyed by its domain, and every connection is new (`Connection: close` //! is one request per connection). +//! - **Script fetches (phase-7.md item 7.16).** A committed renderer's +//! `FetchScript { request, url }` is exactly a `FetchStyle` in what the +//! kernel does ([`fetch_sub`] is the one function both call, with +//! `script` false and true): the same resolution against the committed +//! URL, the same transducer, limits, credentials (7.0(c) S1: Fetch's +//! defaults, same-origin requests carry cookies, cross-origin ones carry +//! none) and tables (a script fetch is a [`SubFetch`] with `script` set, +//! so it shares a renderer's limits with its style sheet fetches). The +//! request is a classic script's without `crossorigin` (destination +//! "script", mode "no-cors"): `GET` of the resolved URL with no header, +//! body or option of the renderer's. What differs is the answer, which is +//! `ScriptResponse { request, content type }`, `ScriptBody` frames and +//! `ScriptEnd`, or `ScriptFailed { request }` ([`script_frames`], +//! [`script_failed_frame`]), so that a renderer cannot read a script's +//! bytes as a sheet's. A `FetchScript` before the renderer's first commit +//! is a disallowed frame (killed), as `FetchStyle` is. The opaque-response +//! blocking that 7.0(c) lists for no-cors responses is not modelled yet: +//! it needs `Fetch` (the later slice of 7.16), whose CORS and ORB checks +//! decide what a renderer may read of a cross-origin response; until it +//! lands, a cross-origin script is fetched without credentials and handed +//! to the renderer whole, as a style sheet is (listed). //! - **Sub-fetch connections are named `(renderer, serial, hop)`**, not by //! [`State::next_conn`]: the outputs are `SubConnect`, `SubSend` and //! `SubClose`, and the shell reports with [`Event::SubNet`]. The serial is @@ -677,7 +698,7 @@ pub struct UserInput { pub key: u64, } -/// A style sheet fetch in flight (item 5.19). +/// A style sheet or script fetch in flight (items 5.19 and 7.16). pub struct SubFetch { /// The renderer that asked. pub renderer: nat, @@ -687,6 +708,10 @@ pub struct SubFetch { pub serial: nat, /// The renderer's own id for it, which every answer carries. pub request: u64, + /// Whether it is a script fetch (`FetchScript`, item 7.16), answered + /// with `Script*` frames, and not a style sheet fetch (`FetchStyle`), + /// answered with `Style*` frames. + pub script: bool, /// The renderer's tab, which owns its connections. pub tab: nat, /// The transducer's state. @@ -2500,11 +2525,50 @@ pub open spec fn style_failed_frame(request: u64) -> Seq { reply_frame(clazel_ipc::message::spec::Message::StyleFailed { request }) } +/// The `ScriptBody` frames of `body`, in order: consecutive pieces of at most +/// `max_script_chunk` octets, none for an empty body (item 7.16). +pub open spec fn script_body_frames(request: u64, body: Seq) -> Seq + decreases body.len(), +{ + if body.len() == 0 { + seq![] + } else if body.len() <= clazel_ipc::message::spec::max_script_chunk() { + reply_frame(clazel_ipc::message::spec::Message::ScriptBody { request, bytes: body }) + } else { + reply_frame(clazel_ipc::message::spec::Message::ScriptBody { request, bytes: body.take(clazel_ipc::message::spec::max_script_chunk() as int) }) + + script_body_frames(request, body.skip(clazel_ipc::message::spec::max_script_chunk() as int)) + } +} + +/// The frames of a fetched script: `ScriptResponse`, the `ScriptBody` frames +/// and `ScriptEnd`, as one write (item 7.16). +pub open spec fn script_frames(request: u64, doc: Document) -> Seq { + reply_frame(clazel_ipc::message::spec::Message::ScriptResponse { request, content_type: doc.content_type }) + script_body_frames(request, doc.body) + + reply_frame(clazel_ipc::message::spec::Message::ScriptEnd { request }) +} + +/// The frame of `ScriptFailed` (item 7.16). +pub open spec fn script_failed_frame(request: u64) -> Seq { + reply_frame(clazel_ipc::message::spec::Message::ScriptFailed { request }) +} + +/// The frames of a sub-fetch's response: a script's if it is a script fetch, +/// a sheet's if not. +pub open spec fn sub_frames(script: bool, request: u64, doc: Document) -> Seq { + if script { script_frames(request, doc) } else { style_frames(request, doc) } +} + +/// The frame of a sub-fetch's failure: `ScriptFailed` for a script fetch, +/// `StyleFailed` for a sheet fetch. +pub open spec fn sub_failed_frame(script: bool, request: u64) -> Seq { + if script { script_failed_frame(request) } else { style_failed_frame(request) } +} + /// The outputs of a sub-fetch's transducer actions, on connection `hop` of /// sub-fetch `serial` of renderer `id`: the connection the last `Connect` /// gave, the outputs, and the frames to the renderer if the fetch ended /// (`Done` or `Fail`; nothing after it is read). -pub open spec fn sub_actions(id: nat, serial: nat, request: u64, hop: nat, actions: Seq) -> (nat, Seq, Option>) +pub open spec fn sub_actions(id: nat, serial: nat, request: u64, script: bool, hop: nat, actions: Seq) -> (nat, Seq, Option>) decreases actions.len(), { if actions.len() == 0 { @@ -2513,19 +2577,19 @@ pub open spec fn sub_actions(id: nat, serial: nat, request: u64, hop: nat, actio let rest = actions.drop_first(); match actions[0] { clazel_fetch::transducer::spec::Action::Connect { host, port, tls } => { - let (h, out, end) = sub_actions(id, serial, request, hop + 1, rest); + let (h, out, end) = sub_actions(id, serial, request, script, hop + 1, rest); (h, seq![Output::SubConnect { renderer: id, serial, hop: hop + 1, host, port, tls }] + out, end) }, clazel_fetch::transducer::spec::Action::Send(bytes) => { - let (h, out, end) = sub_actions(id, serial, request, hop, rest); + let (h, out, end) = sub_actions(id, serial, request, script, hop, rest); (h, seq![Output::SubSend { renderer: id, serial, hop, bytes }] + out, end) }, clazel_fetch::transducer::spec::Action::Close => { - let (h, out, end) = sub_actions(id, serial, request, hop, rest); + let (h, out, end) = sub_actions(id, serial, request, script, hop, rest); (h, seq![Output::SubClose { renderer: id, serial, hop }] + out, end) }, - clazel_fetch::transducer::spec::Action::Done { url, response } => (hop, seq![], Some(style_frames(request, response_document(response)))), - clazel_fetch::transducer::spec::Action::Fail(_) => (hop, seq![], Some(style_failed_frame(request))), + clazel_fetch::transducer::spec::Action::Done { url, response } => (hop, seq![], Some(sub_frames(script, request, response_document(response)))), + clazel_fetch::transducer::spec::Action::Fail(_) => (hop, seq![], Some(sub_failed_frame(script, request))), } } } @@ -2539,14 +2603,16 @@ pub open spec fn sub_finish(fs: Seq, f: SubFetch, out: Seq, en } } -/// A committed renderer's `FetchStyle { request, url }` (item 5.19): refused -/// with `StyleFailed` past a limit or for a URL that does not decode, -/// resolve or parse; otherwise a sub-fetch is started by the transducer -/// navigations use, in the renderer's table, on connections of its tab -/// whose partition key is its domain. -pub open spec fn fetch_style(rules: Seq, urls: UrlFns, fetch: FetchFns, s: State, r: Renderer, request: u64, url: Seq) -> (State, Seq) { +/// A committed renderer's `FetchStyle { request, url }` (item 5.19) or +/// `FetchScript { request, url }` (item 7.16, `script` true): refused with +/// `StyleFailed` (`ScriptFailed`) past a limit or for a URL that does not +/// decode, resolve or parse; otherwise a sub-fetch is started by the +/// transducer navigations use, in the renderer's table, on connections of its +/// tab whose partition key is its domain. The two differ only in the frames +/// that answer them. +pub open spec fn fetch_sub(rules: Seq, urls: UrlFns, fetch: FetchFns, s: State, r: Renderer, script: bool, request: u64, url: Seq) -> (State, Seq) { let (serial, in_document) = subcount_of(s.subcounts, r.id, r.lock); - let refused = (s, reply(r, clazel_ipc::message::spec::Message::StyleFailed { request })); + let refused = (s, reply_failed(r, script, request)); if live_subfetches(s.subfetches, r.id, r.lock) >= max_subfetches_at_once() || in_document >= max_subfetches_per_document() || serial >= max_subfetch_serial() { refused @@ -2564,6 +2630,7 @@ pub open spec fn fetch_style(rules: Seq, urls: UrlFns, f lock: r.lock, serial, request, + script, tab: r.tab, fetch: fs, hop: 0, @@ -2571,7 +2638,7 @@ pub open spec fn fetch_style(rules: Seq, urls: UrlFns, f partition: crate::domain::domain_of_renderer(rules, r), ended: false, }; - let (hop, out, end) = sub_actions(r.id, serial, request, 0, actions); + let (hop, out, end) = sub_actions(r.id, serial, request, script, 0, actions); let counts = set_subcount(s.subcounts, r.id, r.lock, serial + 1, in_document + 1); let table = match end { None => s.subfetches.push(SubFetch { hop, ..f }), @@ -2589,6 +2656,22 @@ pub open spec fn fetch_style(rules: Seq, urls: UrlFns, f } } +/// A single `ToRenderer` of the failure frame of a sub-fetch of kind +/// `script`, to renderer `r`. +pub open spec fn reply_failed(r: Renderer, script: bool, request: u64) -> Seq { + seq![Output::ToRenderer { id: r.id, bytes: sub_failed_frame(script, request) }] +} + +/// `FetchStyle` (item 5.19): [`fetch_sub`] for a style sheet. +pub open spec fn fetch_style(rules: Seq, urls: UrlFns, fetch: FetchFns, s: State, r: Renderer, request: u64, url: Seq) -> (State, Seq) { + fetch_sub(rules, urls, fetch, s, r, false, request, url) +} + +/// `FetchScript` (item 7.16): [`fetch_sub`] for a script. +pub open spec fn fetch_script(rules: Seq, urls: UrlFns, fetch: FetchFns, s: State, r: Renderer, request: u64, url: Seq) -> (State, Seq) { + fetch_sub(rules, urls, fetch, s, r, true, request, url) +} + /// Sub-fetch `f`'s renderer is live, committed and locked to its lock, and /// `f` has not ended: `f` belongs to the renderer's current document. pub open spec fn subfetch_live(s: State, f: SubFetch) -> bool { @@ -2613,7 +2696,7 @@ pub open spec fn sub_net(rules: Seq, fetch: FetchFns, s: let cred = credentialed(fetch, f.lock, f.fetch.url); let (fs, actions, ops) = clazel_fetch::transducer::spec::step(fetch.http, fetch.urls, f.fetch, input, subfetch_jar(fetch, s, f), s.now); let jar = if cred { apply_net_ops(rules, s.jar, ops) } else { s.jar }; - let (h, out, end) = sub_actions(renderer, serial, f.request, hop, actions); + let (h, out, end) = sub_actions(renderer, serial, f.request, f.script, hop, actions); let (table, outs) = sub_finish(s.subfetches, SubFetch { fetch: fs, hop: h, ..f }, out, end); (State { subfetches: table, jar, ..s }, outs) }, @@ -2645,7 +2728,7 @@ pub open spec fn sweep(s: State, fs: Seq) -> (Seq, Seq= f.started + subfetch_timeout() { - (rest, close + seq![Output::ToRenderer { id: f.renderer, bytes: style_failed_frame(f.request) }] + out) + (rest, close + seq![Output::ToRenderer { id: f.renderer, bytes: sub_failed_frame(f.script, f.request) }] + out) } else { (seq![f] + rest, out) } @@ -2673,7 +2756,7 @@ pub open spec fn decode_renderer_frame(bytes: Seq) -> Option) -> Option { match decode_renderer_frame(bytes) { - Some(m) => if (m is Display || m is Title || m is FetchStyle) && !r.committed { None } else { Some(m) }, + Some(m) => if (m is Display || m is Title || m is FetchStyle || m is FetchScript) && !r.committed { None } else { Some(m) }, None => None, } } @@ -2745,6 +2828,8 @@ pub open spec fn handle_message( clazel_ipc::message::spec::Message::Title { title } => (State { titles: set_title(s.titles, r.id, r.lock, title), ..s }, seq![]), // Item 5.19. clazel_ipc::message::spec::Message::FetchStyle { request, url } => fetch_style(rules, urls, fetch, s, r, request, url), + // Item 7.16. + clazel_ipc::message::spec::Message::FetchScript { request, url } => fetch_script(rules, urls, fetch, s, r, request, url), // A message a renderer may not send: unreachable, see // `decode_renderer_frame`. _ => (s, seq![]), diff --git a/crates/clazel-kernel/src/statements.rs b/crates/clazel-kernel/src/statements.rs index 46a6d1610..a6adf6add 100644 --- a/crates/clazel-kernel/src/statements.rs +++ b/crates/clazel-kernel/src/statements.rs @@ -762,7 +762,9 @@ pub open spec fn viewport_only_to_own_tab_statement( // Style sheet fetches (phase-5.md item 5.19). // --------------------------------------------------------------------- -/// `theorem_subfetch_only_to_requester`: every frame of a sub-fetch's answer +/// `theorem_subfetch_only_to_requester` (restated for item 7.16: a script +/// fetch's frames are `Script*`, a sheet fetch's `Style*`, by the sub-fetch's +/// `script` flag): every frame of a sub-fetch's answer /// goes to the renderer that asked, under its own request id, and only while /// the sub-fetch belongs to that renderer's current document (it is live: /// the renderer is live, committed and has the lock it asked with, and no @@ -780,14 +782,14 @@ pub open spec fn subfetch_only_to_requester_statement(rules: Seq { &&& out[k]->ToRenderer_id == renderer &&& subfetch_live(s, f) - &&& (out[k]->ToRenderer_bytes == style_failed_frame(f.request) || exists|doc: Document| - out[k]->ToRenderer_bytes == #[trigger] style_frames(f.request, doc)) + &&& (out[k]->ToRenderer_bytes == sub_failed_frame(f.script, f.request) || exists|doc: Document| + out[k]->ToRenderer_bytes == #[trigger] sub_frames(f.script, f.request, doc)) }, None => false, }, Event::Tick { time } => exists|j: int| 0 <= j < s.subfetches.len() && s.subfetches[j].renderer == out[k]->ToRenderer_id && subfetch_live(tick(s, time).0, s.subfetches[j]) - && out[k]->ToRenderer_bytes == style_failed_frame(s.subfetches[j].request), + && out[k]->ToRenderer_bytes == sub_failed_frame(s.subfetches[j].script, s.subfetches[j].request), _ => true, } } @@ -886,6 +888,65 @@ pub open spec fn commit_ends_subfetches_statement(urls: UrlFns, s: State, tab: n } } +// --------------------------------------------------------------------- +// Script fetches (phase-7.md item 7.16). +// --------------------------------------------------------------------- + +/// The fetch a script fetch starts, as the transducer is given it: a +/// sub-fetch of renderer `r` that is a script fetch, under the renderer's +/// request id, on its tab and with its domain as partition key, whose +/// transducer state is `start` of the URL the kernel resolved and parsed: +/// the renderer's only contribution to the request is the URL text. +pub open spec fn script_fetch_started(rules: Seq, urls: UrlFns, fetch: FetchFns, s: State, r: Renderer, request: u64, url: Seq, f: SubFetch) -> bool { + &&& f.script + &&& f.renderer == r.id && f.lock == r.lock && f.tab == r.tab && f.request == request + &&& f.serial == subcount_of(s.subcounts, r.id, r.lock).0 + &&& f.partition == crate::domain::domain_of_renderer(rules, r) + &&& f.started == s.now && !f.ended + &&& exists|relative: Seq, resolved: Seq, parsed: clazel_url::url::spec::Url| + clazel_encoding::utf8::spec::utf8_decode_without_bom_or_fail(url) == Some(relative) && (urls.resolve)(r.url, relative) == Some(resolved) + && (fetch.parse)(resolved) == Some(parsed) && f.fetch == clazel_fetch::transducer::spec::start(parsed).0 +} + +/// `theorem_script_fetch_shape` (item 7.16): whatever frame `bytes` renderer +/// `id` sends, if it is a `FetchScript { request, url }` the kernel accepts +/// (the sender is committed), then +/// - the step changes nothing but the sender's sub-fetch table and counts +/// (not the renderers, jar, storage, connections, counters, viewports, +/// titles or GPU records); +/// - it either leaves the table alone (refused, or finished at once) or adds +/// exactly one sub-fetch, a script fetch of the sender, on its tab and +/// under its domain's partition key, whose request is the transducer's +/// `start` of the URL the kernel resolved against the sender's committed +/// URL ([`script_fetch_started`]): a `GET` with no header, body, method, +/// mode or credentials mode of the renderer's, which is 5.19's request +/// shape; +/// - every output is for the sender and is a `ScriptFailed` or a script's +/// `ScriptResponse`, `ScriptBody` frames and `ScriptEnd` under the sender's +/// request id (never a `Style*` frame), or a connection the sender's +/// sub-fetch asks for. +pub open spec fn script_fetch_shape_statement(rules: Seq, urls: UrlFns, fetch: FetchFns, s: State, id: nat, bytes: Seq) -> bool { + let (s1, out) = step(rules, urls, fetch, s, Event::FromRenderer { id, bytes }); + match find_by_id(s.renderers, id, 0) { + None => true, + Some(i) => match accepted_message(s.renderers[i], bytes) { + Some(clazel_ipc::message::spec::Message::FetchScript { request, url }) => { + let r = s.renderers[i]; + &&& r.committed + &&& s1 == State { subfetches: s1.subfetches, subcounts: s1.subcounts, ..s } + &&& (s1.subfetches == s.subfetches || exists|f: SubFetch| s1.subfetches == s.subfetches.push(f) && script_fetch_started(rules, urls, fetch, s, r, request, url, f)) + &&& forall|k: int| + 0 <= k < out.len() ==> match #[trigger] out[k] { + Output::ToRenderer { id: x, bytes: b } => x == id && (b == script_failed_frame(request) || exists|doc: Document| b == #[trigger] script_frames(request, doc)), + Output::SubConnect { renderer: x, .. } => x == id, + _ => false, + } + }, + _ => true, + }, + } +} + // --------------------------------------------------------------------- // The GPU crash policy (phase-5.md item 5.17c). // --------------------------------------------------------------------- From 216433cbb12fe4655c437c2f439c2dd252c07055 Mon Sep 17 00:00:00 2001 From: Alex Tiernan-Berry Date: Sun, 22 Nov 2026 10:58:07 +0000 Subject: [PATCH 4/5] clazel-kernel: FetchScript proven (fetch_sub, exec, theorem_script_fetch_shape) FetchStyle and FetchScript run through one function, fetch_sub, with the sub-fetch's script flag choosing the frames; the existing sub-fetch lemmas and the noninterference proofs take the flag, and theorem_script_fetch_shape is proven. Verus: 876 verified, 0 errors. Co-Authored-By: Claude Opus 5.5 --- crates/clazel-kernel/Cargo.toml | 6 + crates/clazel-kernel/mutations.json | 2 +- crates/clazel-kernel/src/display_theorems.rs | 4 +- crates/clazel-kernel/src/exec/frames.rs | 32 +++ crates/clazel-kernel/src/exec/records.rs | 3 + crates/clazel-kernel/src/exec/step.rs | 5 +- crates/clazel-kernel/src/exec/subfetch.rs | 176 ++++++++++-- crates/clazel-kernel/src/mutation_lemmas.rs | 1 + crates/clazel-kernel/src/net_theorems.rs | 4 +- crates/clazel-kernel/src/quark.rs | 4 +- crates/clazel-kernel/src/spec.rs | 23 ++ crates/clazel-kernel/src/subfetch_rel.rs | 108 +++---- crates/clazel-kernel/src/subfetch_theorems.rs | 264 ++++++++++++++---- crates/clazel-kernel/src/surface_theorems.rs | 4 +- crates/clazel-kernel/src/theorems.rs | 9 +- crates/clazel-kernel/src/unwind_base.rs | 4 +- crates/clazel-kernel/src/unwinding_b.rs | 16 +- crates/clazel-kernel/src/unwinding_d.rs | 31 +- 18 files changed, 526 insertions(+), 170 deletions(-) diff --git a/crates/clazel-kernel/Cargo.toml b/crates/clazel-kernel/Cargo.toml index ba1ec2f32..57b009290 100644 --- a/crates/clazel-kernel/Cargo.toml +++ b/crates/clazel-kernel/Cargo.toml @@ -135,6 +135,12 @@ theorems = [ "theorem_subfetch_ownership", "theorem_subfetch_limits", "theorem_commit_ends_subfetches", + # Phase 7 item 7.16: script fetches (`FetchScript`, answered with + # `Script*` frames), as `FetchStyle` is, by the same function + # (`fetch_sub`). The statement is in `statements.rs`; the proof in + # `subfetch_theorems.rs`; the noninterference over `FetchScript` is + # `FetchStyle`'s (`subfetch_rel.rs`), whose lemmas take the `script` flag. + "theorem_script_fetch_shape", # Phase 5 item 5.17c: the GPU crash policy. The statements are in # `statements.rs`; the proofs in `gpu_theorems.rs`, the noninterference # over `GpuExited` and its declassified parts in `gpu_rel.rs`. diff --git a/crates/clazel-kernel/mutations.json b/crates/clazel-kernel/mutations.json index c2a7d1991..f22899c56 100644 --- a/crates/clazel-kernel/mutations.json +++ b/crates/clazel-kernel/mutations.json @@ -629,7 +629,7 @@ { "id": "display-before-commit", "file": "src/spec.rs", - "find": "Some(m) => if (m is Display || m is Title || m is FetchStyle) && !r.committed { None } else { Some(m) },", + "find": "Some(m) => if (m is Display || m is Title || m is FetchStyle || m is FetchScript) && !r.committed { None } else { Some(m) },", "replace": "Some(m) => Some(m),", "expect": "killed", "module": "mutation_lemmas", diff --git a/crates/clazel-kernel/src/display_theorems.rs b/crates/clazel-kernel/src/display_theorems.rs index c2c286ce2..ffbb7dfe5 100644 --- a/crates/clazel-kernel/src/display_theorems.rs +++ b/crates/clazel-kernel/src/display_theorems.rs @@ -95,8 +95,8 @@ proof fn lemma_handle_no_show(rules: Seq, urls: UrlFns, lemma_storage_call_no_show(s, r, m); } }, - clazel_ipc::message::spec::Message::FetchStyle { request, url } => { - crate::subfetch_rel::lemma_fetch_style_shape(rules, urls, fetch, s, r, request, url); + clazel_ipc::message::spec::Message::FetchStyle { .. } | clazel_ipc::message::spec::Message::FetchScript { .. } => { + crate::subfetch_rel::lemma_fetch_sub_shape(rules, urls, fetch, s, r, m is FetchScript, sub_request_id(m), sub_request_url(m)); }, _ => {}, } diff --git a/crates/clazel-kernel/src/exec/frames.rs b/crates/clazel-kernel/src/exec/frames.rs index ea12ecbf8..23d26a69f 100644 --- a/crates/clazel-kernel/src/exec/frames.rs +++ b/crates/clazel-kernel/src/exec/frames.rs @@ -80,6 +80,10 @@ pub open spec fn message_texts_ok(m: clazel_ipc::message::spec::Message) -> bool clazel_ipc::message::spec::Message::StyleResponse { content_type, .. } => bytes_ok(content_type), clazel_ipc::message::spec::Message::StyleBody { bytes, .. } => bytes_ok(bytes), clazel_ipc::message::spec::Message::StyleEnd { .. } | clazel_ipc::message::spec::Message::StyleFailed { .. } => true, + clazel_ipc::message::spec::Message::FetchScript { url, .. } | clazel_ipc::message::spec::Message::UpdateUrl { url, .. } => text_ok(url), + clazel_ipc::message::spec::Message::ScriptResponse { content_type, .. } => bytes_ok(content_type), + clazel_ipc::message::spec::Message::ScriptBody { bytes, .. } => bytes_ok(bytes), + clazel_ipc::message::spec::Message::ScriptEnd { .. } | clazel_ipc::message::spec::Message::ScriptFailed { .. } => true, } } @@ -232,6 +236,30 @@ pub proof fn lemma_message_ok(m: clazel_ipc::message::spec::Message) lemma_msg(m, 2, 113, seq![clazel_ipc::cbor::spec::Token::Uint(request)]); lemma_one(clazel_ipc::cbor::spec::Token::Uint(request)); }, + clazel_ipc::message::spec::Message::FetchScript { request, url } => { + lemma_msg(m, 3, 16, seq![clazel_ipc::cbor::spec::Token::Uint(request), clazel_ipc::cbor::spec::Token::Text(url)]); + lemma_two(clazel_ipc::cbor::spec::Token::Uint(request), clazel_ipc::cbor::spec::Token::Text(url)); + }, + clazel_ipc::message::spec::Message::UpdateUrl { replace, url } => { + lemma_msg(m, 3, 17, seq![clazel_ipc::cbor::spec::Token::Bool(replace), clazel_ipc::cbor::spec::Token::Text(url)]); + lemma_two(clazel_ipc::cbor::spec::Token::Bool(replace), clazel_ipc::cbor::spec::Token::Text(url)); + }, + clazel_ipc::message::spec::Message::ScriptResponse { request, content_type } => { + lemma_msg(m, 3, 115, seq![clazel_ipc::cbor::spec::Token::Uint(request), clazel_ipc::cbor::spec::Token::Bytes(content_type)]); + lemma_two(clazel_ipc::cbor::spec::Token::Uint(request), clazel_ipc::cbor::spec::Token::Bytes(content_type)); + }, + clazel_ipc::message::spec::Message::ScriptBody { request, bytes } => { + lemma_msg(m, 3, 116, seq![clazel_ipc::cbor::spec::Token::Uint(request), clazel_ipc::cbor::spec::Token::Bytes(bytes)]); + lemma_two(clazel_ipc::cbor::spec::Token::Uint(request), clazel_ipc::cbor::spec::Token::Bytes(bytes)); + }, + clazel_ipc::message::spec::Message::ScriptEnd { request } => { + lemma_msg(m, 2, 117, seq![clazel_ipc::cbor::spec::Token::Uint(request)]); + lemma_one(clazel_ipc::cbor::spec::Token::Uint(request)); + }, + clazel_ipc::message::spec::Message::ScriptFailed { request } => { + lemma_msg(m, 2, 118, seq![clazel_ipc::cbor::spec::Token::Uint(request)]); + lemma_one(clazel_ipc::cbor::spec::Token::Uint(request)); + }, } } @@ -391,6 +419,10 @@ pub fn message_ok_exec(m: &Msg) -> (r: bool) Msg::StyleResponse { content_type, .. } => bytes_ok_exec(content_type.as_slice()), Msg::StyleBody { bytes, .. } => bytes_ok_exec(bytes.as_slice()), Msg::StyleEnd { .. } | Msg::StyleFailed { .. } => true, + Msg::FetchScript { url, .. } | Msg::UpdateUrl { url, .. } => text_ok_exec(url.as_slice()), + Msg::ScriptResponse { content_type, .. } => bytes_ok_exec(content_type.as_slice()), + Msg::ScriptBody { bytes, .. } => bytes_ok_exec(bytes.as_slice()), + Msg::ScriptEnd { .. } | Msg::ScriptFailed { .. } => true, } } diff --git a/crates/clazel-kernel/src/exec/records.rs b/crates/clazel-kernel/src/exec/records.rs index ddb238730..efb63c4bc 100644 --- a/crates/clazel-kernel/src/exec/records.rs +++ b/crates/clazel-kernel/src/exec/records.rs @@ -411,6 +411,8 @@ pub struct SubFetchRecord { pub serial: u64, /// The renderer's own id for it. pub request: u64, + /// Whether it is a script fetch (item 7.16). + pub script: bool, /// The renderer's tab. pub tab: u64, /// The transducer's state. @@ -434,6 +436,7 @@ impl View for SubFetchRecord { lock: self.lock@, serial: self.serial as nat, request: self.request, + script: self.script, tab: self.tab as nat, fetch: self.fetch@, hop: self.hop as nat, diff --git a/crates/clazel-kernel/src/exec/step.rs b/crates/clazel-kernel/src/exec/step.rs index 58aa5ccf6..16cacdb0b 100644 --- a/crates/clazel-kernel/src/exec/step.rs +++ b/crates/clazel-kernel/src/exec/step.rs @@ -1590,7 +1590,8 @@ pub fn handle_message_exec(urls: &U, fetch: &F, let outs = one_output(OutputRecord::Show { tab: r.tab, url: copy(r.url.as_slice()), title, text, links }); (s, outs) }, - Msg::FetchStyle { request, url } => super::subfetch::fetch_style_exec(urls, fetch, s, &r, request, url.as_slice()), + Msg::FetchStyle { request, url } => super::subfetch::fetch_sub_exec(urls, fetch, s, &r, false, request, url.as_slice()), + Msg::FetchScript { request, url } => super::subfetch::fetch_sub_exec(urls, fetch, s, &r, true, request, url.as_slice()), Msg::Title { title } => { let mut s = s; let titles = super::surfaces::set_title_exec(s.titles.as_slice(), r.id, &r.lock, title); @@ -1660,7 +1661,7 @@ pub fn from_renderer_exec(urls: &U, fetch: &F, s Some(r) => r.committed, None => false, }; - let display = matches!(m, Msg::Display { .. } | Msg::Title { .. } | Msg::FetchStyle { .. }); + let display = matches!(m, Msg::Display { .. } | Msg::Title { .. } | Msg::FetchStyle { .. } | Msg::FetchScript { .. }); if clazel_ipc::message::codec::is_from_renderer(&m) && (committed || !display) { handle_message_exec(urls, fetch, s, i, m) } else { diff --git a/crates/clazel-kernel/src/exec/subfetch.rs b/crates/clazel-kernel/src/exec/subfetch.rs index 87d21d7dd..62efaad6d 100644 --- a/crates/clazel-kernel/src/exec/subfetch.rs +++ b/crates/clazel-kernel/src/exec/subfetch.rs @@ -559,25 +559,141 @@ pub fn style_failed_frame_exec(request: u64) -> (r: Vec) reply_frame_exec(&Msg::StyleFailed { request }) } +/// One more step of [`script_body_frames`]. +proof fn lemma_script_body_frames_step(request: u64, b: Seq, pos: nat) + requires + pos < b.len(), + ensures + script_body_frames(request, b.skip(pos as int)) == if b.len() - pos <= clazel_ipc::message::spec::max_script_chunk() { + reply_frame(clazel_ipc::message::spec::Message::ScriptBody { request, bytes: b.skip(pos as int) }) + } else { + reply_frame( + clazel_ipc::message::spec::Message::ScriptBody { + request, + bytes: b.subrange(pos as int, (pos + clazel_ipc::message::spec::max_script_chunk()) as int), + }, + ) + script_body_frames(request, b.skip((pos + clazel_ipc::message::spec::max_script_chunk()) as int)) + }, +{ + let r = b.skip(pos as int); + let c = clazel_ipc::message::spec::max_script_chunk(); + assert(r.len() == b.len() - pos); + if r.len() > c { + assert(r.take(c as int) =~= b.subrange(pos as int, (pos + c) as int)); + assert(r.skip(c as int) =~= b.skip((pos + c) as int)); + } +} + +/// [`script_frames`] of a sheet with this content type and body. +pub fn script_frames_exec(request: u64, content_type: &[u8], body: &[u8]) -> (r: Vec) + ensures + r@ == script_frames(request, Document { content_type: content_type@, kind: kind_document(), body: body@ }), +{ + let mut out = reply_frame_exec(&Msg::ScriptResponse { request, content_type: vstd::slice::slice_to_vec(content_type) }); + let ghost head = out@; + let ghost c = clazel_ipc::message::spec::max_script_chunk(); + proof { + clazel_ipc::message::codec::lemma_max_script_chunk(); + assert(body@.skip(0) =~= body@); + } + let chunk = clazel_ipc::message::codec::MAX_SCRIPT_CHUNK; + let mut pos: usize = 0; + while pos < body.len() + invariant + pos <= body.len(), + c == clazel_ipc::message::spec::max_script_chunk(), + chunk as nat == c, + head + script_body_frames(request, body@) == out@ + script_body_frames(request, body@.skip(pos as int)), + decreases body.len() - pos, + { + proof { + lemma_script_body_frames_step(request, body@, pos as nat); + } + let rest = body.len().saturating_sub(pos); + if rest <= chunk { + let piece = reply_frame_exec(&Msg::ScriptBody { request, bytes: vstd::slice::slice_to_vec(vstd::slice::slice_subrange(body, pos, body.len())) }); + proof { + assert(body@.subrange(pos as int, body.len() as int) =~= body@.skip(pos as int)); + assert(body@.skip(body.len() as int) =~= Seq::::empty()); + assert(script_body_frames(request, Seq::::empty()) == Seq::::empty()); + } + let ghost before = out@; + out.extend_from_slice(piece.as_slice()); + assert(out@ =~= before + piece@); + pos = body.len(); + assert(out@ + script_body_frames(request, body@.skip(pos as int)) =~= out@); + } else { + let end = pos.saturating_add(chunk); + let piece = reply_frame_exec(&Msg::ScriptBody { request, bytes: vstd::slice::slice_to_vec(vstd::slice::slice_subrange(body, pos, end)) }); + let ghost before = out@; + out.extend_from_slice(piece.as_slice()); + assert(out@ =~= before + piece@); + pos = end; + } + } + let ghost before = out@; + let tail = reply_frame_exec(&Msg::ScriptEnd { request }); + out.extend_from_slice(tail.as_slice()); + proof { + assert(body@.skip(body.len() as int) =~= Seq::::empty()); + assert(out@ =~= before + tail@); + assert(out@ =~= head + script_body_frames(request, body@) + tail@); + } + out +} + +/// [`script_failed_frame`]. +pub fn script_failed_frame_exec(request: u64) -> (r: Vec) + ensures + r@ == script_failed_frame(request), +{ + reply_frame_exec(&Msg::ScriptFailed { request }) +} + +/// [`sub_frames`] of a response with this content type and body. +pub fn sub_frames_exec(script: bool, request: u64, content_type: &[u8], body: &[u8]) -> (r: Vec) + ensures + r@ == sub_frames(script, request, Document { content_type: content_type@, kind: kind_document(), body: body@ }), +{ + if script { + script_frames_exec(request, content_type, body) + } else { + style_frames_exec(request, content_type, body) + } +} + +/// [`sub_failed_frame`]. +pub fn sub_failed_frame_exec(script: bool, request: u64) -> (r: Vec) + ensures + r@ == sub_failed_frame(script, request), +{ + if script { + script_failed_frame_exec(request) + } else { + style_failed_frame_exec(request) + } +} + // --------------------------------------------------------------------- // Actions. // --------------------------------------------------------------------- /// The connection [`sub_actions`] ends on is the one it started from plus /// its `Connect`s, at most. -pub proof fn lemma_sub_actions_hop(id: nat, serial: nat, request: u64, hop: nat, actions: Seq) +pub proof fn lemma_sub_actions_hop(id: nat, serial: nat, request: u64, script: bool, hop: nat, actions: Seq) ensures - hop <= sub_actions(id, serial, request, hop, actions).0 <= hop + clazel_fetch::transducer::contract::count_connects(actions), + hop <= sub_actions(id, serial, request, script, hop, actions).0 <= hop + clazel_fetch::transducer::contract::count_connects(actions), decreases actions.len(), { if actions.len() > 0 { lemma_count_head(actions); match actions[0] { - clazel_fetch::transducer::spec::Action::Connect { .. } => lemma_sub_actions_hop(id, serial, request, hop + 1, actions.drop_first()), + clazel_fetch::transducer::spec::Action::Connect { .. } => lemma_sub_actions_hop(id, serial, request, script, hop + 1, actions.drop_first()), clazel_fetch::transducer::spec::Action::Send(_) | clazel_fetch::transducer::spec::Action::Close => lemma_sub_actions_hop( id, serial, request, + script, hop, actions.drop_first(), ), @@ -587,12 +703,12 @@ pub proof fn lemma_sub_actions_hop(id: nat, serial: nat, request: u64, hop: nat, } /// [`sub_actions`]. -pub fn sub_actions_exec(id: u64, serial: u64, request: u64, hop: u64, actions: Vec) -> (out: (u64, Vec, Option>)) +pub fn sub_actions_exec(id: u64, serial: u64, request: u64, script: bool, hop: u64, actions: Vec) -> (out: (u64, Vec, Option>)) requires hop as nat + clazel_fetch::transducer::contract::count_connects(clazel_fetch::transducer::types::actions_view(actions@)) <= 0xFFFF_FFFF_FFFF_FFFFnat, ensures ({ - let (h, o, e) = sub_actions(id as nat, serial as nat, request, hop as nat, clazel_fetch::transducer::types::actions_view(actions@)); + let (h, o, e) = sub_actions(id as nat, serial as nat, request, script, hop as nat, clazel_fetch::transducer::types::actions_view(actions@)); &&& out.0 as nat == h &&& outputs_view(out.1@) == o &&& match out.2 { @@ -619,26 +735,26 @@ pub fn sub_actions_exec(id: u64, serial: u64, request: u64, hop: u64, actions: V match act { ActionBuf::Connect { host, port, tls } => { let h1 = hop.saturating_add(1); - let (h, out, end) = sub_actions_exec(id, serial, request, h1, actions); + let (h, out, end) = sub_actions_exec(id, serial, request, script, h1, actions); let first = one_output(OutputRecord::SubConnect { renderer: id, serial, hop: h1, host, port: port as u64, tls }); (h, append_outputs(first, out), end) }, ActionBuf::Send(bytes) => { - let (h, out, end) = sub_actions_exec(id, serial, request, hop, actions); + let (h, out, end) = sub_actions_exec(id, serial, request, script, hop, actions); let first = one_output(OutputRecord::SubSend { renderer: id, serial, hop, bytes }); (h, append_outputs(first, out), end) }, ActionBuf::Close => { - let (h, out, end) = sub_actions_exec(id, serial, request, hop, actions); + let (h, out, end) = sub_actions_exec(id, serial, request, script, hop, actions); let first = one_output(OutputRecord::SubClose { renderer: id, serial, hop }); (h, append_outputs(first, out), end) }, ActionBuf::Done { url: _, response } => { let content_type = content_type_exec(response.fields.as_slice()); - let frames = style_frames_exec(request, content_type.as_slice(), response.body.as_slice()); + let frames = sub_frames_exec(script, request, content_type.as_slice(), response.body.as_slice()); (hop, no_outputs(), Some(frames)) }, - ActionBuf::Fail(_) => (hop, no_outputs(), Some(style_failed_frame_exec(request))), + ActionBuf::Fail(_) => (hop, no_outputs(), Some(sub_failed_frame_exec(script, request))), } } @@ -656,15 +772,28 @@ pub open spec fn keeps_rest(before: StateRecord, after: StateRecord) -> bool { &&& after.next_conn == before.next_conn } -/// `FetchStyle { request, url }` of renderer `r` ([`fetch_style`]). -pub fn fetch_style_exec(urls: &U, fetch: &F, s: StateRecord, r: &RendererRecord, request: u64, url: &[u8]) -> (out: ( +/// [`reply_failed`]: the failure frame of a sub-fetch of this kind, to `r`. +pub fn reply_failed_exec(r: &RendererRecord, script: bool, request: u64) -> (out: Vec) + ensures + outputs_view(out@) == reply_failed(r@, script, request), +{ + if script { + reply_exec(r, &Msg::ScriptFailed { request }) + } else { + reply_exec(r, &Msg::StyleFailed { request }) + } +} + +/// `FetchStyle { request, url }` (`script` false) or `FetchScript { request, +/// url }` (`script` true) of renderer `r` ([`fetch_sub`]). +pub fn fetch_sub_exec(urls: &U, fetch: &F, s: StateRecord, r: &RendererRecord, script: bool, request: u64, url: &[u8]) -> (out: ( StateRecord, Vec, )) requires subfetches_ok::(s.subfetches@), ensures - result_view(out) == fetch_style(crate::contract::psl(), urls.urls(), fetch.fetch(), s@, r@, request, url@), + result_view(out) == fetch_sub(crate::contract::psl(), urls.urls(), fetch.fetch(), s@, r@, script, request, url@), subfetches_ok::(out.0.subfetches@), keeps_rest(s, out.0), out.0.jar@ == s.jar@, @@ -673,27 +802,27 @@ pub fn fetch_style_exec(urls: &U, fetch: &F, s: let (serial, in_document) = subcount_of_exec(s.subcounts.as_slice(), r.id, &r.lock); let live = live_subfetches_exec(s.subfetches.as_slice(), r.id, &r.lock); if live >= 8 || in_document >= 64 || serial == 0xFFFF_FFFF_FFFF_FFFFu64 { - let outs = reply_exec(r, &Msg::StyleFailed { request }); + let outs = reply_failed_exec(r, script, request); return (s, outs); } let relative = match clazel_encoding::utf8::decode::decode_without_bom_or_fail(url) { Some(v) => v, None => { - let outs = reply_exec(r, &Msg::StyleFailed { request }); + let outs = reply_failed_exec(r, script, request); return (s, outs); }, }; let resolved = match urls.resolve(r.url.as_slice(), relative.as_slice()) { Some(v) => v, None => { - let outs = reply_exec(r, &Msg::StyleFailed { request }); + let outs = reply_failed_exec(r, script, request); return (s, outs); }, }; let parsed = match fetch.parse(resolved.as_slice()) { Some(p) => p, None => { - let outs = reply_exec(r, &Msg::StyleFailed { request }); + let outs = reply_failed_exec(r, script, request); return (s, outs); }, }; @@ -703,9 +832,9 @@ pub fn fetch_style_exec(urls: &U, fetch: &F, s: F::nav_ok_idle(&fs); reveal_with_fuel(clazel_fetch::transducer::contract::count_connects, 2); } - let (hop, out, end) = sub_actions_exec(r.id, serial, request, 0, actions); + let (hop, out, end) = sub_actions_exec(r.id, serial, request, script, 0, actions); proof { - lemma_sub_actions_hop(r.id as nat, serial as nat, request, 0, av); + lemma_sub_actions_hop(r.id as nat, serial as nat, request, script, 0, av); } let counts = set_subcount_exec(s.subcounts.as_slice(), r.id, &r.lock, serial.saturating_add(1), in_document.saturating_add(1)); let mut s = s; @@ -715,6 +844,7 @@ pub fn fetch_style_exec(urls: &U, fetch: &F, s: lock: r.lock@, serial: serial as nat, request, + script, tab: r.tab as nat, fetch: fs@, hop: 0, @@ -730,6 +860,7 @@ pub fn fetch_style_exec(urls: &U, fetch: &F, s: lock: clone_origin(&r.lock), serial, request, + script, tab: r.tab, fetch: fs, hop, @@ -879,9 +1010,9 @@ pub fn sub_net_exec(fetch: &F, s: StateRecord, renderer: u64, s } let ghost av = clazel_fetch::transducer::types::actions_view(actions@); proof { - lemma_sub_actions_hop(renderer as nat, serial as nat, f.request, hop as nat, av); + lemma_sub_actions_hop(renderer as nat, serial as nat, f.request, f.script, hop as nat, av); } - let (h2, out, end) = sub_actions_exec(renderer, serial, f.request, hop, actions); + let (h2, out, end) = sub_actions_exec(renderer, serial, f.request, f.script, hop, actions); match end { None => { let rec = SubFetchRecord { @@ -889,6 +1020,7 @@ pub fn sub_net_exec(fetch: &F, s: StateRecord, renderer: u64, s lock: f.lock, serial: f.serial, request: f.request, + script: f.script, tab: f.tab, fetch: fs, hop: h2, @@ -1005,7 +1137,7 @@ pub fn sweep_exec(rs: &[RendererRecord], now: u64, fs: Vec, urls }, clazel_ipc::message::spec::Message::CookieGet => {}, clazel_ipc::message::spec::Message::CookieSet { cookie_string } => {}, - clazel_ipc::message::spec::Message::FetchStyle { request, url } => { - crate::subfetch_rel::lemma_fetch_style_shape(rules, urls, fetch, s, r, request, url); + clazel_ipc::message::spec::Message::FetchStyle { .. } | clazel_ipc::message::spec::Message::FetchScript { .. } => { + crate::subfetch_rel::lemma_fetch_sub_shape(rules, urls, fetch, s, r, m is FetchScript, sub_request_id(m), sub_request_url(m)); }, _ => { crate::lock::lemma_storage_call_frame(s, r, m); diff --git a/crates/clazel-kernel/src/quark.rs b/crates/clazel-kernel/src/quark.rs index fe82a1daa..d54680300 100644 --- a/crates/clazel-kernel/src/quark.rs +++ b/crates/clazel-kernel/src/quark.rs @@ -390,9 +390,9 @@ pub proof fn quark_cookie_integrity(rules: Seq, urls: Ur } } }, - Some(clazel_ipc::message::spec::Message::FetchStyle { request, url }) => { + Some(m2) if is_sub_request(m2) => { if r.committed { - crate::subfetch_rel::lemma_fetch_style_shape(rules, urls, fetch, s, r, request, url); + crate::subfetch_rel::lemma_fetch_sub_shape(rules, urls, fetch, s, r, m2 is FetchScript, sub_request_id(m2), sub_request_url(m2)); } }, _ => {}, diff --git a/crates/clazel-kernel/src/spec.rs b/crates/clazel-kernel/src/spec.rs index 85b73156a..38159cbdf 100644 --- a/crates/clazel-kernel/src/spec.rs +++ b/crates/clazel-kernel/src/spec.rs @@ -2672,6 +2672,29 @@ pub open spec fn fetch_script(rules: Seq, urls: UrlFns, fetch_sub(rules, urls, fetch, s, r, true, request, url) } +/// The message asks for a sub-fetch: a `FetchStyle` or a `FetchScript`. +pub open spec fn is_sub_request(m: clazel_ipc::message::spec::Message) -> bool { + m is FetchStyle || m is FetchScript +} + +/// The `request` id of a sub-fetch request (0 for any other message). +pub open spec fn sub_request_id(m: clazel_ipc::message::spec::Message) -> u64 { + match m { + clazel_ipc::message::spec::Message::FetchStyle { request, .. } => request, + clazel_ipc::message::spec::Message::FetchScript { request, .. } => request, + _ => 0, + } +} + +/// The `url` of a sub-fetch request (empty for any other message). +pub open spec fn sub_request_url(m: clazel_ipc::message::spec::Message) -> Seq { + match m { + clazel_ipc::message::spec::Message::FetchStyle { url, .. } => url, + clazel_ipc::message::spec::Message::FetchScript { url, .. } => url, + _ => seq![], + } +} + /// Sub-fetch `f`'s renderer is live, committed and locked to its lock, and /// `f` has not ended: `f` belongs to the renderer's current document. pub open spec fn subfetch_live(s: State, f: SubFetch) -> bool { diff --git a/crates/clazel-kernel/src/subfetch_rel.rs b/crates/clazel-kernel/src/subfetch_rel.rs index 75f12652e..c0d9ac5e7 100644 --- a/crates/clazel-kernel/src/subfetch_rel.rs +++ b/crates/clazel-kernel/src/subfetch_rel.rs @@ -304,10 +304,10 @@ pub proof fn lemma_set_subcount_domain( // --------------------------------------------------------------------- /// The outputs of [`sub_actions`] are its sub-fetch's connection outputs. -pub proof fn lemma_sub_actions_outputs(id: nat, serial: nat, request: u64, hop: nat, actions: Seq) +pub proof fn lemma_sub_actions_outputs(id: nat, serial: nat, request: u64, script: bool, hop: nat, actions: Seq) ensures forall|k: int| - 0 <= k < sub_actions(id, serial, request, hop, actions).1.len() ==> match #[trigger] sub_actions(id, serial, request, hop, actions).1[k] { + 0 <= k < sub_actions(id, serial, request, script, hop, actions).1.len() ==> match #[trigger] sub_actions(id, serial, request, script, hop, actions).1[k] { Output::SubConnect { renderer, serial: y, .. } => renderer == id && y == serial, Output::SubSend { renderer, serial: y, .. } => renderer == id && y == serial, Output::SubClose { renderer, serial: y, .. } => renderer == id && y == serial, @@ -318,17 +318,18 @@ pub proof fn lemma_sub_actions_outputs(id: nat, serial: nat, request: u64, hop: if actions.len() > 0 { let rest = actions.drop_first(); match actions[0] { - clazel_fetch::transducer::spec::Action::Connect { .. } => lemma_sub_actions_outputs(id, serial, request, hop + 1, rest), + clazel_fetch::transducer::spec::Action::Connect { .. } => lemma_sub_actions_outputs(id, serial, request, script, hop + 1, rest), clazel_fetch::transducer::spec::Action::Send(_) | clazel_fetch::transducer::spec::Action::Close => lemma_sub_actions_outputs( id, serial, request, + script, hop, rest, ), _ => {}, } - let out = sub_actions(id, serial, request, hop, actions).1; + let out = sub_actions(id, serial, request, script, hop, actions).1; assert forall|k: int| 0 <= k < out.len() implies match #[trigger] out[k] { Output::SubConnect { renderer, serial: y, .. } => renderer == id && y == serial, Output::SubSend { renderer, serial: y, .. } => renderer == id && y == serial, @@ -338,12 +339,12 @@ pub proof fn lemma_sub_actions_outputs(id: nat, serial: nat, request: u64, hop: match actions[0] { clazel_fetch::transducer::spec::Action::Connect { .. } => { if k > 0 { - assert(out[k] == sub_actions(id, serial, request, hop + 1, rest).1[k - 1]); + assert(out[k] == sub_actions(id, serial, request, script, hop + 1, rest).1[k - 1]); } }, clazel_fetch::transducer::spec::Action::Send(_) | clazel_fetch::transducer::spec::Action::Close => { if k > 0 { - assert(out[k] == sub_actions(id, serial, request, hop, rest).1[k - 1]); + assert(out[k] == sub_actions(id, serial, request, script, hop, rest).1[k - 1]); } }, _ => {}, @@ -355,12 +356,12 @@ pub proof fn lemma_sub_actions_outputs(id: nat, serial: nat, request: u64, hop: /// Two action lists that differ only in the octets of their `Send`s give /// the same connection, the same end, and outputs that differ only in the /// octets of their `SubSend`s (none renderer-bound). -pub proof fn lemma_sub_actions_same_but_sends(id: nat, serial: nat, request: u64, hop: nat, a: Seq, b: Seq) +pub proof fn lemma_sub_actions_same_but_sends(id: nat, serial: nat, request: u64, script: bool, hop: nat, a: Seq, b: Seq) requires clazel_fetch::transducer::contract::same_but_sends(a, b), ensures - sub_actions(id, serial, request, hop, a).0 == sub_actions(id, serial, request, hop, b).0, - sub_actions(id, serial, request, hop, a).2 == sub_actions(id, serial, request, hop, b).2, + sub_actions(id, serial, request, script, hop, a).0 == sub_actions(id, serial, request, script, hop, b).0, + sub_actions(id, serial, request, script, hop, a).2 == sub_actions(id, serial, request, script, hop, b).2, decreases a.len(), { if a.len() > 0 { @@ -372,20 +373,20 @@ pub proof fn lemma_sub_actions_same_but_sends(id: nat, serial: nat, request: u64 } assert((a[0] is Send && b[0] is Send) || a[0] == b[0]); match a[0] { - clazel_fetch::transducer::spec::Action::Connect { .. } => lemma_sub_actions_same_but_sends(id, serial, request, hop + 1, ra, rb), - _ => lemma_sub_actions_same_but_sends(id, serial, request, hop, ra, rb), + clazel_fetch::transducer::spec::Action::Connect { .. } => lemma_sub_actions_same_but_sends(id, serial, request, script, hop + 1, ra, rb), + _ => lemma_sub_actions_same_but_sends(id, serial, request, script, hop, ra, rb), } } } /// Every renderer-bound output of a `SubNet` is the `ToRenderer` of its end. -pub proof fn lemma_renderer_outs_sub(out: Seq, id: nat, serial: nat, request: u64, hop: nat, actions: Seq) +pub proof fn lemma_renderer_outs_sub(out: Seq, id: nat, serial: nat, request: u64, script: bool, hop: nat, actions: Seq) requires - out == sub_actions(id, serial, request, hop, actions).1, + out == sub_actions(id, serial, request, script, hop, actions).1, ensures crate::noninterference::renderer_outs(out) == Seq::::empty(), { - lemma_sub_actions_outputs(id, serial, request, hop, actions); + lemma_sub_actions_outputs(id, serial, request, script, hop, actions); crate::unwind_base::lemma_filter_none(out, |o: Output| crate::noninterference::renderer_bound(o)); } @@ -539,8 +540,8 @@ pub proof fn lemma_subfetch_events_own_none(rules: Seq, if let Some(f) = subnet_target(s, renderer, serial) { if subfetch_live(s, f) && hop != 0 && f.hop == hop { let actions = clazel_fetch::transducer::spec::step(fetch.http, fetch.urls, f.fetch, input, subfetch_jar(fetch, s, f), s.now).1; - let (h, o, end) = sub_actions(renderer, serial, f.request, hop, actions); - lemma_sub_actions_outputs(renderer, serial, f.request, hop, actions); + let (h, o, end) = sub_actions(renderer, serial, f.request, f.script, hop, actions); + lemma_sub_actions_outputs(renderer, serial, f.request, f.script, hop, actions); assert forall|k: int| 0 <= k < out.len() implies !((#[trigger] out[k]) is Connect || out[k] is Send || out[k] is Close) by { if k < o.len() { assert(out[k] == o[k]); @@ -597,32 +598,32 @@ pub proof fn lemma_outputs_of_concat(a: Seq, b: Seq, x: nat) } /// [`sub_actions`]'s outputs are its renderer's. -pub proof fn lemma_sub_actions_of(id: nat, serial: nat, request: u64, hop: nat, actions: Seq) +pub proof fn lemma_sub_actions_of(id: nat, serial: nat, request: u64, script: bool, hop: nat, actions: Seq) ensures - outputs_of(sub_actions(id, serial, request, hop, actions).1, id), + outputs_of(sub_actions(id, serial, request, script, hop, actions).1, id), { - lemma_sub_actions_outputs(id, serial, request, hop, actions); + lemma_sub_actions_outputs(id, serial, request, script, hop, actions); } /// What a `FetchStyle` changes and sends: only the sub-fetch table and /// counts, and only to its sender. -pub proof fn lemma_fetch_style_shape(rules: Seq, urls: UrlFns, fetch: FetchFns, s: State, r: Renderer, request: u64, url: Seq) +pub proof fn lemma_fetch_sub_shape(rules: Seq, urls: UrlFns, fetch: FetchFns, s: State, r: Renderer, script: bool, request: u64, url: Seq) ensures ({ - let (s1, out) = fetch_style(rules, urls, fetch, s, r, request, url); + let (s1, out) = fetch_sub(rules, urls, fetch, s, r, script, request, url); &&& s1 == State { subfetches: s1.subfetches, subcounts: s1.subcounts, ..s } &&& outputs_of(out, r.id) }), { - let (s1, out) = fetch_style(rules, urls, fetch, s, r, request, url); - assert(outputs_of(reply(r, clazel_ipc::message::spec::Message::StyleFailed { request }), r.id)); + let (s1, out) = fetch_sub(rules, urls, fetch, s, r, script, request, url); + assert(outputs_of(reply_failed(r, script, request), r.id)); if let Some(relative) = clazel_encoding::utf8::spec::utf8_decode_without_bom_or_fail(url) { if let Some(resolved) = (urls.resolve)(r.url, relative) { if let Some(parsed) = (fetch.parse)(resolved) { let (serial, in_document) = subcount_of(s.subcounts, r.id, r.lock); let actions = clazel_fetch::transducer::spec::start(parsed).1; - let (hop, o, end) = sub_actions(r.id, serial, request, 0, actions); - lemma_sub_actions_of(r.id, serial, request, 0, actions); + let (hop, o, end) = sub_actions(r.id, serial, request, script, 0, actions); + lemma_sub_actions_of(r.id, serial, request, script, 0, actions); if let Some(frames) = end { lemma_outputs_of_concat(o, seq![Output::ToRenderer { id: r.id, bytes: frames }], r.id); } @@ -645,8 +646,8 @@ pub proof fn lemma_sub_net_shape(rules: Seq, fetch: Fetc if let Some(f) = subnet_target(s, renderer, serial) { if subfetch_live(s, f) && hop != 0 && f.hop == hop { let actions = clazel_fetch::transducer::spec::step(fetch.http, fetch.urls, f.fetch, input, subfetch_jar(fetch, s, f), s.now).1; - let (h, o, end) = sub_actions(renderer, serial, f.request, hop, actions); - lemma_sub_actions_of(renderer, serial, f.request, hop, actions); + let (h, o, end) = sub_actions(renderer, serial, f.request, f.script, hop, actions); + lemma_sub_actions_of(renderer, serial, f.request, f.script, hop, actions); if let Some(frames) = end { lemma_outputs_of_concat(o, seq![Output::ToRenderer { id: renderer, bytes: frames }], renderer); } @@ -661,7 +662,7 @@ pub open spec fn sweep_outputs_ok(s: State, fs: Seq, out: Seq) 0 <= k < out.len() ==> match #[trigger] out[k] { Output::SubClose { renderer, .. } => exists|j: int| 0 <= j < fs.len() && fs[j].renderer == renderer, Output::ToRenderer { id, bytes } => exists|j: int| - 0 <= j < fs.len() && fs[j].renderer == id && subfetch_live(s, fs[j]) && bytes == style_failed_frame(fs[j].request), + 0 <= j < fs.len() && fs[j].renderer == id && subfetch_live(s, fs[j]) && bytes == sub_failed_frame(fs[j].script, fs[j].request), _ => false, } } @@ -679,11 +680,11 @@ pub proof fn lemma_sweep_shape(s: State, fs: Seq) let (rest, o) = sweep(s, t); let out = sweep(s, fs).1; let close = if f.hop > 0 { seq![Output::SubClose { renderer: f.renderer, serial: f.serial, hop: f.hop }] } else { Seq::::empty() }; - let failed = seq![Output::ToRenderer { id: f.renderer, bytes: style_failed_frame(f.request) }]; + let failed = seq![Output::ToRenderer { id: f.renderer, bytes: sub_failed_frame(f.script, f.request) }]; assert forall|k: int| 0 <= k < out.len() implies match #[trigger] out[k] { Output::SubClose { renderer, .. } => exists|j: int| 0 <= j < fs.len() && fs[j].renderer == renderer, Output::ToRenderer { id, bytes } => exists|j: int| - 0 <= j < fs.len() && fs[j].renderer == id && subfetch_live(s, fs[j]) && bytes == style_failed_frame(fs[j].request), + 0 <= j < fs.len() && fs[j].renderer == id && subfetch_live(s, fs[j]) && bytes == sub_failed_frame(fs[j].script, fs[j].request), _ => false, } by { let pre = if !subfetch_live(s, f) { @@ -705,7 +706,7 @@ pub proof fn lemma_sweep_shape(s: State, fs: Seq) assert(fs[j + 1] == t[j]); }, Output::ToRenderer { id, bytes } => { - let j = choose|j: int| 0 <= j < t.len() && t[j].renderer == id && subfetch_live(s, t[j]) && bytes == style_failed_frame(t[j].request); + let j = choose|j: int| 0 <= j < t.len() && t[j].renderer == id && subfetch_live(s, t[j]) && bytes == sub_failed_frame(t[j].script, t[j].request); assert(fs[j + 1] == t[j]); }, _ => {}, @@ -742,7 +743,7 @@ pub open spec fn sub_net_after(rules: Seq, fetch: FetchF ) { let cred = credentialed(fetch, f.lock, f.fetch.url); let (fs, actions, ops) = clazel_fetch::transducer::spec::step(fetch.http, fetch.urls, f.fetch, input, subfetch_jar(fetch, s, f), s.now); - let (h, out, end) = sub_actions(renderer, serial, f.request, hop, actions); + let (h, out, end) = sub_actions(renderer, serial, f.request, f.script, hop, actions); (sub_finish(s.subfetches, SubFetch { fetch: fs, hop: h, ..f }, out, end).0, if cred { apply_net_ops(rules, s.jar, ops) } else { s.jar }) } @@ -805,11 +806,11 @@ pub proof fn lemma_d_subnet( clazel_fetch::transducer::theorems::theorem_ops_name_request(fetch.http, fetch.urls, f.fetch, input, ja, s1.now); let (fsa, aa, opsa) = clazel_fetch::transducer::spec::step(fetch.http, fetch.urls, f.fetch, input, ja, s1.now); let (fsb, ab, opsb) = clazel_fetch::transducer::spec::step(fetch.http, fetch.urls, f.fetch, input, jb, s2.now); - lemma_sub_actions_same_but_sends(renderer, serial, f.request, hop, aa, ab); - let (ha, outa, enda) = sub_actions(renderer, serial, f.request, hop, aa); - let (hb, outb, endb) = sub_actions(renderer, serial, f.request, hop, ab); - lemma_renderer_outs_sub(outa, renderer, serial, f.request, hop, aa); - lemma_renderer_outs_sub(outb, renderer, serial, f.request, hop, ab); + lemma_sub_actions_same_but_sends(renderer, serial, f.request, f.script, hop, aa, ab); + let (ha, outa, enda) = sub_actions(renderer, serial, f.request, f.script, hop, aa); + let (hb, outb, endb) = sub_actions(renderer, serial, f.request, f.script, hop, ab); + lemma_renderer_outs_sub(outa, renderer, serial, f.request, f.script, hop, aa); + lemma_renderer_outs_sub(outb, renderer, serial, f.request, f.script, hop, ab); let g = SubFetch { fetch: fsa, hop: ha, ..f }; if let Some(frames) = enda { crate::net_rel::lemma_renderer_outs_concat(outa, seq![Output::ToRenderer { id: renderer, bytes: frames }]); @@ -930,8 +931,8 @@ pub proof fn lemma_local_respect_subnet(rules: Seq, urls crate::invariant::lemma_step_preserves_wf(rules, urls, fetch, s1, e); let ja = subfetch_jar(fetch, s1, f); let (fsa, aa, opsa) = clazel_fetch::transducer::spec::step(fetch.http, fetch.urls, f.fetch, input, ja, s1.now); - let (ha, outa, enda) = sub_actions(renderer, serial, f.request, hop, aa); - lemma_sub_actions_outputs(renderer, serial, f.request, hop, aa); + let (ha, outa, enda) = sub_actions(renderer, serial, f.request, f.script, hop, aa); + lemma_sub_actions_outputs(renderer, serial, f.request, f.script, hop, aa); // `f` is `r`'s: its lock is `r`'s, of `d2`. crate::invariant::lemma_find_by_id(s1.renderers, renderer, 0); assert(f.lock == r.lock); @@ -1005,7 +1006,7 @@ pub proof fn lemma_live_domain(rules: Seq, fs: Seq, urls: UrlFns, fetch: FetchFns, @@ -1013,6 +1014,7 @@ pub proof fn lemma_fetch_style_domain( s1: State, s2: State, r: Renderer, + script: bool, request: u64, url: Seq, ) @@ -1022,11 +1024,11 @@ pub proof fn lemma_fetch_style_domain( crate::domain::subcounts_of_domain(rules, s1.subcounts, d) == crate::domain::subcounts_of_domain(rules, s2.subcounts, d), s1.now == s2.now, ensures - fetch_style(rules, urls, fetch, s1, r, request, url).1 == fetch_style(rules, urls, fetch, s2, r, request, url).1, - crate::domain::subfetches_of_domain(rules, fetch_style(rules, urls, fetch, s1, r, request, url).0.subfetches, d) - == crate::domain::subfetches_of_domain(rules, fetch_style(rules, urls, fetch, s2, r, request, url).0.subfetches, d), - crate::domain::subcounts_of_domain(rules, fetch_style(rules, urls, fetch, s1, r, request, url).0.subcounts, d) - == crate::domain::subcounts_of_domain(rules, fetch_style(rules, urls, fetch, s2, r, request, url).0.subcounts, d), + fetch_sub(rules, urls, fetch, s1, r, script, request, url).1 == fetch_sub(rules, urls, fetch, s2, r, script, request, url).1, + crate::domain::subfetches_of_domain(rules, fetch_sub(rules, urls, fetch, s1, r, script, request, url).0.subfetches, d) + == crate::domain::subfetches_of_domain(rules, fetch_sub(rules, urls, fetch, s2, r, script, request, url).0.subfetches, d), + crate::domain::subcounts_of_domain(rules, fetch_sub(rules, urls, fetch, s1, r, script, request, url).0.subcounts, d) + == crate::domain::subcounts_of_domain(rules, fetch_sub(rules, urls, fetch, s2, r, script, request, url).0.subcounts, d), { lemma_live_domain(rules, s1.subfetches, r.id, r.lock, d); lemma_live_domain(rules, s2.subfetches, r.id, r.lock, d); @@ -1038,12 +1040,13 @@ pub proof fn lemma_fetch_style_domain( if let Some(resolved) = (urls.resolve)(r.url, relative) { if let Some(parsed) = (fetch.parse)(resolved) { let (fs, actions) = clazel_fetch::transducer::spec::start(parsed); - let (hop, o, end) = sub_actions(r.id, serial, request, 0, actions); + let (hop, o, end) = sub_actions(r.id, serial, request, script, 0, actions); let f = SubFetch { renderer: r.id, lock: r.lock, serial, request, + script, tab: r.tab, fetch: fs, hop, @@ -1060,13 +1063,13 @@ pub proof fn lemma_fetch_style_domain( /// A `FetchStyle` of a renderer of another domain leaves `d`'s tables as /// they are. -pub proof fn lemma_fetch_style_other(rules: Seq, urls: UrlFns, fetch: FetchFns, d: crate::domain::Domain, s: State, r: Renderer, request: u64, url: Seq) +pub proof fn lemma_fetch_sub_other(rules: Seq, urls: UrlFns, fetch: FetchFns, d: crate::domain::Domain, s: State, r: Renderer, script: bool, request: u64, url: Seq) requires crate::domain::domain_of_renderer(rules, r) != d, ensures - crate::domain::subfetches_of_domain(rules, fetch_style(rules, urls, fetch, s, r, request, url).0.subfetches, d) + crate::domain::subfetches_of_domain(rules, fetch_sub(rules, urls, fetch, s, r, script, request, url).0.subfetches, d) == crate::domain::subfetches_of_domain(rules, s.subfetches, d), - crate::domain::subcounts_of_domain(rules, fetch_style(rules, urls, fetch, s, r, request, url).0.subcounts, d) + crate::domain::subcounts_of_domain(rules, fetch_sub(rules, urls, fetch, s, r, script, request, url).0.subcounts, d) == crate::domain::subcounts_of_domain(rules, s.subcounts, d), { let (serial, in_document) = subcount_of(s.subcounts, r.id, r.lock); @@ -1075,12 +1078,13 @@ pub proof fn lemma_fetch_style_other(rules: Seq, urls: U if let Some(resolved) = (urls.resolve)(r.url, relative) { if let Some(parsed) = (fetch.parse)(resolved) { let (fs, actions) = clazel_fetch::transducer::spec::start(parsed); - let (hop, o, end) = sub_actions(r.id, serial, request, 0, actions); + let (hop, o, end) = sub_actions(r.id, serial, request, script, 0, actions); let f = SubFetch { renderer: r.id, lock: r.lock, serial, request, + script, tab: r.tab, fetch: fs, hop, @@ -1173,7 +1177,7 @@ pub open spec fn d_failures(rules: Seq, s: State, fs: Se } else { let f = fs[0]; (if crate::domain::domain_of_lock(rules, f.lock) == d && subfetch_live(s, f) && s.now >= f.started + subfetch_timeout() { - seq![Output::ToRenderer { id: f.renderer, bytes: style_failed_frame(f.request) }] + seq![Output::ToRenderer { id: f.renderer, bytes: sub_failed_frame(f.script, f.request) }] } else { seq![] }) + d_failures(rules, s, fs.drop_first(), d) @@ -1241,7 +1245,7 @@ pub proof fn lemma_sweep_outputs_for(rules: Seq, urls: U lemma_sweep_outputs_for(rules, urls, d, s, sb, t, rest); let o = sweep(t, rest).1; let close = if f.hop > 0 { seq![Output::SubClose { renderer: f.renderer, serial: f.serial, hop: f.hop }] } else { Seq::::empty() }; - let failed = seq![Output::ToRenderer { id: f.renderer, bytes: style_failed_frame(f.request) }]; + let failed = seq![Output::ToRenderer { id: f.renderer, bytes: sub_failed_frame(f.script, f.request) }]; let pre = if !subfetch_live(t, f) { close } else if t.now >= f.started + subfetch_timeout() { diff --git a/crates/clazel-kernel/src/subfetch_theorems.rs b/crates/clazel-kernel/src/subfetch_theorems.rs index 893c18768..b0c03f3a8 100644 --- a/crates/clazel-kernel/src/subfetch_theorems.rs +++ b/crates/clazel-kernel/src/subfetch_theorems.rs @@ -51,10 +51,11 @@ pub open spec fn tables_kept(s: State, s1: State) -> bool { table_kept(s.subfetches, s1.subfetches) && counts_kept(s.subcounts, s1.subcounts) } -/// The event is a `FetchStyle` the kernel accepts from a live renderer. -pub open spec fn is_fetch_style(s: State, e: Event) -> bool { +/// The event is a `FetchStyle` or `FetchScript` the kernel accepts from a +/// live renderer. +pub open spec fn is_sub_fetch_request(s: State, e: Event) -> bool { e matches Event::FromRenderer { id, bytes } && find_by_id(s.renderers, id, 0) matches Some(i) && accepted_message(s.renderers[i], bytes) matches Some(m) - && m is FetchStyle + && is_sub_request(m) } /// [`sub_free`] of a concatenation. @@ -212,7 +213,7 @@ pub proof fn lemma_begin_tables(rules: Seq, urls: UrlFns #[verifier::spinoff_prover] pub proof fn lemma_from_renderer_tables(rules: Seq, urls: UrlFns, fetch: FetchFns, s: State, id: nat, bytes: Seq) requires - !is_fetch_style(s, Event::FromRenderer { id, bytes }), + !is_sub_fetch_request(s, Event::FromRenderer { id, bytes }), ensures tables_kept(s, from_renderer(rules, urls, fetch, s, id, bytes).0), sub_free(from_renderer(rules, urls, fetch, s, id, bytes).1), @@ -237,7 +238,7 @@ pub proof fn lemma_from_renderer_tables(rules: Seq, urls #[verifier::spinoff_prover] pub proof fn lemma_handle_message_tables(rules: Seq, urls: UrlFns, fetch: FetchFns, s: State, r: Renderer, m: clazel_ipc::message::spec::Message) requires - !(m is FetchStyle), + !is_sub_request(m), ensures tables_kept(s, handle_message(rules, urls, fetch, s, r, m).0), sub_free(handle_message(rules, urls, fetch, s, r, m).1), @@ -322,7 +323,7 @@ pub proof fn lemma_net_tables(rules: Seq, urls: UrlFns, #[verifier::spinoff_prover] pub proof fn lemma_step_tables(rules: Seq, urls: UrlFns, fetch: FetchFns, s: State, e: Event) requires - !(e is SubNet || e is Tick || is_fetch_style(s, e)), + !(e is SubNet || e is Tick || is_sub_fetch_request(s, e)), ensures tables_kept(s, step(rules, urls, fetch, s, e).0), sub_free(step(rules, urls, fetch, s, e).1), @@ -804,7 +805,7 @@ pub proof fn lemma_sub_net_tables(rules: Seq, fetch: Fet if let Some(f) = subnet_target(s, renderer, serial) { if subfetch_live(s, f) && hop != 0 && f.hop == hop { let (fsa, actions, ops) = clazel_fetch::transducer::spec::step(fetch.http, fetch.urls, f.fetch, input, subfetch_jar(fetch, s, f), s.now); - let (h, out, end) = sub_actions(renderer, serial, f.request, hop, actions); + let (h, out, end) = sub_actions(renderer, serial, f.request, f.script, hop, actions); let g = SubFetch { fetch: fsa, hop: h, ..f }; if end is Some { lemma_drop_table(s.subfetches, g, id, lock); @@ -861,12 +862,13 @@ pub proof fn lemma_subnet_key_facts(s: State, renderer: nat, serial: nat) } /// What a `FetchStyle` does to the tables. -pub proof fn lemma_fetch_style_tables( +pub proof fn lemma_fetch_sub_tables( rules: Seq, urls: UrlFns, fetch: FetchFns, s: State, r: Renderer, + script: bool, request: u64, url: Seq, id: nat, @@ -874,7 +876,7 @@ pub proof fn lemma_fetch_style_tables( ) ensures ({ - let s1 = fetch_style(rules, urls, fetch, s, r, request, url).0; + let s1 = fetch_sub(rules, urls, fetch, s, r, script, request, url).0; let (serial, in_document) = subcount_of(s.subcounts, r.id, r.lock); &&& s1 == s || { &&& serial < max_subfetch_serial() @@ -898,15 +900,17 @@ pub proof fn lemma_step_tables_wf(rules: Seq, urls: UrlF subfetch_tables_wf(step(rules, urls, fetch, s, e).0), { let s1 = step(rules, urls, fetch, s, e).0; - if is_fetch_style(s, e) { + if is_sub_fetch_request(s, e) { let id = e->FromRenderer_id; let i = find_by_id(s.renderers, id, 0)->Some_0; let r = s.renderers[i]; let m = accepted_message(r, e->FromRenderer_bytes)->Some_0; - let request = m->FetchStyle_request; - let url = m->FetchStyle_url; - assert(s1 == fetch_style(rules, urls, fetch, s, r, request, url).0); - lemma_fetch_style_tables(rules, urls, fetch, s, r, request, url, r.id, r.lock); + let request = sub_request_id(m); + let url = sub_request_url(m); + let script = m is FetchScript; + let script = m is FetchScript; + assert(s1 == fetch_sub(rules, urls, fetch, s, r, script, request, url).0); + lemma_fetch_sub_tables(rules, urls, fetch, s, r, script, request, url, r.id, r.lock); if s1 != s { let (serial, in_document) = subcount_of(s.subcounts, r.id, r.lock); assert forall|j: int| 0 <= j < s1.subfetches.len() implies (#[trigger] s1.subfetches[j]).serial < subcount_of( @@ -1022,21 +1026,21 @@ pub proof fn lemma_reachable_tables_wf(rules: Seq, urls: /// The frames a sub-fetch's actions end with are `StyleFailed`, or a sheet's /// `StyleResponse`, `StyleBody` and `StyleEnd`. -pub proof fn lemma_sub_actions_end(id: nat, serial: nat, request: u64, hop: nat, actions: Seq) +pub proof fn lemma_sub_actions_end(id: nat, serial: nat, request: u64, script: bool, hop: nat, actions: Seq) ensures - sub_actions(id, serial, request, hop, actions).2 matches Some(x) ==> (x == style_failed_frame(request) || exists|doc: Document| - x == #[trigger] style_frames(request, doc)), + sub_actions(id, serial, request, script, hop, actions).2 matches Some(x) ==> (x == sub_failed_frame(script, request) || exists|doc: Document| + x == #[trigger] sub_frames(script, request, doc)), decreases actions.len(), { if actions.len() > 0 { let rest = actions.drop_first(); match actions[0] { - clazel_fetch::transducer::spec::Action::Connect { .. } => lemma_sub_actions_end(id, serial, request, hop + 1, rest), - clazel_fetch::transducer::spec::Action::Send(_) => lemma_sub_actions_end(id, serial, request, hop, rest), - clazel_fetch::transducer::spec::Action::Close => lemma_sub_actions_end(id, serial, request, hop, rest), + clazel_fetch::transducer::spec::Action::Connect { .. } => lemma_sub_actions_end(id, serial, request, script, hop + 1, rest), + clazel_fetch::transducer::spec::Action::Send(_) => lemma_sub_actions_end(id, serial, request, script, hop, rest), + clazel_fetch::transducer::spec::Action::Close => lemma_sub_actions_end(id, serial, request, script, hop, rest), clazel_fetch::transducer::spec::Action::Done { url, response } => { let doc = response_document(response); - assert(sub_actions(id, serial, request, hop, actions).2 == Some(style_frames(request, doc))); + assert(sub_actions(id, serial, request, script, hop, actions).2 == Some(sub_frames(script, request, doc))); }, clazel_fetch::transducer::spec::Action::Fail(_) => {}, } @@ -1044,11 +1048,11 @@ pub proof fn lemma_sub_actions_end(id: nat, serial: nat, request: u64, hop: nat, } /// Actions with no `Send` give no `SubSend`. -pub proof fn lemma_sub_actions_no_send(id: nat, serial: nat, request: u64, hop: nat, actions: Seq) +pub proof fn lemma_sub_actions_no_send(id: nat, serial: nat, request: u64, script: bool, hop: nat, actions: Seq) requires clazel_fetch::transducer::theorems::no_sends(actions), ensures - forall|k: int| 0 <= k < sub_actions(id, serial, request, hop, actions).1.len() ==> !((#[trigger] sub_actions(id, serial, request, hop, actions).1[k]) is SubSend), + forall|k: int| 0 <= k < sub_actions(id, serial, request, script, hop, actions).1.len() ==> !((#[trigger] sub_actions(id, serial, request, script, hop, actions).1[k]) is SubSend), decreases actions.len(), { if actions.len() > 0 { @@ -1060,8 +1064,8 @@ pub proof fn lemma_sub_actions_no_send(id: nat, serial: nat, request: u64, hop: } assert(!(actions[0] is Send)); match actions[0] { - clazel_fetch::transducer::spec::Action::Connect { .. } => lemma_sub_actions_no_send(id, serial, request, hop + 1, rest), - clazel_fetch::transducer::spec::Action::Close => lemma_sub_actions_no_send(id, serial, request, hop, rest), + clazel_fetch::transducer::spec::Action::Connect { .. } => lemma_sub_actions_no_send(id, serial, request, script, hop + 1, rest), + clazel_fetch::transducer::spec::Action::Close => lemma_sub_actions_no_send(id, serial, request, script, hop, rest), _ => {}, } } @@ -1069,12 +1073,12 @@ pub proof fn lemma_sub_actions_no_send(id: nat, serial: nat, request: u64, hop: /// A `FetchStyle` sends nothing on a sub-fetch connection: the transducer's /// `start` only asks for a connection, or fails. -pub proof fn lemma_fetch_style_no_send(rules: Seq, urls: UrlFns, fetch: FetchFns, s: State, r: Renderer, request: u64, url: Seq) +pub proof fn lemma_fetch_sub_no_send(rules: Seq, urls: UrlFns, fetch: FetchFns, s: State, r: Renderer, script: bool, request: u64, url: Seq) ensures forall|k: int| - 0 <= k < fetch_style(rules, urls, fetch, s, r, request, url).1.len() ==> !((#[trigger] fetch_style(rules, urls, fetch, s, r, request, url).1[k]) is SubSend), + 0 <= k < fetch_sub(rules, urls, fetch, s, r, script, request, url).1.len() ==> !((#[trigger] fetch_sub(rules, urls, fetch, s, r, script, request, url).1[k]) is SubSend), { - let out = fetch_style(rules, urls, fetch, s, r, request, url).1; + let out = fetch_sub(rules, urls, fetch, s, r, script, request, url).1; let (serial, in_document) = subcount_of(s.subcounts, r.id, r.lock); if !(live_subfetches(s.subfetches, r.id, r.lock) >= max_subfetches_at_once() || in_document >= max_subfetches_per_document() || serial >= max_subfetch_serial()) { @@ -1086,8 +1090,8 @@ pub proof fn lemma_fetch_style_no_send(rules: Seq, urls: reveal_with_fuel(clazel_fetch::transducer::spec::begin, 1); assert(actions.len() == 1); } - lemma_sub_actions_no_send(r.id, serial, request, 0, actions); - let o = sub_actions(r.id, serial, request, 0, actions).1; + lemma_sub_actions_no_send(r.id, serial, request, script, 0, actions); + let o = sub_actions(r.id, serial, request, script, 0, actions).1; assert forall|k: int| 0 <= k < out.len() implies !((#[trigger] out[k]) is SubSend) by { if k < o.len() { assert(out[k] == o[k]); @@ -1115,14 +1119,14 @@ pub proof fn theorem_subfetch_only_to_requester(rules: SeqToRenderer_id == renderer &&& subfetch_live(s, f) - &&& (out[k]->ToRenderer_bytes == style_failed_frame(f.request) || exists|doc: Document| - out[k]->ToRenderer_bytes == #[trigger] style_frames(f.request, doc)) + &&& (out[k]->ToRenderer_bytes == sub_failed_frame(f.script, f.request) || exists|doc: Document| + out[k]->ToRenderer_bytes == #[trigger] sub_frames(f.script, f.request, doc)) } by { if k < o.len() { assert(out[k] == o[k]); @@ -1135,7 +1139,7 @@ pub proof fn theorem_subfetch_only_to_requester(rules: SeqToRenderer_id && subfetch_live(tick(s, time).0, s.subfetches[j]) - && out[k]->ToRenderer_bytes == style_failed_frame(s.subfetches[j].request) by { + && out[k]->ToRenderer_bytes == sub_failed_frame(s.subfetches[j].script, s.subfetches[j].request) by { match out[k] { Output::ToRenderer { .. } => {}, _ => {}, @@ -1159,11 +1163,11 @@ pub proof fn lemma_credentials_subnet(rules: Seq, urls: if subfetch_live(s, f) && hop != 0 && f.hop == hop { let jar = subfetch_jar(fetch, s, f); let (fsa, actions, ops) = clazel_fetch::transducer::spec::step(fetch.http, fetch.urls, f.fetch, input, jar, s.now); - let (h, o, end) = sub_actions(renderer, serial, f.request, hop, actions); + let (h, o, end) = sub_actions(renderer, serial, f.request, f.script, hop, actions); clazel_fetch::transducer::theorems::lemma_sends_only_on_connected(fetch.http, fetch.urls, f.fetch, input, jar, s.now); clazel_fetch::transducer::theorems::theorem_wire_cookies(fetch.http, fetch.urls, f.fetch, input, jar, s.now); if clazel_fetch::transducer::theorems::no_sends(actions) { - lemma_sub_actions_no_send(renderer, serial, f.request, hop, actions); + lemma_sub_actions_no_send(renderer, serial, f.request, f.script, hop, actions); assert forall|k: int| 0 <= k < out.len() implies !((#[trigger] out[k]) is SubSend) by { if k < o.len() { assert(out[k] == o[k]); @@ -1173,7 +1177,7 @@ pub proof fn lemma_credentials_subnet(rules: Seq, urls: let bytes = actions[0]->Send_0; assert(actions == seq![clazel_fetch::transducer::spec::Action::Send(bytes)]); assert(actions.drop_first() =~= Seq::::empty()); - assert(sub_actions(renderer, serial, f.request, hop, Seq::::empty()) == (hop, Seq::::empty(), None::>)); + assert(sub_actions(renderer, serial, f.request, f.script, hop, Seq::::empty()) == (hop, Seq::::empty(), None::>)); assert(seq![Output::SubSend { renderer, serial, hop, bytes }] + Seq::::empty() =~= seq![Output::SubSend { renderer, serial, hop, bytes }]); assert(o == seq![Output::SubSend { renderer, serial, hop, bytes }]); assert(end is None); @@ -1190,12 +1194,12 @@ pub proof fn theorem_subfetch_credentials(rules: Seq, ur crate::statements::subfetch_credentials_statement(rules, urls, fetch, s, e), { let out = step(rules, urls, fetch, s, e).1; - if is_fetch_style(s, e) { + if is_sub_fetch_request(s, e) { let i = find_by_id(s.renderers, e->FromRenderer_id, 0)->Some_0; let r = s.renderers[i]; let m = accepted_message(r, e->FromRenderer_bytes)->Some_0; - assert(out == fetch_style(rules, urls, fetch, s, r, m->FetchStyle_request, m->FetchStyle_url).1); - lemma_fetch_style_no_send(rules, urls, fetch, s, r, m->FetchStyle_request, m->FetchStyle_url); + assert(out == fetch_sub(rules, urls, fetch, s, r, m is FetchScript, sub_request_id(m), sub_request_url(m)).1); + lemma_fetch_sub_no_send(rules, urls, fetch, s, r, m is FetchScript, sub_request_id(m), sub_request_url(m)); } else { match e { Event::SubNet { renderer, serial, hop, input } => { @@ -1226,8 +1230,8 @@ pub proof fn theorem_subfetch_ownership(rules: Seq, urls crate::statements::subfetch_ownership_statement(rules, urls, fetch, s, e), { lemma_reachable_tables_wf(rules, urls, fetch, s); - if is_fetch_style(s, e) { - lemma_ownership_fetch_style(rules, urls, fetch, s, e); + if is_sub_fetch_request(s, e) { + lemma_ownership_sub_request(rules, urls, fetch, s, e); } else { lemma_ownership_other(rules, urls, fetch, s, e); } @@ -1235,10 +1239,10 @@ pub proof fn theorem_subfetch_ownership(rules: Seq, urls /// [`theorem_subfetch_ownership`] for an accepted `FetchStyle`. #[verifier::spinoff_prover] -pub proof fn lemma_ownership_fetch_style(rules: Seq, urls: UrlFns, fetch: FetchFns, s: State, e: Event) +pub proof fn lemma_ownership_sub_request(rules: Seq, urls: UrlFns, fetch: FetchFns, s: State, e: Event) requires subfetch_tables_wf(s), - is_fetch_style(s, e), + is_sub_fetch_request(s, e), ensures crate::statements::subfetch_ownership_statement(rules, urls, fetch, s, e), { @@ -1248,11 +1252,12 @@ pub proof fn lemma_ownership_fetch_style(rules: Seq, url let i = find_by_id(s.renderers, id, 0)->Some_0; let r = s.renderers[i]; let m = accepted_message(r, e->FromRenderer_bytes)->Some_0; - let request = m->FetchStyle_request; - let url = m->FetchStyle_url; - assert((s1, out) == fetch_style(rules, urls, fetch, s, r, request, url)); - crate::subfetch_rel::lemma_fetch_style_shape(rules, urls, fetch, s, r, request, url); - lemma_fetch_style_tables(rules, urls, fetch, s, r, request, url, r.id, r.lock); + let request = sub_request_id(m); + let url = sub_request_url(m); + let script = m is FetchScript; + assert((s1, out) == fetch_sub(rules, urls, fetch, s, r, script, request, url)); + crate::subfetch_rel::lemma_fetch_sub_shape(rules, urls, fetch, s, r, script, request, url); + lemma_fetch_sub_tables(rules, urls, fetch, s, r, script, request, url, r.id, r.lock); assert forall|k: int| 0 <= k < out.len() && ((#[trigger] out[k]) is SubConnect || out[k] is SubSend || out[k] is SubClose) implies crate::domain::output_id(out[k]) == id by { match out[k] { Output::SubConnect { .. } => {}, @@ -1295,7 +1300,7 @@ pub proof fn lemma_ownership_fetch_style(rules: Seq, url pub proof fn lemma_ownership_other(rules: Seq, urls: UrlFns, fetch: FetchFns, s: State, e: Event) requires subfetch_tables_wf(s), - !is_fetch_style(s, e), + !is_sub_fetch_request(s, e), ensures crate::statements::subfetch_ownership_statement(rules, urls, fetch, s, e), { @@ -1356,14 +1361,16 @@ pub proof fn theorem_subfetch_limits( { lemma_reachable_tables_wf(rules, urls, fetch, s); let s1 = step(rules, urls, fetch, s, e).0; - if is_fetch_style(s, e) { + if is_sub_fetch_request(s, e) { let i = find_by_id(s.renderers, e->FromRenderer_id, 0)->Some_0; let r = s.renderers[i]; let m = accepted_message(r, e->FromRenderer_bytes)->Some_0; - let request = m->FetchStyle_request; - let url = m->FetchStyle_url; - assert(s1 == fetch_style(rules, urls, fetch, s, r, request, url).0); - lemma_fetch_style_tables(rules, urls, fetch, s, r, request, url, id, lock); + let request = sub_request_id(m); + let url = sub_request_url(m); + let script = m is FetchScript; + let script = m is FetchScript; + assert(s1 == fetch_sub(rules, urls, fetch, s, r, script, request, url).0); + lemma_fetch_sub_tables(rules, urls, fetch, s, r, script, request, url, id, lock); if s1 != s { let (serial, in_document) = subcount_of(s.subcounts, r.id, r.lock); lemma_subcount_set(s.subcounts, r.id, r.lock, serial + 1, in_document + 1, id, lock); @@ -1430,4 +1437,147 @@ pub proof fn theorem_commit_ends_subfetches(urls: UrlFns, s: State, tab: nat, ur } } +// --------------------------------------------------------------------- +// Script fetches (phase-7.md item 7.16). +// --------------------------------------------------------------------- + +/// The transducer's `start` gives one action, a `Connect` or a `Fail`. +pub proof fn lemma_start_actions(parsed: clazel_url::url::spec::Url) + ensures + clazel_fetch::transducer::spec::start(parsed).1.len() == 1, + clazel_fetch::transducer::spec::start(parsed).1[0] is Connect || clazel_fetch::transducer::spec::start(parsed).1[0] is Fail, +{ + reveal_with_fuel(clazel_fetch::transducer::spec::begin, 1); +} + +/// What a `FetchScript` of renderer `r` does ([`script_fetch_shape_statement`], +/// for the sender `r`). +pub proof fn lemma_script_fetch_shape_of(rules: Seq, urls: UrlFns, fetch: FetchFns, s: State, r: Renderer, request: u64, url: Seq) + ensures + ({ + let (s1, out) = fetch_script(rules, urls, fetch, s, r, request, url); + &&& s1 == State { subfetches: s1.subfetches, subcounts: s1.subcounts, ..s } + &&& (s1.subfetches == s.subfetches || exists|f: SubFetch| + s1.subfetches == s.subfetches.push(f) && crate::statements::script_fetch_started(rules, urls, fetch, s, r, request, url, f)) + &&& forall|k: int| + 0 <= k < out.len() ==> match #[trigger] out[k] { + Output::ToRenderer { id: x, bytes: b } => x == r.id && (b == script_failed_frame(request) || exists|doc: Document| b == #[trigger] script_frames(request, doc)), + Output::SubConnect { renderer: x, .. } => x == r.id, + _ => false, + } + }), +{ + crate::subfetch_rel::lemma_fetch_sub_shape(rules, urls, fetch, s, r, true, request, url); + lemma_fetch_sub_no_send(rules, urls, fetch, s, r, true, request, url); + let (s1, out) = fetch_sub(rules, urls, fetch, s, r, true, request, url); + let (serial, in_document) = subcount_of(s.subcounts, r.id, r.lock); + assert(fetch_script(rules, urls, fetch, s, r, request, url) == (s1, out)); + if live_subfetches(s.subfetches, r.id, r.lock) >= max_subfetches_at_once() || in_document >= max_subfetches_per_document() || serial >= max_subfetch_serial() { + assert(out == reply_failed(r, true, request)); + assert(out[0] == Output::ToRenderer { id: r.id, bytes: script_failed_frame(request) }); + } else { + match clazel_encoding::utf8::spec::utf8_decode_without_bom_or_fail(url) { + None => { + assert(out[0] == Output::ToRenderer { id: r.id, bytes: script_failed_frame(request) }); + }, + Some(relative) => match (urls.resolve)(r.url, relative) { + None => { + assert(out[0] == Output::ToRenderer { id: r.id, bytes: script_failed_frame(request) }); + }, + Some(resolved) => match (fetch.parse)(resolved) { + None => { + assert(out[0] == Output::ToRenderer { id: r.id, bytes: script_failed_frame(request) }); + }, + Some(parsed) => { + let (fs, actions) = clazel_fetch::transducer::spec::start(parsed); + lemma_start_actions(parsed); + let (hop, o, end) = sub_actions(r.id, serial, request, true, 0, actions); + crate::subfetch_rel::lemma_sub_actions_outputs(r.id, serial, request, true, 0, actions); + lemma_sub_actions_no_send(r.id, serial, request, true, 0, actions); + lemma_sub_actions_end(r.id, serial, request, true, 0, actions); + // `actions` is a single `Connect` or `Fail`: no `Close`. + let rest = actions.drop_first(); + assert(rest.len() == 0); + reveal_with_fuel(sub_actions, 2); + assert(sub_actions(r.id, serial, request, true, 0, rest) == (0nat, Seq::::empty(), None::>)); + assert(sub_actions(r.id, serial, request, true, 1, rest) == (1nat, Seq::::empty(), None::>)); + assert forall|k: int| 0 <= k < o.len() implies (#[trigger] o[k]) is SubConnect by { + match actions[0] { + clazel_fetch::transducer::spec::Action::Connect { host, port, tls } => { + assert(o =~= seq![Output::SubConnect { renderer: r.id, serial, hop: 1, host, port, tls }]); + }, + _ => { + assert(o =~= Seq::::empty()); + }, + } + } + let f = SubFetch { + renderer: r.id, + lock: r.lock, + serial, + request, + script: true, + tab: r.tab, + fetch: fs, + hop: 0, + started: s.now, + partition: crate::domain::domain_of_renderer(rules, r), + ended: false, + }; + match end { + None => { + let g = SubFetch { hop, ..f }; + assert(s1.subfetches == s.subfetches.push(g)); + assert(crate::statements::script_fetch_started(rules, urls, fetch, s, r, request, url, g)) by { + assert(clazel_encoding::utf8::spec::utf8_decode_without_bom_or_fail(url) == Some(relative)); + assert((urls.resolve)(r.url, relative) == Some(resolved)); + assert((fetch.parse)(resolved) == Some(parsed)); + assert(g.fetch == clazel_fetch::transducer::spec::start(parsed).0); + } + assert forall|k: int| 0 <= k < out.len() implies match #[trigger] out[k] { + Output::ToRenderer { id: x, bytes: b } => x == r.id && (b == script_failed_frame(request) || exists|doc: Document| b == #[trigger] script_frames(request, doc)), + Output::SubConnect { renderer: x, .. } => x == r.id, + _ => false, + } by { + assert(out[k] == o[k]); + } + }, + Some(frames) => { + assert(out == o + seq![Output::ToRenderer { id: r.id, bytes: frames }]); + assert forall|k: int| 0 <= k < out.len() implies match #[trigger] out[k] { + Output::ToRenderer { id: x, bytes: b } => x == r.id && (b == script_failed_frame(request) || exists|doc: Document| b == #[trigger] script_frames(request, doc)), + Output::SubConnect { renderer: x, .. } => x == r.id, + _ => false, + } by { + if k < o.len() { + assert(out[k] == o[k]); + } else { + assert(out[k] == Output::ToRenderer { id: r.id, bytes: frames }); + assert(frames == sub_failed_frame(true, request) || exists|doc: Document| frames == #[trigger] sub_frames(true, request, doc)); + } + } + }, + } + }, + }, + }, + } + } +} + +/// **`theorem_script_fetch_shape`** (item 7.16). +pub proof fn theorem_script_fetch_shape(rules: Seq, urls: UrlFns, fetch: FetchFns, s: State, id: nat, bytes: Seq) + ensures + crate::statements::script_fetch_shape_statement(rules, urls, fetch, s, id, bytes), +{ + crate::invariant::lemma_find_by_id(s.renderers, id, 0); + if let Some(i) = find_by_id(s.renderers, id, 0) { + let r = s.renderers[i]; + if let Some(clazel_ipc::message::spec::Message::FetchScript { request, url }) = accepted_message(r, bytes) { + lemma_script_fetch_shape_of(rules, urls, fetch, s, r, request, url); + assert(step(rules, urls, fetch, s, Event::FromRenderer { id, bytes }) == fetch_script(rules, urls, fetch, s, r, request, url)); + } + } +} + } // verus! diff --git a/crates/clazel-kernel/src/surface_theorems.rs b/crates/clazel-kernel/src/surface_theorems.rs index 9ce580f8e..b6d6b4500 100644 --- a/crates/clazel-kernel/src/surface_theorems.rs +++ b/crates/clazel-kernel/src/surface_theorems.rs @@ -108,8 +108,8 @@ proof fn lemma_from_renderer_no_surface(rules: Seq, urls lemma_storage_call_no_surface(s, r, m); } }, - clazel_ipc::message::spec::Message::FetchStyle { request, url } => { - crate::subfetch_rel::lemma_fetch_style_shape(rules, urls, fetch, s, r, request, url); + clazel_ipc::message::spec::Message::FetchStyle { .. } | clazel_ipc::message::spec::Message::FetchScript { .. } => { + crate::subfetch_rel::lemma_fetch_sub_shape(rules, urls, fetch, s, r, m is FetchScript, sub_request_id(m), sub_request_url(m)); }, _ => {}, }, diff --git a/crates/clazel-kernel/src/theorems.rs b/crates/clazel-kernel/src/theorems.rs index ce4d19e6d..ff619dcde 100644 --- a/crates/clazel-kernel/src/theorems.rs +++ b/crates/clazel-kernel/src/theorems.rs @@ -142,10 +142,11 @@ pub proof fn theorem_reply_only_to_sender(rules: Seq, ur Some(m) => { if let clazel_ipc::message::spec::Message::Display { title, text, links } = m { lemma_reply_display(rules, urls, fetch, s, id, bytes, i); - } else if let clazel_ipc::message::spec::Message::FetchStyle { request, url } = m { - // Item 5.19: a `FetchStyle` answers its sender and asks for - // its sender's sub-fetch connections only. - crate::subfetch_rel::lemma_fetch_style_shape(rules, urls, fetch, s, r, request, url); + } else if is_sub_request(m) { + // Items 5.19 and 7.16: a `FetchStyle` or `FetchScript` + // answers its sender and asks for its sender's sub-fetch + // connections only. + crate::subfetch_rel::lemma_fetch_sub_shape(rules, urls, fetch, s, r, m is FetchScript, sub_request_id(m), sub_request_url(m)); } else if let clazel_ipc::message::spec::Message::Navigate { url } = m { if let Some(relative) = clazel_encoding::utf8::spec::utf8_decode_without_bom_or_fail(url) { if let Some(resolved) = (urls.resolve)(r.url, relative) { diff --git a/crates/clazel-kernel/src/unwind_base.rs b/crates/clazel-kernel/src/unwind_base.rs index 27c40899f..3f6c2d868 100644 --- a/crates/clazel-kernel/src/unwind_base.rs +++ b/crates/clazel-kernel/src/unwind_base.rs @@ -621,8 +621,8 @@ pub proof fn lemma_step_gpu_frame(rules: Seq, urls: UrlF } } } - if let clazel_ipc::message::spec::Message::FetchStyle { request, url } = m { - crate::subfetch_rel::lemma_fetch_style_shape(rules, urls, fetch, s, r, request, url); + if is_sub_request(m) { + crate::subfetch_rel::lemma_fetch_sub_shape(rules, urls, fetch, s, r, m is FetchScript, sub_request_id(m), sub_request_url(m)); } } } diff --git a/crates/clazel-kernel/src/unwinding_b.rs b/crates/clazel-kernel/src/unwinding_b.rs index d88e7e231..a80635b76 100644 --- a/crates/clazel-kernel/src/unwinding_b.rs +++ b/crates/clazel-kernel/src/unwinding_b.rs @@ -58,8 +58,8 @@ pub proof fn lemma_local_outputs(rules: Seq, urls: UrlFn } } } - if let clazel_ipc::message::spec::Message::FetchStyle { request, url } = m { - crate::subfetch_rel::lemma_fetch_style_shape(rules, urls, fetch, s, r, request, url); + if is_sub_request(m) { + crate::subfetch_rel::lemma_fetch_sub_shape(rules, urls, fetch, s, r, m is FetchScript, sub_request_id(m), sub_request_url(m)); } } else { crate::net_theorems::lemma_closes_of_tab(s.conns, r.tab); @@ -236,11 +236,13 @@ pub proof fn lemma_local_respect_renderer(rules: Seq, ur if let Some(clazel_ipc::message::spec::Message::Title { title }) = accepted_message(r, bytes) { crate::surface_rel::lemma_titles_set_other(rules, s1.titles, r.id, r.lock, title, d); } - // Item 5.19: a `FetchStyle` changes only its sender's sub-fetches and - // counts, of another domain. - if let Some(clazel_ipc::message::spec::Message::FetchStyle { request, url }) = accepted_message(r, bytes) { - crate::subfetch_rel::lemma_fetch_style_shape(rules, urls, fetch, s1, r, request, url); - crate::subfetch_rel::lemma_fetch_style_other(rules, urls, fetch, d, s1, r, request, url); + // Items 5.19 and 7.16: a `FetchStyle` or `FetchScript` changes only + // its sender's sub-fetches and counts, of another domain. + if let Some(m2) = accepted_message(r, bytes) { + if is_sub_request(m2) { + crate::subfetch_rel::lemma_fetch_sub_shape(rules, urls, fetch, s1, r, m2 is FetchScript, sub_request_id(m2), sub_request_url(m2)); + crate::subfetch_rel::lemma_fetch_sub_other(rules, urls, fetch, d, s1, r, m2 is FetchScript, sub_request_id(m2), sub_request_url(m2)); + } } crate::unwinding_d::lemma_rel_same_table(rules, urls, d, s1, s2, s1b, s2); } diff --git a/crates/clazel-kernel/src/unwinding_d.rs b/crates/clazel-kernel/src/unwinding_d.rs index f9b4c524c..466379032 100644 --- a/crates/clazel-kernel/src/unwinding_d.rs +++ b/crates/clazel-kernel/src/unwinding_d.rs @@ -277,10 +277,10 @@ pub proof fn lemma_d_kill(rules: Seq, urls: UrlFns, fetc crate::unwinding::lemma_rel_from_sets(rules, urls, d, s1b, s2b); } -/// A `FetchStyle` of a renderer of `d` (item 5.19): the same outputs, and -/// related states. +/// A `FetchStyle` or `FetchScript` of a renderer of `d` (items 5.19 and +/// 7.16): the same outputs, and related states. #[verifier::spinoff_prover] -pub proof fn lemma_d_fetch_style( +pub proof fn lemma_d_fetch_sub( rules: Seq, urls: UrlFns, fetch: FetchFns, @@ -289,15 +289,13 @@ pub proof fn lemma_d_fetch_style( s2: State, id: nat, bytes: Seq, - request: u64, - url: Seq, + m: clazel_ipc::message::spec::Message, ) requires crate::noninterference::rel(rules, urls, d, s1, s2), crate::domain::event_domain(rules, s1, Event::FromRenderer { id, bytes }) == Some(d), - accepted_message(s1.renderers[find_by_id(s1.renderers, id, 0)->Some_0], bytes) == Some( - clazel_ipc::message::spec::Message::FetchStyle { request, url }, - ), + accepted_message(s1.renderers[find_by_id(s1.renderers, id, 0)->Some_0], bytes) == Some(m), + is_sub_request(m), ensures crate::noninterference::renderer_outs(step(rules, urls, fetch, s1, Event::FromRenderer { id, bytes }).1) == crate::noninterference::renderer_outs(step(rules, urls, fetch, s2, Event::FromRenderer { id, bytes }).1), crate::noninterference::rel(rules, urls, d, step(rules, urls, fetch, s1, Event::FromRenderer { id, bytes }).0, step(rules, urls, fetch, s2, Event::FromRenderer { id, bytes }).0), @@ -307,15 +305,18 @@ pub proof fn lemma_d_fetch_style( let i1 = find_by_id(s1.renderers, id, 0)->Some_0; let i2 = find_by_id(s2.renderers, id, 0)->Some_0; let r = s1.renderers[i1]; - assert(step(rules, urls, fetch, s1, e) == fetch_style(rules, urls, fetch, s1, r, request, url)); - assert(step(rules, urls, fetch, s2, e) == fetch_style(rules, urls, fetch, s2, r, request, url)); + let script = m is FetchScript; + let request = sub_request_id(m); + let url = sub_request_url(m); + assert(step(rules, urls, fetch, s1, e) == fetch_sub(rules, urls, fetch, s1, r, script, request, url)); + assert(step(rules, urls, fetch, s2, e) == fetch_sub(rules, urls, fetch, s2, r, script, request, url)); crate::invariant::lemma_step_preserves_wf(rules, urls, fetch, s1, e); crate::invariant::lemma_step_preserves_wf(rules, urls, fetch, s2, e); crate::unwind_base::lemma_jar_no_public_suffix_step(rules, urls, fetch, s1, e); crate::unwind_base::lemma_jar_no_public_suffix_step(rules, urls, fetch, s2, e); - crate::subfetch_rel::lemma_fetch_style_shape(rules, urls, fetch, s1, r, request, url); - crate::subfetch_rel::lemma_fetch_style_shape(rules, urls, fetch, s2, r, request, url); - crate::subfetch_rel::lemma_fetch_style_domain(rules, urls, fetch, d, s1, s2, r, request, url); + crate::subfetch_rel::lemma_fetch_sub_shape(rules, urls, fetch, s1, r, script, request, url); + crate::subfetch_rel::lemma_fetch_sub_shape(rules, urls, fetch, s2, r, script, request, url); + crate::subfetch_rel::lemma_fetch_sub_domain(rules, urls, fetch, d, s1, s2, r, script, request, url); let (s1b, o1) = step(rules, urls, fetch, s1, e); let (s2b, o2) = step(rules, urls, fetch, s2, e); lemma_rel_same_table(rules, urls, d, s1, s2, s1b, s2b); @@ -354,8 +355,8 @@ pub proof fn lemma_d_event(rules: Seq, urls: UrlFns, fet crate::surface_rel::lemma_titles_set_same(rules, s1.titles, s2.titles, r.id, r.lock, title, d); lemma_rel_same_table(rules, urls, d, s1, s2, s1b, s2b); assert(o1 == o2); - } else if let clazel_ipc::message::spec::Message::FetchStyle { request, url } = m { - lemma_d_fetch_style(rules, urls, fetch, d, s1, s2, id, bytes, request, url); + } else if is_sub_request(m) { + lemma_d_fetch_sub(rules, urls, fetch, d, s1, s2, id, bytes, m); } else { // `Display` (item 4.12) changes nothing and shows the same // on the same tab in both runs: the sender is the same From 426c670f3d8954e26423bc0a16eec73c07754deb Mon Sep 17 00:00:00 2001 From: Alex Tiernan-Berry Date: Sun, 22 Nov 2026 15:34:23 +0000 Subject: [PATCH 5/5] clazel-ipc mutations: re-anchor two stale find strings on is_from_renderer The 7.16 messages added lines to is_from_renderer, so dir-navigate-not-renderer and msg-display-direction no longer matched their find text. Only find/replace changed; expect and certificates are untouched. Co-Authored-By: Claude Opus 5.5 --- crates/clazel-ipc/mutations.json | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/crates/clazel-ipc/mutations.json b/crates/clazel-ipc/mutations.json index cfe2394c1..ffdf59e23 100644 --- a/crates/clazel-ipc/mutations.json +++ b/crates/clazel-ipc/mutations.json @@ -731,8 +731,8 @@ { "id": "dir-navigate-not-renderer", "file": "src/message/spec.rs", - "find": "| Message::StorageLength\n | Message::Navigate { .. }\n | Message::Display { .. }\n | Message::Title { .. }\n | Message::FetchStyle { .. } => true,", - "replace": "| Message::StorageLength\n | Message::Display { .. }\n | Message::Title { .. }\n | Message::FetchStyle { .. } => true,", + "find": "| Message::StorageLength\n | Message::Navigate { .. }\n | Message::FetchScript { .. }\n | Message::UpdateUrl { .. }\n | Message::Display { .. }\n | Message::Title { .. }\n | Message::FetchStyle { .. } => true,", + "replace": "| Message::StorageLength\n | Message::FetchScript { .. }\n | Message::UpdateUrl { .. }\n | Message::Display { .. }\n | Message::Title { .. }\n | Message::FetchStyle { .. } => true,", "expect": "killed", "reason": "Navigate is not counted as a renderer message: the kernel rejects it, so lemma_example_renderer_navigate is false.", "certificate": { @@ -978,8 +978,8 @@ { "id": "msg-display-direction", "file": "src/message/spec.rs", - "find": " | Message::Navigate { .. }\n | Message::Display { .. }\n | Message::Title { .. }\n | Message::FetchStyle { .. } => true,", - "replace": " | Message::Navigate { .. }\n | Message::Title { .. }\n | Message::FetchStyle { .. } => true,", + "find": " | Message::Navigate { .. }\n | Message::FetchScript { .. }\n | Message::UpdateUrl { .. }\n | Message::Display { .. }\n | Message::Title { .. }\n | Message::FetchStyle { .. } => true,", + "replace": " | Message::Navigate { .. }\n | Message::FetchScript { .. }\n | Message::UpdateUrl { .. }\n | Message::Title { .. }\n | Message::FetchStyle { .. } => true,", "expect": "killed", "reason": "Display is not counted as a renderer message: the kernel rejects it, so lemma_example_display is false.", "certificate": {