1use crate::fetch::{self, Decision, Paused};
2use crate::net::Ws;
3use crate::protected::{Opener, Protected};
4use crate::shield;
5use crate::worlds::Worlds;
6use serde_json::{json, Value};
7use std::collections::{BTreeMap, BTreeSet, VecDeque};
8use std::time::{Duration, Instant};
9
10#[path = "webmcp_guard.rs"]
11mod webmcp_guard;
12#[path = "page_scope.rs"]
13mod page_scope;
14#[path = "document_order.rs"]
15mod document_order;
16#[path = "issued.rs"]
17mod issued;
18pub(crate) use issued::target_refusal;
19
20pub trait Transport {
21 fn send_text(&mut self, text: &str) -> Result<(), String>;
22 fn recv_text(&mut self, deadline: Instant) -> Result<Option<String>, String>;
23}
24
25impl Transport for Ws {
26 fn send_text(&mut self, text: &str) -> Result<(), String> {
27 Ws::send_text(self, text)
28 }
29
30 fn recv_text(&mut self, deadline: Instant) -> Result<Option<String>, String> {
31 Ws::recv_text(self, deadline)
32 }
33}
34
35pub type Decider = Box<dyn FnMut(&Paused) -> Decision>;
36
37pub const UNSEEN: &str = "slicc: refused: slicc hasn't seen this request, so it could be seven's\n";
38pub const UNGUARDED: &str = "slicc: refused: slicc can't keep seven's origin out of this target\n";
39pub const RENDERER_CRASHED: &str = "slicc: refused: renderer crashed\n";
40pub const GUARD_SETUP: Duration = Duration::from_secs(30);
41const OPTIONAL_STEP: Duration = Duration::from_secs(10);
42const DOCUMENT_CHECK: Duration = Duration::from_secs(2);
43const WAITER_SLICE: Duration = Duration::from_millis(5);
44const AUTO_ATTACH: &str = "slicc: refused: auto-attach is not supported by slicc-cdp\n";
45const FLATTEN: &str = "slicc: refused: attach with flatten: true\n";
46const PERSISTENT: &str = "slicc: refused: persistent page capabilities are not supported by slicc-cdp\n";
47pub const COOKIES: &str = "slicc: refused: cookies on seven's origin\n";
48pub const STREAM: &str = "slicc: refused: slicc didn't hand out this stream, so it could be seven's\n";
49
50struct CarrierTarget {
51 origin: Option<String>,
52 protected: bool,
53 url: url::Url,
54}
55
56#[derive(Clone, Debug)]
57struct DocumentState {
58 frames: BTreeMap<String, Vec<String>>,
59 worker: Option<(String, String)>,
60 scope: Option<String>,
61 epoch: u64,
62 page_scope: Option<(String, u64, u64)>,
63 runtime_scope_epoch: Option<u64>,
64}
65
66impl PartialEq for DocumentState {
67 fn eq(&self, other: &Self) -> bool {
68 self.scope == other.scope && self.epoch == other.epoch && self.worker == other.worker && self.frames.len() == other.frames.len()
69 && self.frames.iter().all(|(id, frame)| other.frames.get(id).is_some_and(|current| {
70 frame[0] == current[0] && frame[2..] == current[2..] && (!frame[0].is_empty() || frame[1] == current[1])
71 }))
72 }
73}
74
75#[derive(Clone)]
76struct ContextProof {
77 id: i64,
78 frame: String,
79 origin: String,
80 name: String,
81 loader: Option<String>,
82 default: bool,
83}
84
85struct Navigation {
86 params: Value,
87 session: Option<String>,
88 reply: Option<Value>,
89 detached: bool,
90}
91
92struct MainDocument {
93 frame_id: String,
94 url: String,
95 origin: String,
96 unreachable_url: String,
97 navigating: bool,
98 navigation_url: String,
99 previous: bool,
100 probed: bool,
101}
102
103pub type Waiter = Box<dyn FnMut(&Cdp)>;
104
105pub struct Cdp {
106 ws: Box<dyn Transport>,
107 next_id: i64,
108 detaching: BTreeMap<i64, String>,
109 detached_ordinary: BTreeSet<String>,
110 navigations: BTreeMap<i64, Navigation>,
111 events: Vec<Value>,
112 dialog_sessions: BTreeSet<String>,
113 dialogs: BTreeMap<String, Dialog>,
114 dialog_documents: BTreeMap<String, DialogDocument>,
115 dialog_epoch: u64,
116 trace_cookies: Vec<Value>,
117 guard: Protected,
118 paused: VecDeque<Paused>,
119 deciders: BTreeMap<String, Decider>,
120 decided: BTreeMap<i64, (String, String)>,
121 fetch_errors: Vec<String>,
122 blocked: BTreeSet<String>,
123 crashed_sessions: BTreeSet<String>,
124 crashed_targets: BTreeSet<String>,
125 session_targets: BTreeMap<String, String>,
126 protected_targets: BTreeSet<String>,
127 guards: BTreeMap<String, String>,
128 page_scope_sessions: BTreeMap<String, String>,
129 checking_page_events: bool,
130 pending_page_events: VecDeque<Value>,
131 runtime_scope_epochs: BTreeMap<String, u64>,
132 page_scope_owners: BTreeMap<String, String>,
133 page_scope_epochs: BTreeMap<String, u64>,
134 page_scope_unknown: u64,
135 guard_sessions: BTreeSet<String>,
136 guarding: BTreeSet<String>,
137 probing: BTreeSet<String>,
138 abandoned: BTreeSet<String>,
139 unguarded_optional: BTreeMap<String, BTreeSet<String>>,
140 notices: Vec<String>,
141 discovering: bool,
142 requests: BTreeMap<String, bool>,
143 redirects: BTreeSet<String>,
144 protected_body_requests: BTreeSet<String>,
145 seen_network: BTreeMap<(String, String), String>,
146 terminal_network: BTreeSet<(String, String)>,
147 client_navigation_urls: BTreeMap<String, String>,
148 request_aliases: BTreeMap<String, BTreeSet<String>>,
149 request_resources: BTreeMap<String, BTreeSet<(String, String)>>,
150 protected_request_pages: BTreeSet<(String, String)>,
151 protected_resources: BTreeSet<(String, String)>,
152 protected_target_resources: BTreeSet<(String, String)>,
153 source_resources: BTreeMap<(String, String), String>,
154 handed: BTreeSet<(String, String)>,
155 answering: BTreeMap<i64, (String, String)>,
156 held: BTreeMap<String, Vec<Value>>,
157 streams: BTreeMap<String, (Option<String>, Option<DocumentState>)>,
158 document_epochs: BTreeMap<String, u64>,
159 unchecked_documents: BTreeMap<(String, String, String), document_order::ObservedDocument>,
160 removed_frames: BTreeMap<(String, String), (String, String)>,
161 document_versions: BTreeMap<(String, String), String>,
162 created_blanks: BTreeMap<String, (String, String, i64)>,
163 navigated_blanks: BTreeMap<String, (String, String, String)>,
164 context_frames: BTreeMap<(String, String), String>,
165 context_proofs: BTreeMap<(String, String), ContextProof>,
166 runtime_sessions: BTreeMap<String, String>,
167 created_contexts: BTreeSet<(String, i64)>,
168 cached_documents: BTreeMap<String, DocumentState>,
169 paused_documents: BTreeSet<(String, String)>,
170 executing_sessions: BTreeSet<String>,
171 contexts: BTreeSet<String>,
172 targets: BTreeMap<String, Value>,
173 worlds: Worlds,
174 frames: BTreeMap<String, Vec<String>>,
175 frame_parents: BTreeMap<String, String>,
176 frame_decisions: BTreeMap<String, bool>,
177 frame_sessions: BTreeMap<String, BTreeSet<String>>,
178 frame_epoch: u64,
179 frame_versions: BTreeMap<String, u64>,
180 documents: BTreeMap<String, MainDocument>,
181 unobserved: BTreeSet<String>,
182 webmcp: webmcp_guard::Webmcp,
183 waiting_calls: BTreeSet<i64>,
184 call_replies: BTreeMap<i64, Value>,
185 issued: issued::Issued,
186 waiter: Option<Waiter>,
187 waiter_due: Instant,
188 #[cfg(test)]
189 runtime_preparing: bool,
190 #[cfg(test)]
191 runtime_probe: Vec<Value>,
192 #[cfg(test)]
193 pub(crate) paused_trail: Vec<(String, String, &'static str)>,
194}
195
196impl Drop for Cdp {
197 fn drop(&mut self) {
198 self.retire_private_sessions(Instant::now() + DOCUMENT_CHECK);
199 }
200}
201
202impl Cdp {
203 fn retire_private_sessions(&mut self, deadline: Instant) {
204 self.waiter = None;
205 let sessions = self.guard_sessions.clone();
206 for session in sessions {
207 if !self.guard_sessions.contains(&session) { continue }
208 if self.guards.values().any(|guard| guard == &session) {
209 let left = deadline.saturating_duration_since(Instant::now());
210 if left.is_zero() { let _ = self.send("Fetch.disable", json!({}), Some(&session)); }
211 else { let _ = self.raw_call("Fetch.disable", json!({}), Some(&session), left); }
212 }
213 let left = deadline.saturating_duration_since(Instant::now());
214 if left.is_zero() { let _ = self.send("Target.detachFromTarget", json!({"sessionId":session}), None); }
215 else { let _ = self.raw_call("Target.detachFromTarget", json!({"sessionId":session}), None, left); }
216 }
217 }
218
219 pub fn connect(url: &str) -> Result<Self, String> {
220 Ok(Self::from_transport(Box::new(crate::net::ws_connect(url)?)))
221 }
222
223 pub fn from_transport(ws: Box<dyn Transport>) -> Self {
224 Self {
225 ws,
226 next_id: 0,
227 detaching: BTreeMap::new(),
228 detached_ordinary: BTreeSet::new(),
229 navigations: BTreeMap::new(),
230 events: Vec::new(),
231 dialog_sessions: BTreeSet::new(),
232 dialogs: BTreeMap::new(),
233 dialog_documents: BTreeMap::new(),
234 dialog_epoch: 0,
235 trace_cookies: Vec::new(),
236 guard: Protected::default(),
237 paused: VecDeque::new(),
238 deciders: BTreeMap::new(),
239 decided: BTreeMap::new(),
240 fetch_errors: Vec::new(),
241 blocked: BTreeSet::new(),
242 crashed_sessions: BTreeSet::new(),
243 crashed_targets: BTreeSet::new(),
244 session_targets: BTreeMap::new(),
245 protected_targets: BTreeSet::new(),
246 guards: BTreeMap::new(),
247 page_scope_sessions: BTreeMap::new(),
248 checking_page_events: false,
249 pending_page_events: VecDeque::new(),
250 runtime_scope_epochs: BTreeMap::new(),
251 page_scope_owners: BTreeMap::new(),
252 page_scope_epochs: BTreeMap::new(),
253 page_scope_unknown: 0,
254 guard_sessions: BTreeSet::new(),
255 guarding: BTreeSet::new(),
256 probing: BTreeSet::new(),
257 abandoned: BTreeSet::new(),
258 unguarded_optional: BTreeMap::new(),
259 notices: Vec::new(),
260 discovering: false,
261 requests: BTreeMap::new(),
262 redirects: BTreeSet::new(),
263 protected_body_requests: BTreeSet::new(),
264 seen_network: BTreeMap::new(),
265 terminal_network: BTreeSet::new(),
266 client_navigation_urls: BTreeMap::new(),
267 request_aliases: BTreeMap::new(),
268 request_resources: BTreeMap::new(),
269 protected_request_pages: BTreeSet::new(),
270 protected_resources: BTreeSet::new(),
271 protected_target_resources: BTreeSet::new(),
272 source_resources: BTreeMap::new(),
273 handed: BTreeSet::new(),
274 answering: BTreeMap::new(),
275 held: BTreeMap::new(),
276 streams: BTreeMap::new(),
277 document_epochs: BTreeMap::new(),
278 unchecked_documents: BTreeMap::new(),
279 removed_frames: BTreeMap::new(),
280 document_versions: BTreeMap::new(),
281 created_blanks: BTreeMap::new(),
282 navigated_blanks: BTreeMap::new(),
283 context_frames: BTreeMap::new(),
284 context_proofs: BTreeMap::new(),
285 runtime_sessions: BTreeMap::new(),
286 created_contexts: BTreeSet::new(),
287 cached_documents: BTreeMap::new(),
288 paused_documents: BTreeSet::new(),
289 executing_sessions: BTreeSet::new(),
290 contexts: BTreeSet::new(),
291 targets: BTreeMap::new(),
292 worlds: Worlds::default(),
293 frames: BTreeMap::new(),
294 frame_parents: BTreeMap::new(),
295 frame_decisions: BTreeMap::new(),
296 frame_sessions: BTreeMap::new(),
297 frame_epoch: 0,
298 frame_versions: BTreeMap::new(),
299 documents: BTreeMap::new(),
300 unobserved: BTreeSet::new(),
301 webmcp: webmcp_guard::Webmcp::default(),
302 waiting_calls: BTreeSet::new(),
303 call_replies: BTreeMap::new(),
304 issued: issued::Issued::default(),
305 waiter: None,
306 waiter_due: Instant::now(),
307 #[cfg(test)]
308 runtime_preparing: false,
309 #[cfg(test)]
310 runtime_probe: Vec::new(),
311 #[cfg(test)]
312 paused_trail: Vec::new(),
313 }
314 }
315
316 #[cfg(test)]
317 pub(crate) fn fixture_session(&mut self, session: &str) {
318 struct Fixture {
319 inner: Box<dyn Transport>,
320 inbox: VecDeque<String>,
321 worlds: BTreeMap<String, Vec<Value>>,
322 pending_worlds: BTreeMap<i64, (String, Value)>,
323 target_infos: Vec<Value>,
324 }
325 impl Transport for Fixture {
326 fn send_text(&mut self, text: &str) -> Result<(), String> {
327 let call: Value = serde_json::from_str(text).unwrap();
328 if call["method"] == "Target.getTargets" && call["params"]["filter"] == json!([{}]) {
329 self.inbox.push_back(json!({"id":call["id"],"result":{"targetInfos":self.target_infos}}).to_string());
330 Ok(())
331 } else if call["method"] == "Page.getFrameTree" && call["sessionId"].as_str().is_some_and(|session| session.starts_with("fixture-guard:") || session == "S" || session == "OTHER") {
332 self.inbox.push_back(json!({"id":call["id"],"result":{"frameTree":{"frame":{"id":"F","loaderId":"L","url":"https://example.test/","securityOrigin":"https://example.test"}}}}).to_string());
333 Ok(())
334 } else if call["sessionId"].as_str().is_some_and(|session| session.starts_with("fixture-guard:")) && matches!(call["method"].as_str(), Some("Runtime.disable" | "Runtime.enable")) {
335 if call["method"] == "Runtime.enable" {
336 self.inbox.push_back(json!({"method":"Runtime.executionContextCreated","sessionId":call["sessionId"],"params":{"context":{"id":1,"uniqueId":"fixture-context","origin":"https://example.test","name":"","auxData":{"frameId":"F","isDefault":true}}}}).to_string());
337 let owner = call["sessionId"].as_str().unwrap().strip_prefix("fixture-guard:").unwrap();
338 for context in self.worlds.get(owner).into_iter().flatten() {
339 self.inbox.push_back(json!({"method":"Runtime.executionContextCreated","sessionId":call["sessionId"],"params":{"context":context}}).to_string());
340 }
341 }
342 self.inbox.push_back(json!({"id":call["id"],"result":{}}).to_string());
343 Ok(())
344 } else {
345 if call["method"] == "Page.createIsolatedWorld" {
346 self.pending_worlds.insert(call["id"].as_i64().unwrap(), (call["sessionId"].as_str().unwrap().to_string(), call["params"].clone()));
347 }
348 self.inner.send_text(text)
349 }
350 }
351 fn recv_text(&mut self, deadline: Instant) -> Result<Option<String>, String> {
352 let text = match self.inbox.pop_front() { Some(text) => Some(text), None => self.inner.recv_text(deadline)? };
353 if let Some(text) = &text {
354 let reply: Value = serde_json::from_str(text).unwrap();
355 if let Some((owner, params)) = reply["id"].as_i64().and_then(|id| self.pending_worlds.remove(&id)) {
356 if let Some(id) = reply.pointer("/result/executionContextId").and_then(Value::as_i64) {
357 self.worlds.entry(owner).or_default().push(json!({"id":id,"uniqueId":format!("fixture-world:{id}"),"origin":"","name":params["worldName"],"auxData":{"frameId":params["frameId"],"isDefault":false}}));
358 }
359 }
360 }
361 Ok(text)
362 }
363 }
364 struct Empty;
365 impl Transport for Empty {
366 fn send_text(&mut self, _: &str) -> Result<(), String> { Ok(()) }
367 fn recv_text(&mut self, _: Instant) -> Result<Option<String>, String> { Ok(None) }
368 }
369 let target = format!("fixture:{session}");
370 let guard = format!("fixture-guard:{session}");
371 self.targets.insert(target.clone(), json!({"targetId":target,"type":"page","url":"https://example.test/"}));
372 self.session_targets.insert(session.into(), target.clone());
373 self.guards.insert(target.clone(), guard.clone());
374 self.guard_sessions.insert(guard);
375 self.unobserved.insert(target);
376 let inner = std::mem::replace(&mut self.ws, Box::new(Empty));
377 self.ws = Box::new(Fixture { inner, inbox:VecDeque::new(), worlds:BTreeMap::new(), pending_worlds:BTreeMap::new(), target_infos:self.targets.values().cloned().collect() });
378 }
379
380 pub fn events(&self) -> &[Value] {
381 &self.events
382 }
383
384 pub fn guard(&self) -> &Protected {
385 &self.guard
386 }
387
388 pub fn protect_origins(&mut self, extra_origins: &[&str]) {
389 self.guard = Protected::new(extra_origins);
390 }
391
392 pub fn take_notices(&mut self) -> Vec<String> {
393 std::mem::take(&mut self.notices)
394 }
395
396 pub fn unguarded_optional(&self, target_id: &str) -> Vec<String> {
397 self.unguarded_optional
398 .get(target_id)
399 .map(|steps| steps.iter().cloned().collect())
400 .unwrap_or_default()
401 }
402
403 pub fn session_blocked(&self, session_id: &str) -> bool {
404 self.blocked.contains(session_id)
405 }
406
407 pub fn content_blocked(&self, session_id: &str) -> bool {
408 self.blocked.contains(session_id) || self.guard_sessions.contains(session_id)
409 || self.session_target(session_id).and_then(|target| self.documents.get(&target)).is_some_and(|doc| self.sealed(doc))
410 }
411
412 #[cfg(test)]
413 pub(crate) fn document_evidence(&self, target_id: &str) -> String {
414 self.documents.get(target_id).map_or_else(|| "none".to_string(), |doc| {
415 format!("url={} unreachable={} navigating={} previous={} probed={}", doc.url, doc.unreachable_url, doc.navigating, doc.previous, doc.probed)
416 })
417 }
418
419 pub fn is_protected_target(&self, target_id: &str) -> bool {
420 self.protected_targets.contains(target_id)
421 || self
422 .session_targets
423 .iter()
424 .any(|(session, target)| target == target_id && self.blocked.contains(session))
425 }
426
427 pub fn set_decider(&mut self, session_id: &str, decider: Option<Decider>) {
428 match decider {
429 Some(decider) => {
430 self.deciders.insert(session_id.to_string(), decider);
431 let queued: Vec<Paused> = self.paused.drain(..).collect();
432 for paused in queued {
433 if paused.session_id == session_id {
434 self.decide_inline(paused);
435 } else {
436 self.paused.push_back(paused);
437 }
438 }
439 }
440 None => {
441 self.deciders.remove(session_id);
442 }
443 }
444 }
445
446 pub fn has_decider(&self, session_id: &str) -> bool {
447 self.deciders.contains_key(session_id)
448 }
449
450 #[cfg(test)]
451 fn runtime_stage(&mut self, method: &str, stage: &str) {
452 if method == "Runtime.evaluate" { self.runtime_probe.push(json!({"stage":stage})); }
453 }
454
455 #[cfg(test)]
456 fn runtime_contexts(&mut self, method: &str, stage: &str, guard: &str, target: &str, state: &DocumentState, selected: Option<&str>) {
457 if method != "Runtime.evaluate" { return }
458 let contexts: Vec<Value> = self.context_proofs.iter().filter(|((owner, _), _)| owner == guard).map(|((_, unique), proof)| {
459 let frame = state.frames.get(&proof.frame);
460 json!({"default":proof.default,"frame_known":frame.is_some(),
461 "main_frame":frame.is_some_and(|frame| frame[4].is_empty()),
462 "origin_known":url::Url::parse(&proof.origin).is_ok(),
463 "origin_protected":self.guard.url(&proof.origin),
464 "origin_opaque":matches!(proof.origin.as_str(), "" | "://" | "null"),
465 "origin_matches_frame":frame.is_some_and(|frame| frame[2] == proof.origin),
466 "loader_known":proof.loader.as_ref().is_some_and(|loader| !loader.is_empty()),
467 "loader_matches_frame":proof.loader.as_ref().zip(frame).is_some_and(|(loader, frame)| loader == &frame[0]),
468 "selected":selected == Some(unique.as_str())})
469 }).collect();
470 self.runtime_probe.push(json!({"stage":stage,"private_contexts":contexts,
471 "frame_count":state.frames.len(),"scope_known":state.scope.is_some(),
472 "scope_default":state.scope.as_deref() == Some(""),
473 "page_scope_known":state.page_scope.is_some(),"worker":state.worker.is_some(),
474 "owned_blank":state.frames.iter().any(|(id, frame)| frame[1] == "about:blank" && self.owns_blank(target, id, &frame[0]))}));
475 }
476
477 #[cfg(test)]
478 fn runtime_prepare_probe(&mut self, category: &str, details: Value) {
479 if self.runtime_preparing { self.runtime_probe.push(json!({"stage":"prepare-check","category":category,"details":details})); }
480 }
481
482 #[cfg(test)]
483 fn runtime_prepare_frames(&mut self, tree: &Value, frames: &BTreeMap<String, Vec<String>>) {
484 let mut pending = vec![(tree, None)];
485 while let Some((node, parent)) = pending.pop() {
486 let Some(frame) = node.get("frame") else {
487 self.runtime_prepare_probe("frame-placement", json!({"frame_present":false}));
488 return;
489 };
490 let id = frame.get("id").and_then(Value::as_str).unwrap_or("");
491 if !frames.contains_key(id) {
492 let url = frame.get("url").and_then(Value::as_str).unwrap_or("");
493 let origin = self.page_scope_origin(frame).or_else(|| frame.get("securityOrigin").and_then(Value::as_str)).unwrap_or("");
494 self.runtime_prepare_probe("frame-evidence", json!({"id_known":frame_text_known(id),"url_known":frame_text_known(url),
495 "parent_matches":frame.get("parentId").is_none_or(|id| id.as_str() == parent),
496 "loader_known":frame.get("loaderId").and_then(Value::as_str).is_some_and(|id| frame_text_known(id)),
497 "initial_blank":url == "about:blank" && frame.get("loaderId").and_then(Value::as_str) == Some(""),
498 "origin_empty":origin.is_empty(),"origin_null":origin == "null","origin_opaque":origin == "://",
499 "origin_protected":self.guard.url(origin),"url_protected":self.guard.url(url),
500 "error_unverified":self.unverified_error(url, frame.get("unreachableUrl").and_then(Value::as_str).unwrap_or(""))}));
501 return;
502 }
503 if let Some(children) = node.get("childFrames") {
504 let Some(children) = children.as_array() else {
505 self.runtime_prepare_probe("frame-placement", json!({"children_valid":false}));
506 return;
507 };
508 for child in children.iter().rev() { pending.push((child, Some(id))); }
509 }
510 }
511 self.runtime_prepare_probe("frame-placement", json!({"collection_complete":false}));
512 }
513
514 #[cfg(test)]
515 pub(crate) fn runtime_diagnostics(&self) -> &[Value] { &self.runtime_probe }
516
517 pub fn take_fetch_errors(&mut self) -> Vec<String> {
518 std::mem::take(&mut self.fetch_errors)
519 }
520
521 pub fn call(
522 &mut self,
523 method: &str,
524 params: Value,
525 session_id: Option<&str>,
526 ) -> Result<Value, String> {
527 let result = self.call_for(method, params, session_id, Duration::from_secs(30));
528 #[cfg(test)]
529 if result.is_err() && method == "Runtime.evaluate" && std::env::var_os("CI").is_some() {
530 eprintln!("document call refused: stages={:?}", self.runtime_diagnostics().iter().filter_map(|probe| probe.get("stage").and_then(Value::as_str)).collect::<Vec<_>>());
531 }
532 result
533 }
534
535 pub fn call_for(
536 &mut self,
537 method: &str,
538 params: Value,
539 session_id: Option<&str>,
540 timeout: Duration,
541 ) -> Result<Value, String> {
542 let session_id = session_id.filter(|id| !id.is_empty());
543 #[cfg(test)]
544 if method == "Runtime.evaluate" { self.runtime_probe.clear(); }
545 #[cfg(test)]
546 self.runtime_stage(method, "admit");
547 self.admit(method, ¶ms, session_id)?;
548 if method == "Page.navigate" { self.remember_navigation(¶ms, session_id); }
549 if method == "Target.createTarget" {
550 return self.create_target(params, timeout);
551 }
552 #[cfg(test)]
553 self.runtime_stage(method, "prepare");
554 let mut checks = self.prepare(method, ¶ms, session_id)?;
555 #[cfg(test)]
556 self.runtime_stage(method, "pin");
557 let pinned = self.pin_execution(method, ¶ms, session_id, &mut checks)?;
558 let object_pin = method == "Runtime.callFunctionOn" && params.get("objectId").is_some() && !checks.is_empty();
559 let executed = pinned.is_some() && method != "Runtime.compileScript" || object_pin;
560 let mut sent = params.clone();
561 if let Some(unique) = &pinned {
562 sent.as_object_mut().ok_or_else(|| self.refusal())?.remove("contextId");
563 sent.as_object_mut().unwrap().remove("executionContextId");
564 sent.as_object_mut().unwrap().remove("executionContextUniqueId");
565 sent.as_object_mut().unwrap().remove("executionContextName");
566 if method == "Runtime.compileScript" {
567 let target = session_id.and_then(|session| self.session_target(session)).ok_or_else(|| self.refusal())?;
568 let guard = self.guards.get(&target).or_else(|| self.runtime_sessions.get(&target)).ok_or_else(|| self.refusal())?;
569 let proof = self.context_proofs.get(&(guard.clone(), unique.clone())).ok_or_else(|| self.refusal())?;
570 sent["executionContextId"] = json!(proof.id);
571 } else { sent["uniqueContextId"] = json!(unique); }
572 }
573 let (forwarded, sent) = self.fetch_command(method, sent, session_id);
574 let compile_session = if method == "Runtime.compileScript" {
575 session_id.and_then(|session| self.session_target(session)).and_then(|target| self.guards.get(&target).or_else(|| self.runtime_sessions.get(&target))).cloned()
576 } else { None };
577 let frame_epoch = self.frame_epoch;
578 #[cfg(test)]
579 self.runtime_stage(method, "forward");
580 let result = match self.raw_call_execution(&forwarded, sent, compile_session.as_deref().or(session_id), timeout, executed) {
581 Ok(result) => result,
582 Err(message) => {
583 #[cfg(test)]
584 if method == "Runtime.evaluate" {
585 let text = message.to_lowercase();
586 self.runtime_probe.push(json!({"stage":"backend-error","refusal":message.starts_with("slicc: refused:"),
587 "context_missing":text.contains("cannot find context") || text.contains("cannot find execution context"),
588 "context_destroyed":text.contains("context was destroyed"),"transport":transport_error(&message)}));
589 }
590 if executed && !message.starts_with("slicc: refused:") && !transport_error(&message) {
591 #[cfg(test)]
592 self.runtime_stage(method, "error-page-proof");
593 self.verify_checks(&checks, false, true)?;
594 }
595 return Err(message);
596 }
597 };
598 #[cfg(test)]
599 self.runtime_stage(method, "reply-proof");
600 if content_command(method, ¶ms) == Some(true) && !executed {
601 self.verify_checks(&checks, matches!(method, "IO.read" | "IO.close"), !method.starts_with("Input."))?;
602 }
603 if executed { self.verify_execution(&checks)?; }
604 if let (true, Some(session), Some(id)) = (
605 shield::answers_interception(method),
606 session_id,
607 shield::request_key(¶ms),
608 ) {
609 self.settle(session, &id);
610 }
611 if let Some(session) = session_id {
612 if self.blocked.contains(session) && !harmless(method, ¶ms) && !executed {
613 return Err(self.refusal());
614 }
615 }
616 if let Some(frame) = params.get("frameId").and_then(Value::as_str) {
617 if self.frame_refused(frame, session_id)? {
618 return Err(self.refusal());
619 }
620 }
621 if crosses_frames(method, ¶ms) && self.frame_tree_refused(session_id)? {
622 return Err(self.refusal());
623 }
624 if (params.get("frameId").and_then(Value::as_str).is_some() || crosses_frames(method, ¶ms)) && frame_epoch != self.frame_epoch {
625 return Err(self.refusal());
626 }
627 #[cfg(test)]
628 self.runtime_stage(method, "reply-admission");
629 let result = self.after(method, ¶ms, session_id, result)?;
630 self.bind_streams(method, session_id, &result, &checks);
631 #[cfg(test)]
632 self.runtime_stage(method, "complete");
633 Ok(result)
634 }
635
636 pub fn start_navigation(&mut self, params: Value, session: Option<&str>) -> Result<i64, String> {
637 let session = session.filter(|session| !session.is_empty());
638 self.admit("Page.navigate", ¶ms, session)?;
639 self.remember_navigation(¶ms, session);
640 let id = self.send("Page.navigate", params.clone(), session)?;
641 self.navigations.insert(id, Navigation { params, session: session.map(str::to_string), reply: None, detached: false });
642 Ok(id)
643 }
644
645 pub fn poll_navigation(&mut self, id: i64) -> Option<Result<Value, String>> {
646 let navigation = self.navigations.get(&id)?;
647 if self.renderer_crashed(navigation.session.as_deref(), None) {
648 self.navigations.remove(&id);
649 return Some(Err(RENDERER_CRASHED.to_string()));
650 }
651 let refused = navigation.detached || navigation.session.as_deref().is_some_and(|session| self.blocked.contains(session) && !harmless("Page.navigate", &navigation.params));
652 if refused {
653 self.navigations.remove(&id);
654 return Some(Err(self.refusal()));
655 }
656 navigation.reply.as_ref()?;
657 let navigation = self.navigations.remove(&id).unwrap();
658 let reply = navigation.reply.unwrap();
659 if let Some(error) = reply.get("error") {
660 let (message, _) = shield::redact_text(&self.guard, error.get("message").and_then(Value::as_str).unwrap_or("CDP error"));
661 return Some(Err(format!("Page.navigate: {message}\n")));
662 }
663 Some(self.after("Page.navigate", &navigation.params, navigation.session.as_deref(), reply.get("result").cloned().unwrap_or(Value::Null)))
664 }
665
666 pub fn cancel_navigation(&mut self, id: i64) {
667 self.navigations.remove(&id);
668 }
669
670 pub fn notify(
671 &mut self,
672 method: &str,
673 params: Value,
674 session_id: Option<&str>,
675 ) -> Result<(), String> {
676 let session_id = session_id.filter(|id| !id.is_empty());
677 self.admit(method, ¶ms, session_id)?;
678 if matches!(method, "Target.createTarget" | "Target.attachToTarget") {
679 return Err(format!("{method} must be a call, not a notify\n"));
680 }
681 if content_command(method, ¶ms) == Some(true) {
682 self.call(method, params, session_id)?;
683 return Ok(());
684 }
685 self.prepare(method, ¶ms, session_id)?;
686 let answered = shield::answers_interception(method)
687 .then(|| shield::request_key(¶ms))
688 .flatten()
689 .zip(session_id.map(str::to_string));
690 let (forwarded, params) = self.fetch_command(method, params, session_id);
691 let sent = self.send(&forwarded, params, session_id)?;
692 if let Some((id, session)) = answered {
693 self.answering.insert(sent, (session, id));
694 }
695 Ok(())
696 }
697
698 fn refusal(&self) -> String {
699 format!("{}\n", self.guard.refusal())
700 }
701
702 fn admit(&mut self, method: &str, params: &Value, session_id: Option<&str>) -> Result<(), String> {
703 if self.renderer_crashed(session_id, params.get("targetId").and_then(Value::as_str)) { return Err(RENDERER_CRASHED.to_string()) }
704 if method == "Page.handleJavaScriptDialog" {
705 if params.get("accept").and_then(Value::as_bool).is_none()
706 || params.get("promptText").is_some_and(|text| !text.is_string())
707 || !params.as_object().is_some_and(|object| object.keys().all(|key| matches!(key.as_str(), "accept" | "promptText"))) {
708 return Err(self.refusal());
709 }
710 return self.admit_dialog(session_id.ok_or_else(|| self.refusal())?);
711 }
712 if session_id.is_some_and(|session| self.dialog_sessions.contains(session)) { return Err(self.refusal()) }
713 if let Some(session) = session_id {
714 if self.blocked.contains(session) && !harmless(method, params) {
715 return Err(self.refusal());
716 }
717 if self.guard_sessions.contains(session) {
718 return Err(self.refusal());
719 }
720 if self.session_target(session).is_some_and(|target| !self.refresh(&target)) {
721 return Err(self.refusal());
722 }
723 if !recovery(method, params) && self.session_target(session).and_then(|target| self.documents.get(&target)).is_some_and(|doc| self.sealed(doc)) {
724 return Err(self.refusal());
725 }
726 if !harmless(method, params) {
727 if let Some(target) = self.session_target(session) {
728 if self.documents.get(&target).is_some_and(|doc| doc.navigating || self.guard.error_page_url(&doc.url) || !doc.unreachable_url.is_empty()) {
729 if self.target_protected(&target, false)? {
730 return Err(self.refusal());
731 }
732 } else if self.targets.get(&target).is_some_and(|info| self.info_protected(info, &[])) {
733 if self.target_protected(&target, false)? {
734 return Err(self.refusal());
735 }
736 }
737 }
738 }
739 }
740 if matches!(method, "Network.loadNetworkResource" | "Page.captureSnapshot") {
741 return Err(self.refusal());
742 }
743 if !shield::body_method(method) && self.content_refused(method, params, session_id.unwrap_or("")) {
744 return Err(self.refusal());
745 }
746 if crosses_frames(method, params) && self.frame_tree_refused(session_id)? {
747 return Err(self.refusal());
748 }
749 if Worlds::selectors(params) || Worlds::sensitive(method) {
750 let session = session_id.unwrap_or("");
751 if !self.worlds.enabled(session) && (Worlds::sensitive(method) || self.worlds.reason(session, method, params).is_some()) {
752 self.raw_call("Runtime.enable", json!({}), session_id, Duration::from_secs(10))?;
753 self.worlds.enable(session);
754 }
755 if let Some(reason) = self.worlds.reason(session, method, params) {
756 return Err(reason.into());
757 }
758 }
759 if params
760 .get("targetId")
761 .and_then(|v| v.as_str())
762 .is_some_and(|target| self.abandoned.contains(target))
763 {
764 return Err(UNGUARDED.to_string());
765 }
766 if let Some(reason) = shield::browser_wide(method, params, session_id, &self.contexts) {
767 return Err(reason);
768 }
769 if method == "Browser.setWindowBounds" {
770 self.admit_window(params, session_id)?;
771 } else if shield::persistent_capability(method) && !self.network_state_admitted(method, params, session_id) {
772 return Err(PERSISTENT.into());
773 }
774 if method == "Target.autoAttachRelated" || method == "Target.setAutoAttach"
775 && params.get("autoAttach").and_then(|v| v.as_bool()) == Some(true)
776 {
777 return Err(AUTO_ATTACH.into());
778 }
779 if matches!(method, "Target.attachToTarget" | "Target.setAutoAttach")
780 && params.get("flatten").and_then(|v| v.as_bool()) != Some(true)
781 {
782 return Err(FLATTEN.into());
783 }
784 if let Some(reason) = shield::command_url_refusal(&self.guard, params, method) {
785 if reason == self.guard.refusal() && shield::cookie_method(method) {
786 return Err(COOKIES.into());
787 }
788 return Err(format!("{reason}\n"));
789 }
790 if method.starts_with("PWA.") {
791 for key in ["manifestId", "installUrlOrBundleUrl"] {
792 if let Some(url) = params.get(key).and_then(Value::as_str) {
793 if self.guard.url(url) {
794 return Err(format!("{}\n", self.guard.refusal_for_url(url)));
795 }
796 }
797 }
798 }
799 if shield::cookie_method(method) && shield::cookie_refused(&self.guard, params) {
800 return Err(COOKIES.into());
801 }
802 if shield::names_protected_storage(&self.guard, params) {
803 return Err(self.refusal());
804 }
805 if method == "Page.navigateToHistoryEntry" {
806 let entry = params.get("entryId").and_then(|v| v.as_i64()).ok_or_else(|| self.refusal())?;
807 let history = self.raw_call(
808 "Page.getNavigationHistory",
809 json!({}),
810 session_id,
811 DOCUMENT_CHECK,
812 ).map_err(|_| self.refusal())?;
813 let url = history
814 .get("entries")
815 .and_then(|v| v.as_array())
816 .and_then(|entries| {
817 entries
818 .iter()
819 .find(|item| item.get("id").and_then(|v| v.as_i64()) == Some(entry))
820 })
821 .and_then(|item| item.get("url").and_then(|v| v.as_str()))
822 .filter(|url| !url.is_empty())
823 .ok_or_else(|| self.refusal())?
824 .to_string();
825 if self.guard.url(&url) {
826 return Err(format!("{}\n", self.guard.refusal_for_url(&url)));
827 }
828 }
829 if let Some(frame) = params.get("frameId").and_then(Value::as_str) {
830 if self.frame_refused(frame, session_id)? {
831 let url = self.frames.get(frame).and_then(|known| known.first()).map(String::as_str).unwrap_or("");
832 return Err(format!("{}\n", self.guard.refusal_for_url(url)));
833 }
834 }
835 if !matches!(method, "Target.getTargetInfo" | "Target.detachFromTarget") {
836 for key in ["targetId"] {
837 if let Some(target) = params.get(key).and_then(|v| v.as_str()) {
838 let target = target.to_string();
839 if self.target_protected(&target, false)? {
840 let url = self.targets.get(&target).and_then(|info| info.get("url")).and_then(Value::as_str).unwrap_or("");
841 return Err(format!("{}\n", self.guard.refusal_for_url(url)));
842 }
843 }
844 }
845 }
846 let issued = self.client_issued(method, params, session_id)?;
847 if shield::interception_method(method) {
848 let id = shield::request_key(params).unwrap_or_default();
849 let handed = session_id
850 .is_some_and(|session| self.handed.contains(&(session.to_string(), id.clone())));
851 if !handed || self.requests.get(&id) == Some(&true) {
852 return Err(UNSEEN.into());
853 }
854 }
855 if let Some(session) = session_id.filter(|_| issued) { self.issue(params, session)?; }
856 if shield::body_method(method) {
857 let id = shield::request_key(params);
858 match id.as_deref().and_then(|id| self.request_state(id)) {
859 Some(true) => return Err(self.refusal()),
860 Some(false) => {}
861 None => {
862 let deadline = Instant::now() + Duration::from_secs(2);
863 let mut known = None;
864 while known.is_none() && Instant::now() < deadline {
865 if !self.pump(deadline)? {
866 break;
867 }
868 known = id.as_deref().and_then(|id| self.request_state(id));
869 }
870 match known {
871 Some(false) => {}
872 Some(true) => return Err(self.refusal()),
873 None => return Err(UNSEEN.into()),
874 }
875 }
876 }
877 }
878 if method == "Network.replayXHR" { return Err(self.refusal()) }
879 if method == "IO.read" {
880 let handle = params.get("handle").and_then(|v| v.as_str()).unwrap_or("");
881 if !self.streams.contains_key(handle) {
882 return Err(STREAM.into());
883 }
884 }
885 Ok(())
886 }
887
888 pub fn settled_refusal(&self, method: &str, params: &Value, session_id: Option<&str>) -> Option<String> {
889 let session_id = session_id.filter(|id| !id.is_empty());
890 if self.renderer_crashed(session_id, params.get("targetId").and_then(Value::as_str)) { return Some(RENDERER_CRASHED.to_string()) }
891 if method == "Page.handleJavaScriptDialog" || harmless(method, params) { return None }
892 if session_id.is_some_and(|session| self.blocked.contains(session)) { return Some(self.refusal()) }
893 let reason = if matches!(method, "Network.loadNetworkResource" | "Page.captureSnapshot") {
894 self.refusal()
895 } else if shield::persistent_capability(method) && method != "Browser.setWindowBounds" && (session_id.is_none() || !shield::network_state(method, params)) {
896 PERSISTENT.to_string()
897 } else if method == "Target.autoAttachRelated" || method == "Target.setAutoAttach" && params.get("autoAttach").and_then(Value::as_bool) == Some(true) {
898 AUTO_ATTACH.to_string()
899 } else if matches!(method, "Target.attachToTarget" | "Target.setAutoAttach") && params.get("flatten").and_then(Value::as_bool) != Some(true) {
900 FLATTEN.to_string()
901 } else {
902 return None;
903 };
904 if session_id.is_some_and(|session| self.dialog_sessions.contains(session) || self.guard_sessions.contains(session))
905 || self.content_refused(method, params, session_id.unwrap_or("")) {
906 return Some(self.refusal());
907 }
908 if reason == self.refusal() { return Some(reason) }
909 if Worlds::selectors(params) || Worlds::sensitive(method) { return None }
910 if params.get("targetId").and_then(Value::as_str).is_some_and(|target| self.abandoned.contains(target)) { return Some(UNGUARDED.to_string()) }
911 Some(shield::browser_wide(method, params, session_id, &self.contexts).unwrap_or(reason))
912 }
913
914 fn network_state_admitted(&self, method: &str, params: &Value, session_id: Option<&str>) -> bool {
915 let Some(session) = session_id else { return false };
916 shield::network_state(method, params)
917 && !self.guard_sessions.contains(session)
918 && !self.dialog_sessions.contains(session)
919 && !self.blocked.contains(session)
920 && self.session_target(session).is_some_and(|target| {
921 !self.protected_targets.contains(&target)
922 && !self.abandoned.contains(&target)
923 && self.targets.get(&target).is_some_and(|info| {
924 info.get("type").and_then(Value::as_str) == Some("page") && !self.info_protected(info, &[])
925 })
926 })
927 }
928
929 fn prepare(&mut self, method: &str, params: &Value, session: Option<&str>) -> Result<Vec<(String, DocumentState)>, String> {
930 #[cfg(test)]
931 let previous = self.runtime_preparing;
932 #[cfg(test)]
933 { self.runtime_preparing = method == "Runtime.evaluate"; }
934 let result = self.prepare_state(method, params, session);
935 #[cfg(test)]
936 { self.runtime_preparing = previous; }
937 result
938 }
939
940 fn prepare_state(&mut self, method: &str, params: &Value, session: Option<&str>) -> Result<Vec<(String, DocumentState)>, String> {
941 #[cfg(test)]
942 self.runtime_prepare_probe("command-classification", json!({}));
943 let content = content_command(method, params).ok_or_else(|| self.refusal())?;
944 let mut checks = Vec::new();
945 if !content { return Ok(checks) }
946 let runtime = method.starts_with("Runtime.");
947 let page_scope = if page_scope::content(method) {
948 Some(if method == "Runtime.evaluate" && !Worlds::selectors(params) { self.verify_runtime_page_scope_state(session)? }
949 else { self.verify_page_scope_state(session)? })
950 } else { None };
951 if storage_content(method) && method != "Storage.getStorageKeyForFrame" {
952 if !self.storage_scope_verified(params) { return Err(self.refusal()) }
953 return Ok(checks);
954 }
955 if matches!(method, "Fetch.getResponseBody" | "Network.getResponseBody" | "Network.getRequestPostData")
956 && session.and_then(|session| self.session_target(session)).is_some_and(|target| self.document_paused(&target))
957 && shield::request_key(params).is_some_and(|id| self.request_state(&id) == Some(false)) { return Ok(checks) }
958 if matches!(method, "IO.read" | "IO.close") {
959 let saved = params.get("handle").and_then(Value::as_str).and_then(|handle| self.streams.get(handle)).cloned();
960 let Some((Some(target), Some(expected))) = saved else { return Err(self.refusal()) };
961 let mut current = self.document_state_for(&target, true, expected.scope.as_deref()).ok_or_else(|| self.refusal())?;
962 if let Some(proof) = &expected.page_scope {
963 let guard = self.guards.get(&target).cloned().ok_or_else(|| self.refusal())?;
964 if &self.verify_page_scope(Some(&guard))? != proof { return Err(self.refusal()) }
965 current.page_scope = Some(proof.clone());
966 }
967 if current != expected { return Err(self.refusal()) }
968 checks.push((target, current));
969 }
970 if let Some(session) = session {
971 #[cfg(test)]
972 self.runtime_prepare_probe("selected-session", json!({"target_known":self.session_target(session).is_some(),"blocked":self.blocked.contains(session)}));
973 let target = self.session_target(session).ok_or_else(|| self.refusal())?;
974 if !checks.iter().any(|(known, _)| known == &target) {
975 let selected_frame = params.get("frameId").and_then(Value::as_str).map(str::to_string).or_else(|| {
976 ["contextId", "executionContextId", "uniqueContextId", "executionContextUniqueId", "executionContextName"].into_iter().find_map(|key| {
977 let value = params.get(key)?;
978 let label = if matches!(key, "contextId" | "executionContextId") { "id" } else if key == "executionContextName" { "name" } else { "unique" };
979 let value = value.as_str().map(str::to_string).unwrap_or_else(|| value.to_string());
980 self.context_frames.get(&(session.to_string(), format!("{label}:{value}"))).cloned()
981 })
982 });
983 let scope = if crosses_frames(method, params) || page_scope::content(method) && !runtime { None } else { Some(selected_frame.as_deref().unwrap_or("")) };
984 let mut state = if self.document_paused(&target) {
985 #[cfg(test)]
986 self.runtime_prepare_probe("paused-document-provenance", json!({"cached_state":self.cached_documents.contains_key(&target),
987 "guard_present":self.guards.contains_key(&target),"document_known":self.documents.contains_key(&target),
988 "previous_protected":self.documents.get(&target).is_some_and(|doc| doc.previous),"target_protected":self.protected_targets.contains(&target)}));
989 if !matches!(method, "Runtime.evaluate" | "Runtime.callFunctionOn") { return Err(self.refusal()) }
990 self.cached_documents.get(&target).cloned().ok_or_else(|| self.refusal())?
991 } else if let Some((_, state)) = page_scope.as_ref().filter(|(proof, state)| proof.0 == target && (!runtime || Self::runtime_page_reusable(state))) {
992 #[cfg(test)]
993 self.runtime_prepare_probe("selected-frame-placement", json!({"source":"fresh-page-proof","explicit_frame":selected_frame.is_some()}));
994 if runtime { Self::scoped_page_state(state, scope.unwrap_or("")).ok_or_else(|| self.refusal())? } else { state.clone() }
995 } else {
996 #[cfg(test)]
997 self.runtime_prepare_probe("selected-document-state", json!({"source":"private-document-proof","guard_present":self.guards.contains_key(&target)}));
998 self.document_state_for(&target, true, scope).ok_or_else(|| self.refusal())?
999 };
1000 #[cfg(test)]
1001 self.runtime_prepare_probe("blocking", json!({"blocked":self.blocked.contains(session)}));
1002 if self.blocked.contains(session) { return Err(self.refusal()) }
1003 for key in ["frameId", "contextId", "executionContextId", "uniqueContextId", "executionContextUniqueId", "executionContextName"] {
1004 if let Some(value) = params.get(key) {
1005 let frame = if key == "frameId" {
1006 value.as_str().map(str::to_string)
1007 } else {
1008 let label = if matches!(key, "contextId" | "executionContextId") { "id" } else if key == "executionContextName" { "name" } else { "unique" };
1009 let value = value.as_str().map(str::to_string).unwrap_or_else(|| value.to_string());
1010 self.context_frames.get(&(session.to_string(), format!("{label}:{value}"))).cloned()
1011 };
1012 #[cfg(test)]
1013 self.runtime_prepare_probe("selector-placement", json!({"selector_known":frame.is_some(),"frame_present":frame.as_ref().is_some_and(|frame| state.frames.contains_key(frame))}));
1014 if frame.is_none_or(|frame| !state.frames.contains_key(&frame)) { return Err(self.refusal()) }
1015 }
1016 }
1017 state.page_scope = page_scope.map(|(proof, _)| proof);
1018 state.runtime_scope_epoch = state.page_scope.as_ref().filter(|_| runtime).map(|proof| self.runtime_scope_epochs.get(&proof.0).copied().unwrap_or(0));
1019 checks.push((target, state));
1020 }
1021 }
1022 #[cfg(test)]
1023 self.runtime_prepare_probe("selected-state-complete", json!({"checks_present":!checks.is_empty()}));
1024 if checks.is_empty() { return Err(self.refusal()) }
1025 Ok(checks)
1026 }
1027
1028 fn scoped_page_state(state: &DocumentState, scope: &str) -> Option<DocumentState> {
1029 let mut current = if scope.is_empty() { state.frames.iter().find(|(_, frame)| frame[4].is_empty())?.0.as_str() } else { scope };
1030 let mut selected = state.clone();
1031 selected.frames.clear();
1032 loop {
1033 let frame = state.frames.get(current)?;
1034 if selected.frames.insert(current.to_string(), frame.clone()).is_some() { return None }
1035 if frame[4].is_empty() { break }
1036 current = &frame[4];
1037 }
1038 selected.scope = Some(scope.to_string());
1039 Some(selected)
1040 }
1041
1042 fn runtime_page_reusable(state: &DocumentState) -> bool {
1043 state.frames.values().find(|frame| frame[4].is_empty()).is_some_and(|frame| {
1044 url::Url::parse(&frame[1]).is_ok_and(|url| matches!(url.scheme(), "http" | "https"))
1045 })
1046 }
1047
1048 fn document_paused(&self, target: &str) -> bool {
1049 self.paused_documents.iter().any(|(session, _)| self.session_target(session).as_deref() == Some(target))
1050 }
1051
1052 fn pin_execution(&mut self, method: &str, params: &Value, session: Option<&str>, checks: &mut Vec<(String, DocumentState)>) -> Result<Option<String>, String> {
1053 if !matches!(method, "Runtime.evaluate" | "Runtime.callFunctionOn" | "Runtime.compileScript") || checks.is_empty() { return Ok(None) }
1054 if method == "Runtime.callFunctionOn" && params.get("objectId").is_some() { return Ok(None) }
1055 let session = session.ok_or_else(|| self.refusal())?;
1056 let target = self.session_target(session).ok_or_else(|| self.refusal())?;
1057 let mut state = checks.iter().find(|(id, _)| id == &target).map(|(_, state)| state.clone()).ok_or_else(|| self.refusal())?;
1058 let guard = if let Some(guard) = self.guards.get(&target).or_else(|| self.runtime_sessions.get(&target)) {
1059 guard.clone()
1060 } else {
1061 if state.worker.is_none() { return Err(self.refusal()) }
1062 let result = self.raw_call("Target.attachToTarget", json!({"targetId":target,"flatten":true}), None, DOCUMENT_CHECK)?;
1063 let guard = result.get("sessionId").and_then(Value::as_str).ok_or_else(|| self.refusal())?.to_string();
1064 self.guard_sessions.insert(guard.clone());
1065 self.session_targets.insert(guard.clone(), target.clone());
1066 self.runtime_sessions.insert(target.clone(), guard.clone());
1067 guard
1068 };
1069 let choose = |proofs: &BTreeMap<(String, String), ContextProof>, state: &DocumentState| {
1070 proofs.iter().find(|((owner, unique), proof)| {
1071 owner == &guard && if let Some(id) = params.get("contextId").or_else(|| params.get("executionContextId")).and_then(Value::as_i64) {
1072 proof.id == id
1073 } else if let Some(id) = params.get("uniqueContextId").or_else(|| params.get("executionContextUniqueId")).and_then(Value::as_str) {
1074 unique == id
1075 } else if let Some(name) = params.get("executionContextName").and_then(Value::as_str) {
1076 proof.name == name
1077 } else { proof.default && (state.worker.is_some() || state.scope.as_deref() == Some(proof.frame.as_str()) || state.frames.get(&proof.frame).is_some_and(|evidence| evidence[4].is_empty())) }
1078 }).map(|((_, unique), proof)| (unique.clone(), proof.clone()))
1079 };
1080 let mut selected = choose(&self.context_proofs, &state);
1081 #[cfg(test)]
1082 self.runtime_contexts(method, "private-context-initial", &guard, &target, &state, selected.as_ref().map(|(unique, _)| unique.as_str()));
1083 let paused = self.document_paused(&target);
1084 let stable_context = selected.as_ref().is_some_and(|(_, proof)| state.worker.is_some()
1085 || state.frames.get(&proof.frame).is_some_and(|evidence| proof.loader.as_deref() == Some(evidence[0].as_str())));
1086 if !paused && !stable_context {
1087 let deadline = Instant::now() + DOCUMENT_CHECK;
1088 for attempt in 0..2 {
1089 self.context_proofs.retain(|(owner, _), _| owner != &guard);
1090 let left = deadline.saturating_duration_since(Instant::now());
1091 if left.is_zero() { return Err(self.refusal()) }
1092 self.raw_call("Runtime.disable", json!({}), Some(&guard), left)?;
1093 let left = deadline.saturating_duration_since(Instant::now());
1094 if left.is_zero() { return Err(self.refusal()) }
1095 self.raw_call("Runtime.enable", json!({}), Some(&guard), left)?;
1096 #[cfg(test)]
1097 self.runtime_contexts(method, "private-context-replayed", &guard, &target, &state, selected.as_ref().map(|(unique, _)| unique.as_str()));
1098 let current = self.document_state_for(&target, true, state.scope.as_deref()).ok_or_else(|| self.refusal())?;
1099 #[cfg(test)]
1100 self.runtime_contexts(method, "private-context-current", &guard, &target, ¤t, selected.as_ref().map(|(unique, _)| unique.as_str()));
1101 let same = if state.worker.is_some() { state.worker == current.worker } else {
1102 state.frames.iter().filter(|(_, evidence)| evidence[4].is_empty()).all(|(id, evidence)| current.frames.get(id).is_some_and(|now| evidence[0] == now[0] && evidence[2] == now[2]))
1103 };
1104 if self.blocked.contains(session) { return Err(self.refusal()) }
1105 if !same {
1106 let ordinary_default_commit = state.worker.is_none() && state.scope.as_deref() == Some("") && state.frames.len() == 1
1107 && !Worlds::selectors(params) && self.guards.get(&target) == Some(&guard)
1108 && state.page_scope.as_ref().is_some_and(|proof| proof.0 == target)
1109 && state.frames.iter().all(|(id, before)| current.frames.get(id).is_some_and(|after| before[0] != after[0]
1110 && Self::runtime_page_reusable(¤t)));
1111 if attempt != 0 || !ordinary_default_commit { return Err(self.refusal()) }
1112 #[cfg(test)]
1113 self.runtime_stage(method, "private-context-readmission");
1114 *checks = self.prepare(method, params, Some(session))?;
1115 state = checks.iter().find(|(id, _)| id == &target).map(|(_, state)| state.clone()).ok_or_else(|| self.refusal())?;
1116 continue;
1117 }
1118 selected = choose(&self.context_proofs, &state);
1119 if selected.is_some() { break }
1120 }
1121 }
1122 #[cfg(test)]
1123 self.runtime_contexts(method, "private-context-validation", &guard, &target, &state, selected.as_ref().map(|(unique, _)| unique.as_str()));
1124 let (unique, proof) = selected.ok_or_else(|| self.refusal())?;
1125 let owned_world = !proof.default && self.created_contexts.contains(&(session.to_string(), proof.id));
1126 let owned_blank = proof.default && state.frames.get(&proof.frame).is_some_and(|evidence| evidence[1] == "about:blank"
1127 && self.owns_blank(&target, &proof.frame, &evidence[0]));
1128 if unique.is_empty() || proof.origin == "null" && !owned_blank || proof.origin.is_empty() && !owned_world && !owned_blank || self.guard.url(&proof.origin) { return Err(self.refusal()) }
1129 if state.worker.is_none() {
1130 let evidence = state.frames.get(&proof.frame).ok_or_else(|| self.refusal())?;
1131 if proof.loader.as_deref() != Some(evidence[0].as_str()) { return Err(self.refusal()) }
1132 }
1133 Ok(Some(unique))
1134 }
1135
1136 fn storage_scope_verified(&self, params: &Value) -> bool {
1137 let mut scopes = Vec::new();
1138 fn collect(value: &Value, scopes: &mut Vec<String>) -> bool {
1139 let Some(items) = value.as_object() else { return false };
1140 for (key, value) in items {
1141 if matches!(key.as_str(), "origin" | "securityOrigin" | "storageKey" | "cacheId") {
1142 let Some(text) = value.as_str() else { return false };
1143 scopes.push(if key == "cacheId" { text.split('|').next().unwrap_or("").to_string() } else { text.to_string() });
1144 } else if value.is_object() && !collect(value, scopes) { return false }
1145 }
1146 true
1147 }
1148 collect(params, &mut scopes) && !scopes.is_empty() && scopes.iter().all(|scope| {
1149 let mut parts = scope.split('^');
1150 let origin = parts.next().unwrap_or("");
1151 let valid = |text: &str| url::Url::parse(text).ok().is_some_and(|url| url.origin().ascii_serialization() != "null" && !self.guard.url(text));
1152 valid(origin) && !self.guard.storage_key(scope)
1153 && parts.filter_map(|part| part.strip_prefix('0')).all(valid)
1154 })
1155 }
1156
1157 fn verify_checks(&mut self, checks: &[(String, DocumentState)], same_document: bool, stable_page: bool) -> Result<(), String> {
1158 for (target, expected) in checks {
1159 let current = if let Some(proof) = &expected.page_scope {
1160 let session = self.guards.get(&proof.0).cloned().ok_or_else(|| self.refusal())?;
1161 let (current, state) = self.verify_page_scope_state(Some(&session))?;
1162 if stable_page && ¤t != proof { return Err(self.refusal()) }
1163 if current.0 == *target && (expected.runtime_scope_epoch.is_none() || Self::runtime_page_reusable(&state)) {
1164 Some(if expected.runtime_scope_epoch.is_some() { Self::scoped_page_state(&state, expected.scope.as_deref().unwrap_or("")).ok_or_else(|| self.refusal())? } else { state })
1165 } else { None }
1166 } else { None };
1167 let current = match current {
1168 Some(state) => state,
1169 None => self.document_state_for(target, true, expected.scope.as_deref()).ok_or_else(|| self.refusal())?,
1170 };
1171 if same_document && ¤t != expected { return Err(self.refusal()) }
1172 }
1173 Ok(())
1174 }
1175
1176 fn verify_execution(&mut self, checks: &[(String, DocumentState)]) -> Result<(), String> {
1177 for (_, state) in checks {
1178 if let Some(proof) = &state.page_scope {
1179 let session = self.guards.get(&proof.0).cloned().ok_or_else(|| self.refusal())?;
1180 if self.session_target(&session).as_deref() != Some(&proof.0) { return Err(self.refusal()) }
1181 if self.page_scope_unknown != proof.2 || state.runtime_scope_epoch != Some(self.runtime_scope_epochs.get(&proof.0).copied().unwrap_or(0)) {
1182 if self.verify_page_scope(Some(&session))?.0 != proof.0 { return Err(self.refusal()) }
1183 }
1184 }
1185 }
1186 for (target, state) in checks {
1187 let owner = state.worker.as_ref().map_or(target.as_str(), |(_, owner)| owner.as_str());
1188 if self.unchecked_document(owner) {
1189 let guard = self.guards.get(owner).cloned().ok_or_else(|| self.refusal())?;
1190 self.verify_page_scope_state(Some(&guard))?;
1191 }
1192 }
1193 let sealed = checks.iter().any(|(target, state)| {
1194 let owner = state.worker.as_ref().map_or(target.as_str(), |(_, owner)| owner.as_str());
1195 self.unchecked_document(owner) || self.documents.get(owner).is_some_and(|doc| self.unverified_error(&doc.url, &doc.unreachable_url))
1196 });
1197 if sealed { Err(self.refusal()) } else { Ok(()) }
1198 }
1199
1200 fn unverified_error(&self, url: &str, unreachable: &str) -> bool {
1201 let error = self.guard.error_page_url(url) || !unreachable.is_empty()
1202 || url.get(..13).is_some_and(|scheme| scheme.eq_ignore_ascii_case("chrome-error:"));
1203 error && (url::Url::parse(unreachable).is_err() || self.guard.url(unreachable))
1204 }
1205
1206 fn bind_streams(&mut self, method: &str, session: Option<&str>, result: &Value, checks: &[(String, DocumentState)]) {
1207 let target = session.and_then(|session| self.session_target(session));
1208 let document = target.as_ref().and_then(|target| checks.iter().find(|(known, _)| known == target)).map(|(_, state)| state.clone());
1209 for stream in [result.get("stream"), result.pointer("/resource/stream")].into_iter().flatten().filter_map(Value::as_str) {
1210 self.streams.insert(stream.to_string(), (target.clone(), document.clone()));
1211 }
1212 if method == "IO.resolveBlob" {
1213 if let Some(uuid) = result.get("uuid").and_then(Value::as_str) {
1214 self.streams.insert(format!("blob:{uuid}"), (target, document));
1215 }
1216 }
1217 }
1218
1219 fn request_state(&self, id: &str) -> Option<bool> {
1220 if self.redirects.contains(id) { Some(true) } else { self.requests.get(id).copied() }
1221 }
1222
1223 fn after(
1224 &mut self,
1225 method: &str,
1226 params: &Value,
1227 session_id: Option<&str>,
1228 mut result: Value,
1229 ) -> Result<Value, String> {
1230 if self.content_refused(method, params, session_id.unwrap_or("")) {
1231 return Err(self.refusal());
1232 }
1233 if Worlds::sensitive(method) {
1234 if let Some(reason) = self.worlds.reason(session_id.unwrap_or(""), method, params) {
1235 return Err(reason.into());
1236 }
1237 }
1238 if method == "Runtime.enable" {
1239 self.worlds.enable(session_id.unwrap_or(""));
1240 } else if method == "Runtime.disable" {
1241 self.worlds.disable(session_id.unwrap_or(""));
1242 }
1243 self.worlds.reply(session_id.unwrap_or(""), method, &result);
1244 if method == "Page.createIsolatedWorld" {
1245 self.worlds.created(session_id.unwrap_or(""), &result);
1246 if let (Some(frame), Some(id)) = (params.get("frameId").and_then(Value::as_str), result.get("executionContextId")) {
1247 if let Some(id) = id.as_i64() { self.created_contexts.insert((session_id.unwrap_or("").to_string(), id)); }
1248 self.context_frames.insert((session_id.unwrap_or("").to_string(), format!("id:{id}")), frame.to_string());
1249 }
1250 }
1251 if method == "Runtime.compileScript" {
1252 self.worlds.script(session_id.unwrap_or(""), &result);
1253 }
1254 match method {
1255 "Page.navigate" if params.get("url").and_then(Value::as_str) == Some("about:blank")
1256 && params.get("frameId").is_none() && result.get("errorText").is_none()
1257 && result.get("isDownload").is_none_or(|download| download == &json!(false)) => {
1258 if let (Some(target), Some(frame), Some(loader)) = (
1259 session_id.and_then(|session| self.session_target(session)),
1260 result.get("frameId").and_then(Value::as_str).filter(|id| frame_text_known(id)),
1261 result.get("loaderId").and_then(Value::as_str).filter(|id| frame_text_known(id)),
1262 ) {
1263 if let Some(guard) = self.guards.get(&target).filter(|guard| !self.blocked.contains(*guard)) {
1264 if !self.protected_targets.contains(&target) && !self.abandoned.contains(&target)
1265 && self.documents.get(&target).is_some_and(|doc| !doc.previous && doc.frame_id == frame)
1266 && self.targets.get(&target).and_then(|info| info.get("type")).and_then(Value::as_str) == Some("page") {
1267 self.navigated_blanks.insert(target, (guard.clone(), frame.to_string(), loader.to_string()));
1268 }
1269 }
1270 }
1271 }
1272 "Target.attachToTarget" => {
1273 let session = result
1274 .get("sessionId")
1275 .and_then(|v| v.as_str())
1276 .unwrap_or("")
1277 .to_string();
1278 let target = params
1279 .get("targetId")
1280 .and_then(|v| v.as_str())
1281 .unwrap_or("")
1282 .to_string();
1283 if !session.is_empty() {
1284 self.session_targets.insert(session.clone(), target.clone());
1285 if let Err(message) = self.touch(&target) {
1286 if transport_error(&message) {
1287 self.session_targets.remove(&session);
1288 return Err(message);
1289 }
1290 let detached = self.raw_call(
1291 "Target.detachFromTarget",
1292 json!({ "sessionId": session }),
1293 None,
1294 Duration::from_secs(5),
1295 );
1296 self.session_targets.remove(&session);
1297 if let Err(closed) = detached {
1298 if transport_error(&closed) {
1299 return Err(closed);
1300 }
1301 }
1302 return Err(message);
1303 }
1304 if self.protected_targets.contains(&target) {
1305 self.block(&session);
1306 return Err(self.refusal());
1307 }
1308 }
1309 }
1310 "Target.createBrowserContext" => {
1311 if let Some(id) = result.get("browserContextId").and_then(|v| v.as_str()) {
1312 self.contexts.insert(id.to_string());
1313 }
1314 }
1315 "Target.getTargets" => {
1316 let infos = result
1317 .get("targetInfos")
1318 .and_then(|v| v.as_array())
1319 .cloned()
1320 .unwrap_or_default();
1321 for info in &infos {
1322 self.probe_error(info);
1323 }
1324 for info in &infos {
1325 if let Some(id) = info.get("targetId").and_then(|v| v.as_str()) {
1326 self.targets.insert(id.to_string(), info.clone());
1327 }
1328 }
1329 let mut out = Vec::new();
1330 for info in &infos {
1331 let redacted = self.redact(info, &infos);
1332 let url = info.get("url").and_then(Value::as_str).unwrap_or("");
1333 if !(self.guard.target_type(info.get("type").and_then(Value::as_str).unwrap_or(""))
1334 || self.guard.unparseable(url) && self.guard.url(url)) {
1335 out.push(redacted);
1336 }
1337 }
1338 result["targetInfos"] = Value::Array(out);
1339 }
1340 "Target.getTargetInfo" => {
1341 if let Some(info) = result.get("targetInfo").cloned() {
1342 let target = info.get("targetId").and_then(|v| v.as_str()).unwrap_or("").to_string();
1343 self.targets.insert(target.clone(), info.clone());
1344 self.probe_error(&info);
1345 let protected = self.info_protected(&info, &[]);
1346 if protected && !self.documents.contains_key(&target) {
1347 self.protect_target(&target);
1348 }
1349 if protected || self.discovery_redacted(&info) {
1350 result["targetInfo"] = shield::redacted(&info);
1351 }
1352 }
1353 }
1354 _ if shield::cookie_reader(method) => {
1355 let mut cookies = result.get("cookies").and_then(Value::as_array).cloned().unwrap_or_default();
1356 cookies.extend(self.trace_cookies.iter().cloned());
1357 shield::redact_cookie_events(&self.guard, &mut self.events, &json!({ "cookies": cookies }));
1358 shield::drop_protected_cookies(&self.guard, &mut result);
1359 }
1360 _ => {}
1361 }
1362 shield::redact_strings(&self.guard, &mut result);
1363 Ok(result)
1364 }
1365
1366 fn discovery_redacted(&self, info: &Value) -> bool {
1367 self.guard.error_redaction()
1368 && self.guard.url(info.get("url").and_then(Value::as_str).unwrap_or(""))
1369 }
1370
1371 fn redact(&mut self, info: &Value, all: &[Value]) -> Value {
1372 let protected = self.info_protected(info, all);
1373 if protected {
1374 if let Some(target) = info.get("targetId").and_then(Value::as_str) {
1375 if !self.documents.contains_key(target) {
1376 self.protect_target(target);
1377 }
1378 }
1379 }
1380 if protected || self.discovery_redacted(info) {
1381 shield::redacted(info)
1382 } else {
1383 info.clone()
1384 }
1385 }
1386
1387 fn info_protected(&self, info: &Value, all: &[Value]) -> bool {
1388 if self.guard.target_type(info.get("type").and_then(Value::as_str).unwrap_or("")) {
1389 return true;
1390 }
1391 let url = info.get("url").and_then(|v| v.as_str()).unwrap_or("");
1392 let id = info.get("targetId").and_then(|v| v.as_str()).unwrap_or("");
1393 let previous = self.protected_targets.contains(id);
1394 if let Some(doc) = self.documents.get(id) {
1395 if doc.navigating {
1396 return doc.previous || self.guard.url(url) || doc.navigation_url.is_empty() || self.guard.url(&doc.navigation_url);
1397 }
1398 if (self.guard.error_page_url(&doc.url) || !doc.unreachable_url.is_empty()) && !self.masked_error(doc, url) {
1399 if !self.guard.error_document(&doc.url, &doc.origin)
1400 || !(self.reported_unreachable(&doc.unreachable_url, url) || self.guard.error_page_url(url) && doc.url == url && !doc.unreachable_url.is_empty()) {
1401 return true;
1402 }
1403 return self.guard.target_with_document(&doc.unreachable_url, doc.previous, Opener::None,
1404 Some(&doc.url), Some(&doc.unreachable_url), doc.navigating);
1405 }
1406 if doc.previous {
1407 return true;
1408 }
1409 }
1410 let opener = match info
1411 .get("openerId")
1412 .and_then(|v| v.as_str())
1413 .filter(|v| !v.is_empty())
1414 {
1415 None => Opener::None,
1416 Some(opener) => match all
1417 .iter()
1418 .find(|item| item.get("targetId").and_then(|v| v.as_str()) == Some(opener))
1419 {
1420 Some(found) if found.get("targetId") == info.get("targetId") => Opener::Unknown,
1421 Some(found) if self.info_protected(found, &[]) => Opener::Protected,
1422 Some(_) => Opener::Unprotected,
1423 None if self.protected_targets.contains(opener) => Opener::Protected,
1424 None => match self.targets.get(opener) {
1425 Some(found) if found.get("targetId") != info.get("targetId") => {
1426 if self.info_protected(found, &[]) {
1427 Opener::Protected
1428 } else {
1429 Opener::Unprotected
1430 }
1431 }
1432 _ => Opener::Unknown,
1433 },
1434 },
1435 };
1436 self.guard.target(url, previous, opener)
1437 }
1438
1439 pub fn target_protected(&mut self, target_id: &str, frame: bool) -> Result<bool, String> {
1440 self.judge_target(target_id, frame, true)
1441 }
1442
1443 fn judge_target(&mut self, target_id: &str, frame: bool, refusal_protects: bool) -> Result<bool, String> {
1444 if self.protected_targets.contains(target_id) {
1445 return Ok(true);
1446 }
1447 let info = match self.raw_call(
1448 "Target.getTargetInfo",
1449 json!({ "targetId": target_id }),
1450 None,
1451 Duration::from_secs(30),
1452 ) {
1453 Ok(info) => info.get("targetInfo").cloned().unwrap_or(Value::Null),
1454 Err(message) if refusal_protects && message.starts_with("Target.getTargetInfo: slicc: refused:") => {
1455 self.protected_targets.insert(target_id.to_string());
1456 return Ok(true);
1457 }
1458 Err(_) if frame => return Ok(false),
1459 Err(message) => return Err(message),
1460 };
1461 if info.is_object() {
1462 self.targets.insert(target_id.to_string(), info.clone());
1463 if self.documents.get(target_id).is_some_and(|doc| doc.probed) {
1464 self.documents.remove(target_id);
1465 } else if !self.refresh(target_id) {
1466 return Ok(true);
1467 }
1468 self.probe_error(&info);
1469 }
1470 let url = info.get("url").and_then(|v| v.as_str()).unwrap_or("").to_string();
1471 let opener = match info
1472 .get("openerId")
1473 .and_then(|v| v.as_str())
1474 .filter(|id| !id.is_empty())
1475 .map(str::to_string)
1476 {
1477 None => Opener::None,
1478 Some(id) if self.protected_targets.contains(&id) => Opener::Protected,
1479 Some(id) => match self.raw_call(
1480 "Target.getTargetInfo",
1481 json!({ "targetId": id }),
1482 None,
1483 Duration::from_secs(30),
1484 ) {
1485 Ok(found) => {
1486 let opener_info = found.get("targetInfo").unwrap_or(&Value::Null);
1487 let opener_url = opener_info.get("url").and_then(Value::as_str).unwrap_or("");
1488 if self.guard.target_type(opener_info.get("type").and_then(Value::as_str).unwrap_or(""))
1489 || self.guard.target(opener_url, false, Opener::Unknown)
1490 {
1491 Opener::Protected
1492 } else {
1493 Opener::Unprotected
1494 }
1495 }
1496 Err(_) => Opener::Unknown,
1497 },
1498 };
1499 let protected = if self.documents.contains_key(target_id) {
1500 self.info_protected(&info, &[])
1501 } else {
1502 self.guard.target_type(info.get("type").and_then(Value::as_str).unwrap_or(""))
1503 || self.guard.target(&url, false, opener)
1504 };
1505 if protected && !self.documents.contains_key(target_id) {
1506 self.protect_target(target_id);
1507 }
1508 Ok(protected)
1509 }
1510
1511 fn create_target(&mut self, params: Value, timeout: Duration) -> Result<Value, String> {
1512 let url = params
1513 .get("url")
1514 .and_then(|v| v.as_str())
1515 .unwrap_or("about:blank")
1516 .to_string();
1517 let mut blank = params.clone();
1518 blank["url"] = json!("about:blank");
1519 let mark = self.events.len();
1520 let result = self.raw_call("Target.createTarget", blank, None, timeout)?;
1521 let target = result
1522 .get("targetId")
1523 .and_then(|v| v.as_str())
1524 .unwrap_or("")
1525 .to_string();
1526 if let Err(message) = self.touch(&target) {
1527 let closed = self
1528 .raw_call(
1529 "Target.closeTarget",
1530 json!({ "targetId": target }),
1531 None,
1532 Duration::from_secs(5),
1533 )
1534 .and_then(|result| {
1535 if result.get("success").and_then(Value::as_bool) != Some(true) {
1536 return Err("Target.closeTarget did not confirm success\n".into());
1537 }
1538 self.wait_destroyed(&target, mark, Duration::from_secs(2))
1539 });
1540 return Err(match closed {
1541 Ok(()) => message,
1542 Err(error) => format!("{message}slicc: refused: cleanup: {}\n", error.trim()),
1543 });
1544 }
1545 self.record_initial_blank(&target);
1546 if !url.eq_ignore_ascii_case("about:blank") {
1547 let guard = self.guards.get(&target).cloned();
1548 self.send("Page.navigate", json!({ "url": url }), guard.as_deref())?;
1549 }
1550 Ok(result)
1551 }
1552
1553 fn record_initial_blank(&mut self, target: &str) {
1554 if let Some(recorded) = self.initial_blank_evidence(target, true) {
1555 self.created_blanks.insert(target.to_string(), recorded);
1556 let _ = self.document_state_for(target, true, Some(""));
1557 }
1558 }
1559
1560 pub fn created_blank(&self, target: &str) -> Option<Value> {
1561 self.created_blanks.get(target).map(|(frame, loader, entry)| json!([frame, loader, entry]))
1562 }
1563
1564 pub fn restore_created_blank(&mut self, target: &str, proof: &Value) -> bool {
1565 let expected = proof.as_array().filter(|values| values.len() == 3).and_then(|values| {
1566 Some((values[0].as_str()?.to_string(), values[1].as_str()?.to_string(), values[2].as_i64()?))
1567 });
1568 let Some(expected) = expected else { return false };
1569 if self.initial_blank_evidence(target, false).as_ref() != Some(&expected) { return false }
1570 self.created_blanks.insert(target.to_string(), expected);
1571 true
1572 }
1573
1574 fn owns_blank(&self, target: &str, frame: &str, loader: &str) -> bool {
1575 self.created_blanks.get(target).is_some_and(|(id, version, _)| id == frame && version == loader)
1576 || self.navigated_blanks.get(target).is_some_and(|(guard, id, version)| self.guards.get(target) == Some(guard) && id == frame && version == loader)
1577 }
1578
1579 fn initial_blank_evidence(&mut self, target: &str, empty: bool) -> Option<(String, String, i64)> {
1580 let guard = self.guards.get(target)?.clone();
1581 let result = self.raw_call("Target.getTargetInfo", json!({"targetId":target}), None, DOCUMENT_CHECK).ok()?;
1582 let info = result.get("targetInfo")?;
1583 if info.get("targetId").and_then(Value::as_str) != Some(target)
1584 || info.get("type").and_then(Value::as_str) != Some("page")
1585 || info.get("url").and_then(Value::as_str) != Some("about:blank")
1586 || info.get("openerId").is_some() || info.get("openerFrameId").is_some() { return None }
1587 let history = self.raw_call("Page.getNavigationHistory", json!({}), Some(&guard), DOCUMENT_CHECK).ok()?;
1588 let entries = history.get("entries")?.as_array()?;
1589 if history.get("currentIndex").and_then(Value::as_i64) != Some(0) || entries.len() != 1
1590 || entries[0].get("url").and_then(Value::as_str) != Some("about:blank") { return None }
1591 let entry = entries[0].get("id")?.as_i64()?;
1592 let state = self.document_state(target, false)?;
1593 if empty && state.frames.len() != 1 { return None }
1594 let (id, evidence) = state.frames.iter().find(|(_, evidence)| evidence[4].is_empty())?;
1595 if evidence[1] != "about:blank" || !evidence[3].is_empty()
1596 || matches!(evidence[2].as_str(), "" | "null") || self.guard.url(&evidence[2]) { return None }
1597 Some((id.clone(), evidence[0].clone(), entry))
1598 }
1599
1600 fn wait_destroyed(&mut self, target: &str, mark: usize, timeout: Duration) -> Result<(), String> {
1601 let deadline = Instant::now() + timeout;
1602 let destroyed = |events: &[Value]| {
1603 events[mark..].iter().any(|event| {
1604 event.get("method").and_then(Value::as_str) == Some("Target.targetDestroyed")
1605 && event.pointer("/params/targetId").and_then(Value::as_str) == Some(target)
1606 })
1607 };
1608 loop {
1609 if destroyed(&self.events) {
1610 return Ok(());
1611 }
1612 let left = deadline.saturating_duration_since(Instant::now());
1613 if left.is_zero() {
1614 return Err(
1615 "Target.targetDestroyed timed out and Target.getTargets did not confirm closure\n".into()
1616 );
1617 }
1618 let listed = self.raw_call("Target.getTargets", json!({}), None, left);
1619 let absent = listed
1620 .as_ref()
1621 .ok()
1622 .and_then(|result| result.get("targetInfos"))
1623 .and_then(Value::as_array)
1624 .is_some_and(|infos| {
1625 infos.iter().all(|info| info.get("targetId").and_then(Value::as_str).is_some())
1626 && !infos.iter().any(|info| info.get("targetId").and_then(Value::as_str) == Some(target))
1627 });
1628 if destroyed(&self.events) || absent {
1629 return Ok(());
1630 }
1631 let left = deadline.saturating_duration_since(Instant::now());
1632 self.pump(Instant::now() + left.min(Duration::from_millis(100)))?;
1633 }
1634 }
1635
1636 fn touch(&mut self, target_id: &str) -> Result<(), String> {
1637 if target_id.is_empty() || self.guards.contains_key(target_id) {
1638 return Ok(());
1639 }
1640 let kind = match self.targets.get(target_id) {
1641 Some(info) => info.get("type").and_then(|v| v.as_str()).map(str::to_string),
1642 None => self
1643 .raw_call(
1644 "Target.getTargetInfo",
1645 json!({ "targetId": target_id }),
1646 None,
1647 Duration::from_secs(10),
1648 )
1649 .ok()
1650 .and_then(|info| {
1651 info.pointer("/targetInfo/type")
1652 .and_then(|v| v.as_str())
1653 .map(str::to_string)
1654 }),
1655 };
1656 if kind
1657 .as_deref()
1658 .is_some_and(|kind| !matches!(kind, "page" | "iframe" | "background_page" | "webview" | "other"))
1659 {
1660 return Ok(());
1661 }
1662 let budget = Instant::now() + GUARD_SETUP;
1663 if !self.discovering {
1664 self.raw_call(
1665 "Target.setDiscoverTargets",
1666 json!({ "discover": true }),
1667 None,
1668 GUARD_SETUP,
1669 )
1670 .map_err(unguarded)?;
1671 self.discovering = true;
1672 }
1673 self.guarding.insert(target_id.to_string());
1674 let left = budget.saturating_duration_since(Instant::now());
1675 let attached = if left.is_zero() {
1676 Err("Target.attachToTarget timed out\n".to_string())
1677 } else {
1678 self.raw_call(
1679 "Target.attachToTarget",
1680 json!({ "targetId": target_id, "flatten": true }),
1681 None,
1682 left,
1683 )
1684 };
1685 self.guarding.remove(target_id);
1686 let session = match attached
1687 .map(|value| value.get("sessionId").and_then(|v| v.as_str()).map(str::to_string))
1688 {
1689 Ok(Some(session)) => session,
1690 Ok(None) => {
1691 self.abandon(target_id);
1692 return Err(UNGUARDED.to_string());
1693 }
1694 Err(message) => {
1695 self.abandon(target_id);
1696 return Err(unguarded(message));
1697 }
1698 };
1699 self.guard_sessions.insert(session.clone());
1700 self.guards.insert(target_id.to_string(), session.clone());
1701 let left = budget.saturating_duration_since(Instant::now());
1702 let inspected = if left.is_zero() { Err("Inspector.enable timed out\n".to_string()) }
1703 else { self.raw_call("Inspector.enable", json!({}), Some(&session), left) };
1704 if let Err(message) = inspected {
1705 return Err(self.guard_failure(target_id, &session, message));
1706 }
1707 let setup = [
1708 (
1709 "Fetch.enable",
1710 json!({ "patterns": [{ "urlPattern": "*", "resourceType": "Document", "requestStage": "Request" }] }),
1711 ),
1712 ("Network.enable", json!({})),
1713 ("Network.setBypassServiceWorker", json!({ "bypass": true })),
1714 ("Page.enable", json!({})),
1715 ("Runtime.enable", json!({})),
1716 ];
1717 for (method, params) in setup {
1718 if method == "Runtime.enable" {
1719 let _ = self.document_state_for(target_id, false, Some(""));
1720 let _ = self.document_state_for(target_id, true, Some(""));
1721 }
1722 let optional = matches!(method, "Page.enable" | "Runtime.enable");
1723 let left = budget.saturating_duration_since(Instant::now());
1724 let span = if optional { left.min(OPTIONAL_STEP) } else { left };
1725 let answer = if span.is_zero() {
1726 Err(format!("{method} timed out\n"))
1727 } else {
1728 self.raw_call(method, params, Some(&session), span)
1729 };
1730 if method == "Page.enable" && answer.is_err() {
1731 self.unobserved.insert(target_id.to_string());
1732 }
1733 let failed = match answer {
1734 Ok(_) => None,
1735 Err(message) if optional && message == format!("{method} timed out\n") => {
1736 if self
1737 .unguarded_optional
1738 .entry(target_id.to_string())
1739 .or_default()
1740 .insert(method.to_string())
1741 {
1742 self.notices
1743 .push(format!("slicc: guard: {method} timed out; continuing\n"));
1744 }
1745 None
1746 }
1747 Err(message) if optional && message.starts_with(&format!("{method}:")) => None,
1748 Err(message) => Some(message),
1749 };
1750 if let Some(message) = failed {
1751 return Err(self.guard_failure(target_id, &session, message));
1752 }
1753 }
1754 if self.documents.get(target_id).is_none_or(|doc| doc.probed) {
1755 let left = budget.saturating_duration_since(Instant::now());
1756 if !left.is_zero() {
1757 let epoch = self.frame_epoch;
1758 if let Ok(tree) = self.raw_exchange("Page.getFrameTree", json!({}), Some(&session), left.min(OPTIONAL_STEP), false) {
1759 if self.tree_current(&tree, epoch) {
1760 self.record_frames(&tree, &session);
1761 }
1762 if self.documents.get(target_id).is_none_or(|doc| doc.probed) {
1763 if let Some(frame) = tree.pointer("/frameTree/frame").filter(|frame| self.main_frame_current(frame, epoch)) {
1764 self.main_commit(&session, frame);
1765 }
1766 }
1767 }
1768 }
1769 }
1770 Ok(())
1771 }
1772
1773 fn guard_failure(&mut self, target: &str, session: &str, message: String) -> String {
1774 self.guards.remove(target);
1775 self.abandon(target);
1776 let _ = self.raw_call("Target.detachFromTarget", json!({ "sessionId": session }), None, Duration::from_secs(5));
1777 unguarded(message)
1778 }
1779
1780 fn abandon(&mut self, target_id: &str) {
1781 self.abandoned.insert(target_id.to_string());
1782 self.protect_target(target_id);
1783 }
1784
1785 fn adopt_guard_attach(&mut self, value: &Value) {
1786 if value.get("method").and_then(|v| v.as_str()) != Some("Target.attachedToTarget") {
1787 return;
1788 }
1789 let target = value
1790 .pointer("/params/targetInfo/targetId")
1791 .and_then(|v| v.as_str())
1792 .unwrap_or("");
1793 let Some(session) = value.pointer("/params/sessionId").and_then(|v| v.as_str()) else {
1794 return;
1795 };
1796 if self.guarding.contains(target) {
1797 self.guard_sessions.insert(session.to_string());
1798 } else if self.abandoned.contains(target) {
1799 self.guard_sessions.insert(session.to_string());
1800 let _ = self.send(
1801 "Target.detachFromTarget",
1802 json!({ "sessionId": session }),
1803 None,
1804 );
1805 }
1806 }
1807
1808 fn block(&mut self, session_id: &str) {
1809 let newly_blocked = self.blocked.insert(session_id.to_string());
1810 if self.webmcp_is_paused(session_id) {
1811 self.webmcp.deferred.insert(session_id.to_string());
1812 self.webmcp_revoke(session_id);
1813 return;
1814 }
1815 if !newly_blocked && !self.webmcp.deferred.remove(session_id) {
1816 return;
1817 }
1818 self.webmcp_revoke(session_id);
1819 if let Some(target) = self.session_targets.get(session_id) {
1820 self.protected_targets.insert(target.clone());
1821 }
1822 let queued: Vec<Paused> = self.paused.drain(..).collect();
1823 for paused in queued {
1824 if paused.session_id == session_id {
1825 self.answer_protected(&paused);
1826 } else {
1827 self.paused.push_back(paused);
1828 }
1829 }
1830 if !self.executing_sessions.contains(session_id) { self.detach_blocked(session_id); }
1831 }
1832
1833 fn detach_blocked(&mut self, session_id: &str) {
1834 let _ = self.send("Fetch.disable", json!({}), Some(session_id));
1835 let _ = self.send(
1836 "Target.detachFromTarget",
1837 json!({ "sessionId": session_id }),
1838 None,
1839 );
1840 }
1841
1842 fn session_target(&self, session_id: &str) -> Option<String> {
1843 self.session_targets.get(session_id).cloned().or_else(|| {
1844 self.guards
1845 .iter()
1846 .find(|(_, guard)| guard.as_str() == session_id)
1847 .map(|(target, _)| target.clone())
1848 })
1849 }
1850
1851 fn main_commit(&mut self, session: &str, frame: &Value) {
1852 let Some(target) = self.session_target(session) else { return };
1853 if self.guards.get(&target).is_some_and(|guard| guard != session) && !self.unobserved.contains(&target) {
1854 if self.guard.url(frame.get("url").and_then(Value::as_str).unwrap_or(""))
1855 || self.guard.url(frame.get("securityOrigin").and_then(Value::as_str).unwrap_or(""))
1856 {
1857 self.committed_protected(session);
1858 }
1859 return;
1860 }
1861 let Some(frame_id) = frame.get("id").and_then(Value::as_str) else { return };
1862 if let Some(loader) = frame.get("loaderId").and_then(Value::as_str).filter(|loader| !loader.is_empty()) {
1863 self.document_versions.insert((target.clone(), frame_id.to_string()), loader.to_string());
1864 }
1865 let url = format!("{}{}", frame.get("url").and_then(Value::as_str).unwrap_or(""), frame.get("urlFragment").and_then(Value::as_str).unwrap_or(""));
1866 let origin = frame.get("securityOrigin").and_then(Value::as_str).unwrap_or("").to_string();
1867 let unreachable_url = frame.get("unreachableUrl").and_then(Value::as_str).unwrap_or("").to_string();
1868 let reported = self.targets.get(&target).and_then(|info| info.get("url")).and_then(Value::as_str);
1869 let unknown = unreachable_url.is_empty() && reported.is_none_or(|reported| self.guard.url(reported));
1870 let previous = self.documents.get(&target).map(|doc| doc.previous).unwrap_or_else(|| {
1871 self.protected_targets.contains(&target) || unknown || self.guard.url(&unreachable_url)
1872 });
1873 let error = self.guard.error_page_url(&url) || !unreachable_url.is_empty();
1874 let protected = self.targets.get(&target).is_some_and(|info| self.guard.target_type(info.get("type").and_then(Value::as_str).unwrap_or(""))) || if error {
1875 previous || unknown || !self.guard.error_document(&url, &origin)
1876 } else {
1877 self.guard.target(&url, self.protected_targets.contains(&target), Opener::None) || self.guard.url(&origin)
1878 };
1879 self.documents.insert(target.clone(), MainDocument {
1880 frame_id: frame_id.to_string(), url, origin, unreachable_url, navigating: false, navigation_url: String::new(), previous: protected, probed: false,
1881 });
1882 if protected {
1883 self.protect_target(&target);
1884 } else if !self.abandoned.contains(&target) {
1885 self.protected_targets.remove(&target);
1886 }
1887 }
1888
1889 pub fn recovering(&self, target_id: &str) -> bool {
1890 self.documents.get(target_id).is_some_and(|doc| doc.probed && !doc.previous)
1891 }
1892
1893 fn document_state(&mut self, target: &str, content: bool) -> Option<DocumentState> {
1894 self.document_state_for(target, content, None)
1895 }
1896
1897 fn document_state_for(&mut self, target: &str, content: bool, scope: Option<&str>) -> Option<DocumentState> {
1898 let Some(guard) = self.guards.get(target).cloned() else {
1899 if self.protected_targets.contains(target) { return None }
1900 let result = self.raw_call("Target.getTargetInfo", json!({"targetId":target}), None, DOCUMENT_CHECK).ok()?;
1901 let info = result.get("targetInfo")?;
1902 let text = |key| info.get(key).and_then(Value::as_str).unwrap_or("");
1903 if text("targetId") != target || !matches!(text("type"), "worker" | "service_worker" | "shared_worker")
1904 || url::Url::parse(text("url")).is_err() || self.guard.target(text("url"), false, Opener::Unknown) { return None }
1905 let owner = text("openerId");
1906 if !self.guards.contains_key(owner) { return None }
1907 let mut state = self.document_state(owner, true)?;
1908 state.worker = Some((text("url").to_string(), owner.to_string()));
1909 return Some(state);
1910 };
1911 #[cfg(test)]
1912 self.runtime_prepare_probe("private-document-read", json!({}));
1913 let tree = self.raw_call("Page.getFrameTree", json!({}), Some(&guard), DOCUMENT_CHECK).ok()?;
1914 if content { self.verify_document_order(&tree, Some(&guard)).ok()?; }
1915 #[cfg(test)]
1916 self.runtime_prepare_probe("private-document-stability", json!({"guard_stable":self.guards.get(target) == Some(&guard)}));
1917 if self.guards.get(target) != Some(&guard) { return None }
1918 let epoch = self.document_epochs.get(target).copied().unwrap_or(0);
1919 #[cfg(test)]
1920 self.runtime_prepare_probe("private-selected-placement", json!({"tree_present":tree.get("frameTree").is_some()}));
1921 let node = tree.get("frameTree")?;
1922 let scoped;
1923 let node = if let Some(id) = scope {
1924 scoped = Self::scoped_document_tree(node, id)?;
1925 &scoped
1926 } else { node };
1927 let frame = node.get("frame")?;
1928 let parent = frame.get("parentId").and_then(Value::as_str);
1929 let mut frames = BTreeMap::new();
1930 #[cfg(test)]
1931 self.runtime_prepare_probe("private-parent-placement", json!({"parent_present":parent.is_some()}));
1932 if let Some(parent) = parent {
1933 let info = self.raw_call("Target.getTargetInfo", json!({"targetId":target}), None, DOCUMENT_CHECK).ok()?;
1934 let info = info.get("targetInfo")?;
1935 if info.get("targetId").and_then(Value::as_str) != Some(target) || info.get("type").and_then(Value::as_str) != Some("iframe")
1936 || info.get("parentFrameId").and_then(Value::as_str) != Some(parent) { return None }
1937 let owner = self.guards.keys().find(|owner| owner.as_str() != target && self.targets.get(*owner).and_then(|info| info.get("type")).and_then(Value::as_str) == Some("page")
1938 && self.documents.get(*owner).is_some_and(|doc| doc.frame_id == parent)).cloned()?;
1939 let parent_guard = self.guards.get(&owner)?.clone();
1940 let parent_tree = self.raw_call("Page.getFrameTree", json!({}), Some(&parent_guard), DOCUMENT_CHECK).ok()?;
1941 let parent_frame = parent_tree.pointer("/frameTree/frame")?;
1942 if parent_frame.get("id").and_then(Value::as_str) != Some(parent) || parent_frame.get("parentId").is_some() { return None }
1943 frames = self.document_state_for(&owner, true, Some(parent))?.frames;
1944 }
1945 if !self.collect_document_frames(node, &mut frames, content, parent) {
1946 #[cfg(test)]
1947 self.runtime_prepare_frames(node, &frames);
1948 return None;
1949 }
1950 #[cfg(test)]
1951 self.runtime_prepare_probe("private-loader-provenance", json!({"loader_regressed":content && frames.iter().any(|(id, evidence)| evidence[0].is_empty() && self.document_versions.contains_key(&(target.to_string(), id.clone())))}));
1952 if content && frames.iter().any(|(id, evidence)| evidence[0].is_empty() && self.document_versions.contains_key(&(target.to_string(), id.clone()))) { return None }
1953 if content && self.guard.inheriting(frame.get("url").and_then(Value::as_str).unwrap_or(""))
1954 && frame.get("securityOrigin").and_then(Value::as_str) == Some("://")
1955 {
1956 let id = frame.get("id").and_then(Value::as_str)?;
1957 let loader = frame.get("loaderId").and_then(Value::as_str)?;
1958 #[cfg(test)]
1959 self.runtime_prepare_probe("private-blank-provenance", json!({"blank_url":frame.get("url").and_then(Value::as_str) == Some("about:blank"),"owned_blank":self.owns_blank(target, id, loader)}));
1960 if frame.get("url").and_then(Value::as_str) != Some("about:blank") || !self.owns_blank(target, id, loader) { return None }
1961 if self.navigated_blanks.contains_key(target) {
1962 let info = self.raw_call("Target.getTargetInfo", json!({"targetId":target}), None, DOCUMENT_CHECK).ok()?;
1963 let info = info.get("targetInfo")?;
1964 if info.get("targetId").and_then(Value::as_str) != Some(target) || info.get("type").and_then(Value::as_str) != Some("page")
1965 || info.get("url").and_then(Value::as_str) != Some("about:blank") || info.get("openerId").is_some() || info.get("openerFrameId").is_some()
1966 || frame.get("parentId").is_some() || self.guards.get(target) != Some(&guard) || !self.owns_blank(target, id, loader) { return None }
1967 }
1968 }
1969 self.main_commit(&guard, frame);
1970 #[cfg(test)]
1971 self.runtime_prepare_probe("private-document-origin", json!({"target_protected":self.protected_targets.contains(target)}));
1972 if self.protected_targets.contains(target) { return None }
1973 for (id, evidence) in &frames {
1974 self.frames.insert(id.clone(), vec![evidence[1].clone(), evidence[2].clone()]);
1975 self.note_parent(id, &evidence[4]);
1976 if content { self.frame_decisions.insert(id.clone(), false); }
1977 if !evidence[0].is_empty() {
1978 self.document_versions.insert((target.to_string(), id.clone()), evidence[0].clone());
1979 }
1980 }
1981 let scope = if parent.is_some() && scope == Some("") { frame.get("id").and_then(Value::as_str) } else { scope };
1982 let state = DocumentState { frames, worker:None, scope:scope.map(str::to_string), epoch, page_scope:None, runtime_scope_epoch:None };
1983 if content { self.cached_documents.insert(target.to_string(), state.clone()); }
1984 Some(state)
1985 }
1986
1987 fn scoped_document_tree(node: &Value, id: &str) -> Option<Value> {
1988 let frame = node.get("frame")?;
1989 if id.is_empty() || frame.get("id").and_then(Value::as_str) == Some(id) { return Some(json!({"frame":frame})) }
1990 node.get("childFrames")?.as_array()?.iter().find_map(|child| Self::scoped_document_tree(child, id))
1991 .map(|child| json!({"frame":frame,"childFrames":[child]}))
1992 }
1993
1994 fn collect_document_frames(&self, node: &Value, frames: &mut BTreeMap<String, Vec<String>>, content: bool, parent: Option<&str>) -> bool {
1995 let Some(frame) = node.get("frame") else { return false };
1996 let origin = self.page_scope_origin(frame);
1997 let text = |key| if key == "securityOrigin" { origin.unwrap_or_else(|| frame.get(key).and_then(Value::as_str).unwrap_or("")) } else { frame.get(key).and_then(Value::as_str).unwrap_or("") };
1998 let root = parent.is_none();
1999 if ["id", "url"].iter().any(|key| matches!(text(*key), "" | "null" | "://"))
2000 || frame.get("parentId").is_some_and(|id| id.as_str() != parent) { return false }
2001 let initial_blank = text("url") == "about:blank" && frame.get("loaderId").and_then(Value::as_str) == Some("")
2002 && (root || parent.and_then(|id| frames.get(id)).is_some_and(|evidence| !self.guard.url(&evidence[1]) && !self.guard.url(&evidence[2])));
2003 let parent_allowed = !root && parent.and_then(|id| frames.get(id)).is_some_and(|evidence| !self.guard.url(&evidence[1]) && !self.guard.url(&evidence[2]));
2004 let inherited = parent_allowed && self.guard.inheriting(text("url")) && !matches!(text("securityOrigin"), "" | "null" | "://") && self.frame_decisions.get(text("id")) != Some(&true);
2005 let allowed_error = !root && self.guard.error_document(text("url"), text("securityOrigin"))
2006 && !text("unreachableUrl").is_empty() && self.frame_decisions.get(text("id")) == Some(&false);
2007 let data = (root || parent_allowed) && self.guard.data_document(text("url"));
2008 let opaque = self.guard.opaque_document(text("url"), root) || !root && initial_blank || inherited || allowed_error || data;
2009 if content && (text("loaderId") == "null" || text("loaderId").is_empty() && !initial_blank
2010 || matches!(text("securityOrigin"), "" | "null") || text("securityOrigin") == "://" && !opaque
2011 || !root && !allowed_error && (self.guard.url(text("url")) || self.guard.url(text("securityOrigin")))
2012 || self.unverified_error(text("url"), text("unreachableUrl"))) { return false }
2013 let evidence = vec![text("loaderId").to_string(), format!("{}{}", text("url"), text("urlFragment")), text("securityOrigin").to_string(), text("unreachableUrl").to_string(), parent.unwrap_or("").to_string()];
2014 if frames.insert(text("id").to_string(), evidence).is_some() { return false }
2015 match node.get("childFrames") {
2016 None => true,
2017 Some(children) => children.as_array().is_some_and(|children| children.iter().all(|child| self.collect_document_frames(child, frames, content, Some(text("id"))))),
2018 }
2019 }
2020
2021 fn refresh(&mut self, target: &str) -> bool {
2022 let Some(doc) = self.documents.get(target) else { return true };
2023 if self.document_paused(target) { return true }
2024 if doc.navigating || doc.probed || !(self.guard.error_page_url(&doc.url) || !doc.unreachable_url.is_empty()) {
2025 return true;
2026 }
2027 let Some(guard) = self.guards.get(target).cloned() else { return true };
2028 let frame = self.raw_call("Page.getFrameTree", json!({}), Some(&guard), OPTIONAL_STEP).ok().and_then(|tree| tree.pointer("/frameTree/frame").cloned());
2029 match frame {
2030 Some(frame) if self.guards.get(target) == Some(&guard) => {
2031 self.main_commit(&guard, &frame);
2032 true
2033 }
2034 _ => false,
2035 }
2036 }
2037
2038 fn probe_candidate(&self, info: &Value) -> bool {
2039 let text = |key: &str| info.get(key).and_then(Value::as_str).unwrap_or("");
2040 let target = text("targetId");
2041 !target.is_empty() && text("type") == "page" && text("openerId").is_empty() && (self.guard.url(text("url")) || self.guard.error_page_url(text("url"))) && !self.guard.unparseable(text("url"))
2042 && !self.documents.contains_key(target) && !self.abandoned.contains(target) && !self.guards.contains_key(target)
2043 }
2044
2045 fn probe_error(&mut self, info: &Value) {
2046 let text = |value: &Value, key: &str| value.get(key).and_then(Value::as_str).unwrap_or("").to_string();
2047 let target = text(info, "targetId");
2048 let url = text(info, "url");
2049 if !self.probe_candidate(info) || self.protected_targets.contains(&target) {
2050 return;
2051 }
2052 self.probing.insert(target.clone());
2053 self.guarding.insert(target.clone());
2054 let attached = self.raw_call("Target.attachToTarget", json!({ "targetId": target, "flatten": true }), None, OPTIONAL_STEP);
2055 self.guarding.remove(&target);
2056 let Some(session) = attached.ok().map(|value| text(&value, "sessionId")).filter(|session| !session.is_empty()) else {
2057 self.probing.remove(&target);
2058 return;
2059 };
2060 self.guard_sessions.insert(session.clone());
2061 let frame = self.raw_call("Page.getFrameTree", json!({}), Some(&session), OPTIONAL_STEP).ok()
2062 .and_then(|tree| tree.pointer("/frameTree/frame").cloned())
2063 .filter(|frame| self.guard.error_document(&text(frame, "url"), &text(frame, "securityOrigin"))
2064 && (self.reported_unreachable(&text(frame, "unreachableUrl"), &url) || self.guard.error_page_url(&url) && text(frame, "url") == url));
2065 let history = match frame {
2066 Some(_) => self.raw_call("Page.getNavigationHistory", json!({}), Some(&session), OPTIONAL_STEP).ok(),
2067 None => None,
2068 };
2069 let _ = self.raw_call("Target.detachFromTarget", json!({ "sessionId": session }), None, OPTIONAL_STEP);
2070 self.probing.remove(&target);
2071 let (Some(frame), Some(history)) = (frame, history) else { return };
2072 let unreachable_url = text(&frame, "unreachableUrl");
2073 if self.documents.contains_key(&target) || !self.ordinary_history(&history, &unreachable_url) {
2074 return;
2075 }
2076 self.documents.insert(target, MainDocument {
2077 frame_id: text(&frame, "id"), url: text(&frame, "url"), origin: text(&frame, "securityOrigin"), unreachable_url,
2078 navigating: false, navigation_url: String::new(), previous: false, probed: true,
2079 });
2080 }
2081
2082 fn reported_unreachable(&self, unreachable: &str, reported: &str) -> bool {
2083 !unreachable.is_empty()
2084 && (reported == unreachable
2085 || url::Url::parse(unreachable).is_ok_and(|parsed| {
2086 let origin = parsed.origin().ascii_serialization();
2087 reported == origin || reported.strip_suffix('/') == Some(origin.as_str())
2088 }))
2089 }
2090
2091 fn ordinary_history(&self, history: &Value, url: &str) -> bool {
2092 let entries = history.get("entries").and_then(Value::as_array).cloned().unwrap_or_default();
2093 let current = history.get("currentIndex").and_then(Value::as_u64).and_then(|index| usize::try_from(index).ok()).unwrap_or(0);
2094 current >= 1
2095 && entries.get(current).is_some_and(|entry| {
2096 self.reported_unreachable(url, entry.get("url").and_then(Value::as_str).unwrap_or("")) && entry.get("transitionType").and_then(Value::as_str) != Some("reload")
2097 })
2098 && entries.iter().enumerate().all(|(index, entry)| {
2099 index == current || ["url", "userTypedURL"].iter().all(|key| !self.guard.url(entry.get(*key).and_then(Value::as_str).unwrap_or("")))
2100 })
2101 }
2102
2103 fn sealed(&self, doc: &MainDocument) -> bool {
2104 (self.guard.error_page_url(&doc.url) || !doc.unreachable_url.is_empty())
2105 && (doc.unreachable_url.is_empty() || self.guard.url(&doc.unreachable_url))
2106 }
2107
2108 fn masked_error(&self, doc: &MainDocument, reported: &str) -> bool {
2109 doc.unreachable_url.is_empty()
2110 && self.guard.error_document(&doc.url, &doc.origin)
2111 && !self.guard.url(reported)
2112 }
2113
2114 fn committed_protected(&mut self, session_id: &str) {
2115 match self.session_target(session_id) {
2116 Some(target) => self.protect_target(&target),
2117 None => self.block(session_id),
2118 }
2119 if !self.guard_sessions.contains(session_id) {
2120 self.block(session_id);
2121 }
2122 }
2123
2124 fn frame_tree_refused(&mut self, session_id: Option<&str>) -> Result<bool, String> {
2125 let Some(session) = session_id else {
2126 return Ok(true);
2127 };
2128 let tree = match self.raw_call("Page.getFrameTree", json!({}), Some(session), Duration::from_secs(10)) {
2129 Ok(tree) => tree,
2130 Err(message) if transport_error(&message) => return Err(message),
2131 Err(_) => return Ok(true),
2132 };
2133 self.verify_page_scope(Some(session))?;
2134 Ok(tree.get("frameTree").is_none_or(|node| self.tree_node_refused(node)))
2135 }
2136
2137 fn tree_node_refused(&self, node: &Value) -> bool {
2138 let frame = node.get("frame").unwrap_or(&Value::Null);
2139 let unknown = ["id", "url", "securityOrigin"].iter().any(|key| {
2140 let text = if *key == "securityOrigin" { self.page_scope_origin(frame).or_else(|| frame.get(*key).and_then(Value::as_str)) } else { frame.get(*key).and_then(Value::as_str) };
2141 text.is_none_or(|text| !frame_text_known(text))
2142 });
2143 unknown || self.frame_protected(frame.get("id").and_then(Value::as_str).unwrap_or(""))
2144 || node.get("childFrames").is_some_and(|children| children.as_array().is_none_or(|children| children.iter().any(|child| self.tree_node_refused(child))))
2145 }
2146
2147 fn frame_refused(&mut self, frame_id: &str, session_id: Option<&str>) -> Result<bool, String> {
2148 if self.frames.get(frame_id).is_some_and(|known| known.first().is_some_and(|url| self.guard.inheriting(url)) && !self.frame_verified(frame_id)) {
2149 self.verify_page_scope(session_id)?;
2150 }
2151 let known = self.frames.contains_key(frame_id);
2152 if self.frame_protected(frame_id) || known && !self.frame_verified(frame_id) {
2153 return Ok(true);
2154 }
2155 let other_target = session_id.and_then(|session| self.session_target(session)).is_some_and(|target| target != frame_id);
2156 let target_allowed = match self.judge_target(frame_id, false, !other_target) {
2157 Ok(true) => return Ok(true),
2158 Ok(false) => self.targets.get(frame_id).is_some_and(|info| info.get("targetId").and_then(Value::as_str) == Some(frame_id)
2159 && info.get("url").and_then(Value::as_str).is_some_and(frame_text_known)),
2160 Err(message) if transport_error(&message) => return Err(message),
2161 Err(_) => false,
2162 };
2163 let Some(session) = session_id else {
2164 return Ok(!target_allowed);
2165 };
2166 match self.raw_call("Page.getFrameTree", json!({}), Some(session), Duration::from_secs(10)) {
2167 Ok(_) => Ok(!self.frame_sessions.get(session).is_some_and(|frames| frames.contains(frame_id)) || !self.frame_verified(frame_id)),
2168 Err(message) if transport_error(&message) => Err(message),
2169 Err(message) if message.contains("slicc: refused:") => Ok(true),
2170 Err(_) => Ok(known || !target_allowed),
2171 }
2172 }
2173
2174 fn frame_verified(&self, frame_id: &str) -> bool {
2175 self.frame_chain_verified(frame_id, 0)
2176 }
2177
2178 fn frame_chain_verified(&self, frame_id: &str, depth: usize) -> bool {
2179 let Some(known) = self.frames.get(frame_id) else { return false };
2180 if depth > self.frames.len() || !frame_text_known(frame_id) || self.protected_targets.contains(frame_id)
2181 || known.len() < 2 || known.iter().any(|text| self.guard.url(text)) { return false }
2182 if known.iter().all(|text| frame_text_known(text)) { return true }
2183 frame_text_known(&known[0]) && self.guard.data_document(&known[0]) && known[1..].iter().all(|text| text == "://" || frame_text_known(text))
2184 && self.frame_parents.get(frame_id).is_none_or(|parent| self.frame_chain_verified(parent, depth + 1))
2185 }
2186
2187 fn tree_current(&self, tree: &Value, epoch: u64) -> bool {
2188 epoch == self.frame_epoch || self.tree_matches_updates(tree, epoch)
2189 }
2190
2191 fn main_frame_current(&self, frame: &Value, epoch: u64) -> bool {
2192 frame.get("id").and_then(Value::as_str).is_some_and(|id| self.frame_versions.get(id).is_none_or(|version| *version <= epoch))
2193 }
2194
2195 fn tree_matches_updates(&self, tree: &Value, epoch: u64) -> bool {
2196 let mut frames = BTreeMap::new();
2197 if let Some(node) = tree.get("frameTree") {
2198 Self::collect_frames(node, &mut frames);
2199 }
2200 let updates = self.frame_versions.iter().filter(|(_, version)| **version > epoch).collect::<Vec<_>>();
2201 !updates.is_empty() && updates.iter().all(|(id, _)| self.frames.get(*id).is_some_and(|known| {
2202 frames.get(*id).is_some_and(|fresh| known.get(..2) == fresh.get(..2)
2203 && known.iter().skip(2).all(|origin| Some(origin) == fresh.get(1)))
2204 }))
2205 }
2206
2207 fn record_frames(&mut self, tree: &Value, session: &str) {
2208 let mut frames = BTreeMap::new();
2209 if let Some(node) = tree.get("frameTree") {
2210 Self::collect_frames(node, &mut frames);
2211 let mut queue = vec![(node, None::<&str>)];
2212 while let Some((node, parent)) = queue.pop() {
2213 if let Some(frame) = node.get("frame") {
2214 if let Some(id) = frame.get("id").and_then(Value::as_str) {
2215 if let Some(known) = frames.get_mut(id) {
2216 if let Some(origin) = self.page_scope_origin(frame) { known[1] = origin.to_string(); }
2217 if let Some(parent) = parent { if frame.get("parentId").is_none() { known[2] = parent.to_string(); } }
2218 }
2219 for child in node.get("childFrames").and_then(Value::as_array).into_iter().flatten() { queue.push((child, Some(id))); }
2220 }
2221 }
2222 }
2223 }
2224 let ids = frames.keys().cloned().collect::<BTreeSet<_>>();
2225 for id in self.frame_sessions.insert(session.to_string(), ids.clone()).unwrap_or_default().difference(&ids) {
2226 self.frames.remove(id);
2227 self.frame_parents.remove(id);
2228 }
2229 for (id, mut evidence) in frames {
2230 let parent = evidence.pop().unwrap_or_default();
2231 self.note_parent(&id, &parent);
2232 self.frames.insert(id, evidence);
2233 }
2234 }
2235
2236 fn note_parent(&mut self, frame_id: &str, parent: &str) {
2237 if parent.is_empty() { self.frame_parents.remove(frame_id); } else { self.frame_parents.insert(frame_id.to_string(), parent.to_string()); }
2238 }
2239
2240 fn collect_frames(node: &Value, frames: &mut BTreeMap<String, Vec<String>>) {
2241 let frame = node.get("frame").unwrap_or(&Value::Null);
2242 let text = |key: &str| frame.get(key).and_then(Value::as_str).unwrap_or("");
2243 if !text("id").is_empty() {
2244 let url = format!("{}{}", text("url"), text("urlFragment"));
2245 frames.insert(text("id").to_string(), vec![url, text("securityOrigin").to_string(), text("parentId").to_string()]);
2246 }
2247 for child in node.get("childFrames").and_then(Value::as_array).into_iter().flatten() {
2248 Self::collect_frames(child, frames);
2249 }
2250 }
2251
2252 fn frame_protected(&self, frame_id: &str) -> bool {
2253 if frame_id.is_empty() {
2254 return false;
2255 }
2256 self.protected_targets.contains(frame_id)
2257 || self
2258 .frames
2259 .get(frame_id)
2260 .is_some_and(|known| known.iter().any(|url| self.guard.url(url)))
2261 }
2262
2263 fn initiated_by_protected(&self, paused: &Paused) -> bool {
2264 if self.frame_protected(&paused.frame_id) {
2265 return true;
2266 }
2267 if self
2268 .session_target(&paused.session_id)
2269 .is_some_and(|target| self.protected_targets.contains(&target))
2270 {
2271 return true;
2272 }
2273 ["referer", "origin"].iter().any(|name| {
2274 paused
2275 .header(name)
2276 .is_some_and(|value| value != "null" && self.guard.url(value))
2277 })
2278 }
2279
2280 fn protect_target(&mut self, target_id: &str) {
2281 self.protected_targets.insert(target_id.to_string());
2282 if let Some(doc) = self.documents.get_mut(target_id) {
2283 doc.previous = true;
2284 }
2285 let sessions: Vec<String> = self
2286 .session_targets
2287 .iter()
2288 .filter(|(_, have)| have.as_str() == target_id)
2289 .map(|(session, _)| session.clone())
2290 .collect();
2291 for session in sessions {
2292 self.block(&session);
2293 }
2294 }
2295
2296 fn answer_protected(&mut self, paused: &Paused) {
2297 self.fail_seen_network(&json!({"sessionId":paused.session_id,"params":{"networkId":paused.network_id,"requestId":paused.request_id}}));
2298 self.settle(&paused.session_id, &paused.request_id);
2299 if paused.resource_type == "Document" {
2300 let _ = self.send(
2301 "Fetch.failRequest",
2302 json!({ "requestId": paused.request_id, "errorReason": "BlockedByClient" }),
2303 Some(&paused.session_id),
2304 );
2305 } else {
2306 self.continue_plain(&paused.session_id, &paused.request_id);
2307 }
2308 }
2309
2310 fn continue_plain(&mut self, session_id: &str, request_id: &str) {
2311 self.settle(session_id, request_id);
2312 let _ = self.send(
2313 "Fetch.continueRequest",
2314 json!({ "requestId": request_id }),
2315 Some(session_id),
2316 );
2317 }
2318
2319 fn content_refused(&self, method: &str, params: &Value, session: &str) -> bool {
2320 if shield::body_method(method) && shield::request_key(params).is_some_and(|id| self.protected_body_requests.contains(&id)) { return true }
2321 if shield::body_method(method) && shield::request_key(params).is_some_and(|id| self.request_state(&id) == Some(true)) {
2322 return true;
2323 }
2324 if matches!(method, "Page.getResourceContent" | "Page.searchInResource") {
2325 return self.resource_protected(session, params.get("url").and_then(Value::as_str).unwrap_or(""));
2326 }
2327 if matches!(method, "CSS.getStyleSheetText" | "Debugger.getScriptSource" | "Debugger.getWasmBytecode" | "Debugger.searchInContent" | "Debugger.disassembleWasmModule") {
2328 let id = params.get("styleSheetId").or_else(|| params.get("scriptId")).and_then(Value::as_str).unwrap_or("");
2329 return self.source_resources.get(&(session.to_string(), id.to_string())).is_none_or(|url| self.resource_protected(session, url));
2330 }
2331 false
2332 }
2333
2334 fn protect_resource(&mut self, session: &str, url: &str) {
2335 let Some(url) = self.guard.resource_key(url) else { return };
2336 self.protected_resources.insert((session.to_string(), url.clone()));
2337 if let Some(target) = self.session_target(session) {
2338 self.protected_target_resources.insert((target, url));
2339 }
2340 }
2341
2342 fn redirector_protected(&self, url: &str) -> bool {
2343 let Some(key) = self.guard.resource_key(url) else { return true };
2344 self.guard.url(url) || self.protected_resources.iter().any(|(_, resource)| resource == &key)
2345 }
2346
2347 fn resource_protected(&self, session: &str, url: &str) -> bool {
2348 let Some(key) = self.guard.resource_key(url) else { return true };
2349 self.guard.url(url) || self.protected_resources.contains(&(session.to_string(), key.clone()))
2350 || self.session_target(session).is_some_and(|target| self.protected_target_resources.contains(&(target, key)))
2351 }
2352
2353 fn protect_body_request(&mut self, id: &str) {
2354 let mut ids = self.request_aliases.get(id).cloned().unwrap_or_default();
2355 ids.insert(id.to_string());
2356 for id in ids {
2357 self.protected_body_requests.insert(id.clone());
2358 for (peer, url) in self.request_resources.get(&id).cloned().unwrap_or_default() { self.protect_resource(&peer, &url); }
2359 }
2360 }
2361
2362 fn mark_redirect(&mut self, id: &str) {
2363 let mut ids = self.request_aliases.get(id).cloned().unwrap_or_default();
2364 ids.insert(id.to_string());
2365 for id in ids {
2366 self.redirects.insert(id.clone());
2367 for (session, url) in self.request_resources.get(&id).cloned().unwrap_or_default() {
2368 self.protect_resource(&session, &url);
2369 }
2370 }
2371 }
2372
2373 fn watch(&mut self, value: &mut Value) {
2374 let method = value
2375 .get("method")
2376 .and_then(|v| v.as_str())
2377 .unwrap_or("")
2378 .to_string();
2379 let session = value
2380 .get("sessionId")
2381 .and_then(|v| v.as_str())
2382 .map(str::to_string);
2383 let params = value.get("params").cloned().unwrap_or(Value::Null);
2384 self.observe_document_order(&method, ¶ms, session.as_deref());
2385 self.page_scope_changed(&method, ¶ms, session.as_deref());
2386 if let Some(target) = session.as_deref().and_then(|session| self.session_target(session)) {
2387 if method == "Page.frameNavigated" {
2388 let id = params.pointer("/frame/id").and_then(Value::as_str).unwrap_or("").to_string();
2389 let loader = params.pointer("/frame/loaderId").and_then(Value::as_str).unwrap_or("").to_string();
2390 let key = (target.clone(), id);
2391 if loader.is_empty() || self.document_versions.get(&key) != Some(&loader) {
2392 if !loader.is_empty() { self.document_versions.insert(key, loader); }
2393 *self.document_epochs.entry(target).or_default() += 1;
2394 }
2395 } else if method == "Page.frameDetached" {
2396 let id = params.get("frameId").and_then(Value::as_str).unwrap_or("").to_string();
2397 if params.get("reason").and_then(Value::as_str) == Some("remove") { self.note_frame_removal(&target, &id); }
2398 self.forget_frame_order(&target, session.as_deref().unwrap_or(""), &id, matches!(params.get("reason").and_then(Value::as_str), Some("remove" | "swap")));
2399 if self.document_versions.remove(&(target.clone(), id)).is_some() {
2400 *self.document_epochs.entry(target).or_default() += 1;
2401 }
2402 } else if method == "Page.frameAttached" {
2403 if let Some(id) = params.get("frameId").and_then(Value::as_str) { self.removed_frames.remove(&(target, id.to_string())); }
2404 }
2405 }
2406 if matches!(method.as_str(), "Runtime.executionContextDestroyed" | "Runtime.executionContextsCleared") {
2407 if let Some(session) = session.as_ref() {
2408 let target = self.session_target(session);
2409 let id = params.get("executionContextId").and_then(Value::as_i64);
2410 let unique = params.get("executionContextUniqueId").and_then(Value::as_str);
2411 let cleared = method == "Runtime.executionContextsCleared";
2412 let owners: BTreeSet<String> = self.context_proofs.keys().map(|(owner, _)| owner.clone()).chain(self.created_contexts.iter().map(|(owner, _)| owner.clone())).filter(|owner| owner == session || target.is_some() && self.session_target(owner) == target).collect();
2413 self.context_proofs.retain(|(owner, key), proof| !owners.contains(owner) || !(cleared || id == Some(proof.id) || unique == Some(key.as_str())));
2414 self.created_contexts.retain(|(owner, key)| !owners.contains(owner) || !(cleared || id == Some(*key)));
2415 }
2416 }
2417 if method == "Runtime.executionContextCreated" {
2418 if let (Some(session), Some(unique), Some(id)) = (session.as_ref(), params.pointer("/context/uniqueId").and_then(Value::as_str), params.pointer("/context/id").and_then(Value::as_i64)) {
2419 let frame = params.pointer("/context/auxData/frameId").and_then(Value::as_str).unwrap_or("").to_string();
2420 let loader = self.session_target(session).and_then(|target| self.document_versions.get(&(target, frame.clone())).cloned());
2421 self.context_proofs.insert((session.clone(), unique.to_string()), ContextProof {
2422 id, frame, loader, origin:params.pointer("/context/origin").and_then(Value::as_str).unwrap_or("").to_string(),
2423 name:params.pointer("/context/name").and_then(Value::as_str).unwrap_or("").to_string(),
2424 default:params.pointer("/context/auxData/isDefault").and_then(Value::as_bool) == Some(true),
2425 });
2426 }
2427 if let Some(session) = session.as_ref() {
2428 let frame = params.pointer("/context/auxData/frameId").and_then(Value::as_str);
2429 for (label, key) in [("id", "id"), ("unique", "uniqueId"), ("name", "name")] {
2430 if let Some(id) = params.pointer("/context").and_then(|context| context.get(key)) {
2431 let id = id.as_str().map(str::to_string).unwrap_or_else(|| id.to_string());
2432 let key = (session.clone(), format!("{label}:{id}"));
2433 if let Some(frame) = frame { self.context_frames.insert(key, frame.to_string()); }
2434 else { self.context_frames.remove(&key); }
2435 }
2436 }
2437 }
2438 }
2439 if let Some(id) = params.get("requestId").and_then(Value::as_str) {
2440 if self.redirect_page_protected(value) {
2441 self.protected_request_pages.insert((session.clone().unwrap_or_default(), id.to_string()));
2442 }
2443 }
2444 if let Some(id) = params.get("requestId").and_then(|v| v.as_str()) {
2445 if let Some(url) = shield::request_url(¶ms) {
2446 let resource = (session.clone().unwrap_or_default(), url.clone());
2447 self.request_resources.entry(id.to_string()).or_default().insert(resource.clone());
2448 if self.redirects.contains(id) || self.protected_body_requests.contains(id) || self.guard.url(&url) {
2449 self.protect_resource(&resource.0, &resource.1);
2450 }
2451 let initiator = ["documentURL"]
2452 .iter()
2453 .filter_map(|key| params.get(*key).and_then(|v| v.as_str()))
2454 .chain(params.pointer("/initiator/url").and_then(|v| v.as_str()))
2455 .any(|text| self.guard.url(text))
2456 || params
2457 .get("frameId")
2458 .and_then(|v| v.as_str())
2459 .is_some_and(|frame| self.frame_protected(frame));
2460 let protected = initiator
2461 || self.guard.url(&url)
2462 || self.guard.url(&shield::web_socket_as_http(&url));
2463 let entry = self.requests.entry(id.to_string()).or_insert(false);
2464 *entry = *entry || protected;
2465 }
2466 }
2467 if let Some(id) = params.get("requestId").and_then(Value::as_str) {
2468 let authority = if method == "Network.requestWillBeSentExtraInfo" { params.clone() } else { params.get("request").cloned().unwrap_or(Value::Null) };
2469 if shield::scheme_less_protected(&self.guard, &authority) {
2470 self.requests.insert(id.to_string(), true);
2471 for (peer, url) in self.request_resources.get(id).cloned().unwrap_or_default() { self.protect_resource(&peer, &url); }
2472 }
2473 if self.protected_carrier(value, false) { self.protect_body_request(id); }
2474 if self.actual_redirect_carrier(value) { self.mark_redirect(id); }
2475 }
2476 if let Some((id, url)) = match method.as_str() {
2477 "Debugger.scriptParsed" | "Debugger.scriptFailedToParse" => params.get("scriptId").and_then(Value::as_str).zip(params.get("url").and_then(Value::as_str)),
2478 "CSS.styleSheetAdded" => params.pointer("/header/styleSheetId").and_then(Value::as_str).zip(params.pointer("/header/sourceURL").and_then(Value::as_str)),
2479 _ => None,
2480 } {
2481 self.source_resources.insert((session.clone().unwrap_or_default(), id.to_string()), url.to_string());
2482 }
2483 if matches!(method.as_str(), "Page.frameNavigated" | "Page.frameAttached" | "Page.frameDetached" | "Page.navigatedWithinDocument") {
2484 self.frame_epoch += 1;
2485 }
2486 match method.as_str() {
2487 "Page.frameAttached" | "Page.frameDetached" => {
2488 if method == "Page.frameAttached" && session.as_ref().is_some_and(|session| self.guard_sessions.contains(session)) {
2489 if let (Some(id), Some(parent)) = (params.get("frameId").and_then(Value::as_str), params.get("parentFrameId").and_then(Value::as_str)) {
2490 if let Some(protected) = self.frame_decisions.get(parent).copied() {
2491 self.frame_decisions.entry(id.to_string()).or_insert(protected);
2492 }
2493 }
2494 }
2495 if let Some(id) = params.get("frameId").and_then(Value::as_str) {
2496 self.frames.remove(id);
2497 self.frame_parents.remove(id);
2498 self.frame_versions.insert(id.to_string(), self.frame_epoch);
2499 for frames in self.frame_sessions.values_mut() {
2500 frames.remove(id);
2501 }
2502 }
2503 }
2504 "Page.navigatedWithinDocument" => {
2505 if let Some(id) = params.get("frameId").and_then(Value::as_str) {
2506 self.frame_versions.insert(id.to_string(), self.frame_epoch);
2507 if let Some(known) = self.frames.get_mut(id).and_then(|known| known.first_mut()) {
2508 *known = params.get("url").and_then(Value::as_str).unwrap_or("").to_string();
2509 }
2510 }
2511 }
2512 "Page.frameNavigated" => {
2513 let Some(session) = session else { return };
2514 let frame = params.get("frame").cloned().unwrap_or(Value::Null);
2515 let url = format!(
2516 "{}{}",
2517 frame.get("url").and_then(|v| v.as_str()).unwrap_or(""),
2518 frame.get("urlFragment").and_then(|v| v.as_str()).unwrap_or("")
2519 );
2520 let origin = frame
2521 .get("securityOrigin")
2522 .and_then(|v| v.as_str())
2523 .unwrap_or("")
2524 .to_string();
2525 if let Some(id) = frame.get("id").and_then(|v| v.as_str()) {
2526 self.frames.insert(id.to_string(), vec![url.clone(), origin.clone()]);
2527 self.note_parent(id, frame.get("parentId").and_then(Value::as_str).unwrap_or(""));
2528 if self.guard.url(&url) || self.guard.url(&origin) {
2529 self.frame_decisions.insert(id.to_string(), true);
2530 } else if !self.guard.error_page_url(&url) && !matches!(origin.as_str(), "" | "null" | "://") {
2531 self.frame_decisions.insert(id.to_string(), false);
2532 }
2533 self.frame_versions.insert(id.to_string(), self.frame_epoch);
2534 self.frame_sessions.entry(session.clone()).or_default().insert(id.to_string());
2535 }
2536 if frame.get("parentId").is_none() {
2537 self.main_commit(&session, &frame);
2538 if self.session_target(&session).is_none() && (self.guard.url(&url) || self.guard.url(&origin)) {
2539 self.committed_protected(&session);
2540 }
2541 }
2542 }
2543 "Page.frameStartedNavigating" => {
2544 if matches!(params.get("navigationType").and_then(Value::as_str), Some("sameDocument" | "historySameDocument")) {
2545 return;
2546 }
2547 if let Some(target) = session.as_deref().and_then(|session| self.session_target(session)) {
2548 if self.guards.get(&target).is_some_and(|guard| Some(guard) != session.as_ref()) && !self.unobserved.contains(&target) {
2549 return;
2550 }
2551 if let Some(doc) = self.documents.get_mut(&target) {
2552 if params.get("frameId").and_then(Value::as_str) == Some(&doc.frame_id) {
2553 doc.navigating = true;
2554 doc.navigation_url = params.get("url").and_then(Value::as_str).unwrap_or("").to_string();
2555 }
2556 }
2557 }
2558 }
2559 "Runtime.executionContextCreated" => {
2560 let Some(session) = session else { return };
2561 let origin = params
2562 .pointer("/context/origin")
2563 .and_then(|v| v.as_str())
2564 .unwrap_or("");
2565 let default = params
2566 .pointer("/context/auxData/isDefault")
2567 .and_then(|v| v.as_bool())
2568 .unwrap_or(true);
2569 if let Some(frame) = params.pointer("/context/auxData/frameId").and_then(|v| v.as_str()) {
2570 if default {
2571 self.frames
2572 .entry(frame.to_string())
2573 .or_default()
2574 .push(origin.to_string());
2575 }
2576 }
2577 if default && self.guard.url(origin) {
2578 self.committed_protected(&session);
2579 }
2580 }
2581 "Target.targetCreated" | "Target.targetInfoChanged" => {
2582 let info = params.get("targetInfo").cloned().unwrap_or(Value::Null);
2583 let target = info
2584 .get("targetId")
2585 .and_then(|v| v.as_str())
2586 .unwrap_or("")
2587 .to_string();
2588 let url = info.get("url").and_then(|v| v.as_str()).unwrap_or("");
2589 if !target.is_empty() {
2590 self.targets.insert(target.clone(), info.clone());
2591 }
2592 if self.info_protected(&info, &[]) && !self.documents.contains_key(&target) && !self.probing.contains(&target) && !self.probe_candidate(&info) {
2593 self.protect_target(&target);
2594 }
2595 if self.info_protected(&info, &[]) || self.discovery_redacted(&info) {
2596 value["params"]["targetInfo"] = shield::redacted(&info);
2597 } else if !self.documents.contains_key(&target) && !self.guard.target(url, false, Opener::Unknown)
2598 && !self.abandoned.contains(&target)
2599 {
2600 self.protected_targets.remove(&target);
2601 }
2602 }
2603 "Target.attachedToTarget" => {
2604 if let Some(info) = params.get("targetInfo") {
2605 value["params"]["targetInfo"] = if info.get("targetId").and_then(Value::as_str).is_some_and(|target| self.probing.contains(target)) {
2606 shield::redacted(info)
2607 } else {
2608 self.redact(info, &[])
2609 };
2610 }
2611 }
2612 "Target.targetDestroyed" => {
2613 if let Some(target) = params.get("targetId").and_then(|v| v.as_str()) {
2614 self.guards.remove(target);
2615 self.targets.remove(target);
2616 self.created_blanks.remove(target);
2617 self.navigated_blanks.remove(target);
2618 self.documents.remove(target);
2619 self.unchecked_documents.retain(|(owner, _, _), _| owner != target);
2620 self.removed_frames.retain(|(owner, _), _| owner != target);
2621 self.unobserved.remove(target);
2622 }
2623 }
2624 "Target.detachedFromTarget" => {
2625 if let Some(child) = params.get("sessionId").and_then(|v| v.as_str()) {
2626 self.forget_session(child);
2627 }
2628 }
2629 _ => {}
2630 }
2631 }
2632
2633 fn hand(&mut self, session_id: &str, request_id: &str) {
2634 self.handed
2635 .insert((session_id.to_string(), request_id.to_string()));
2636 }
2637
2638 fn settle(&mut self, session_id: &str, request_id: &str) {
2639 self.paused_documents.remove(&(session_id.to_string(), request_id.to_string()));
2640 self.handed
2641 .remove(&(session_id.to_string(), request_id.to_string()));
2642 }
2643
2644 fn challenge_protected(&self, value: &Value) -> bool {
2645 let session = value.get("sessionId").and_then(|v| v.as_str()).unwrap_or("");
2646 let params = value.get("params").cloned().unwrap_or(Value::Null);
2647 let id = params.get("requestId").and_then(|v| v.as_str()).unwrap_or("");
2648 let text = |pointer: &str| params.pointer(pointer).and_then(|v| v.as_str()).unwrap_or("");
2649 self.request_state(id) == Some(true)
2650 || self.blocked.contains(session)
2651 || self.guard_sessions.contains(session)
2652 || self.frame_protected(text("/frameId"))
2653 || self
2654 .session_target(session)
2655 .is_some_and(|target| self.protected_targets.contains(&target))
2656 || ["/request/url", "/authChallenge/origin"]
2657 .iter()
2658 .any(|pointer| self.guard.url(text(pointer)))
2659 }
2660
2661 fn hidden(&self, value: &Value) -> bool {
2662 let method = value.get("method").and_then(|v| v.as_str()).unwrap_or("");
2663 if method == "Target.receivedMessageFromTarget" {
2664 return true;
2665 }
2666 if let Some(session) = value.get("sessionId").and_then(|v| v.as_str()) {
2667 if self.blocked.contains(session) || self.guard_sessions.contains(session) {
2668 return true;
2669 }
2670 }
2671 if method.starts_with("Target.") {
2672 let info = value.pointer("/params/targetInfo");
2673 let reported = info.and_then(|info| info.get("targetId")).and_then(Value::as_str)
2674 .and_then(|target| self.targets.get(target)).or(info);
2675 if let Some(url) = reported.and_then(|info| info.get("url")).and_then(Value::as_str) {
2676 if self.guard.unparseable(url) && self.guard.url(url) {
2677 return true;
2678 }
2679 }
2680 if let Some(child) = value.pointer("/params/sessionId").and_then(|v| v.as_str()) {
2681 if self.guard_sessions.contains(child) || self.blocked.contains(child)
2682 && !(method == "Target.detachedFromTarget" && self.detached_ordinary.contains(child)) {
2683 return true;
2684 }
2685 }
2686 return false;
2687 }
2688 let params = value.get("params").cloned().unwrap_or(Value::Null);
2689 if let Some(id) = params.get("requestId").and_then(|v| v.as_str()) {
2690 if self.requests.get(id) == Some(&true) || self.redirect_page_protected(value) {
2691 return true;
2692 }
2693 }
2694 shield::loaded_urls_protected(&self.guard, ¶ms)
2695 }
2696
2697 fn fail_seen_network(&mut self, value: &Value) {
2698 let Some(id) = value.pointer("/params/networkId").and_then(Value::as_str).or_else(|| value.pointer("/params/requestId").and_then(Value::as_str)) else { return };
2699 let session = value.get("sessionId").and_then(Value::as_str).unwrap_or("");
2700 if self.guard_sessions.contains(session) && self.request_state(id) != Some(true) { return }
2701 let target = self.session_target(session);
2702 let keys: Vec<_> = self.seen_network.keys().filter(|(peer, request)| request == id && (peer == session || target.is_some() && self.session_target(peer) == target)).cloned().collect();
2703 for key in keys {
2704 let kind = self.seen_network.remove(&key).unwrap();
2705 if self.terminal_network.insert(key.clone()) {
2706 self.events.push(json!({"method":"Network.loadingFailed","sessionId":key.0,"params":{"requestId":key.1,"timestamp":value.pointer("/params/timestamp").and_then(Value::as_f64).unwrap_or(0.0),"type":kind,"errorText":"net::ERR_BLOCKED_BY_CLIENT","canceled":true,"blockedReason":"inspector"}}));
2707 }
2708 }
2709 }
2710
2711 fn visible_network(&mut self, value: &Value) {
2712 let method = value.get("method").and_then(Value::as_str).unwrap_or("");
2713 if !method.starts_with("Network.") { return }
2714 let Some(id) = value.pointer("/params/requestId").and_then(Value::as_str) else { return };
2715 let key = (value.get("sessionId").and_then(Value::as_str).unwrap_or("").to_string(), id.to_string());
2716 if matches!(method, "Network.loadingFinished" | "Network.loadingFailed") {
2717 self.seen_network.remove(&key);
2718 self.terminal_network.insert(key);
2719 } else {
2720 let kind = value.pointer("/params/type").and_then(Value::as_str).filter(|kind| matches!(*kind, "Document" | "Stylesheet" | "Image" | "Media" | "Font" | "Script" | "TextTrack" | "XHR" | "Fetch" | "Prefetch" | "EventSource" | "WebSocket" | "Manifest" | "SignedExchange" | "Ping" | "CSPViolationReport" | "Preflight" | "Other")).unwrap_or("Other");
2721 self.seen_network.entry(key).or_insert_with(|| kind.to_string());
2722 }
2723 }
2724
2725 fn ordinary_redirect_url(&self, url: &str) -> bool {
2726 !self.guard.url(url) && !self.guard.url(&shield::web_socket_as_http(url)) && url::Url::parse(&shield::web_socket_as_http(url)).is_ok_and(|url| matches!(url.scheme(), "http" | "https") && url.has_host())
2727 }
2728
2729 fn remember_navigation(&mut self, params: &Value, session: Option<&str>) {
2730 if let Some((session, url)) = session.zip(params["url"].as_str()).filter(|(_, url)| self.ordinary_redirect_url(url)) {
2731 self.client_navigation_urls.insert(session.to_string(), url.to_string());
2732 }
2733 }
2734
2735 fn ordinary_network_source(&self, session: &str, id: &str) -> Option<String> {
2736 let resources: Vec<_> = self.request_resources.get(id).into_iter().flatten().filter(|(peer, _)| peer == session).map(|(_, url)| url).collect();
2737 if resources.is_empty() || resources.iter().any(|url| !self.ordinary_redirect_url(url)) { return None }
2738 resources.first().map(|url| (*url).clone())
2739 }
2740
2741 fn actual_redirect_carrier(&self, value: &Value) -> bool {
2742 self.protected_carrier(value, true)
2743 }
2744
2745 fn protected_carrier(&self, value: &Value, navigation: bool) -> bool {
2746 let params = &value["params"];
2747 let method = value["method"].as_str().unwrap_or("");
2748 if navigation && method == "Network.requestWillBeSentExtraInfo" { return false }
2749 let (headers, status, source) = match method {
2750 "Network.requestWillBeSent" => (params.pointer("/redirectResponse/headers"), params.pointer("/redirectResponse/status"), params.pointer("/redirectResponse/url").and_then(Value::as_str).map(str::to_string)),
2751 "Network.responseReceived" => (params.pointer("/response/headers"), params.pointer("/response/status"), params.pointer("/response/url").and_then(Value::as_str).map(str::to_string)),
2752 "Fetch.requestPaused" => (params.get("responseHeaders"), params.get("responseStatusCode"), params.pointer("/request/url").and_then(Value::as_str).map(str::to_string)),
2753 "Network.responseReceivedExtraInfo" | "Network.requestWillBeSentExtraInfo" => (params.get("headers"), params.get("statusCode"), self.ordinary_network_source(value["sessionId"].as_str().unwrap_or(""), params["requestId"].as_str().unwrap_or(""))),
2754 _ => return false,
2755 };
2756 let source = source.as_deref().unwrap_or("https://ordinary.invalid/");
2757 let redirect = status.and_then(Value::as_u64).is_some_and(|status| matches!(status, 301 | 302 | 303 | 307 | 308));
2758 let sensitive = |target: &str| Self::carrier_targets(&self.guard, target, source).is_none_or(|targets| targets.iter().any(|target| target.protected && {
2759 let url = &target.url;
2760 !url.path().trim_matches('/').is_empty() || url.query().is_some() || url.fragment().is_some() || !url.username().is_empty() || url.password().is_some()
2761 }));
2762 let protected = |name: &str, text: &str| {
2763 match name.to_ascii_lowercase().as_str() {
2764 "location" if navigation && redirect => Self::carrier_targets(&self.guard, text, source).is_none_or(|targets| targets.iter().any(|target| target.protected)),
2765 "location" | "content-location" if !navigation => sensitive(text),
2766 "refresh" => Self::redirect_header_value(&self.guard, name, text, source).is_none_or(|text| text.split_once(";url=").is_none_or(|(_, url)| self.guard.url(url))),
2767 "link" => text.split([',', '\n']).any(|part| part.trim().strip_prefix('<').and_then(|part| part.split_once('>')).is_some_and(|(target, _)| sensitive(target))),
2768 _ => false,
2769 }
2770 };
2771 let found = match headers {
2772 Some(Value::Object(headers)) => headers.iter().any(|(name, value)| value.as_str().is_some_and(|text| protected(name, text))),
2773 Some(Value::Array(headers)) => headers.iter().any(|field| field["name"].as_str().zip(field["value"].as_str()).is_some_and(|(name, text)| protected(name, text))),
2774 _ => false,
2775 };
2776 found || ["headersText", "requestHeadersText"].iter().filter(|field| !navigation || **field == "headersText").any(|field| params.get(*field).and_then(Value::as_str).is_some_and(|text| text.lines().filter_map(|line| line.split_once(':')).any(|(name, value)| protected(name.trim(), value.trim()))))
2777 }
2778
2779 fn ordinary_late_extra_info(&self, value: &Value) -> bool {
2780 let session = value["sessionId"].as_str().unwrap_or("");
2781 let id = value["params"]["requestId"].as_str().unwrap_or("");
2782 self.requests.get(id) == Some(&false) && !self.redirects.contains(id) && !self.protected_body_requests.contains(id) && !self.guard_sessions.contains(session)
2783 && !self.redirect_page_protected(value) && !shield::loaded_urls_protected(&self.guard, &value["params"])
2784 && self.ordinary_network_source(session, id).is_some()
2785 }
2786
2787 fn redirect_page_protected(&self, value: &Value) -> bool {
2788 let session = value.get("sessionId").and_then(Value::as_str).unwrap_or("");
2789 let params = &value["params"];
2790 let hop = value["method"] == "Network.requestWillBeSent" && params["type"] == "Document" && params.pointer("/redirectResponse/url").and_then(Value::as_str).is_some_and(|url| self.ordinary_redirect_url(url)) && params.get("documentURL").is_some_and(|url| Some(url) == params.pointer("/request/url"));
2791 self.blocked.contains(session)
2792 || self.protected_request_pages.iter().any(|(peer, id)| id == params["requestId"].as_str().unwrap_or("") && (peer == session || self.session_target(session).is_some_and(|target| self.session_target(peer).as_ref() == Some(&target))))
2793 || self.session_target(session).is_some_and(|target| self.protected_targets.contains(&target) || self.documents.get(&target).is_some_and(|doc| self.guard.url(&doc.url) || self.guard.url(&doc.origin)))
2794 || params.get("frameId").and_then(Value::as_str).is_some_and(|frame| self.frame_protected(frame))
2795 || params.get("initiator").is_some_and(|initiator| shield::loaded_urls_protected(&self.guard, initiator))
2796 || !hop && params.get("documentURL").and_then(Value::as_str).is_some_and(|url| self.guard.url(url))
2797 }
2798
2799 fn refresh_parts(text: &str) -> Option<(&str, Option<&str>)> {
2800 let text = text.trim_start_matches(|ch: char| ch.is_ascii_whitespace());
2801 let bytes = text.as_bytes();
2802 let mut at = bytes.iter().take_while(|byte| byte.is_ascii_digit()).count();
2803 if at == 0 { return None }
2804 if bytes.get(at) == Some(&b'.') {
2805 at += 1;
2806 while bytes.get(at).is_some_and(u8::is_ascii_digit) { at += 1; }
2807 }
2808 let delay = &text[..at];
2809 let tail = text[at..].trim_start_matches(|ch: char| ch.is_ascii_whitespace());
2810 if tail.is_empty() { return Some((delay, None)) }
2811 let mut target = tail.strip_prefix(';').or_else(|| tail.strip_prefix(','))?.trim_matches(|ch: char| ch.is_ascii_whitespace());
2812 if target.get(..3).is_some_and(|key| key.eq_ignore_ascii_case("url")) {
2813 if let Some(value) = target[3..].trim_start_matches(|ch: char| ch.is_ascii_whitespace()).strip_prefix('=') {
2814 target = value.trim_start_matches(|ch: char| ch.is_ascii_whitespace());
2815 }
2816 }
2817 if let Some(quote) = target.chars().next().filter(|ch| matches!(ch, '\'' | '"')) {
2818 target = &target[1..];
2819 target = target.split(quote).next().unwrap_or("");
2820 }
2821 target = target.trim_matches(|ch: char| ch.is_ascii_whitespace());
2822 Some((delay, (!target.is_empty()).then_some(target)))
2823 }
2824
2825 pub fn ordinary_redirect_target(&self, source: &str, target: &str) -> Result<String, String> {
2826 target_refusal(&self.guard, source, target).map_err(|_| self.refusal())
2827 }
2828
2829 fn carrier_targets(guard: &Protected, target: &str, source: &str) -> Option<Vec<CarrierTarget>> {
2830 let base = url::Url::parse(source).ok()?;
2831 let mut target = target.trim().to_string();
2832 if target.chars().any(char::is_control) { return None }
2833 let mut targets = Vec::new();
2834 for _ in 0..9 {
2835 let url = base.join(&target).ok()?;
2836 let keyed = guard.resource_key(&target).and_then(|key| url::Url::parse(&key).ok()).unwrap_or_else(|| url.clone());
2837 let origin = keyed.origin().ascii_serialization();
2838 let web = origin.starts_with("http://") || origin.starts_with("https://");
2839 let protected = if web { guard.url(&origin) } else { guard.url(keyed.as_str()) };
2840 targets.push(CarrierTarget { origin: web.then_some(origin), protected, url });
2841 let decoded = shield::decode_percent(&target);
2842 if decoded == target { return Some(targets) }
2843 target = decoded;
2844 }
2845 None
2846 }
2847
2848 fn redirect_header_value(guard: &Protected, name: &str, text: &str, source: &str) -> Option<String> {
2849 if text.is_empty() || text.chars().any(|ch| ch.is_control() && !(name.eq_ignore_ascii_case("refresh") && ch == '\t')) { return None }
2850 let origin = |target: &str| {
2851 let targets = Self::carrier_targets(guard, target, source)?;
2852 targets.iter().find(|target| target.protected).unwrap_or(&targets[0]).origin.clone()
2853 };
2854 match name.to_ascii_lowercase().as_str() {
2855 "location" | "content-location" => origin(text),
2856 "refresh" => {
2857 let (delay, target) = Self::refresh_parts(text)?;
2858 Some(format!("{delay};url={}", origin(target.unwrap_or(source))?))
2859 }
2860 "link" => text.split(',').map(|part| {
2861 let (target, params) = part.trim().strip_prefix('<')?.split_once('>')?;
2862 let mut link = format!("<{}>", origin(target)?);
2863 for param in params.split(';') {
2864 let Some((key, value)) = param.trim().split_once('=') else { continue };
2865 let key = key.to_ascii_lowercase();
2866 let value = value.trim();
2867 let tokens = value.trim_matches('"');
2868 if matches!(key.as_str(), "rel" | "rev") && !tokens.is_empty() && tokens.split_ascii_whitespace().all(|token| matches!(token, "preconnect" | "prefetch" | "preload" | "next" | "prev" | "stylesheet" | "canonical" | "alternate" | "noopener" | "noreferrer" | "icon" | "dns-prefetch" | "upskill" | "https://www.sliccy.ai/rel/upskill")) {
2869 link.push_str(&format!("; {key}={value}"));
2870 }
2871 }
2872 Some(link)
2873 }).collect::<Option<Vec<_>>>().map(|links| links.join(", ")),
2874 _ => None,
2875 }
2876 }
2877
2878 pub fn ordinary_response_body(&self, session: &str, request_id: &str) -> bool {
2879 !self.content_blocked(session) && self.request_state(request_id) == Some(false)
2880 && !self.protected_body_requests.contains(request_id) && self.ordinary_network_source(session, request_id).is_some()
2881 }
2882
2883 pub fn redact_redirect_carriers(&self, headers: &mut Value, source: &str) {
2884 let Some(fields) = headers.as_object_mut() else { return };
2885 fields.retain(|name, value| {
2886 let kind = name.to_ascii_lowercase();
2887 if !matches!(kind.as_str(), "location" | "content-location" | "refresh" | "link") { return true }
2888 let Some(text) = value.as_str() else { return false };
2889 let targets = match kind.as_str() {
2890 "refresh" => Self::refresh_parts(text).and_then(|(_, target)| Self::carrier_targets(&self.guard, target.unwrap_or(source), source)),
2891 "link" => text.split(',').map(|part| part.trim().strip_prefix('<').and_then(|part| part.split_once('>')).and_then(|(target, _)| Self::carrier_targets(&self.guard, target, source))).collect::<Option<Vec<_>>>().map(|parts| parts.into_iter().flatten().collect()),
2892 _ => Self::carrier_targets(&self.guard, text, source),
2893 };
2894 if targets.is_some_and(|targets| !targets.is_empty() && targets.iter().all(|target| !target.protected && matches!(target.url.scheme(), "http" | "https") && target.url.has_host())) { return true }
2895 match Self::redirect_header_value(&self.guard, name, text, source) {
2896 Some(safe) => { *value = json!(safe); true }
2897 None => false,
2898 }
2899 });
2900 }
2901
2902 fn redirect_headers(headers: &mut Value, source: &str, guard: &Protected) {
2903 match headers {
2904 Value::Object(fields) => fields.retain(|name, value| {
2905 let safe = value.as_str().and_then(|text| Self::redirect_header_value(guard, name, text, source));
2906 if let Some(safe) = safe { *value = json!(safe); true } else { false }
2907 }),
2908 Value::Array(fields) => {
2909 fields.retain_mut(|field| {
2910 let safe = field.get("name").and_then(Value::as_str).zip(field.get("value").and_then(Value::as_str)).and_then(|(name, text)| Self::redirect_header_value(guard, name, text, source));
2911 if let Some(safe) = safe { field["value"] = json!(safe); true } else { false }
2912 });
2913 for field in fields { if let Some(fields) = field.as_object_mut() { fields.retain(|name, _| matches!(name.as_str(), "name" | "value")); } }
2914 }
2915 _ => *headers = json!({}),
2916 }
2917 }
2918
2919 fn visible_redirect(&self, value: &mut Value) -> bool {
2920 let session = value.get("sessionId").and_then(Value::as_str).unwrap_or("").to_string();
2921 if self.guard_sessions.contains(&session) || self.redirect_page_protected(value) { return false }
2922 let id = value.pointer("/params/requestId").and_then(Value::as_str).unwrap_or("").to_string();
2923 let method = value.get("method").and_then(Value::as_str).unwrap_or("").to_string();
2924 let params = &value["params"];
2925 let source = match method.as_str() {
2926 "Network.requestWillBeSent" => params.pointer("/redirectResponse/url").and_then(Value::as_str).map(str::to_string),
2927 "Network.responseReceived" => params.pointer("/response/url").and_then(Value::as_str).map(str::to_string),
2928 "Fetch.requestPaused" => params.pointer("/request/url").and_then(Value::as_str).map(str::to_string),
2929 "Network.responseReceivedExtraInfo" => self.ordinary_network_source(&session, &id),
2930 _ => return false,
2931 };
2932 let Some(source) = source.filter(|url| self.ordinary_redirect_url(url)) else { return false };
2933 let mut loaded = params.clone();
2934 if method == "Network.requestWillBeSent" {
2935 if let Some(fields) = loaded.as_object_mut() { fields.remove("request"); fields.remove("documentURL"); }
2936 }
2937 if shield::loaded_urls_protected(&self.guard, &loaded) { return false }
2938 if method == "Fetch.requestPaused" && Paused::from_event(value).is_none_or(|paused| self.initiated_by_protected(&paused)) { return false }
2939 let mut carriers = match method.as_str() {
2940 "Network.responseReceived" => params.pointer("/response/headers"),
2941 "Network.requestWillBeSent" => params.pointer("/redirectResponse/headers"),
2942 "Network.responseReceivedExtraInfo" => params.get("headers"),
2943 _ => params.get("responseHeaders"),
2944 }.cloned().unwrap_or(Value::Null);
2945 Self::redirect_headers(&mut carriers, &source, &self.guard);
2946 if !shield::redact_strings(&self.guard, &mut carriers) { return false }
2947 if method == "Network.responseReceivedExtraInfo" && !self.requests.contains_key(&id) { return false }
2948 let status = match method.as_str() {
2949 "Network.requestWillBeSent" => value.pointer("/params/redirectResponse/status"),
2950 "Network.responseReceived" => value.pointer("/params/response/status"),
2951 "Network.responseReceivedExtraInfo" => value.pointer("/params/statusCode"),
2952 "Fetch.requestPaused" => value.pointer("/params/responseStatusCode"),
2953 _ => return false,
2954 }.and_then(Value::as_u64);
2955 if !status.is_some_and(|status| matches!(status, 301 | 302 | 303 | 307 | 308)) || method == "Network.requestWillBeSent" && !self.seen_network.contains_key(&(session, id)) {
2956 return false;
2957 }
2958 let mut redacted = value.clone();
2959 if !shield::redact_strings(&self.guard, &mut redacted) { return false }
2960 let params = &mut redacted["params"];
2961 if method == "Network.responseReceivedExtraInfo" {
2962 if let Some(fields) = params.as_object_mut() { fields.retain(|key, _| matches!(key.as_str(), "requestId" | "statusCode" | "headers" | "headersText")); }
2963 Self::redirect_headers(&mut params["headers"], &source, &self.guard);
2964 if params.get("headersText").is_some() {
2965 let headers = params["headers"].as_object().map(|headers| headers.iter().map(|(name, value)| format!("{name}: {}\r\n", value.as_str().unwrap())).collect::<String>()).unwrap_or_default();
2966 params["headersText"] = json!(format!("HTTP/1.1 {}\r\n{headers}\r\n", status.unwrap()));
2967 }
2968 } else {
2969 let request = json!({"url":params.pointer("/request/url").cloned().unwrap_or(Value::Null),"method":params.pointer("/request/method").and_then(Value::as_str).filter(|method| matches!(*method, "GET" | "HEAD" | "POST" | "PUT" | "DELETE" | "CONNECT" | "OPTIONS" | "TRACE" | "PATCH")).unwrap_or("GET"),"headers":{}});
2970 if method == "Fetch.requestPaused" {
2971 if let Some(fields) = params.as_object_mut() { fields.retain(|key, _| matches!(key.as_str(), "requestId" | "networkId" | "frameId" | "resourceType" | "responseStatusCode" | "responseHeaders")); }
2972 Self::redirect_headers(&mut params["responseHeaders"], &source, &self.guard);
2973 params["responseStatusText"] = json!("");
2974 params["request"] = request;
2975 } else {
2976 let key = if method == "Network.requestWillBeSent" { "redirectResponse" } else { "response" };
2977 let mut response = params[key].clone();
2978 if let Some(fields) = response.as_object_mut() { fields.retain(|key, _| matches!(key.as_str(), "url" | "status" | "headers")); }
2979 response["statusText"] = json!("");
2980 Self::redirect_headers(&mut response["headers"], &source, &self.guard);
2981 if let Some(fields) = params.as_object_mut() { fields.retain(|key, _| matches!(key.as_str(), "requestId" | "loaderId" | "frameId" | "timestamp" | "wallTime" | "type")); }
2982 if method == "Network.requestWillBeSent" { params["request"] = request; }
2983 params[key] = response;
2984 }
2985 }
2986 *value = redacted;
2987 true
2988 }
2989
2990 fn deliver(&mut self, value: Value) {
2991 self.deliver_event(value);
2992 if !self.checking_page_events {
2993 while let Some(event) = self.pending_page_events.pop_front() { self.deliver_event(event); }
2994 }
2995 }
2996
2997 fn deliver_event(&mut self, mut value: Value) {
2998 self.watch(&mut value);
2999 if value.get("method").and_then(Value::as_str) == Some("Page.screencastFrame") {
3000 if let Some(session) = value.get("sessionId").and_then(Value::as_str) {
3001 let _ = self.send("Page.stopScreencast", json!({}), Some(session));
3002 }
3003 return;
3004 }
3005 if value.get("method").and_then(Value::as_str).is_some_and(page_scope::content_event) {
3006 let session = value.get("sessionId").and_then(Value::as_str);
3007 if session.is_some_and(|session| self.guard_sessions.contains(session)) { return }
3008 if self.checking_page_events { self.pending_page_events.push_back(value); return }
3009 self.checking_page_events = true;
3010 let verified = self.verify_page_scope(session).is_ok();
3011 self.checking_page_events = false;
3012 if !verified { return }
3013 }
3014 let key = (value.get("sessionId").and_then(Value::as_str).unwrap_or("").to_string(), value.pointer("/params/requestId").and_then(Value::as_str).unwrap_or("").to_string());
3015 let terminal = self.terminal_network.contains(&key);
3016 let late_ordinary = terminal && matches!(value["method"].as_str(), Some("Network.responseReceivedExtraInfo" | "Network.requestWillBeSentExtraInfo")) && self.ordinary_late_extra_info(&value);
3017 if value.get("method").and_then(Value::as_str).is_some_and(|method| method.starts_with("Network.") && method != "Network.responseReceivedExtraInfo") && terminal && !late_ordinary { return }
3018 let guarded = self.blocked.contains(&key.0) || shield::loaded_urls_protected(&self.guard, &value["params"]) || self.hidden(&value) || self.redirects.contains(&key.1);
3019 if guarded && self.visible_redirect(&mut value) {
3020 let hop = value.get("method").and_then(Value::as_str) == Some("Network.requestWillBeSent");
3021 self.events.push(value.clone());
3022 if hop { self.fail_seen_network(&value); }
3023 return;
3024 }
3025 if terminal && !late_ordinary { return }
3026 if self.worlds.event(&value, &self.guard) {
3027 if value.get("method").and_then(Value::as_str) == Some("Debugger.paused") {
3028 let _ = self.send("Debugger.resume", json!({}), value.get("sessionId").and_then(Value::as_str));
3029 }
3030 return;
3031 }
3032 if guarded && !value.get("method").and_then(Value::as_str).unwrap_or("").starts_with("Target.") {
3033 self.fail_seen_network(&value);
3034 return;
3035 }
3036 self.adopt_guard_attach(&value);
3037 if self.blocked.contains(value.get("sessionId").and_then(Value::as_str).unwrap_or("")) || !value.get("method").and_then(Value::as_str).unwrap_or("").starts_with("Target.") && shield::loaded_urls_protected(&self.guard, &value["params"]) {
3038 self.fail_seen_network(&value);
3039 return;
3040 }
3041 let echoed_url = (value["method"] == "Network.requestWillBeSent" && value["params"]["type"] == "Document" && !guarded
3042 && !self.protected_body_requests.contains(&key.1) && self.client_navigation_urls.get(&key.0).is_some_and(|url| value.pointer("/params/request/url").and_then(Value::as_str) == Some(url.as_str()))).then(|| value["params"]["request"]["url"].clone());
3043 shield::redact_strings(&self.guard, &mut value);
3044 if let Some(url) = echoed_url { value["params"]["request"]["url"] = url; }
3045 if self.hidden(&value) {
3046 self.fail_seen_network(&value);
3047 return;
3048 }
3049 let method = value.get("method").and_then(|v| v.as_str()).unwrap_or("");
3050 self.worlds.visible_event(value.get("sessionId").and_then(Value::as_str).unwrap_or(""), method, &value["params"]);
3051 let id = value
3052 .pointer("/params/requestId")
3053 .and_then(|v| v.as_str())
3054 .map(str::to_string);
3055 let session = value.get("sessionId").and_then(|v| v.as_str());
3056 if let (true, Some(session), Some(id)) = (method.starts_with("Fetch."), session, &id) {
3057 let session = session.to_string();
3058 if value.pointer("/params/resourceType").and_then(Value::as_str) == Some("Document") {
3059 self.paused_documents.insert((session.clone(), id.clone()));
3060 }
3061 self.hand(&session, id);
3062 }
3063 if method.ends_with("ExtraInfo") {
3064 if let Some(id) = id.clone() {
3065 if let Some(cookies) = value.pointer("/params/associatedCookies").and_then(Value::as_array) {
3066 self.trace_cookies.extend(cookies.iter().filter_map(|item| item.get("cookie").cloned()));
3067 }
3068 shield::strip_protected_associated(&self.guard, &mut value);
3069 if self.requests.get(&id) != Some(&false) {
3070 self.held.entry(id).or_default().push(value);
3071 return;
3072 }
3073 }
3074 }
3075 if !terminal { self.visible_network(&value); }
3076 self.events.push(value);
3077 if let Some(id) = id {
3078 if self.requests.get(&id) == Some(&false) {
3079 if let Some(held) = self.held.remove(&id) {
3080 for event in held { self.deliver(event); }
3081 }
3082 }
3083 }
3084 }
3085
3086 fn renderer_crashed(&self, session: Option<&str>, target: Option<&str>) -> bool {
3087 target.is_some_and(|target| self.crashed_targets.contains(target))
3088 || session.is_some_and(|session| self.crashed_sessions.contains(session)
3089 || self.session_target(session).is_some_and(|target| self.crashed_targets.contains(&target)))
3090 }
3091
3092 fn observe_renderer_crash(&mut self, value: &Value) {
3093 let method = value.get("method").and_then(Value::as_str).unwrap_or("");
3094 let reason = value.pointer("/params/reason").and_then(Value::as_str).unwrap_or("").to_ascii_lowercase();
3095 if method != "Inspector.targetCrashed" && !(matches!(method, "Inspector.detached" | "Target.detachedFromTarget")
3096 && reason.contains("crash")) { return }
3097 let session = if method == "Target.detachedFromTarget" { value.pointer("/params/sessionId") } else { value.get("sessionId") }
3098 .and_then(Value::as_str).filter(|session| !session.is_empty());
3099 if let Some(session) = session {
3100 self.crashed_sessions.insert(session.to_string());
3101 if let Some(target) = self.session_target(session) {
3102 self.crashed_targets.insert(target.clone());
3103 self.crashed_sessions.extend(self.session_targets.iter().filter(|(_, owner)| *owner == &target).map(|(session, _)| session.clone()));
3104 }
3105 }
3106 }
3107
3108 fn raw_call(
3109 &mut self,
3110 method: &str,
3111 params: Value,
3112 session_id: Option<&str>,
3113 timeout: Duration,
3114 ) -> Result<Value, String> {
3115 self.raw_call_execution(method, params, session_id, timeout, false)
3116 }
3117
3118 fn raw_call_execution(
3119 &mut self,
3120 method: &str,
3121 params: Value,
3122 session_id: Option<&str>,
3123 timeout: Duration,
3124 pinned: bool,
3125 ) -> Result<Value, String> {
3126 let active = pinned.then_some(session_id).flatten();
3127 if let Some(session) = active { self.executing_sessions.insert(session.to_string()); }
3128 let result = self.raw_call_wait(method, params, session_id, timeout, pinned);
3129 if let Some(session) = active {
3130 self.executing_sessions.remove(session);
3131 if self.blocked.contains(session) { self.detach_blocked(session); }
3132 }
3133 result
3134 }
3135
3136 fn raw_call_wait(
3137 &mut self,
3138 method: &str,
3139 params: Value,
3140 session_id: Option<&str>,
3141 timeout: Duration,
3142 pinned: bool,
3143 ) -> Result<Value, String> {
3144 let frame_epoch = self.frame_epoch;
3145 let page = session_id.and_then(|session| self.session_target(session)).and_then(|target| self.page_scope_owner(&target))
3146 .map(|page| (page.clone(), self.page_scope_epochs.get(&page).copied().unwrap_or(0), self.page_scope_unknown));
3147 let result = self.raw_exchange(method, params, session_id, timeout, pinned)?;
3148 if method == "Page.getFrameTree" {
3149 let stable_page = page.is_some_and(|(page, epoch, unknown)| self.page_scope_epochs.get(&page).copied().unwrap_or(0) == epoch && self.page_scope_unknown == unknown);
3150 if !stable_page && !self.tree_current(&result, frame_epoch) {
3151 return Err(self.refusal());
3152 }
3153 self.record_frames(&result, session_id.unwrap_or(""));
3154 }
3155 Ok(result)
3156 }
3157
3158 fn raw_exchange(
3159 &mut self,
3160 method: &str,
3161 params: Value,
3162 session_id: Option<&str>,
3163 timeout: Duration,
3164 pinned: bool,
3165 ) -> Result<Value, String> {
3166 if self.renderer_crashed(session_id, None) { return Err(RENDERER_CRASHED.to_string()) }
3167 let id = self.send(method, params, session_id)?;
3168 self.waiting_calls.insert(id);
3169 let result = self.raw_reply(method, id, session_id, timeout, pinned);
3170 self.waiting_calls.remove(&id);
3171 self.call_replies.remove(&id);
3172 if method == "Page.getFrameTree" && session_id.is_some_and(|session| self.guard_sessions.contains(session)) {
3173 if let Ok(tree) = &result { let _ = self.verify_document_order(tree, session_id); }
3174 }
3175 result
3176 }
3177
3178 fn raw_reply(&mut self, method: &str, id: i64, session_id: Option<&str>, timeout: Duration, pinned: bool) -> Result<Value, String> {
3179 let deadline = Instant::now() + timeout;
3180 let was_blocked = session_id.is_some_and(|session| self.blocked.contains(session));
3181 loop {
3182 if self.renderer_crashed(session_id, None) { return Err(RENDERER_CRASHED.to_string()) }
3183 let value = match self.call_replies.remove(&id) {
3184 Some(value) => value,
3185 None => {
3186 let text = match self.recv(deadline)? {
3187 Some(text) => text,
3188 None => return Err(if pinned && session_id.is_some_and(|session| self.blocked.contains(session)) { self.refusal() } else { format!("{method} timed out\n") }),
3189 };
3190 serde_json::from_str::<Value>(&text)
3191 .map_err(|err| format!("CDP response was not JSON: {err}\n"))?
3192 }
3193 };
3194 if value.get("id").and_then(|item| item.as_i64()) == Some(id) {
3195 self.detach_reply(id, &value);
3196 if let Some(error) = value.get("error") {
3197 if pinned && session_id.is_some_and(|session| self.blocked.contains(session)) { return Err(self.refusal()) }
3198 let text = error
3199 .get("message")
3200 .and_then(|item| item.as_str())
3201 .unwrap_or("CDP error");
3202 let (text, _) = shield::redact_text(&self.guard, text);
3203 return Err(format!("{method}: {text}\n"));
3204 }
3205 if method == "Target.attachToTarget" {
3206 if let Some(session) = value.pointer("/result/sessionId").and_then(Value::as_str) {
3207 self.blocked.remove(session);
3208 self.detached_ordinary.remove(session);
3209 }
3210 }
3211 return Ok(value.get("result").cloned().unwrap_or(Value::Null));
3212 }
3213 let detached = value.get("method").and_then(|v| v.as_str())
3214 == Some("Target.detachedFromTarget")
3215 && value.pointer("/params/sessionId").and_then(|v| v.as_str()) == session_id;
3216 self.absorb(value);
3217 if self.renderer_crashed(session_id, None) { return Err(RENDERER_CRASHED.to_string()) }
3218 if let Some(session) = session_id {
3219 if detached || (!pinned && !was_blocked && self.blocked.contains(session)) {
3220 return Err(self.refusal());
3221 }
3222 }
3223 }
3224 }
3225
3226 fn send(&mut self, method: &str, params: Value, session_id: Option<&str>) -> Result<i64, String> {
3227 self.webmcp_trace_fetch_command(method, ¶ms, session_id);
3228 self.next_id += 1;
3229 let id = self.next_id;
3230 let mut message = json!({
3231 "id": id,
3232 "method": method,
3233 "params": params,
3234 });
3235 if let Some(session_id) = session_id {
3236 message["sessionId"] = json!(session_id);
3237 }
3238 self.ws.send_text(&message.to_string())?;
3239 if method == "Target.detachFromTarget" {
3240 if let Some(session) = message.pointer("/params/sessionId").and_then(Value::as_str) {
3241 self.detaching.insert(id, session.to_string());
3242 }
3243 }
3244 Ok(id)
3245 }
3246
3247 pub fn set_waiter(&mut self, waiter: Option<Waiter>) {
3248 self.waiter = waiter;
3249 }
3250
3251 fn recv(&mut self, deadline: Instant) -> Result<Option<String>, String> {
3252 loop {
3253 let Some(mut waiter) = self.waiter.take() else { return self.ws.recv_text(deadline) };
3254 let now = Instant::now();
3255 if now >= self.waiter_due {
3256 waiter(self);
3257 self.waiter_due = Instant::now() + WAITER_SLICE;
3258 }
3259 self.waiter = Some(waiter);
3260 let until = deadline.min(self.waiter_due);
3261 if let Some(text) = self.ws.recv_text(until)? { return Ok(Some(text)) }
3262 if until == deadline { return Ok(None) }
3263 }
3264 }
3265
3266 pub fn pump(&mut self, deadline: Instant) -> Result<bool, String> {
3267 self.webmcp_sweep();
3268 let result = match self.recv(deadline)? {
3269 Some(text) => {
3270 if let Ok(value) = serde_json::from_str::<Value>(&text) {
3271 self.absorb(value);
3272 }
3273 Ok(true)
3274 }
3275 None => Ok(false),
3276 };
3277 self.webmcp_sweep();
3278 result
3279 }
3280
3281 pub fn next_paused(
3282 &mut self,
3283 session_id: Option<&str>,
3284 timeout: Duration,
3285 ) -> Result<Option<Paused>, String> {
3286 let deadline = Instant::now() + timeout;
3287 loop {
3288 let found = self
3289 .paused
3290 .iter()
3291 .position(|paused| session_id.is_none_or(|id| paused.session_id == id));
3292 if let Some(index) = found {
3293 return Ok(self.paused.remove(index));
3294 }
3295 if let Some(session) = session_id {
3296 if self.blocked.contains(session) {
3297 return Err(self.refusal());
3298 }
3299 }
3300 if Instant::now() >= deadline || !self.pump(deadline)? {
3301 return Ok(None);
3302 }
3303 }
3304 }
3305
3306 pub fn wait_event(
3307 &mut self,
3308 from: usize,
3309 timeout: Duration,
3310 mut matches: impl FnMut(&Value) -> bool,
3311 ) -> Result<Option<Value>, String> {
3312 let deadline = Instant::now() + timeout;
3313 let mut seen = from;
3314 loop {
3315 while seen < self.events.len() {
3316 if matches(&self.events[seen]) {
3317 return Ok(Some(self.events[seen].clone()));
3318 }
3319 seen += 1;
3320 }
3321 if Instant::now() >= deadline || !self.pump(deadline)? {
3322 return Ok(None);
3323 }
3324 }
3325 }
3326
3327 pub(crate) fn forget_paused(&mut self, session_id: &str) {
3328 self.paused.retain(|paused| paused.session_id != session_id);
3329 self.deciders.remove(session_id);
3330 }
3331
3332 fn detach_reply(&mut self, id: i64, value: &Value) {
3333 if let Some(session) = self.detaching.remove(&id) {
3334 if value.get("error").is_none() { self.forget_session(&session); }
3335 }
3336 }
3337
3338 fn forget_session(&mut self, session: &str) {
3339 self.webmcp_cancel_queued(session);
3340 if !self.blocked.contains(session) && !self.guard_sessions.contains(session) {
3341 self.detached_ordinary.insert(session.to_string());
3342 }
3343 let target = self.session_target(session);
3344 if self.blocked.contains(session) {
3345 if let Some(target) = &target { self.protected_targets.insert(target.clone()); }
3346 self.unchecked_documents.retain(|(_, owner, _), _| owner != session);
3347 }
3348 let guards: Vec<String> = self.guards.iter().filter(|(_, guard)| guard.as_str() == session).map(|(target, _)| target.clone()).collect();
3349 self.session_targets.remove(session);
3350 self.page_scope_sessions.retain(|_, owner| owner != session);
3351 self.guard_sessions.remove(session);
3352 self.blocked.insert(session.to_string());
3353 self.detaching.retain(|_, owner| owner != session);
3354 for target in guards {
3355 self.guards.remove(&target);
3356 self.documents.remove(&target);
3357 self.cached_documents.remove(&target);
3358 self.abandon(&target);
3359 }
3360 self.runtime_sessions.retain(|_, owner| owner != session);
3361 self.frame_sessions.remove(session);
3362 self.context_frames.retain(|(owner, _), _| owner != session);
3363 self.context_proofs.retain(|(owner, _), _| owner != session);
3364 self.created_contexts.retain(|(owner, _)| owner != session);
3365 self.executing_sessions.remove(session);
3366 self.dialog_sessions.remove(session);
3367 self.dialogs.remove(session);
3368 self.dialog_documents.remove(session);
3369 self.forget_paused(session);
3370 self.paused_documents.retain(|(owner, _)| owner != session);
3371 self.handed.retain(|(owner, _)| owner != session);
3372 self.answering.retain(|_, (owner, _)| owner != session);
3373 self.decided.retain(|_, (owner, _)| owner != session);
3374 self.held.remove(session);
3375 self.navigated_blanks.retain(|_, (owner, _, _)| owner != session);
3376 self.seen_network.retain(|(owner, _), _| owner != session);
3377 self.terminal_network.retain(|(owner, _)| owner != session);
3378 self.client_navigation_urls.remove(session);
3379 self.protected_request_pages.retain(|(owner, _)| owner != session);
3380 self.protected_resources.retain(|(owner, _)| owner != session);
3381 self.source_resources.retain(|(owner, _), _| owner != session);
3382 for resources in self.request_resources.values_mut() { resources.retain(|(owner, _)| owner != session); }
3383 for navigation in self.navigations.values_mut() {
3384 if navigation.session.as_deref() == Some(session) { navigation.detached = true; }
3385 }
3386 self.worlds.event(&json!({"method":"Target.detachedFromTarget","params":{"sessionId":session}}), &self.guard);
3387 self.issued.forget(session);
3388 self.webmcp.forget(session);
3389 }
3390
3391 fn absorb(&mut self, mut value: Value) {
3392 if let Some(id) = value.get("id").and_then(|item| item.as_i64()) {
3393 self.detach_reply(id, &value);
3394 if self.waiting_calls.contains(&id) {
3395 self.call_replies.insert(id, value.clone());
3396 }
3397 if let Some(navigation) = self.navigations.get_mut(&id) {
3398 navigation.reply = Some(value);
3399 return;
3400 }
3401 if let Some((session, request)) = self.answering.remove(&id) {
3402 if value.get("error").is_none() {
3403 self.settle(&session, &request);
3404 }
3405 }
3406 if let Some((session, request)) = self.decided.remove(&id) {
3407 if let Some(error) = value.get("error") {
3408 let text = error
3409 .get("message")
3410 .and_then(|item| item.as_str())
3411 .unwrap_or("CDP error");
3412 let (text, _) = shield::redact_text(&self.guard, text);
3413 self.fetch_errors.push(format!("Fetch: {text}\n"));
3414 self.continue_plain(&session, &request);
3415 }
3416 }
3417 return;
3418 }
3419 self.observe_renderer_crash(&value);
3420 self.observe_dialog(&value);
3421 if value.get("method").and_then(Value::as_str) == Some("Target.detachedFromTarget") {
3422 let session = value.pointer("/params/sessionId").and_then(Value::as_str);
3423 for navigation in self.navigations.values_mut() {
3424 if navigation.session.as_deref() == session { navigation.detached = true; }
3425 }
3426 }
3427 if self.webmcp_event(&value) {
3428 return;
3429 }
3430 if value.get("method").and_then(|item| item.as_str()) == Some("Fetch.authRequired")
3431 && self.challenge_protected(&value)
3432 {
3433 let id = value.pointer("/params/requestId").cloned().unwrap_or(Value::Null);
3434 if let Some(key) = id.as_str() {
3435 self.requests.insert(key.to_string(), true);
3436 }
3437 let session = value.get("sessionId").and_then(|v| v.as_str()).unwrap_or("").to_string();
3438 let _ = self.send(
3439 "Fetch.continueWithAuth",
3440 json!({ "requestId": id, "authChallengeResponse": { "response": "Default" } }),
3441 Some(&session),
3442 );
3443 return;
3444 }
3445 if value.get("method").and_then(Value::as_str) == Some("Fetch.authRequired") && self.guard_auth(&value) {
3446 return;
3447 }
3448 if value.get("method").and_then(|item| item.as_str()) == Some("Fetch.requestPaused") {
3449 let Some(mut paused) = Paused::from_event(&value) else {
3450 return;
3451 };
3452 if let Some(network) = &paused.network_id {
3453 self.request_aliases.entry(network.clone()).or_default().insert(paused.request_id.clone());
3454 self.request_aliases.entry(paused.request_id.clone()).or_default().insert(network.clone());
3455 if self.redirects.contains(network) {
3456 self.mark_redirect(network);
3457 }
3458 if self.protected_body_requests.contains(network) { self.protect_body_request(network); }
3459 }
3460 if self.issued_hop(&value, &paused) { return; }
3461 let guard_only = self.guard_only(&paused);
3462 let authority_protected = shield::scheme_less_protected(&self.guard, &value["params"]["request"]);
3463 let redirect = self.actual_redirect_carrier(&value);
3464 if self.protected_carrier(&value, false) {
3465 self.protect_body_request(&paused.request_id);
3466 if let Some(network) = &paused.network_id { self.protect_body_request(network); self.protect_resource(&paused.session_id, &paused.url); }
3467 }
3468 let reaches = self.guard.url(&paused.full_url()) || redirect || authority_protected;
3469 let loaded_protected = self.guard.url(&paused.full_url()) || authority_protected;
3470 let protected = reaches;
3471 if loaded_protected {
3472 self.protect_resource(&paused.session_id, &paused.full_url());
3473 }
3474 if redirect {
3475 self.mark_redirect(&paused.request_id);
3476 if let Some(network) = &paused.network_id {
3477 self.mark_redirect(network);
3478 self.protect_resource(&paused.session_id, &paused.url);
3479 }
3480 }
3481 let initiated = self.initiated_by_protected(&paused);
3482 if self.redirect_page_protected(&value) || initiated {
3483 self.protected_request_pages.insert((paused.session_id.clone(), paused.request_id.clone()));
3484 if let Some(network) = &paused.network_id { self.protected_request_pages.insert((paused.session_id.clone(), network.clone())); }
3485 }
3486 #[cfg(test)]
3487 let observed_url = paused.url.clone();
3488 let ordinary_url = (!redirect && !loaded_protected && !initiated && !self.guard_sessions.contains(&paused.session_id) && !self.redirect_page_protected(&value)
3489 && paused.resource_type == "Document" && self.client_navigation_urls.get(&paused.session_id) == Some(&paused.url)
3490 && !self.protected_body_requests.contains(&paused.request_id)
3491 && self.ordinary_redirect_url(&paused.url)).then(|| paused.url.clone());
3492 shield::redact_strings(&self.guard, &mut value);
3493 if let Some(url) = ordinary_url { value["params"]["request"]["url"] = json!(url); }
3494 paused = Paused::from_event(&value).unwrap();
3495 self.requests.insert(paused.request_id.clone(), loaded_protected || initiated);
3496 if let Some(network) = &paused.network_id {
3497 let entry = self.requests.entry(network.clone()).or_insert(false);
3498 *entry = *entry || loaded_protected || initiated;
3499 }
3500 #[cfg(test)]
3501 {
3502 let reason = if self.guard_sessions.contains(&paused.session_id) {
3503 "guard session"
3504 } else if protected {
3505 "reaches a protected origin"
3506 } else if self.blocked.contains(&paused.session_id) {
3507 "blocked session"
3508 } else if initiated {
3509 "initiated by protected"
3510 } else if self.deciders.contains_key(&paused.session_id) {
3511 "decider"
3512 } else {
3513 "queued"
3514 };
3515 self.paused_trail
3516 .push((paused.session_id.clone(), observed_url, reason));
3517 }
3518 if self.guard_sessions.contains(&paused.session_id) {
3519 if reaches && paused.resource_type == "Document" {
3520 self.answer_protected(&paused);
3521 } else {
3522 self.continue_plain(&paused.session_id, &paused.request_id);
3523 }
3524 return;
3525 }
3526 if protected {
3527 if redirect && !authority_protected && self.visible_redirect(&mut value) {
3528 self.events.push(value);
3529 }
3530 self.answer_protected(&paused);
3531 return;
3532 }
3533 if self.blocked.contains(&paused.session_id) || initiated {
3534 self.fail_seen_network(&value);
3535 self.continue_plain(&paused.session_id, &paused.request_id);
3536 return;
3537 }
3538 if self.redirects.contains(&paused.request_id) && !redirect && !protected {
3539 self.continue_plain(&paused.session_id, &paused.request_id);
3540 return;
3541 }
3542 if guard_only {
3543 self.continue_plain(&paused.session_id, &paused.request_id);
3544 return;
3545 }
3546 if paused.resource_type == "Document" {
3547 self.paused_documents.insert((paused.session_id.clone(), paused.request_id.clone()));
3548 }
3549 self.hand(&paused.session_id, &paused.request_id);
3550 if self.deciders.contains_key(&paused.session_id) {
3551 self.decide_inline(paused);
3552 } else {
3553 self.paused.push_back(paused);
3554 }
3555 return;
3556 }
3557 if value.get("method").is_some() {
3558 self.deliver(value);
3559 }
3560 }
3561
3562 fn decide_inline(&mut self, paused: Paused) {
3563 if self.blocked.contains(&paused.session_id) {
3564 self.answer_protected(&paused);
3565 return;
3566 }
3567 if self.defer_issued(&paused) { return }
3568 let Some(decider) = self.deciders.get_mut(&paused.session_id) else {
3569 self.paused.push_back(paused);
3570 return;
3571 };
3572 let decision = decider(&paused);
3573 let (method, params, issued) = match fetch::command(&self.guard, &paused, &decision)
3574 .and_then(|(method, params)| self.client_issued(method, ¶ms, Some(&paused.session_id)).map(|issued| (method, params, issued))) {
3575 Ok(command) => command,
3576 Err(message) => {
3577 self.fetch_errors.push(message);
3578 let (method, params) = fetch::command(&self.guard, &paused, &Decision::default())
3579 .expect("a plain continue is always allowed");
3580 (method, params, false)
3581 }
3582 };
3583 if issued {
3584 if let Err(message) = self.issue(¶ms, &paused.session_id) {
3585 self.fetch_errors.push(message);
3586 self.continue_plain(&paused.session_id, &paused.request_id);
3587 return;
3588 }
3589 }
3590 self.settle(&paused.session_id, &paused.request_id);
3591 if let Ok(id) = self.send(method, params, Some(&paused.session_id)) {
3592 self.decided
3593 .insert(id, (paused.session_id.clone(), paused.request_id.clone()));
3594 }
3595 }
3596
3597 pub fn wait_load(&mut self, session_id: &str) -> Result<(), String> {
3598 if self.events.iter().any(|event| is_load(event, session_id)) {
3599 return Ok(());
3600 }
3601 let probe = self.call_for(
3602 "Runtime.evaluate",
3603 json!({
3604 "expression": "document.readyState",
3605 "returnByValue": true,
3606 }),
3607 Some(session_id),
3608 Duration::from_secs(1),
3609 );
3610 let settled = match &probe {
3611 Ok(result) => probe_is_settled(Ok(result
3612 .pointer("/result/value")
3613 .and_then(|value| value.as_str())))?,
3614 Err(err) => probe_is_settled(Err(err.as_str()))?,
3615 };
3616 if settled {
3617 return Ok(());
3618 }
3619 let deadline = Instant::now() + Duration::from_secs(15);
3620 loop {
3621 if self.blocked.contains(session_id) {
3622 return Err(self.refusal());
3623 }
3624 if self.events.iter().any(|event| is_load(event, session_id)) {
3625 return Ok(());
3626 }
3627 if Instant::now() >= deadline {
3628 return Ok(());
3629 }
3630 if !self.pump(deadline)? {
3631 return Ok(());
3632 }
3633 }
3634 }
3635
3636 pub fn wait_load_since(&mut self, session_id: &str, from: usize) -> Result<(), String> {
3637 let deadline = Instant::now() + Duration::from_secs(15);
3638 loop {
3639 if self.blocked.contains(session_id) {
3640 return Err(self.refusal());
3641 }
3642 if navigation_settled(&self.events, session_id, from) {
3643 return Ok(());
3644 }
3645 if Instant::now() >= deadline {
3646 return Ok(());
3647 }
3648 if !self.pump(deadline)? {
3649 return Ok(());
3650 }
3651 }
3652 }
3653}
3654
3655pub fn transport_error(message: &str) -> bool {
3656 message.starts_with("websocket ") || message.starts_with("CDP response was not JSON")
3657}
3658
3659fn unguarded(message: String) -> String {
3660 if transport_error(&message) || message == RENDERER_CRASHED {
3661 message
3662 } else if let Some(step) = message.strip_suffix(" timed out\n") {
3663 format!("{}: {step} timed out\n", UNGUARDED.trim_end())
3664 } else {
3665 UNGUARDED.to_string()
3666 }
3667}
3668
3669fn frame_text_known(text: &str) -> bool {
3670 !matches!(text, "" | "null" | "://")
3671}
3672
3673fn crosses_frames(method: &str, params: &Value) -> bool {
3674 matches!(method, "DOMSnapshot.captureSnapshot" | "DOMSnapshot.getSnapshot" | "DOM.getFlattenedDocument")
3675 || method.starts_with("DOM.") && (params.get("pierce").and_then(Value::as_bool) == Some(true)
3676 || params.get("depth").and_then(Value::as_i64).is_some_and(|depth| depth < 0 || depth > 1))
3677}
3678
3679fn recovery(method: &str, params: &Value) -> bool {
3680 match method {
3681 "Page.enable" | "Page.disable" | "Page.navigate" | "Page.reload" | "Page.stopLoading" | "Page.navigateToHistoryEntry"
3682 | "Page.getNavigationHistory" | "Page.getFrameTree" | "Page.close" | "Runtime.enable" | "Runtime.disable"
3683 | "Runtime.runIfWaitingForDebugger" | "Network.enable" | "Network.disable" | "Log.enable" | "Log.disable"
3684 | "Fetch.enable" | "Fetch.disable" | "Fetch.continueRequest" | "Fetch.failRequest" | "Fetch.fulfillRequest"
3685 | "Fetch.continueResponse" | "Fetch.continueWithAuth" => true,
3686 "Runtime.evaluate" => {
3687 matches!(params.get("expression").and_then(Value::as_str), Some("document.readyState" | "0"))
3688 && params.as_object().is_some_and(|object| object.keys().all(|key| matches!(key.as_str(), "expression" | "returnByValue")))
3689 }
3690 _ => false,
3691 }
3692}
3693
3694fn content_command(method: &str, params: &Value) -> Option<bool> {
3695 if method == "Runtime.evaluate"
3696 && matches!(params.get("expression").and_then(Value::as_str), Some("document.readyState" | "0" | "document.readyState === 'complete' ? location.href : ''"))
3697 && params.as_object().is_some_and(|object| object.keys().all(|key| matches!(key.as_str(), "expression" | "returnByValue")))
3698 { return Some(false) }
3699 if method == "Runtime.compileScript" && params.get("persistScript").and_then(Value::as_bool) != Some(false) { return None }
3700 if method == "Page.addScriptToEvaluateOnNewDocument" {
3701 return Some(params.get("runImmediately").is_some_and(|value| value != &json!(false)));
3702 }
3703 match method {
3704 "Debugger.setInstrumentationBreakpoint" | "Emulation.setVirtualTimePolicy" | "Overlay.setShowPaintRects"
3705 | "Page.addScriptToEvaluateOnLoad" | "Security.setIgnoreCertificateErrors" | "Inspector.enable" => None,
3706 "Runtime.evaluate" | "Runtime.callFunctionOn" | "Runtime.awaitPromise" | "Runtime.compileScript" | "Runtime.runScript"
3707 | "Runtime.getProperties" | "Runtime.getExceptionDetails" | "Runtime.queryObjects" | "Runtime.globalLexicalScopeNames" | "Runtime.getHeapUsage" | "Runtime.discardConsoleEntries"
3708 | "DOM.collectClassNamesFromSubtree" | "DOM.copyTo" | "DOM.describeNode" | "DOM.focus" | "DOM.getAttributes" | "DOM.getBoxModel" | "DOM.getContentQuads"
3709 | "DOM.getDocument" | "DOM.getFlattenedDocument" | "DOM.getNodesForSubtreeByStyle" | "DOM.getNodeForLocation" | "DOM.getOuterHTML" | "DOM.getRelayoutBoundary" | "DOM.getSearchResults"
3710 | "DOM.hideHighlight" | "DOM.highlightNode" | "DOM.highlightRect" | "DOM.markUndoableState" | "DOM.moveTo" | "DOM.performSearch" | "DOM.pushNodeByPathToFrontend"
3711 | "DOM.pushNodesByBackendIdsToFrontend" | "DOM.querySelector" | "DOM.querySelectorAll" | "DOM.redo" | "DOM.removeAttribute" | "DOM.removeNode" | "DOM.requestChildNodes" | "DOM.requestNode"
3712 | "DOM.resolveNode" | "DOM.setAttributeValue" | "DOM.setAttributesAsText" | "DOM.setFileInputFiles" | "DOM.setNodeName" | "DOM.setNodeValue" | "DOM.setOuterHTML" | "DOM.undo"
3713 | "DOM.getFrameOwner" | "DOM.getNodeStackTraces" | "DOM.getFileInfo" | "DOM.getDetachedDomNodes" | "DOM.getTopLayerElements" | "DOM.discardSearchResults" | "DOM.forceShowPopover"
3714 | "DOMSnapshot.captureSnapshot" | "DOMSnapshot.getSnapshot" | "DOMDebugger.getEventListeners"
3715 | "Input.dispatchDragEvent" | "Input.dispatchKeyEvent" | "Input.dispatchMouseEvent" | "Input.dispatchTouchEvent" | "Input.emulateTouchFromMouseEvent" | "Input.insertText"
3716 | "Input.synthesizePinchGesture" | "Input.synthesizeScrollGesture" | "Input.synthesizeTapGesture" | "Input.cancelDragging" | "Input.imeSetComposition"
3717 | "Accessibility.getFullAXTree" | "Accessibility.getPartialAXTree" | "Accessibility.getRootAXNode" | "Accessibility.getAXNodeAndAncestors" | "Accessibility.getChildAXNodes" | "Accessibility.queryAXTree"
3718 | "Page.captureScreenshot" | "Page.captureSnapshot" | "Page.printToPDF" | "Page.getResourceContent" | "Page.searchInResource" | "Page.getLayoutMetrics" | "Page.getPermissionsPolicyState" | "Page.setDocumentContent"
3719 | "Page.getAppManifest" | "Page.getInstallabilityErrors" | "Page.getAppId" | "Page.startScreencast" | "Page.generateTestReport"
3720 | "Network.getResponseBody" | "Network.getRequestPostData" | "Network.getResponseBodyForInterception" | "Network.searchInResponseBody" | "Network.loadNetworkResource"
3721 | "Network.streamResourceContent" | "Network.takeResponseBodyForInterceptionAsStream" | "Network.replayXHR" | "Audits.getEncodedResponse"
3722 | "Fetch.getResponseBody" | "Fetch.takeResponseBodyAsStream" | "IO.read" | "IO.close" | "IO.resolveBlob"
3723 | "Debugger.evaluateOnCallFrame" | "Debugger.getScriptSource" | "Debugger.searchInContent" | "Debugger.setScriptSource" | "Debugger.setVariableValue" | "Debugger.restartFrame" | "Debugger.stepInto" | "Debugger.stepOut" | "Debugger.stepOver"
3724 | "Debugger.getWasmBytecode" | "Debugger.disassembleWasmModule" | "Debugger.nextWasmDisassemblyChunk" | "Debugger.getPossibleBreakpoints" | "Debugger.pause"
3725 | "HeapProfiler.takeHeapSnapshot" | "HeapProfiler.getHeapObjectId" | "HeapProfiler.getObjectByHeapObjectId" | "HeapProfiler.getSamplingProfile" | "HeapProfiler.stopSampling" | "HeapProfiler.stopTrackingHeapObjects"
3726 | "DOMStorage.getDOMStorageItems" | "DOMStorage.setDOMStorageItem" | "DOMStorage.removeDOMStorageItem" | "DOMStorage.clear"
3727 | "Storage.clearDataForOrigin" | "Storage.clearDataForStorageKey" | "Storage.getUsageAndQuota" | "Storage.getStorageKeyForFrame"
3728 | "CacheStorage.requestCacheNames" | "CacheStorage.requestEntries" | "CacheStorage.requestCachedResponse" | "CacheStorage.deleteCache" | "CacheStorage.deleteEntry"
3729 | "IndexedDB.requestDatabaseNames" | "IndexedDB.requestDatabase" | "IndexedDB.requestData" | "IndexedDB.deleteDatabase" | "IndexedDB.deleteObjectStoreEntries" | "IndexedDB.clearObjectStore" | "IndexedDB.getMetadata"
3730 | "FileSystem.getDirectory"
3731 | "Target.sendMessageToTarget" | "Target.exposeDevToolsProtocol"
3732 | "Profiler.stop" | "Profiler.takePreciseCoverage" | "Profiler.getBestEffortCoverage" | "CSS.getStyleSheetText" | "CSS.getComputedStyleForNode" | "CSS.getMatchedStylesForNode" | "CSS.getInlineStylesForNode"
3733 | "CSS.setStyleSheetText" | "CSS.setStyleTexts" | "CSS.setEffectivePropertyValueForNode" | "CSS.getMediaQueries" | "CSS.getPlatformFontsForNode" => Some(true),
3734 "Page.enable" | "Page.disable" | "Page.navigate" | "Page.reload" | "Page.stopLoading" | "Page.navigateToHistoryEntry" | "Page.close" | "Page.bringToFront"
3735 | "Page.getFrameTree" | "Page.getResourceTree" | "Page.getNavigationHistory" | "Page.handleJavaScriptDialog" | "Page.createIsolatedWorld" | "Page.setLifecycleEventsEnabled" | "Page.removeScriptToEvaluateOnNewDocument"
3736 | "Page.setBypassCSP" | "Page.setWebLifecycleState" | "Page.setInterceptFileChooserDialog" | "Page.stopScreencast" | "Page.screencastFrameAck" | "Page.setDownloadBehavior" | "Page.getCookies" | "Page.deleteCookie"
3737 | "Runtime.enable" | "Runtime.disable" | "Runtime.runIfWaitingForDebugger" | "Runtime.addBinding" | "Runtime.removeBinding" | "Runtime.releaseObject" | "Runtime.releaseObjectGroup" | "Runtime.getIsolateId"
3738 | "Runtime.setAsyncCallStackDepth" | "Runtime.setCustomObjectFormatterEnabled" | "Runtime.setMaxCallStackSizeToCapture" | "Runtime.terminateExecution"
3739 | "DOM.enable" | "DOM.disable" | "DOM.setNodeStackTracesEnabled" | "DOMSnapshot.enable" | "DOMSnapshot.disable" | "Accessibility.enable" | "Accessibility.disable" | "CSS.enable" | "CSS.disable"
3740 | "Input.setIgnoreInputEvents" | "Input.setInterceptDrags" | "Fetch.enable" | "Fetch.disable" | "Fetch.continueRequest" | "Fetch.fulfillRequest" | "Fetch.failRequest" | "Fetch.continueWithAuth" | "Fetch.continueResponse"
3741 | "Network.enable" | "Network.disable" | "Network.setBypassServiceWorker" | "Network.setCacheDisabled" | "Network.setExtraHTTPHeaders" | "Network.setRequestInterception" | "Network.continueInterceptedRequest"
3742 | "Network.setUserAgentOverride" | "Network.setBlockedURLs" | "Network.emulateNetworkConditions" | "Network.emulateNetworkConditionsByRule" | "Network.overrideNetworkState"
3743 | "Network.getCookies" | "Network.getAllCookies" | "Network.setCookie" | "Network.setCookies" | "Network.deleteCookies" | "Network.clearBrowserCookies" | "Network.clearBrowserCache" | "Network.setAcceptedEncodings" | "Network.clearAcceptedEncodingsOverride"
3744 | "Target.attachToTarget" | "Target.attachToBrowserTarget" | "Target.detachFromTarget" | "Target.createTarget" | "Target.closeTarget" | "Target.activateTarget" | "Target.getTargets" | "Target.getTargetInfo"
3745 | "Target.setDiscoverTargets" | "Target.setAutoAttach" | "Target.autoAttachRelated" | "Target.createBrowserContext" | "Target.disposeBrowserContext" | "Target.getBrowserContexts"
3746 | "Browser.getVersion" | "Browser.close" | "Browser.getWindowForTarget" | "Browser.getWindowBounds" | "Browser.setWindowBounds" | "Browser.grantPermissions" | "Browser.resetPermissions" | "Browser.setPermission"
3747 | "Browser.setDownloadBehavior" | "Browser.cancelDownload" | "Browser.getBrowserCommandLine" | "Browser.getHistograms" | "Browser.getHistogram" | "Browser.executeBrowserCommand" | "Browser.setDockTile"
3748 | "Emulation.setCPUThrottlingRate" | "Emulation.setFocusEmulationEnabled" | "Emulation.setDeviceMetricsOverride" | "Emulation.clearDeviceMetricsOverride" | "Emulation.setTouchEmulationEnabled"
3749 | "Emulation.setUserAgentOverride" | "Emulation.setLocaleOverride" | "Emulation.setTimezoneOverride" | "Emulation.setEmulatedMedia" | "Emulation.setGeolocationOverride" | "Emulation.clearGeolocationOverride"
3750 | "Emulation.setScriptExecutionDisabled" | "Emulation.setEmulatedVisionDeficiency" | "Emulation.setEmitTouchEventsForMouse" | "Emulation.setScrollbarsHidden" | "Emulation.setDefaultBackgroundColorOverride"
3751 | "Debugger.enable" | "Debugger.disable" | "Debugger.resume" | "Debugger.setBreakpoint" | "Debugger.setBreakpointByUrl" | "Debugger.removeBreakpoint"
3752 | "Debugger.setBreakpointsActive" | "Debugger.setPauseOnExceptions" | "Debugger.setSkipAllPauses" | "Debugger.setAsyncCallStackDepth" | "Debugger.setBlackboxPatterns" | "Debugger.setBlackboxedRanges"
3753 | "Profiler.enable" | "Profiler.disable" | "Profiler.start" | "Profiler.startPreciseCoverage" | "Profiler.stopPreciseCoverage" | "Profiler.setSamplingInterval"
3754 | "HeapProfiler.enable" | "HeapProfiler.disable" | "HeapProfiler.startSampling" | "HeapProfiler.startTrackingHeapObjects" | "HeapProfiler.collectGarbage"
3755 | "Log.enable" | "Log.disable" | "Log.clear" | "Log.startViolationsReport" | "Log.stopViolationsReport" | "Audits.enable" | "Audits.disable"
3756 | "DOMStorage.enable" | "DOMStorage.disable"
3757 | "Storage.getCookies" | "Storage.setCookies" | "Storage.clearCookies"
3758 | "IndexedDB.enable" | "IndexedDB.disable" | "IndexedDB.releaseObject"
3759 | "ServiceWorker.enable" | "ServiceWorker.disable" | "ServiceWorker.unregister" | "ServiceWorker.startWorker" | "ServiceWorker.stopWorker" | "ServiceWorker.stopAllWorkers" | "ServiceWorker.updateRegistration"
3760 | "PWA.install" | "PWA.launch" | "PWA.uninstall" | "Extensions.loadUnpacked" | "Extensions.uninstall" | "Extensions.getExtensions" | "SystemInfo.getInfo" | "SystemInfo.getProcessInfo"
3761 | "Tracing.start" | "Tracing.end" | "Tracing.getCategories" | "Tracing.recordClockSyncMarker" | "Tracing.requestMemoryDump" | "Slicc.action" => Some(false),
3762 _ => None,
3763 }
3764}
3765
3766fn storage_content(method: &str) -> bool {
3767 matches!(method, "Storage.getStorageKeyForFrame" | "FileSystem.getDirectory")
3768 || ["DOMStorage.", "IndexedDB.", "CacheStorage."].iter().any(|prefix| method.starts_with(prefix))
3769 || matches!(method, "Storage.clearDataForOrigin" | "Storage.clearDataForStorageKey" | "Storage.getUsageAndQuota")
3770}
3771
3772fn harmless(method: &str, params: &Value) -> bool {
3773 match method {
3774 "Fetch.disable" => true,
3775 "Fetch.continueRequest" => params
3776 .as_object()
3777 .is_some_and(|object| object.keys().all(|key| key == "requestId")),
3778 _ => false,
3779 }
3780}
3781
3782fn probe_is_settled(outcome: Result<Option<&str>, &str>) -> Result<bool, String> {
3783 match outcome {
3784 Ok(Some("loading")) | Ok(Some("interactive")) => Ok(false),
3785 Ok(_) => Ok(true),
3786 Err(err)
3787 if err.starts_with("Runtime.evaluate timed out")
3788 || err.starts_with("Runtime.evaluate:") =>
3789 {
3790 Ok(true)
3791 }
3792 Err(err) => Err(err.to_string()),
3793 }
3794}
3795
3796fn navigation_settled(events: &[Value], session_id: &str, from: usize) -> bool {
3797 let mut committed = false;
3798 for event in events.iter().skip(from) {
3799 if !committed && is_commit(event, session_id) {
3800 committed = true;
3801 continue;
3802 }
3803 if committed && is_load(event, session_id) {
3804 return true;
3805 }
3806 }
3807 false
3808}
3809
3810fn is_commit(event: &Value, session_id: &str) -> bool {
3811 if event.get("sessionId").and_then(|value| value.as_str()) != Some(session_id) {
3812 return false;
3813 }
3814 if event.get("method").and_then(|value| value.as_str()) != Some("Page.frameNavigated") {
3815 return false;
3816 }
3817 let url = event
3818 .pointer("/params/frame/url")
3819 .and_then(|value| value.as_str())
3820 .unwrap_or("");
3821 !url.is_empty() && !url.eq_ignore_ascii_case("about:blank")
3822}
3823
3824fn is_load(event: &Value, session_id: &str) -> bool {
3825 if event.get("sessionId").and_then(|v| v.as_str()) != Some(session_id) {
3826 return false;
3827 }
3828 match event.get("method").and_then(|v| v.as_str()) {
3829 Some("Page.loadEventFired") => true,
3830 Some("Page.lifecycleEvent") => {
3831 event.pointer("/params/name").and_then(|v| v.as_str()) == Some("load")
3832 }
3833 _ => false,
3834 }
3835}
3836
3837pub fn attach(cdp: &mut Cdp, target_id: &str) -> Result<String, String> {
3838 let result = cdp.call(
3839 "Target.attachToTarget",
3840 json!({ "targetId": target_id, "flatten": true }),
3841 None,
3842 )?;
3843 result
3844 .get("sessionId")
3845 .and_then(|v| v.as_str())
3846 .map(str::to_string)
3847 .ok_or_else(|| "Target.attachToTarget returned no sessionId\n".to_string())
3848}
3849
3850pub fn detach(cdp: &mut Cdp, session_id: &str) {
3851 let _ = cdp.call(
3852 "Target.detachFromTarget",
3853 json!({ "sessionId": session_id }),
3854 None,
3855 );
3856}
3857
3858#[derive(Clone, Debug, Default)]
3859pub struct ActionNote {
3860 pub kind: String,
3861 pub tab: Option<String>,
3862 pub target: Option<String>,
3863 pub url: Option<String>,
3864 pub key: Option<String>,
3865 pub length: Option<u64>,
3866 pub method: Option<String>,
3867 pub agent: Option<String>,
3868}
3869
3870impl ActionNote {
3871 pub fn start_params(&self) -> Value {
3872 let mut params = serde_json::Map::new();
3873 params.insert("phase".into(), json!("start"));
3874 params.insert("kind".into(), json!(self.kind));
3875 insert_text(&mut params, "tab", self.tab.as_deref());
3876 insert_text(&mut params, "target", self.target.as_deref());
3877 if let Some(url) = self.url.as_deref().and_then(public_url) {
3878 params.insert("url".into(), json!(url));
3879 }
3880 insert_text(&mut params, "key", self.key.as_deref());
3881 if let Some(length) = self.length {
3882 params.insert("length".into(), json!(length));
3883 }
3884 insert_text(&mut params, "method", self.method.as_deref());
3885 insert_text(&mut params, "agent", self.agent.as_deref());
3886 Value::Object(params)
3887 }
3888
3889 pub fn end_params(&self, ok: bool, stderr: &str) -> Value {
3890 let mut params = serde_json::Map::new();
3891 params.insert("phase".into(), json!("end"));
3892 params.insert("ok".into(), json!(ok));
3893 if !ok {
3894 if let Some(error) = action_error(&self.kind, stderr) {
3895 params.insert("error".into(), json!(error));
3896 }
3897 }
3898 insert_text(&mut params, "tab", self.tab.as_deref());
3899 Value::Object(params)
3900 }
3901}
3902
3903fn insert_text(params: &mut serde_json::Map<String, Value>, key: &str, value: Option<&str>) {
3904 if let Some(value) = value.filter(|value| !value.is_empty()) {
3905 params.insert(key.to_string(), json!(value));
3906 }
3907}
3908
3909pub fn first_stderr_line(stderr: &str) -> Option<&str> {
3910 stderr.lines().next().filter(|line| !line.is_empty())
3911}
3912
3913fn public_url(raw: &str) -> Option<String> {
3914 let raw = raw.trim();
3915 if raw.is_empty() {
3916 return None;
3917 }
3918 let without_fragment = raw.split_once('#').map(|(head, _)| head).unwrap_or(raw);
3919 let without_query = without_fragment
3920 .split_once('?')
3921 .map(|(head, _)| head)
3922 .unwrap_or(without_fragment);
3923 if without_query.is_empty() {
3924 return None;
3925 }
3926 if is_about_blank(without_query) {
3927 return Some("about:blank".to_string());
3928 }
3929 if let Some(rest) = without_query.strip_prefix("//") {
3930 let (host, path) = host_and_path(rest)?;
3931 return Some(format!("//{host}{path}"));
3932 }
3933 let (scheme, rest) = without_query.split_once(':')?;
3934 if !is_scheme(scheme) || !scheme_allowed(scheme) {
3935 return None;
3936 }
3937 let scheme = scheme.to_ascii_lowercase();
3938 let Some(authority) = rest.strip_prefix("//") else {
3939 return Some(format!("{scheme}:"));
3940 };
3941 let (host, path) = host_and_path(authority)?;
3942 Some(format!("{scheme}://{host}{path}"))
3943}
3944
3945fn scheme_allowed(scheme: &str) -> bool {
3946 matches!(
3947 scheme.to_ascii_lowercase().as_str(),
3948 "http"
3949 | "https"
3950 | "ws"
3951 | "wss"
3952 | "file"
3953 | "data"
3954 | "javascript"
3955 | "blob"
3956 | "about"
3957 | "chrome"
3958 | "chrome-extension"
3959 | "view-source"
3960 | "ftp"
3961 )
3962}
3963
3964fn is_about_blank(url: &str) -> bool {
3965 let Some((scheme, rest)) = url.split_once(':') else {
3966 return false;
3967 };
3968 scheme.eq_ignore_ascii_case("about") && rest.eq_ignore_ascii_case("blank")
3969}
3970
3971fn is_scheme(scheme: &str) -> bool {
3972 let mut chars = scheme.chars();
3973 match chars.next() {
3974 Some(ch) if ch.is_ascii_alphabetic() => {}
3975 _ => return false,
3976 }
3977 chars.all(|ch| ch.is_ascii_alphanumeric() || ch == '+' || ch == '-' || ch == '.')
3978}
3979
3980fn host_and_path(rest: &str) -> Option<(&str, &str)> {
3981 let (authority, path) = match rest.find('/') {
3982 Some(index) => (&rest[..index], &rest[index..]),
3983 None => (rest, ""),
3984 };
3985 let host = match authority.rfind('@') {
3986 Some(index) => &authority[index + 1..],
3987 None => authority,
3988 };
3989 if host.is_empty() { None } else { Some((host, path)) }
3990}
3991
3992fn action_error(kind: &str, stderr: &str) -> Option<&'static str> {
3993 if kind == "eval" {
3994 return None;
3995 }
3996 let line = first_stderr_line(stderr).unwrap_or("").to_ascii_lowercase();
3997 if line.contains("timed out") {
3998 return Some("timeout");
3999 }
4000 if line.contains("websocket closed")
4001 || line.contains("websocket connection closed")
4002 || line.contains("websocket write failed")
4003 || line.contains("websocket read failed")
4004 || line.contains("connection reset")
4005 || line.contains("broken pipe")
4006 {
4007 return Some("connection lost");
4008 }
4009 if line.contains("no snapshot") || line.contains("likely stale") {
4010 return Some("no snapshot");
4011 }
4012 if line.contains("unknown ref")
4013 || line.contains("element not found")
4014 || line.contains("not an element ref")
4015 || line.contains("could not resolve")
4016 || line.contains("no backend node")
4017 {
4018 return Some("element not found");
4019 }
4020 if line.contains("no open tab is on") {
4021 return Some("not allowed");
4022 }
4023 if line.contains("unknown tab")
4024 || line.contains("--tab")
4025 || line.contains("no open tabs")
4026 || line.contains("explicit tab")
4027 {
4028 return Some("unknown tab");
4029 }
4030 if line.starts_with("navigate:") || line.contains("page.navigate") {
4031 return Some("navigation failed");
4032 }
4033 Some("failed")
4034}
4035
4036pub fn slicc_agent() -> Option<String> {
4037 std::env::var("SLICC_AGENT")
4038 .ok()
4039 .filter(|value| !value.is_empty())
4040}
4041
4042pub fn open(start: crate::connect::Start, runtime: Option<&str>) -> Result<Cdp, String> {
4043 let socket = match start {
4044 crate::connect::Start::Direct(url) => url,
4045 crate::connect::Start::Discover(url) => {
4046 let response = match crate::net::http_get(&url) {
4047 Ok(response) => response,
4048 Err(message) => {
4049 if message.starts_with("HTTP ") || message.contains("does not launch Chrome") {
4050 return Err(message);
4051 }
4052 return Err(format!(
4053 "{message}This CLI does not launch Chrome. Pass --cdp or set SLICC_CDP_URL.\n"
4054 ));
4055 }
4056 };
4057 let body = String::from_utf8_lossy(&response.body).to_string();
4058 crate::connect::websocket_url_from_version(&body)?
4059 }
4060 };
4061 let socket = crate::connect::append_runtime(&socket, runtime);
4062 Cdp::connect(&socket)
4063}
4064
4065include!("dialog.rs");
4066include!("front.rs");
4067include!("window.rs");
4068
4069#[cfg(test)]
4070mod tests {
4071 use super::{first_stderr_line, probe_is_settled, ActionNote, Cdp, Transport};
4072 use serde_json::{json, Value};
4073 use std::collections::VecDeque;
4074 use std::time::{Duration, Instant};
4075
4076 include!("persistent_test.rs");
4077 include!("redirect_test.rs");
4078 include!("redirect_matrix_test.rs");
4079 include!("redirect_race_test.rs");
4080 include!("redirect_terminal_test.rs");
4081 include!("redirect_terminal_guard_test.rs");
4082 include!("redirect_c2_carrier_test.rs");
4083 include!("redirect_grok_test.rs");
4084 include!("redirect_scope_review_test.rs");
4085 include!("ordinary_network_review_test.rs");
4086 include!("pause_metadata_recovery_test.rs");
4087 include!("navigation_echo_test.rs");
4088 include!("refresh_review_test.rs");
4089 include!("refresh_forms_review_test.rs");
4090 include!("redirect_target_taint_test.rs");
4091 include!("redirect_resource_control_test.rs");
4092 include!("navigation_queue_test.rs");
4093 include!("redirect_fragment_test.rs");
4094 include!("redirect_review_test.rs");
4095 include!("redirect_relation_test.rs");
4096 include!("redirect_userinfo_test.rs");
4097 include!("guard_attach_tree_test.rs");
4098 include!("front_test.rs");
4099 include!("window_test.rs");
4100 include!("settled_test.rs");
4101 include!("renderer_crash_test.rs");
4102
4103 #[test]
4104 fn queued_raw_replies_keep_pinned_execution_and_guard_denial_semantics() {
4105 let mut cdp = pending(|_| Vec::new());
4106 cdp.blocked.insert("S".into());
4107 cdp.call_replies.insert(700, json!({"id":700,"error":{"message":"Cannot find context with specified id"}}));
4108 assert_eq!(cdp.raw_reply("Runtime.evaluate", 700, Some("S"), Duration::ZERO, true).unwrap_err(), cdp.refusal());
4109 cdp.call_replies.insert(701, json!({"id":701,"result":{"result":{"value":"ordinary-executed-value"}}}));
4110 assert_eq!(cdp.raw_reply("Runtime.evaluate", 701, Some("S"), Duration::ZERO, true).unwrap()["result"]["value"], "ordinary-executed-value");
4111 assert_eq!(cdp.raw_reply("Runtime.evaluate", 702, Some("S"), Duration::ZERO, true).unwrap_err(), cdp.refusal());
4112 assert!(cdp.call_replies.is_empty());
4113 }
4114
4115 struct Pending {
4116 inbox: VecDeque<String>,
4117 answer: fn(&Value) -> Vec<Value>,
4118 }
4119
4120 impl Transport for Pending {
4121 fn send_text(&mut self, text: &str) -> Result<(), String> {
4122 let message: Value = serde_json::from_str(text).unwrap();
4123 for out in (self.answer)(&message) {
4124 self.inbox.push_back(out.to_string());
4125 }
4126 Ok(())
4127 }
4128
4129 fn recv_text(&mut self, _deadline: Instant) -> Result<Option<String>, String> {
4130 Ok(self.inbox.pop_front())
4131 }
4132 }
4133
4134 fn pending(answer: fn(&Value) -> Vec<Value>) -> Cdp {
4135 let mut cdp = Cdp::from_transport(Box::new(Pending {
4136 inbox: VecDeque::new(),
4137 answer,
4138 }));
4139 cdp.fixture_session("S");
4140 cdp
4141 }
4142
4143 struct Cleanup {
4144 inner: Pending,
4145 destroy_after: Option<Duration>,
4146 destroyed_at: Option<Instant>,
4147 closed: bool,
4148 }
4149
4150 impl Transport for Cleanup {
4151 fn send_text(&mut self, text: &str) -> Result<(), String> {
4152 self.inner.send_text(text)?;
4153 let message: Value = serde_json::from_str(text).unwrap();
4154 if message["method"] == "Target.closeTarget" {
4155 self.closed = true;
4156 self.destroyed_at = self.destroy_after.map(|delay| Instant::now() + delay);
4157 }
4158 Ok(())
4159 }
4160
4161 fn recv_text(&mut self, deadline: Instant) -> Result<Option<String>, String> {
4162 if let Some(message) = self.inner.inbox.pop_front() {
4163 return Ok(Some(message));
4164 }
4165 if let Some(at) = self.destroyed_at.take() {
4166 if at <= deadline {
4167 std::thread::sleep(at.saturating_duration_since(Instant::now()));
4168 return Ok(Some(json!({
4169 "method": "Target.targetDestroyed", "params": { "targetId": "T" }
4170 }).to_string()));
4171 }
4172 self.destroyed_at = Some(at);
4173 }
4174 if self.closed {
4175 std::thread::sleep(deadline.saturating_duration_since(Instant::now()));
4176 }
4177 Ok(None)
4178 }
4179 }
4180
4181 fn error_page_client() -> Cdp {
4182 error_page_client_url("https://seven.sliccy.ai/path?secret#fragment")
4183 }
4184
4185 fn error_page_client_url(url: &str) -> Cdp {
4186 let mut cdp = url_backend(url);
4187 cdp.session_targets.insert("S".into(), "T".into());
4188 cdp.absorb(json!({"method":"Target.targetInfoChanged","params":{"targetInfo":{"targetId":"T","type":"page","url":"https://example.test/"}}}));
4189 cdp.absorb(json!({"method":"Page.frameNavigated","sessionId":"S","params":{"frame":{"id":"F","url":"https://example.test/","securityOrigin":"https://example.test"}}}));
4190 cdp
4191 }
4192
4193 fn observe_document(cdp: &mut Cdp) {
4194 struct Observed {
4195 inner: Box<dyn Transport>,
4196 frame: Value,
4197 inbox: VecDeque<String>,
4198 }
4199 impl Transport for Observed {
4200 fn send_text(&mut self, text: &str) -> Result<(), String> {
4201 let call: Value = serde_json::from_str(text).unwrap();
4202 if call["method"] == "Target.getTargets" {
4203 self.inbox.push_back(json!({"id":call["id"],"result":{"targetInfos":[{"targetId":"T","type":"page","url":self.frame["url"]}]}}).to_string());
4204 Ok(())
4205 } else if call["method"] == "Page.getFrameTree" {
4206 self.inbox.push_back(json!({"id":call["id"],"result":{"frameTree":{"frame":self.frame}}}).to_string());
4207 Ok(())
4208 } else if call["method"] == "Runtime.enable" {
4209 self.inbox.push_back(json!({"method":"Runtime.executionContextCreated","sessionId":call["sessionId"],"params":{"context":{"id":1,"uniqueId":"observed-context","origin":self.frame["securityOrigin"],"name":"","auxData":{"frameId":self.frame["id"],"isDefault":true}}}}).to_string());
4210 self.inbox.push_back(json!({"id":call["id"],"result":{}}).to_string());
4211 Ok(())
4212 } else {
4213 self.inner.send_text(text)
4214 }
4215 }
4216 fn recv_text(&mut self, deadline: Instant) -> Result<Option<String>, String> {
4217 match self.inbox.pop_front() {
4218 Some(text) => Ok(Some(text)),
4219 None => self.inner.recv_text(deadline),
4220 }
4221 }
4222 }
4223 let doc = &cdp.documents["T"];
4224 let frame = json!({"id":doc.frame_id,"loaderId":"L","url":doc.url,"securityOrigin":doc.origin,"unreachableUrl":doc.unreachable_url});
4225 let inner = std::mem::replace(&mut cdp.ws, Box::new(Pending { inbox:VecDeque::new(), answer: |_| Vec::new() }));
4226 cdp.ws = Box::new(Observed { inner, frame, inbox:VecDeque::new() });
4227 cdp.guards.insert("T".into(), "G".into());
4228 cdp.guard_sessions.insert("G".into());
4229 }
4230
4231 fn error_commit(cdp: &mut Cdp, unreachable: &str, origin: &str) {
4232 cdp.absorb(json!({"method":"Page.frameNavigated","sessionId":"S","params":{"frame":{"id":"F","url":"chrome-error://chromewebdata/","securityOrigin":origin,"unreachableUrl":unreachable}}}));
4233 }
4234
4235 #[test]
4236 fn protected_error_page_retains_allowed_recovery_and_redacts_discovery() {
4237 let url = "https://seven.sliccy.ai/path?secret#fragment";
4238 let mut cdp = error_page_client();
4239 error_commit(&mut cdp, url, "://");
4240 let info = json!({"targetId":"T","type":"page","url":url,"title":"SECRET"});
4241 for method in ["Target.targetCreated", "Target.targetInfoChanged", "Target.attachedToTarget"] {
4242 cdp.absorb(json!({"method":method,"params":{"sessionId":"A","targetInfo":info}}));
4243 let event = cdp.events().last().unwrap();
4244 assert_eq!(event["params"]["targetInfo"]["url"], "https://seven.sliccy.ai", "{method}");
4245 assert_eq!(event["params"]["targetInfo"]["title"], "https://seven.sliccy.ai", "{method}");
4246 }
4247 assert!(!cdp.target_protected("T", false).unwrap());
4248 assert!(!cdp.session_blocked("S"));
4249 let listed = cdp.call("Target.getTargets", json!({}), None).unwrap();
4250 assert_eq!(listed["targetInfos"][0]["url"], "https://seven.sliccy.ai");
4251 assert_eq!(listed["targetInfos"][0]["title"], "https://seven.sliccy.ai");
4252 let found = cdp.call("Target.getTargetInfo", json!({"targetId":"T"}), None).unwrap();
4253 assert_eq!(found["targetInfo"]["url"], "https://seven.sliccy.ai");
4254 assert_eq!(found["targetInfo"]["title"], "https://seven.sliccy.ai");
4255 observe_document(&mut cdp);
4256 for method in ["Page.reload", "Page.navigate", "Target.closeTarget"] {
4257 let (params, session) = if method == "Target.closeTarget" {
4258 (json!({"targetId":"T"}), None)
4259 } else {
4260 (json!({"url":"about:blank"}), Some("S"))
4261 };
4262 assert!(cdp.call(method, params, session).is_ok(), "{method}");
4263 }
4264 assert!(cdp.call("Page.navigate", json!({"url":url}), Some("S")).is_err());
4265 }
4266
4267 #[test]
4268 fn protected_error_page_pending_report_does_not_change_previous_decision() {
4269 let mut cdp = error_page_client();
4270 cdp.absorb(json!({"method":"Page.frameStartedNavigating","sessionId":"S","params":{"frameId":"F","url":"https://seven.sliccy.ai/path?secret#fragment"}}));
4271 cdp.absorb(json!({"method":"Target.targetInfoChanged","params":{"targetInfo":{"targetId":"T","type":"page","url":"https://seven.sliccy.ai/path?secret#fragment"}}}));
4272 assert!(cdp.call("Runtime.evaluate", json!({"expression":"document.title"}), Some("S")).is_err());
4273 error_commit(&mut cdp, "https://seven.sliccy.ai/path?secret#fragment", "://");
4274 assert!(!cdp.target_protected("T", false).unwrap());
4275 observe_document(&mut cdp);
4276 assert!(cdp.call("Page.reload", json!({}), Some("S")).is_ok());
4277 }
4278
4279 #[test]
4280 fn protected_error_page_unknown_mismatch_origin_and_inflight_fail_closed() {
4281 let url = "https://seven.sliccy.ai/path?secret#fragment";
4282 for (unreachable, origin, navigating) in [(url, "://", true), ("", "://", false), ("https://seven.sliccy.ai/other", "://", false), (url, "null", false), (url, "https://example.test", false)] {
4283 let mut cdp = error_page_client();
4284 error_commit(&mut cdp, unreachable, origin);
4285 if navigating {
4286 cdp.absorb(json!({"method":"Page.frameStartedNavigating","sessionId":"S","params":{"frameId":"F","url":url}}));
4287 }
4288 assert!(cdp.target_protected("T", false).unwrap(), "{unreachable} {origin} {navigating}");
4289 assert!(cdp.call("Runtime.evaluate", json!({"expression":"document.title"}), Some("S")).is_err());
4290 }
4291 let mut cdp = url_backend(url);
4292 cdp.session_targets.insert("S".into(), "T".into());
4293 error_commit(&mut cdp, url, "://");
4294 assert!(cdp.target_protected("T", false).unwrap());
4295 }
4296
4297 #[test]
4298 fn protected_document_restore_and_error_page_sticky_lock() {
4299 let mut cdp = error_page_client();
4300 let url = "https://seven.sliccy.ai/path?secret#fragment";
4301 error_commit(&mut cdp, url, "://");
4302 assert!(!cdp.target_protected("T", false).unwrap());
4303 cdp.absorb(json!({"method":"Page.frameNavigated","sessionId":"S","params":{"type":"BackForwardCacheRestore","frame":{"id":"F","url":"https://seven.sliccy.ai/real-document","securityOrigin":"https://seven.sliccy.ai"}}}));
4304 assert!(cdp.is_protected_target("T"));
4305 error_commit(&mut cdp, url, "://");
4306 for method in ["Runtime.evaluate", "Page.reload", "Page.navigate", "Target.closeTarget", "Target.attachToTarget"] {
4307 let params = json!({"targetId":"T","url":"about:blank","flatten":true});
4308 assert!(cdp.call(method, params, Some("S")).is_err(), "{method}");
4309 }
4310 }
4311
4312 #[test]
4313 fn protected_error_page_subframes_and_same_document_do_not_replace_evidence() {
4314 let mut cdp = error_page_client();
4315 let url = "https://seven.sliccy.ai/path?secret#fragment";
4316 error_commit(&mut cdp, url, "://");
4317 cdp.absorb(json!({"method":"Page.frameNavigated","sessionId":"S","params":{"frame":{"id":"CHILD","parentId":"F","url":"https://seven.sliccy.ai/child","securityOrigin":"https://seven.sliccy.ai"}}}));
4318 cdp.absorb(json!({"method":"Page.frameStartedNavigating","sessionId":"S","params":{"frameId":"F","navigationType":"sameDocument","url":url}}));
4319 assert!(!cdp.target_protected("T", false).unwrap());
4320 assert!(cdp.frame_protected("CHILD"));
4321 observe_document(&mut cdp);
4322 assert!(cdp.call("Page.reload", json!({}), Some("S")).is_ok());
4323 }
4324
4325 #[test]
4326 fn protected_error_page_real_commit_and_guard_loss_fail_closed() {
4327 let url = "https://seven.sliccy.ai/path?secret#fragment";
4328 for origin in ["https://seven.sliccy.ai", "https://example.test"] {
4329 let mut cdp = error_page_client();
4330 error_commit(&mut cdp, url, "://");
4331 assert!(!cdp.target_protected("T", false).unwrap());
4332 cdp.absorb(json!({"method":"Page.frameNavigated","sessionId":"S","params":{"frame":{"id":"F","url":url,"securityOrigin":origin}}}));
4333 assert!(cdp.is_protected_target("T"));
4334 assert!(cdp.session_blocked("S"));
4335 }
4336 let mut cdp = error_page_client();
4337 error_commit(&mut cdp, url, "://");
4338 cdp.guards.insert("T".into(), "G".into());
4339 cdp.guard_sessions.insert("G".into());
4340 cdp.absorb(json!({"method":"Target.detachedFromTarget","params":{"sessionId":"G"}}));
4341 assert!(cdp.target_protected("T", false).unwrap());
4342 assert!(cdp.call("Runtime.evaluate", json!({"expression":"document.title"}), Some("S")).is_err());
4343 }
4344
4345 #[test]
4346 fn protected_error_page_ordinary_navigation_and_fresh_dns_error_remain_drivable() {
4347 let mut cdp = url_backend("https://example.test/next");
4348 cdp.session_targets.insert("S".into(), "T".into());
4349 cdp.absorb(json!({"method":"Page.frameNavigated","sessionId":"S","params":{"frame":{"id":"F","url":"https://example.test/","securityOrigin":"https://example.test"}}}));
4350 cdp.absorb(json!({"method":"Page.frameStartedNavigating","sessionId":"S","params":{"frameId":"F","url":"https://example.test/next"}}));
4351 assert!(!cdp.target_protected("T", false).unwrap());
4352 observe_document(&mut cdp);
4353 assert!(cdp.call("Runtime.evaluate", json!({"expression":"document.title"}), Some("S")).is_ok());
4354 let mut cdp = url_backend("http://ordinary.invalid/");
4355 cdp.session_targets.insert("S".into(), "T".into());
4356 error_commit(&mut cdp, "http://ordinary.invalid/", "://");
4357 assert!(!cdp.target_protected("T", false).unwrap());
4358 observe_document(&mut cdp);
4359 assert!(cdp.call("Page.navigate", json!({"url":"about:blank"}), Some("S")).is_ok());
4360 }
4361
4362 #[test]
4363 fn protected_error_page_path_query_and_fragment_redact_url_and_title_everywhere() {
4364 for url in [
4365 "https://seven.sliccy.ai/path-secret",
4366 "https://seven.sliccy.ai/?query-secret=hidden",
4367 "https://seven.sliccy.ai/#fragment-secret-hidden",
4368 "https://seven.sliccy.ai/path-secret?query-secret=hidden#fragment-secret-hidden",
4369 ] {
4370 let mut cdp = error_page_client_url(url);
4371 error_commit(&mut cdp, url, "://");
4372 let info = json!({"targetId":"T","type":"page","url":url,"title":url});
4373 for method in ["Target.targetCreated", "Target.targetInfoChanged", "Target.attachedToTarget"] {
4374 cdp.absorb(json!({"method":method,"params":{"sessionId":"A","targetInfo":info}}));
4375 let event = cdp.events().last().unwrap();
4376 for key in ["url", "title"] {
4377 assert_eq!(event["params"]["targetInfo"][key], "https://seven.sliccy.ai", "{method} {key} {url}");
4378 }
4379 }
4380 for method in ["Target.getTargets", "Target.getTargetInfo"] {
4381 let out = cdp.call(method, json!({"targetId":"T"}), None).unwrap();
4382 let info = if method == "Target.getTargets" { &out["targetInfos"][0] } else { &out["targetInfo"] };
4383 for key in ["url", "title"] {
4384 assert_eq!(info[key], "https://seven.sliccy.ai", "{method} {key} {url}");
4385 }
4386 }
4387 assert!(!cdp.target_protected("T", false).unwrap());
4388 assert!(!cdp.session_blocked("S"));
4389 }
4390 }
4391
4392 #[test]
4393 fn protected_seven_fragment_targets_and_url_changes_never_disclose_markers() {
4394 for url in [
4395 "https://seven.sliccy.ai/auth/callback#access_token=MARK",
4396 "https://seven.sliccy.ai/#tailscale=MARK1",
4397 "https://seven.sliccy.ai/#proxy=http%3A%2F%2F127.0.0.1%3A9%2F&key=MARK2",
4398 ] {
4399 for changed in [false, true] {
4400 let mut cdp = url_backend(url);
4401 if changed {
4402 cdp.absorb(json!({"method":"Target.targetInfoChanged","params":{"targetInfo":{"targetId":"T","type":"page","url":"https://seven.sliccy.ai/","title":"clean"}}}));
4403 }
4404 let info = json!({"targetId":"T","type":"page","url":url,"title":url});
4405 for method in ["Target.targetCreated", "Target.targetInfoChanged", "Target.attachedToTarget"] {
4406 let mark = cdp.events().len();
4407 cdp.absorb(json!({"method":method,"params":{"sessionId":"A","targetInfo":info}}));
4408 for event in &cdp.events()[mark..] {
4409 assert!(!event.to_string().contains("MARK"), "{method} {changed} {event}");
4410 for key in ["url", "title"] {
4411 assert_eq!(event["params"]["targetInfo"][key], "https://seven.sliccy.ai", "{method} {key} {url}");
4412 }
4413 }
4414 }
4415 for method in ["Target.getTargets", "Target.getTargetInfo"] {
4416 let params = if method == "Target.getTargets" { json!({}) } else { json!({"targetId":"T"}) };
4417 let out = cdp.call(method, params, None).unwrap();
4418 assert!(!out.to_string().contains("MARK"), "{method} {out}");
4419 let info = if method == "Target.getTargets" { &out["targetInfos"][0] } else { &out["targetInfo"] };
4420 for key in ["url", "title"] {
4421 assert_eq!(info[key], "https://seven.sliccy.ai", "{method} {key} {url}");
4422 }
4423 }
4424 cdp.absorb(json!({"method":"Target.detachedFromTarget","params":{"sessionId":"A","targetId":"T"}}));
4425 assert!(!cdp.events().last().unwrap().to_string().contains("MARK"));
4426 assert!(cdp.target_protected("T", false).unwrap());
4427 }
4428 }
4429 }
4430
4431 fn target_fragment_markers() -> [&'static str; 5] {
4432 [
4433 "https://seven.sliccy.ai/#tailscale=MARK1",
4434 "https://seven.sliccy.ai/#proxy=http%3A%2F%2F127.0.0.1%3A9%2F&key=MARK2",
4435 "https://seven.sliccy.ai/auth/callback#access_token=MARK",
4436 "https://seven.sliccy.ai/path-secret?query-secret=MARK",
4437 "https://seven.sliccy.ai/path-secret?query-secret=MARK#access_token=MARK",
4438 ]
4439 }
4440
4441 #[test]
4442 fn target_info_fragment_markers_are_redacted_in_responses_and_events() {
4443 for url in target_fragment_markers() {
4444 for changed in [false, true] {
4445 let mut cdp = url_backend(url);
4446 if changed {
4447 cdp.absorb(json!({"method":"Target.targetInfoChanged","params":{"targetInfo":{"targetId":"T","type":"page","url":"https://seven.sliccy.ai/","title":"clean"}}}));
4448 }
4449 let info = json!({"targetId":"T","type":"page","url":url,"title":url,"openerId":"OPENER","openerFrameId":"FRAME"});
4450 for method in ["Target.targetCreated", "Target.targetInfoChanged", "Target.attachedToTarget"] {
4451 let mark = cdp.events().len();
4452 cdp.absorb(json!({"method":method,"params":{"sessionId":"A","targetInfo":info}}));
4453 let event = cdp.events()[mark..].iter().find(|event| event["method"] == method).unwrap();
4454 for key in ["url", "title"] {
4455 assert_eq!(event["params"]["targetInfo"][key], "https://seven.sliccy.ai", "{method} {key} {url} {changed}");
4456 }
4457 assert_eq!(event["params"]["targetInfo"]["openerId"], "OPENER");
4458 assert_eq!(event["params"]["targetInfo"]["openerFrameId"], "FRAME");
4459 assert!(!event.to_string().contains("MARK"));
4460 }
4461 for method in ["Target.getTargets", "Target.getTargetInfo"] {
4462 let params = if method == "Target.getTargets" { json!({}) } else { json!({"targetId":"T"}) };
4463 let out = cdp.call(method, params, None).unwrap();
4464 let info = if method == "Target.getTargets" { &out["targetInfos"][0] } else { &out["targetInfo"] };
4465 for key in ["url", "title"] {
4466 assert_eq!(info[key], "https://seven.sliccy.ai", "{method} {key} {url}");
4467 }
4468 assert!(!out.to_string().contains("MARK"));
4469 }
4470 for event in [
4471 json!({"method":"Target.detachedFromTarget","params":{"sessionId":"A","targetId":"T"}}),
4472 json!({"method":"Target.detachedFromTarget","params":{"sessionId":"B"}}),
4473 json!({"method":"Page.frameAttached","sessionId":"S","params":{"frameId":"CHILD","parentFrameId":"FRAME"}}),
4474 ] {
4475 cdp.absorb(event);
4476 assert!(!cdp.events().last().unwrap().to_string().contains("MARK"));
4477 }
4478 }
4479 }
4480 }
4481
4482 #[test]
4483 fn target_info_nonflattened_and_browser_attach_paths_remain_refused() {
4484 for (method, params) in [
4485 ("Target.attachToTarget", json!({"targetId":"T","flatten":false})),
4486 ("Target.attachToBrowserTarget", json!({})),
4487 ("Target.setAutoAttach", json!({"autoAttach":true,"flatten":true})),
4488 ("Target.autoAttachRelated", json!({"targetId":"T","waitForDebuggerOnStart":false})),
4489 ("Target.sendMessageToTarget", json!({"targetId":"T","message":"MARK"})),
4490 ] {
4491 let mut cdp = url_backend("https://example.test/");
4492 assert!(cdp.call(method, params, None).is_err(), "{method}");
4493 }
4494 }
4495
4496 #[test]
4497 fn target_info_wrapped_nonflattened_events_never_disclose_markers() {
4498 for url in target_fragment_markers() {
4499 let mut cdp = url_backend("https://example.test/");
4500 let mark = cdp.events().len();
4501 let nested = json!({"method":"Target.attachedToTarget","params":{"sessionId":"CHILD","targetInfo":{"targetId":"T","type":"page","url":url,"title":url}}});
4502 cdp.absorb(json!({"method":"Target.receivedMessageFromTarget","params":{"sessionId":"A","targetId":"T","message":nested.to_string()}}));
4503 assert_eq!(cdp.events().len(), mark, "{url}");
4504 }
4505 }
4506
4507 #[test]
4508 fn allowed_blank_commit_refreshes_stale_protected_discovery_before_driving() {
4509 let mut cdp = url_backend("about:blank");
4510 cdp.session_targets.insert("S".into(), "T".into());
4511 cdp.absorb(json!({"method":"Page.frameNavigated","sessionId":"S","params":{"frame":{"id":"F","url":"https://example.test/","securityOrigin":"https://example.test"}}}));
4512 error_commit(&mut cdp, "https://seven.sliccy.ai/doc#access_token=MARK", "://");
4513 cdp.absorb(json!({"method":"Target.targetInfoChanged","params":{"targetInfo":{"targetId":"T","type":"page","url":"https://seven.sliccy.ai/doc#access_token=MARK","title":"MARK"}}}));
4514 cdp.absorb(json!({"method":"Page.frameNavigated","sessionId":"S","params":{"frame":{"id":"F","url":"about:blank","securityOrigin":"https://example.test"}}}));
4515 observe_document(&mut cdp);
4516 assert!(cdp.call("Runtime.evaluate", json!({"expression":"document.readyState"}), Some("S")).is_ok());
4517 assert!(!cdp.session_blocked("S"));
4518 assert!(!cdp.is_protected_target("T"));
4519 }
4520
4521 #[test]
4522 fn permitted_error_document_redacts_history_and_refuses_runtime_without_losing_ids() {
4523 struct HistoryResponses(UrlBackend);
4524 impl Transport for HistoryResponses {
4525 fn send_text(&mut self, text: &str) -> Result<(), String> {
4526 let call: Value = serde_json::from_str(text).unwrap();
4527 let protected = self.0.url.clone();
4528 let output = match call["method"].as_str().unwrap() {
4529 "Page.getNavigationHistory" => Some(json!({"currentIndex":1,"entries":[
4530 {"id":701,"url":"https://ordinary.example/ready","title":"ordinary control","userTypedURL":"https://ordinary.example/ready"},
4531 {"id":702,"url":protected,"title":protected,"userTypedURL":protected}
4532 ]})),
4533 "Runtime.evaluate" => Some(json!({"result":{"type":"object","value":{"url":protected,"text":protected}}})),
4534 _ => None,
4535 };
4536 if let Some(output) = output {
4537 self.0.inbox.push_back(json!({"id":call["id"],"result":output}).to_string());
4538 Ok(())
4539 } else {
4540 self.0.send_text(text)
4541 }
4542 }
4543 fn recv_text(&mut self, until: Instant) -> Result<Option<String>, String> {
4544 self.0.recv_text(until)
4545 }
4546 }
4547 for attempted in [
4548 "https://seven.sliccy.ai/private/HISTORY_MARK?key=HISTORY_MARK#access_token=HISTORY_MARK",
4549 "https://vault.sliccy.ai/private/HISTORY_MARK?key=HISTORY_MARK#access_token=HISTORY_MARK",
4550 ] {
4551 let mut cdp = Cdp::from_transport(Box::new(HistoryResponses(UrlBackend { url:attempted.into(), inbox:VecDeque::new() })));
4552 cdp.session_targets.insert("S".into(), "T".into());
4553 cdp.absorb(json!({"method":"Page.frameNavigated","sessionId":"S","params":{"frame":{"id":"F","url":"https://ordinary.example/ready","securityOrigin":"https://ordinary.example"}}}));
4554 error_commit(&mut cdp, attempted, "://");
4555 assert!(!cdp.target_protected("T", false).unwrap());
4556 assert!(!cdp.session_blocked("S"));
4557 observe_document(&mut cdp);
4558 let origin = url::Url::parse(attempted).unwrap().origin().ascii_serialization();
4559 let history = cdp.call("Page.getNavigationHistory", json!({}), Some("S")).unwrap();
4560 assert_eq!(history["currentIndex"], 1);
4561 assert_eq!(history["entries"][0]["id"], 701);
4562 assert_eq!(history["entries"][0]["url"], "https://ordinary.example/ready");
4563 assert_eq!(history["entries"][0]["title"], "ordinary control");
4564 assert_eq!(history["entries"][1]["id"], 702);
4565 for key in ["url", "title", "userTypedURL"] {
4566 assert_eq!(history["entries"][1][key], origin, "{key}");
4567 }
4568 assert!(!history.to_string().contains("HISTORY_MARK"));
4569 let sent = cdp.next_id;
4570 for expression in ["location.href", "Array.from(document.documentElement.innerHTML, c => c.codePointAt(0))"] {
4571 assert!(cdp.call("Runtime.evaluate", json!({"expression":expression,"returnByValue":true}), Some("S")).is_err(), "{expression}");
4572 }
4573 assert_eq!(cdp.next_id, sent + 2);
4574 assert!(cdp.call("Page.reload", json!({}), Some("S")).is_ok());
4575 assert!(!cdp.session_blocked("S"));
4576 }
4577 }
4578
4579 #[test]
4580 fn internal_guard_loss_refuses_direct_commands_even_with_stale_ordinary_discovery() {
4581 for error in [false, true] {
4582 let mut cdp = error_page_client();
4583 if error {
4584 error_commit(&mut cdp, "https://seven.sliccy.ai/path?secret#fragment", "://");
4585 }
4586 assert_eq!(cdp.targets["T"]["url"], "https://example.test/");
4587 assert!(!cdp.session_blocked("S"));
4588 cdp.guards.insert("T".into(), "G".into());
4589 cdp.guard_sessions.insert("G".into());
4590 cdp.absorb(json!({"method":"Target.detachedFromTarget","params":{"sessionId":"G","targetId":"T"}}));
4591 let sent = cdp.next_id;
4592 let result = cdp.call("Runtime.evaluate", json!({"expression":"location.href = 'https://seven.sliccy.ai/'"}), Some("S"));
4593 assert!(result.is_err(), "guard loss must refuse before any discovery refresh");
4594 assert_eq!(cdp.next_id, sent, "no Runtime or discovery command may reach the backend");
4595 assert!(cdp.session_blocked("S"));
4596 assert!(cdp.abandoned.contains("T"));
4597 assert!(cdp.is_protected_target("T"));
4598 assert!(cdp.call("Target.attachToTarget", json!({"targetId":"T","flatten":true}), None).is_err());
4599 }
4600 }
4601
4602 #[test]
4603 fn caller_and_unknown_detach_do_not_abandon_a_healthy_guard() {
4604 let mut cdp = error_page_client_url("https://example.test/");
4605 cdp.guards.insert("T".into(), "G".into());
4606 cdp.guard_sessions.insert("G".into());
4607 for detached in ["UNKNOWN", "OTHER"] {
4608 cdp.session_targets.insert("OTHER".into(), "T".into());
4609 cdp.absorb(json!({"method":"Target.detachedFromTarget","params":{"sessionId":detached,"targetId":"T"}}));
4610 assert_eq!(cdp.guards["T"], "G");
4611 assert!(cdp.documents.contains_key("T"));
4612 assert!(!cdp.abandoned.contains("T"));
4613 assert!(!cdp.session_blocked("S"));
4614 observe_document(&mut cdp);
4615 assert!(cdp.call("Runtime.evaluate", json!({"expression":"document.readyState"}), Some("S")).is_ok());
4616 }
4617 }
4618
4619 const UNPARSEABLE: &str = "slicc: refused: slicc can't parse this URL, so it could be a protected page\n";
4620
4621 fn malformed_urls() -> Vec<String> {
4622 let mut urls = [
4623 "http://exa%20mple.sliccy.ai/",
4624 "http://exa mple.sliccy.ai/",
4625 "http://\u{200d}.sliccy.ai/",
4626 "https://exa%20mple.example/",
4627 "http://xn--1ug.sliccy.ai/",
4628 "http://xn--a.sliccy.ai/",
4629 "view-source:http://exa%20mple.sliccy.ai/",
4630 "blob:http://exa%20mple.sliccy.ai/id",
4631 "filesystem:http://exa%20mple.sliccy.ai/temporary/x",
4632 ].map(str::to_string).to_vec();
4633 urls.push(format!("{}https://example.test/", "view-source:".repeat(9)));
4634 urls
4635 }
4636
4637 struct UrlBackend {
4638 url: String,
4639 inbox: VecDeque<String>,
4640 }
4641
4642 impl Transport for UrlBackend {
4643 fn send_text(&mut self, text: &str) -> Result<(), String> {
4644 let message: Value = serde_json::from_str(text).unwrap();
4645 let info = json!({"targetId":"T","type":"page","url":self.url,"title":"SECRET"});
4646 let result = match message["method"].as_str().unwrap() {
4647 "Target.getTargetInfo" => json!({"targetInfo":info}),
4648 "Target.getTargets" => json!({"targetInfos":[info]}),
4649 "Target.attachToTarget" => json!({"sessionId":"S"}),
4650 "Target.createTarget" => json!({"targetId":"T"}),
4651 "Page.getNavigationHistory" => json!({"entries":[{"id":1,"url":self.url}]}),
4652 _ => json!({}),
4653 };
4654 self.inbox.push_back(json!({"id":message["id"],"result":result}).to_string());
4655 Ok(())
4656 }
4657
4658 fn recv_text(&mut self, _deadline: Instant) -> Result<Option<String>, String> {
4659 Ok(self.inbox.pop_front())
4660 }
4661 }
4662
4663 fn url_backend(url: &str) -> Cdp {
4664 let mut cdp = Cdp::from_transport(Box::new(UrlBackend { url: url.into(), inbox: VecDeque::new() }));
4665 cdp.fixture_session("S");
4666 cdp
4667 }
4668
4669 #[test]
4670 fn issue_401_command_destinations_fail_closed() {
4671 let mut failures = Vec::new();
4672 for url in malformed_urls() {
4673 for method in ["Target.createTarget", "Page.navigate", "Network.loadNetworkResource", "Fetch.continueRequest", "Network.continueInterceptedRequest", "PWA.install", "PWA.launch"] {
4674 let mut cdp = url_backend("about:blank");
4675 cdp.hand("S", "R");
4676 cdp.requests.insert("R".into(), false);
4677 let params = if method.starts_with("PWA.") {
4678 json!({"manifestId":url,"installUrlOrBundleUrl":url})
4679 } else {
4680 json!({"url":url,"requestId":"R","interceptionId":"R"})
4681 };
4682 let result = cdp.call(method, params, Some("S"));
4683 if !result.as_ref().err().is_some_and(|error| error.starts_with("slicc: refused:")) {
4684 failures.push(format!("{method} {url}: {result:?}"));
4685 }
4686 }
4687 }
4688 assert!(failures.is_empty(), "{}", failures.join("\n"));
4689 }
4690
4691 #[test]
4692 fn issue_401_normalized_protected_hosts_are_guarded() {
4693 for url in [
4694 "http://vault%2Esliccy.ai/",
4695 "http://vau%6Ct.sliccy.ai/",
4696 "http://VAULT.sliccy.ai/",
4697 "http://vault.sliccy.ai./",
4698 "http://seven.sliccy.ai./",
4699 ] {
4700 for (method, params) in [
4701 ("Target.createTarget", json!({"url":url})),
4702 ("Page.navigate", json!({"url":url})),
4703 ("Network.setCookie", json!({"url":url,"name":"x","value":"y"})),
4704 ("Network.deleteCookies", json!({"url":url,"name":"x"})),
4705 ("Network.setCookies", json!({"cookies":[{"url":url,"name":"x","value":"y"}]})),
4706 ("Storage.setCookies", json!({"cookies":[{"url":url,"name":"x","value":"y"}]})),
4707 ] {
4708 assert!(url_backend("about:blank").call(method, params, Some("S")).unwrap_err().starts_with("slicc: refused:"), "{method} {url}");
4709 }
4710 let mut cdp = url_backend(url);
4711 let listed = cdp.call("Target.getTargets", json!({}), None).unwrap();
4712 assert_ne!(listed["targetInfos"][0]["url"], url);
4713 assert!(cdp.is_protected_target("T"));
4714 assert!(url_backend(url).call("Target.attachToTarget", json!({"targetId":"T","flatten":true}), None).is_err());
4715 }
4716 }
4717
4718 #[test]
4719 fn issue_401_refusal_text_is_exact() {
4720 for method in ["Page.navigate", "Target.createTarget", "Network.setCookie", "Network.getCookies"] {
4721 let url = "http://exa%20mple.sliccy.ai/";
4722 let params = if method == "Network.getCookies" { json!({"urls":[url]}) } else { json!({"url":url,"name":"x","value":"y"}) };
4723 assert_eq!(url_backend("about:blank").call(method, params, Some("S")).unwrap_err(), UNPARSEABLE, "{method}");
4724 }
4725 }
4726
4727 #[test]
4728 fn issue_401_reported_targets_and_history_fail_closed() {
4729 for url in malformed_urls() {
4730 let mut cdp = url_backend(&url);
4731 let listed = cdp.call("Target.getTargets", json!({}), None).unwrap();
4732 assert!(listed["targetInfos"].as_array().unwrap().is_empty(), "{url}");
4733 assert!(cdp.call("Target.attachToTarget", json!({"targetId":"T","flatten":true}), None).unwrap_err().starts_with("slicc: refused:"), "{url}");
4734 assert!(url_backend(&url).call("Target.attachToTarget", json!({"targetId":"T","flatten":true}), None).is_err(), "{url}");
4735 assert!(url_backend(&url).call("Page.navigateToHistoryEntry", json!({"entryId":1}), Some("S")).is_err(), "{url}");
4736 }
4737 }
4738
4739 #[test]
4740 fn cookie_readers_keep_filtering_parseable_mixed_url_lists() {
4741 assert!(url_backend("about:blank").call("Network.getCookies", json!({"urls":["https://seven.sliccy.ai/", "https://example.test/"]}), Some("S")).is_ok());
4742 assert_eq!(url_backend("about:blank").call("Network.getCookies", json!({"urls":["http://exa%20mple.sliccy.ai/", "https://example.test/"]}), Some("S")).unwrap_err(), UNPARSEABLE);
4743 }
4744
4745 #[test]
4746 fn issue_401_cookie_command_urls_fail_closed() {
4747 let mut failures = Vec::new();
4748 for url in malformed_urls() {
4749 for (method, params) in [
4750 ("Network.setCookie", json!({"url":url,"name":"x","value":"y"})),
4751 ("Network.deleteCookies", json!({"url":url,"name":"x"})),
4752 ("Network.getCookies", json!({"urls":["https://example.test/",url]})),
4753 ("Network.setCookies", json!({"cookies":[{"url":url,"name":"x","value":"y"}]})),
4754 ("Storage.setCookies", json!({"cookies":[{"url":url,"name":"x","value":"y"}]})),
4755 ] {
4756 if url_backend("about:blank").call(method, params, Some("S")).is_ok() {
4757 failures.push(format!("{method} {url}"));
4758 }
4759 }
4760 }
4761 assert!(failures.is_empty(), "{}", failures.join("\n"));
4762 }
4763
4764 #[test]
4765 fn issue_401_loaded_urls_are_never_exposed() {
4766 for url in malformed_urls() {
4767 for event in [
4768 json!({"method":"Page.frameNavigated","sessionId":"S","params":{"frame":{"id":"F","url":"https://example.test/","securityOrigin":url}}}),
4769 json!({"method":"Page.frameNavigated","sessionId":"S","params":{"frame":{"id":"F","url":url,"securityOrigin":"null"}}}),
4770 json!({"method":"Runtime.executionContextCreated","sessionId":"S","params":{"context":{"id":1,"origin":url,"auxData":{"isDefault":true}}}}),
4771 json!({"method":"Runtime.executionContextCreated","sessionId":"S","params":{"context":{"id":1,"origin":url,"auxData":{"isDefault":false}}}}),
4772 json!({"method":"Network.requestWillBeSent","sessionId":"S","params":{"requestId":"R","request":{"url":url}}}),
4773 json!({"method":"Network.webSocketCreated","sessionId":"S","params":{"requestId":"R","url":url.replacen("http:","ws:",1)}}),
4774 json!({"method":"ServiceWorker.workerVersionUpdated","params":{"versions":[{"scriptURL":url,"status":"activated"}]}}),
4775 ] {
4776 let mut cdp = url_backend("about:blank");
4777 cdp.absorb(event.clone());
4778 assert!(cdp.events().is_empty(), "{event}: {:?}", cdp.events());
4779 if event["method"] == "Page.frameNavigated" || event.pointer("/params/context/auxData/isDefault") == Some(&json!(true)) {
4780 assert!(cdp.blocked.contains("S"), "{event}");
4781 }
4782 }
4783 for kind in ["page", "service_worker", "shared_worker", "iframe"] {
4784 let mut cdp = url_backend("about:blank");
4785 cdp.absorb(json!({"method":"Target.targetCreated","params":{"targetInfo":{"targetId":"T","type":kind,"url":url,"title":"SECRET"}}}));
4786 assert!(cdp.is_protected_target("T"), "{kind} {url}");
4787 assert!(cdp.events().is_empty(), "{kind} {url}");
4788 }
4789 }
4790 for origin in ["", "null", "://"] {
4791 let mut cdp = url_backend("about:blank");
4792 cdp.absorb(json!({"method":"Page.frameNavigated","sessionId":"S","params":{"frame":{"id":"F","url":"about:blank","securityOrigin":origin}}}));
4793 assert!(!cdp.blocked.contains("S"));
4794 assert_eq!(cdp.events().len(), 1);
4795 }
4796 }
4797
4798 #[test]
4799 fn issue_401_exemptions_and_read_only_keys_remain_open() {
4800 for url in ["", "null", "://"] {
4801 assert!(url_backend("about:blank").call("Target.createTarget", json!({"url":url}), None).is_ok(), "{url}");
4802 assert!(url_backend("about:blank").call("Page.navigate", json!({"url":url}), Some("S")).is_ok(), "{url}");
4803 }
4804 for url in malformed_urls() {
4805 let mut cdp = url_backend("about:blank");
4806 assert!(cdp.notify("Slicc.action", json!({"url":url,"phase":"start"}), None).is_ok(), "{url}");
4807 assert!(cdp.call("Storage.getUsageAndQuota", json!({"origin":url}), None).is_err(), "{url}");
4808 assert!(cdp.call("Storage.clearDataForStorageKey", json!({"storageKey":format!("{url}^0{url}")}), None).is_err(), "{url}");
4809 }
4810 }
4811
4812 fn cleanup_answer(message: &Value) -> Vec<Value> {
4813 let result = match message["method"].as_str() {
4814 Some("Target.createTarget") => json!({ "targetId": "T" }),
4815 Some("Target.getTargetInfo") => json!({ "targetInfo": {
4816 "targetId": "T", "type": "page", "url": "about:blank"
4817 } }),
4818 Some("Target.getTargets") => json!({ "targetInfos": [
4819 { "targetId": "T", "type": "page", "url": "about:blank" }
4820 ] }),
4821 Some("Target.attachToTarget") => json!({ "sessionId": "S" }),
4822 Some("Network.setBypassServiceWorker") => return Vec::new(),
4823 Some("Target.closeTarget") => return vec![
4824 json!({ "method": "Target.targetDestroyed", "params": { "targetId": "OTHER" } }),
4825 json!({ "id": message["id"], "result": { "success": true } }),
4826 ],
4827 _ => json!({}),
4828 };
4829 vec![json!({ "id": message["id"], "result": result })]
4830 }
4831
4832 fn cleanup(delay: Option<Duration>, answer: fn(&Value) -> Vec<Value>) -> Cdp {
4833 Cdp::from_transport(Box::new(Cleanup {
4834 inner: Pending { inbox: VecDeque::new(), answer },
4835 destroy_after: delay,
4836 destroyed_at: None,
4837 closed: false,
4838 }))
4839 }
4840
4841 #[test]
4842 fn cleanup_waits_for_the_refused_targets_late_destruction() {
4843 let mut cdp = cleanup(Some(Duration::from_millis(40)), cleanup_answer);
4844 let error = cdp.call("Target.createTarget", json!({ "url": "about:blank" }), None).unwrap_err();
4845 assert_eq!(error, "slicc: refused: slicc can't keep seven's origin out of this target: Network.setBypassServiceWorker timed out\n");
4846 assert!(cdp.events().iter().any(|event| event["method"] == "Target.targetDestroyed" && event["params"]["targetId"] == "T"));
4847 assert!(cdp.is_protected_target("T"));
4848 }
4849
4850 #[test]
4851 fn cleanup_confirms_closure_without_browser_events() {
4852 let mut cdp = cleanup(None, |message| {
4853 if message["method"] == "Target.getTargets" {
4854 return vec![json!({ "id": message["id"], "result": { "targetInfos": [
4855 { "targetId": "OTHER", "type": "page", "url": "about:blank" }
4856 ] } })];
4857 }
4858 cleanup_answer(message).into_iter().filter(|reply| reply.get("method").is_none()).collect()
4859 });
4860 let error = cdp.call("Target.createTarget", json!({ "url": "about:blank" }), None).unwrap_err();
4861 assert_eq!(error, "slicc: refused: slicc can't keep seven's origin out of this target: Network.setBypassServiceWorker timed out\n");
4862 assert!(!cdp.events().iter().any(|event| event["method"] == "Target.targetDestroyed"));
4863 assert!(cdp.is_protected_target("T"));
4864 }
4865
4866 #[test]
4867 fn cleanup_reports_a_missing_destruction_event_without_allowing_the_target() {
4868 let mut cdp = cleanup(None, cleanup_answer);
4869 let error = cdp.call("Target.createTarget", json!({ "url": "about:blank" }), None).unwrap_err();
4870 assert!(error.starts_with("slicc: refused:"), "{error}");
4871 assert!(error.contains("Network.setBypassServiceWorker timed out"), "{error}");
4872 assert!(error.contains("Target.targetDestroyed timed out"), "{error}");
4873 assert!(cdp.is_protected_target("T"));
4874 }
4875
4876 #[test]
4877 fn cleanup_reports_a_close_that_did_not_succeed() {
4878 let mut cdp = cleanup(None, |message| {
4879 let mut replies = cleanup_answer(message);
4880 if message["method"] == "Target.closeTarget" {
4881 replies.last_mut().unwrap()["result"] = json!({ "success": false });
4882 }
4883 replies
4884 });
4885 let error = cdp.call("Target.createTarget", json!({ "url": "about:blank" }), None).unwrap_err();
4886 assert!(error.contains("Network.setBypassServiceWorker timed out"), "{error}");
4887 assert!(error.contains("cleanup: Target.closeTarget did not confirm success"), "{error}");
4888 assert!(cdp.is_protected_target("T"));
4889 }
4890
4891 #[test]
4892 fn cleanup_does_not_accept_a_stale_destruction_event() {
4893 let mut cdp = cleanup(None, cleanup_answer);
4894 cdp.absorb(json!({ "method": "Target.targetDestroyed", "params": { "targetId": "T" } }));
4895 let error = cdp.call("Target.createTarget", json!({ "url": "about:blank" }), None).unwrap_err();
4896 assert!(error.contains("Target.targetDestroyed timed out"), "{error}");
4897 assert!(cdp.is_protected_target("T"));
4898 }
4899
4900 #[test]
4901 fn cleanup_accepts_destruction_before_the_close_reply() {
4902 let mut cdp = cleanup(None, |message| {
4903 let mut replies = cleanup_answer(message);
4904 if message["method"] == "Target.closeTarget" {
4905 replies.insert(0, json!({ "method": "Target.targetDestroyed", "params": { "targetId": "T" } }));
4906 }
4907 replies
4908 });
4909 let error = cdp.call("Target.createTarget", json!({ "url": "about:blank" }), None).unwrap_err();
4910 assert!(error.contains("Network.setBypassServiceWorker timed out"), "{error}");
4911 assert!(!error.contains("cleanup:"), "{error}");
4912 }
4913
4914 #[test]
4915 fn privileged_target_types_and_extension_workers_are_guarded() {
4916 let mut cdp = pending(|message| {
4917 let info = match message["params"]["targetId"].as_str() {
4918 Some("UI") => json!({"targetId": "UI", "type": "browser_ui", "url": "https://example.test/"}),
4919 Some("W") => json!({"targetId": "W", "type": "service_worker", "url": "chrome-extension://abc/worker.js"}),
4920 Some("B") => json!({"targetId": "B", "type": "page", "url": "about:blank", "openerId": "UI"}),
4921 _ => json!({"targetId": "P", "type": "page", "url": "https://example.test/"}),
4922 };
4923 let result = match message["method"].as_str() {
4924 Some("Target.getTargetInfo") => json!({"targetInfo": info}),
4925 Some("Target.getTargets") => json!({"targetInfos": [
4926 {"targetId": "UI", "type": "browser_ui", "url": "https://example.test/"},
4927 {"targetId": "P", "type": "page", "url": "https://example.test/"}
4928 ]}),
4929 _ => json!({}),
4930 };
4931 vec![json!({"id": message["id"], "result": result})]
4932 });
4933 assert!(cdp.target_protected("B", false).unwrap());
4934 assert!(cdp.target_protected("UI", false).unwrap());
4935 assert!(cdp.target_protected("W", false).unwrap());
4936 assert!(!cdp.target_protected("P", false).unwrap());
4937 let listed = cdp.call("Target.getTargets", json!({}), None).unwrap();
4938 assert_eq!(listed["targetInfos"].as_array().unwrap().len(), 1);
4939 assert_eq!(listed["targetInfos"][0]["targetId"], "P");
4940 for kind in ["page", "service_worker", "background_page", "other", "iframe"] {
4941 assert!(cdp.info_protected(&json!({
4942 "targetId": "E", "type": kind, "url": "chrome-extension://abc/options.html"
4943 }), &[]));
4944 }
4945 assert!(cdp.info_protected(&json!({
4946 "targetId": "UI", "type": "browser_ui", "url": "about:blank"
4947 }), &[]));
4948 }
4949
4950 fn evaluate(cdp: &mut Cdp) -> (Result<Value, String>, Duration) {
4951 let started = Instant::now();
4952 let result = cdp.call_for(
4953 "Runtime.evaluate",
4954 json!({ "expression": "1" }),
4955 Some("S"),
4956 Duration::from_secs(30),
4957 );
4958 (result, started.elapsed())
4959 }
4960
4961 #[test]
4962 fn a_call_fails_with_the_refusal_once_the_guard_blocks_its_session() {
4963 let mut cdp = pending(|message| match message["method"].as_str() {
4964 Some("Runtime.evaluate") => vec![json!({
4965 "method": "Page.frameNavigated",
4966 "sessionId": "S",
4967 "params": { "frame": { "id": "F", "url": "https://seven.sliccy.ai/os/", "securityOrigin": "https://seven.sliccy.ai" } }
4968 })],
4969 _ => vec![],
4970 });
4971 let (result, spent) = evaluate(&mut cdp);
4972 assert_eq!(result.unwrap_err(), format!("{}\n", cdp.guard().refusal()));
4973 assert!(spent < Duration::from_secs(5), "{spent:?}");
4974 assert!(cdp.session_blocked("S"));
4975 }
4976
4977 #[test]
4978 fn a_call_fails_with_the_refusal_once_its_session_detaches() {
4979 let mut cdp = pending(|_| {
4980 vec![
4981 json!({ "method": "Target.detachedFromTarget", "params": { "sessionId": "other" } }),
4982 json!({ "method": "Target.detachedFromTarget", "params": { "sessionId": "S" } }),
4983 ]
4984 });
4985 let (result, spent) = evaluate(&mut cdp);
4986 assert_eq!(result.unwrap_err(), format!("{}\n", cdp.guard().refusal()));
4987 assert!(spent < Duration::from_secs(5), "{spent:?}");
4988 }
4989
4990 #[test]
4991 fn unrelated_events_do_not_end_a_call() {
4992 let mut cdp = pending(|message| {
4993 vec![
4994 json!({ "method": "Target.detachedFromTarget", "params": { "sessionId": "other" } }),
4995 json!({ "id": message["id"], "result": { "result": { "value": 1 } } }),
4996 ]
4997 });
4998 let (result, _) = evaluate(&mut cdp);
4999 assert_eq!(result.unwrap(), json!({ "result": { "value": 1 } }));
5000 }
5001
5002 #[test]
5003 fn a_harmless_call_on_an_already_blocked_session_still_waits_for_its_reply() {
5004 let mut cdp = pending(|message| match message["method"].as_str() {
5005 Some("Runtime.evaluate") => vec![json!({
5006 "method": "Page.frameNavigated",
5007 "sessionId": "S",
5008 "params": { "frame": { "id": "F", "url": "https://seven.sliccy.ai/os/" } }
5009 })],
5010 Some("Fetch.disable") => vec![
5011 json!({ "method": "Page.lifecycleEvent", "sessionId": "S", "params": { "name": "load" } }),
5012 json!({ "id": message["id"], "result": {} }),
5013 ],
5014 _ => vec![],
5015 });
5016 let _ = evaluate(&mut cdp);
5017 assert!(cdp.session_blocked("S"));
5018 let disabled = cdp.call_for("Fetch.disable", json!({}), Some("S"), Duration::from_secs(30));
5019 assert_eq!(disabled.unwrap(), json!({}));
5020 }
5021
5022 #[test]
5023 fn a_finished_document_does_not_wait_for_load() {
5024 assert_eq!(probe_is_settled(Ok(Some("complete"))).unwrap(), true);
5025 assert_eq!(probe_is_settled(Ok(None)).unwrap(), true);
5026 assert_eq!(
5027 probe_is_settled(Err("Runtime.evaluate timed out\n")).unwrap(),
5028 true
5029 );
5030 assert_eq!(
5031 probe_is_settled(Err("Runtime.evaluate: 'Runtime.evaluate' wasn't found\n")).unwrap(),
5032 true
5033 );
5034 }
5035
5036 #[test]
5037 fn a_blank_load_does_not_settle_the_next_navigation() {
5038 let session = "sess";
5039 let blank_load = json!({
5040 "method": "Page.loadEventFired",
5041 "sessionId": session,
5042 "params": {}
5043 });
5044 let blank_frame = json!({
5045 "method": "Page.frameNavigated",
5046 "sessionId": session,
5047 "params": { "frame": { "url": "about:blank" } }
5048 });
5049 let commit = json!({
5050 "method": "Page.frameNavigated",
5051 "sessionId": session,
5052 "params": { "frame": { "url": "http://a.test/boot" } }
5053 });
5054 let load = json!({
5055 "method": "Page.loadEventFired",
5056 "sessionId": session,
5057 "params": {}
5058 });
5059 let raced = vec![blank_frame, blank_load.clone(), commit.clone()];
5060 assert!(!super::navigation_settled(&raced, session, 0));
5061 let ready = vec![blank_load.clone(), commit.clone(), load.clone()];
5062 assert!(super::navigation_settled(&ready, session, 0));
5063 let stale = vec![commit, load, blank_load];
5064 assert!(!super::navigation_settled(&stale, session, 2));
5065 }
5066
5067 #[test]
5068 fn a_loading_document_still_waits() {
5069 assert_eq!(probe_is_settled(Ok(Some("loading"))).unwrap(), false);
5070 assert_eq!(probe_is_settled(Ok(Some("interactive"))).unwrap(), false);
5071 }
5072
5073 #[test]
5074 fn a_closed_socket_is_not_treated_as_loaded() {
5075 for err in [
5076 "websocket closed 1011 the browser went away\n",
5077 "websocket connection closed\n",
5078 "websocket write failed: broken pipe\n",
5079 "websocket read failed: connection reset\n",
5080 "CDP response was not JSON: eof\n",
5081 ] {
5082 let reported = probe_is_settled(Err(err)).unwrap_err();
5083 assert_eq!(reported, err);
5084 }
5085 }
5086
5087 #[test]
5088 fn action_start_and_end_keep_the_panel_fields() {
5089 let click = ActionNote {
5090 kind: "click".to_string(),
5091 tab: Some("1234".to_string()),
5092 target: Some("button \"Sign in\"".to_string()),
5093 agent: Some("cone:cone-1".to_string()),
5094 ..ActionNote::default()
5095 };
5096 assert_eq!(
5097 click.start_params(),
5098 json!({
5099 "phase": "start",
5100 "kind": "click",
5101 "tab": "1234",
5102 "target": "button \"Sign in\"",
5103 "agent": "cone:cone-1"
5104 })
5105 );
5106 let failed = click.end_params(
5107 false,
5108 "No snapshot available. Run \"snapshot\" first.\nignored\n",
5109 );
5110 assert_eq!(
5111 failed,
5112 json!({
5113 "phase": "end",
5114 "ok": false,
5115 "error": "no snapshot",
5116 "tab": "1234"
5117 })
5118 );
5119 assert!(failed.get("agent").is_none());
5120 assert!(failed.get("kind").is_none());
5121 assert!(failed.get("target").is_none());
5122 let open = ActionNote {
5123 kind: "open".to_string(),
5124 url: Some("http://a.test/".to_string()),
5125 ..ActionNote::default()
5126 };
5127 assert!(open.start_params().get("tab").is_none());
5128 assert_eq!(open.start_params()["url"], "http://a.test/");
5129 let mut opened = open.clone();
5130 opened.tab = Some("TAB1".to_string());
5131 assert_eq!(opened.end_params(true, "")["tab"], "TAB1");
5132 assert!(opened.end_params(true, "").get("error").is_none());
5133 }
5134
5135 #[test]
5136 fn action_params_omit_typed_text_eval_source_and_request_secrets() {
5137 let secret = "secret-text";
5138 let fill = ActionNote {
5139 kind: "fill".to_string(),
5140 tab: Some("T".to_string()),
5141 target: Some("textbox \"Email\"".to_string()),
5142 length: Some(secret.chars().count() as u64),
5143 ..ActionNote::default()
5144 };
5145 let fill_params = fill.start_params();
5146 assert_eq!(fill_params["length"], 11);
5147 assert!(!fill_params.to_string().contains(secret));
5148 assert!(fill_params.get("value").is_none());
5149 let typed = "héllo";
5150 let type_note = ActionNote {
5151 kind: "type".to_string(),
5152 length: Some(typed.chars().count() as u64),
5153 ..ActionNote::default()
5154 };
5155 assert_eq!(type_note.start_params()["length"], 5);
5156 assert!(!type_note.start_params().to_string().contains(typed));
5157 let source = "document.cookie";
5158 let eval_note = ActionNote {
5159 kind: "eval".to_string(),
5160 tab: Some("T".to_string()),
5161 ..ActionNote::default()
5162 };
5163 let eval_params = eval_note.start_params();
5164 assert!(!eval_params.to_string().contains(source));
5165 assert!(eval_params.get("expression").is_none());
5166 let request = ActionNote {
5167 kind: "request".to_string(),
5168 tab: Some("T1".to_string()),
5169 method: Some("POST".to_string()),
5170 url: Some("https://app.example/api/me".to_string()),
5171 ..ActionNote::default()
5172 };
5173 let request_params = request.start_params();
5174 assert_eq!(
5175 request_params,
5176 json!({
5177 "phase": "start",
5178 "kind": "request",
5179 "tab": "T1",
5180 "method": "POST",
5181 "url": "https://app.example/api/me"
5182 })
5183 );
5184 assert!(!request_params.to_string().contains("Authorization"));
5185 assert!(!request_params.to_string().contains(secret));
5186 let press = ActionNote {
5187 kind: "press".to_string(),
5188 key: Some("Enter".to_string()),
5189 ..ActionNote::default()
5190 };
5191 assert_eq!(press.start_params()["key"], "Enter");
5192 assert!(ActionNote::default().start_params().get("agent").is_none());
5193 assert_eq!(first_stderr_line("only-line"), Some("only-line"));
5194 assert_eq!(first_stderr_line("\n"), None);
5195 }
5196
5197 #[test]
5198 fn action_urls_and_errors_drop_page_secrets() {
5199 let secret = "https://user:pass@app.example/form?q=QUERYSECRET&tok=x#FRAGSECRET";
5200 let open = ActionNote {
5201 kind: "open".to_string(),
5202 url: Some(secret.to_string()),
5203 ..ActionNote::default()
5204 };
5205 let started = open.start_params();
5206 assert_eq!(started["url"], "https://app.example/form");
5207 assert_clean(&started);
5208 let goto = ActionNote {
5209 kind: "goto".to_string(),
5210 url: Some(secret.to_string()),
5211 ..ActionNote::default()
5212 };
5213 assert_eq!(goto.start_params()["url"], "https://app.example/form");
5214 let posted = ActionNote {
5215 kind: "request".to_string(),
5216 method: Some("POST".to_string()),
5217 url: Some(secret.to_string()),
5218 ..ActionNote::default()
5219 };
5220 let request = posted.start_params();
5221 assert_eq!(request["method"], "POST");
5222 assert_eq!(request["url"], "https://app.example/form");
5223 assert_clean(&request);
5224 let gotten = ActionNote {
5225 kind: "request".to_string(),
5226 method: Some("GET".to_string()),
5227 url: Some("http://user:p%40ss@[::1]:8443/a/b?x=1#y".to_string()),
5228 ..ActionNote::default()
5229 };
5230 assert_eq!(gotten.start_params()["url"], "http://[::1]:8443/a/b");
5231 let relative = ActionNote {
5232 kind: "request".to_string(),
5233 method: Some("GET".to_string()),
5234 url: Some("//user:pass@app.example/path?q=QUERYSECRET#FRAGSECRET".to_string()),
5235 ..ActionNote::default()
5236 };
5237 let relative_params = relative.start_params();
5238 assert_eq!(relative_params["url"], "//app.example/path");
5239 assert_clean(&relative_params);
5240 assert_eq!(
5241 ActionNote {
5242 kind: "open".to_string(),
5243 url: Some("about:blank".to_string()),
5244 ..ActionNote::default()
5245 }
5246 .start_params()["url"],
5247 "about:blank"
5248 );
5249 let opaque = [
5250 (
5251 "goto",
5252 "data:text/html,<title>DATASECRET</title>",
5253 Some("data:"),
5254 "DATASECRET",
5255 ),
5256 (
5257 "open",
5258 "data:text/html,DATASECRET2",
5259 Some("data:"),
5260 "DATASECRET2",
5261 ),
5262 (
5263 "goto",
5264 "javascript:void('JSSECRET')",
5265 Some("javascript:"),
5266 "JSSECRET",
5267 ),
5268 (
5269 "open",
5270 "blob:https://example.com/BLOBSECRET",
5271 Some("blob:"),
5272 "BLOBSECRET",
5273 ),
5274 ("goto", "about:blank?q=BLANKSECRET", Some("about:blank"), "BLANKSECRET"),
5275 ("open", "ABOUT:blank?q=BLANKSECRET", Some("about:blank"), "BLANKSECRET"),
5276 ("goto", "About:blank", Some("about:blank"), "BLANKSECRET"),
5277 (
5278 "open",
5279 "DATA:text/html,DATASECRET",
5280 Some("data:"),
5281 "DATASECRET",
5282 ),
5283 (
5284 "open",
5285 "about:srcdoc,ABOUTSECRET",
5286 Some("about:"),
5287 "ABOUTSECRET",
5288 ),
5289 ("goto", "file:/tmp/PATHSECRET", Some("file:"), "PATHSECRET"),
5290 (
5291 "open",
5292 "https:example.com/PATHSECRET",
5293 Some("https:"),
5294 "PATHSECRET",
5295 ),
5296 ("goto", "example.com/PATHSECRET", None, "PATHSECRET"),
5297 ("open", "not a url PATHSECRET", None, "PATHSECRET"),
5298 ("goto", "HOSTSECRET3:8080/path", None, "HOSTSECRET3"),
5299 ("open", "host:8080/x", None, "host:"),
5300 (
5301 "goto",
5302 "USERSECRET5:PASSSECRET5@127.0.0.1/form",
5303 None,
5304 "USERSECRET5",
5305 ),
5306 (
5307 "open",
5308 "USERSECRET5:PASSSECRET5@127.0.0.1/form",
5309 None,
5310 "PASSSECRET5",
5311 ),
5312 ("goto", "user:pw@host/x", None, "user:"),
5313 ("open", "foo:bar", None, "foo:"),
5314 ("goto", "foo://example.com/FOOSECRET", None, "FOOSECRET"),
5315 (
5316 "open",
5317 "view-source:https://example.com/VIEWSECRET",
5318 Some("view-source:"),
5319 "VIEWSECRET",
5320 ),
5321 ];
5322 for (kind, raw, expect, secret) in opaque {
5323 let note = ActionNote {
5324 kind: kind.to_string(),
5325 url: Some(raw.to_string()),
5326 ..ActionNote::default()
5327 };
5328 let params = note.start_params();
5329 match expect {
5330 Some(url) => assert_eq!(params["url"], url, "{raw}"),
5331 None => assert!(params.get("url").is_none(), "{raw} {params}"),
5332 }
5333 assert!(!params.to_string().contains(secret), "{raw} {params}");
5334 }
5335 let eval_failed = ActionNote {
5336 kind: "eval".to_string(),
5337 tab: Some("T".to_string()),
5338 ..ActionNote::default()
5339 };
5340 let eval_end = eval_failed.end_params(false, "Error: EVALSECRET-in-error\n");
5341 assert_eq!(eval_end["ok"], false);
5342 assert!(eval_end.get("error").is_none());
5343 assert_clean(&eval_end);
5344 let cases = [
5345 (
5346 "click",
5347 "Unknown ref \"e1\". Available: e2\n",
5348 "element not found",
5349 ),
5350 (
5351 "screenshot",
5352 "No snapshot available. Run \"snapshot\" first.\n",
5353 "no snapshot",
5354 ),
5355 (
5356 "screenshot",
5357 "screenshot: could not resolve element e1 to a visible box — the snapshot is likely stale\n",
5358 "no snapshot",
5359 ),
5360 (
5361 "click",
5362 "Error: --tab <targetId> is required. Run 'playwright-cli tab-list' to get tab IDs.\n",
5363 "unknown tab",
5364 ),
5365 (
5366 "goto",
5367 "navigate: refused https://app.example/form?q=QUERYSECRET#FRAGSECRET\n",
5368 "navigation failed",
5369 ),
5370 ("click", "Page.navigate timed out\n", "timeout"),
5371 (
5372 "open",
5373 "websocket closed 1011 the browser went away\n",
5374 "connection lost",
5375 ),
5376 (
5377 "request",
5378 "curlwright: no open tab is on https://app.example — pass --tab.\nhttps://other.example/dash?q=QUERYSECRET\n",
5379 "not allowed",
5380 ),
5381 (
5382 "request",
5383 "curlwright: (22) The requested URL returned error: 500\n",
5384 "failed",
5385 ),
5386 ];
5387 for (kind, stderr, code) in cases {
5388 let note = ActionNote {
5389 kind: kind.to_string(),
5390 ..ActionNote::default()
5391 };
5392 let ended = note.end_params(false, stderr);
5393 assert_eq!(ended["error"], code, "{stderr}");
5394 assert_clean(&ended);
5395 }
5396 }
5397
5398 fn assert_clean(value: &serde_json::Value) {
5399 let rendered = value.to_string();
5400 for secret in [
5401 "QUERYSECRET",
5402 "FRAGSECRET",
5403 "EVALSECRET",
5404 "user:pass",
5405 "tok=x",
5406 "p%40ss",
5407 ] {
5408 assert!(!rendered.contains(secret), "{rendered}");
5409 }
5410 }
5411}