Ship oracle journal values, bytecode/frontend hardening, and replay-policy Lean.

Host exposes oracle journals as language values with refuse/copy gates; bytecode and foreign session paths get modularized; applications and verification replay-policy sources land with Lake builds ignored.

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
cflmyandCursor committed 2026-11-06 15:04:27 +08:00
1 parent e3d9021bb6
commit 8f1010f967
101 files changed
+17962 -1727

No files matched your search

+331
View File
@@ -0,0 +1,331 @@
//! Checks every emitted instruction and a control-flow stack-height certificate.
//! This is structural validation, not source/bytecode semantic equivalence.
use super::{FnChunk, Op, Program};
use crate::value::Value;
use std::collections::{HashSet, VecDeque};
#[derive(Debug, Clone)]
pub struct StackCertificate {
pub heights: Vec<Option<usize>>,
}
impl Program {
pub fn verify(&self) -> Result<Vec<StackCertificate>, String> {
let n = self.functions.len();
if self.entry >= n || self.parents.len() != n || self.children.len() != n {
return Err("invalid program function tables".into());
}
for (i, parent) in self.parents.iter().enumerate() {
if parent.is_some_and(|p| p >= n || p == i) {
return Err("invalid function parent".into());
}
for &child in &self.children[i] {
if child >= n || self.parents[child] != Some(i) {
return Err("inconsistent function child".into());
}
}
}
check_forest(&self.parents)?;
for (child, parent) in self.parents.iter().enumerate() {
if let Some(parent) = parent {
if !self.children[*parent].contains(&child)
|| self.functions[*parent].module_path != self.functions[child].module_path
{
return Err("inconsistent parent owner".into());
}
}
}
super::names::verify(self)?;
if self.objects.len() != self.object_bases.len() {
return Err("invalid object tables".into());
}
for (i, (_, fid)) in self.objects.iter().enumerate() {
if *fid >= n
|| self.object_bases[i]
.is_some_and(|base| base >= n || !self.objects.iter().any(|(_, f)| *f == base))
{
return Err("invalid object reference".into());
}
}
if self.methods.iter().any(|(owner, _, fid)| {
*owner >= n || *fid >= n || !self.objects.iter().any(|(_, f)| f == owner)
}) || self.path_index.values().any(|id| *id >= n)
{
return Err("invalid method/export reference".into());
}
let object_ids = self
.objects
.iter()
.enumerate()
.map(|(i, (_, fid))| (*fid, i))
.collect::<std::collections::HashMap<_, _>>();
if object_ids.len() != self.objects.len() {
return Err("duplicate object reference".into());
}
let bases = self
.object_bases
.iter()
.map(|base| base.map(|fid| object_ids[&fid]))
.collect::<Vec<_>>();
check_forest(&bases)?;
if self
.methods
.iter()
.any(|(owner, _, fid)| self.parents[*fid] != Some(*owner))
{
return Err("inconsistent method owner".into());
}
self.functions
.iter()
.enumerate()
.map(|(i, f)| {
verify_chunk(self, i, f)
.map_err(|e| format!("bytecode verification in {}: {e}", f.name))
})
.collect()
}
}
fn verify_chunk(program: &Program, _fid: usize, fun: &FnChunk) -> Result<StackCertificate, String> {
super::expression::verify(fun)?;
super::statement::verify(fun)?;
super::call::verify(program,fun)?;
super::source::verify(fun)?;
let size = fun.code.len();
if size == 0 || fun.spans.len() != size {
return Err("invalid code/span table".into());
}
if fun.defaults.len() != fun.params.len()
|| fun.locals.get(..fun.params.len()) != Some(fun.params.as_slice())
{
return Err("parameters must be a local-slot prefix".into());
}
if fun.locals.iter().collect::<HashSet<_>>().len() != fun.locals.len() {
return Err("duplicate local slot name".into());
}
let local = |i: usize| {
if i < fun.locals.len() {
Ok(())
} else {
Err("invalid local reference".to_string())
}
};
let target = |i: usize| {
if i < size {
Ok(())
} else {
Err("invalid jump target".to_string())
}
};
let function = |i: usize| {
if i < program.functions.len() {
Ok(())
} else {
Err("invalid call target".to_string())
}
};
let text = |i: usize| {
if matches!(fun.constants.get(i), Some(Value::Text(_))) {
Ok(())
} else {
Err("invalid text constant reference".to_string())
}
};
let mut shapes = Vec::with_capacity(size);
for (ip, op) in fun.code.iter().copied().enumerate() {
// pop count, push count, successor PCs. All opcodes are handled.
let next = vec![ip + 1];
let shape = match op {
Op::Constant(i) => {
if i >= fun.constants.len() {
return Err("invalid constant reference".into());
}
(0, 1, next)
}
Op::True | Op::False | Op::None_ => (0, 1, next),
Op::GetLocal(i) => {
local(i)?;
(0, 1, next)
}
Op::SetLocal(i) | Op::CheckBinding(i) => {
local(i)?;
(1, 1, next)
}
Op::Pop | Op::Print => (1, 0, next),
Op::Add
| Op::Sub
| Op::Mul
| Op::Div
| Op::Equal
| Op::NotEqual
| Op::Greater
| Op::GreaterEqual
| Op::Less
| Op::Lessequal
| Op::Split
| Op::Join
| Op::GetIndex
| Op::FootnoteGet => (2, 1, next),
Op::ContractFootnoteGet(i) => {
local(i)?;
(2, 1, next)
}
Op::Negate
| Op::Not
| Op::Input
| Op::Len
| Op::Str
| Op::Int
| Op::TypeOf
| Op::Trim
| Op::IterItems
| Op::CallFn => (1, 1, next),
Op::BuildList(n) => (n, 1, next),
Op::BuildMap(n) => (n.checked_mul(2).ok_or("map arity overflow")?, 1, next),
Op::Jump(t) => {
target(t)?;
(0, 0, vec![t])
}
Op::JumpIfFalse(t) => {
target(t)?;
(1, 0, vec![ip + 1, t])
}
Op::JumpIfProvided(p, t) => {
target(t)?;
if p >= fun.params.len() {
return Err("invalid presence reference".into());
}
(0, 0, vec![ip + 1, t])
}
Op::ResetLoop(id)|Op::CheckLoop(id)=>{
if !matches!(fun.statements.get(id).map(|s|&s.rule),Some(super::StatementRule::While(_))){return Err("invalid source loop reference".into());}
(0,0,next)
},
Op::FillMissingParameters | Op::CheckArguments | Op::RestoreReceiver | Op::CheckFrameArguments => (0, 0, next),
Op::CheckReturn => (1, 1, next),
Op::Call(f, n) => {
function(f)?;
(n, 1, next)
}
Op::CallArgs(f, l) => {
function(f)?;
let layout = fun.call_layouts.get(l).ok_or("invalid call layout")?;
(layout.len(), 1, next)
}
Op::BuiltinCallArgs(name,l)|Op::PluginCallArgs(name,l)=>{
text(name)?;
if matches!(op,Op::BuiltinCallArgs(_,_)) && !matches!(&fun.constants[name],Value::Text(name) if crate::arguments::builtin_signature(name).is_some()){return Err("unknown builtin signature".into());}
let layout=fun.call_layouts.get(l).ok_or("invalid call layout")?;(layout.len(),1,next)
},
Op::HostCallArgs(id,l)=>{
if crate::host::HostFn::from_u16(id).is_none(){return Err("unknown host id".into());}
let layout=fun.call_layouts.get(l).ok_or("invalid call layout")?;(layout.len(),1,next)
},
Op::PathCallArgs(id,l)=>{
if !matches!(fun.calls.get(id).and_then(|c|c.dispatch.as_ref()),Some(super::CallDispatch::Path{..})){return Err("invalid path call record".into());}
let layout=fun.call_layouts.get(l).ok_or("invalid path call layout")?;(layout.len(),1,next)
},
Op::RejectCallResolution(index)=>{text(index)?;(0,0,vec![])},
Op::MethodCall(name, n) => {
text(name)?;
(n.checked_add(1).ok_or("method arity overflow")?, 1, next)
}
Op::MethodCallArgs(name, l) => {
text(name)?;
let layout = fun.call_layouts.get(l).ok_or("invalid method layout")?;
(
layout.len().checked_add(1).ok_or("method arity overflow")?,
1,
next,
)
}
Op::PluginCall(name, n) => {
text(name)?;
if let Value::Text(s) = &fun.constants[name] {
if s.starts_with('@') && n % 2 != 0 {
return Err("odd named plugin arity".into());
}
}
(n, 1, next)
}
Op::HostCall(id, n) => {
if crate::host::HostFn::from_u16(id).is_none() {
return Err("invalid host reference".into());
}
(n, 1, next)
}
Op::TagInstance(f) => {
function(f)?;
if !program.objects.iter().any(|(_, id)| *id == f) {
return Err("invalid constructor reference".into());
}
(1, 1, next)
}
Op::RejectDuplicateArgument(name) | Op::RejectArgumentExpansion(name) => {
text(name)?;
(0, 0, vec![])
}
Op::Return => (1, 0, vec![]),
};
shapes.push(shape);
}
let mut heights = vec![None; size];
heights[0] = Some(0);
let mut queue = VecDeque::from([0]);
while let Some(ip) = queue.pop_front() {
let height = heights[ip].unwrap();
let (pop, push, edges) = &shapes[ip];
if height < *pop {
return Err(format!("stack underflow at {ip}"));
}
if matches!(fun.code[ip], Op::Return) && height != 1 {
return Err(format!("return leaks stack values at {ip}"));
}
let after = (height - pop)
.checked_add(*push)
.ok_or("stack height overflow")?;
for &to in edges {
target(to)?;
match heights[to] {
Some(known) if known != after => {
return Err(format!("inconsistent stack join at {to}"))
}
Some(_) => {}
None => {
heights[to] = Some(after);
queue.push_back(to);
}
}
}
}
Ok(StackCertificate { heights })
}
fn check_forest(parents: &[Option<usize>]) -> Result<(), String> {
let mut colors = vec![0u8; parents.len()];
for start in 0..parents.len() {
if colors[start] != 0 {
continue;
}
let mut cursor = Some(start);
let mut path = Vec::new();
while let Some(node) = cursor {
if node >= parents.len() {
return Err("invalid forest reference".into());
}
if colors[node] == 1 {
return Err("cyclic bytecode declaration graph".into());
}
if colors[node] == 2 {
break;
}
colors[node] = 1;
path.push(node);
cursor = parents[node];
}
for node in path {
colors[node] = 2;
}
}
Ok(())
}