effect
stringclasses 48
values | original_source_type
stringlengths 0
23k
| opens_and_abbrevs
listlengths 2
92
| isa_cross_project_example
bool 1
class | source_definition
stringlengths 9
57.9k
| partial_definition
stringlengths 7
23.3k
| is_div
bool 2
classes | is_type
null | is_proof
bool 2
classes | completed_definiton
stringlengths 1
250k
| dependencies
dict | effect_flags
sequencelengths 0
2
| ideal_premises
sequencelengths 0
236
| mutual_with
sequencelengths 0
11
| file_context
stringlengths 0
407k
| interleaved
bool 1
class | is_simply_typed
bool 2
classes | file_name
stringlengths 5
48
| vconfig
dict | is_simple_lemma
null | source_type
stringlengths 10
23k
| proof_features
sequencelengths 0
1
| name
stringlengths 8
95
| source
dict | verbose_type
stringlengths 1
7.42k
| source_range
dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
FStar.Pervasives.Lemma | val lemma_push_leakage_free (ts: analysis_taints) (ins: S.ins)
: Lemma (requires BC.Push? ins)
(ensures
(let b, ts' = check_if_push_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts)) | [
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_push_leakage_free (ts:analysis_taints) (ins:S.ins) : Lemma
(requires BC.Push? ins)
(ensures (
let (b, ts') = check_if_push_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts
))
=
let (b, ts') = check_if_push_consumes_fixed_time ins ts in
if b then
(
let code = Ins ins in
let lem (s1 s2:S.machine_state) (fuel:nat) : Lemma
(requires is_explicit_leakage_free_lhs code fuel ts.lts ts'.lts s1 s2)
(ensures is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)
[SMTPat (is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)]
=
let BC.Push src t_stk = ins in
let t_out = operand_taint 0 src ts in
let s1' = Some?.v (machine_eval_code code fuel s1) in
let s2' = Some?.v (machine_eval_code code fuel s2) in
let S.Machine_stack _ stack1 = s1.S.ms_stack in
let S.Machine_stack _ stack2 = s2.S.ms_stack in
let S.Machine_stack _ stack1' = s1'.S.ms_stack in
let S.Machine_stack _ stack2' = s2'.S.ms_stack in
let ptr1 = S.eval_reg_64 rRsp s1 - 8 in
let ptr2 = S.eval_reg_64 rRsp s2 - 8 in
let v1 = S.eval_operand src s1 in
let v2 = S.eval_operand src s2 in
assert (ptr1 == ptr2);
if t_out = Secret then ()
else (
let aux () : Lemma (v1 == v2)
= match src with
| OConst _ | OReg _ -> ()
| OMem (_, _) | OStack (_, _) -> S.get_heap_val64_reveal ()
in
aux()
)
in
()
) | val lemma_push_leakage_free (ts: analysis_taints) (ins: S.ins)
: Lemma (requires BC.Push? ins)
(ensures
(let b, ts' = check_if_push_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts))
let lemma_push_leakage_free (ts: analysis_taints) (ins: S.ins)
: Lemma (requires BC.Push? ins)
(ensures
(let b, ts' = check_if_push_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts)) = | false | null | true | let b, ts' = check_if_push_consumes_fixed_time ins ts in
if b
then
(let code = Ins ins in
let lem (s1 s2: S.machine_state) (fuel: nat)
: Lemma (requires is_explicit_leakage_free_lhs code fuel ts.lts ts'.lts s1 s2)
(ensures is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)
[SMTPat (is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)] =
let BC.Push src t_stk = ins in
let t_out = operand_taint 0 src ts in
let s1' = Some?.v (machine_eval_code code fuel s1) in
let s2' = Some?.v (machine_eval_code code fuel s2) in
let S.Machine_stack _ stack1 = s1.S.ms_stack in
let S.Machine_stack _ stack2 = s2.S.ms_stack in
let S.Machine_stack _ stack1' = s1'.S.ms_stack in
let S.Machine_stack _ stack2' = s2'.S.ms_stack in
let ptr1 = S.eval_reg_64 rRsp s1 - 8 in
let ptr2 = S.eval_reg_64 rRsp s2 - 8 in
let v1 = S.eval_operand src s1 in
let v2 = S.eval_operand src s2 in
assert (ptr1 == ptr2);
if t_out = Secret
then ()
else
(let aux () : Lemma (v1 == v2) =
match src with
| OConst _ | OReg _ -> ()
| OMem (_, _) | OStack (_, _) -> S.get_heap_val64_reveal ()
in
aux ())
in
()) | {
"checked_file": "Vale.X64.Leakage_Ins.fst.checked",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Leakage_s.fst.checked",
"Vale.X64.Leakage_Helpers.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Lib.MapTree.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Leakage_Ins.fst"
} | [
"lemma"
] | [
"Vale.X64.Leakage_Helpers.analysis_taints",
"Vale.X64.Machine_Semantics_s.ins",
"Prims.bool",
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.nat",
"Prims.unit",
"Vale.X64.Leakage_s.is_explicit_leakage_free_lhs",
"Vale.X64.Leakage_Helpers.__proj__AnalysisTaints__item__lts",
"Prims.squash",
"Vale.X64.Leakage_s.is_explicit_leakage_free_rhs",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.logical",
"Prims.Nil",
"Vale.X64.Machine_s.operand64",
"Vale.Arch.HeapTypes_s.taint",
"Vale.Def.Types_s.nat64",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.Map.t",
"Prims.int",
"Vale.Def.Types_s.nat8",
"Prims.op_Equality",
"Vale.Arch.HeapTypes_s.Secret",
"Prims.l_True",
"Prims.eq2",
"Vale.Def.Words_s.nat64",
"Vale.X64.Machine_s.nat64",
"Vale.X64.Machine_s.reg_64",
"Vale.X64.Machine_s.maddr",
"Vale.Arch.MachineHeap_s.get_heap_val64_reveal",
"Prims._assert",
"Vale.X64.Machine_Semantics_s.eval_operand",
"Prims.op_Subtraction",
"Vale.X64.Machine_Semantics_s.eval_reg_64",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.Machine_Semantics_s.machine_stack",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_stack",
"FStar.Pervasives.Native.__proj__Some__item__v",
"Vale.X64.Leakage_Ins.machine_eval_code",
"Vale.X64.Leakage_Helpers.operand_taint",
"Vale.X64.Machine_s.precode",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Vale.X64.Bytes_Code_s.ocmp",
"Vale.X64.Machine_s.Ins",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.Leakage_Ins.check_if_push_consumes_fixed_time",
"Vale.X64.Bytes_Code_s.uu___is_Push",
"Prims.l_imp",
"Prims.l_and",
"Vale.X64.Leakage_s.isConstantTime",
"Vale.X64.Leakage_s.isLeakageFree"
] | [] | module Vale.X64.Leakage_Ins
open FStar.Mul
open Vale.Arch.MachineHeap_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
module BC = Vale.X64.Bytes_Code_s
module S = Vale.X64.Machine_Semantics_s
open Vale.X64.Leakage_s
open Vale.X64.Leakage_Helpers
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
unfold let obs_args = S.obs_args
unfold let obs_inouts = S.obs_inouts
unfold let machine_eval_code = S.machine_eval_code
let reveal_machine_eval_code_ins (i:S.ins) (s:S.machine_state) : Lemma
(requires True)
(ensures S.machine_eval_code_ins i s == S.machine_eval_code_ins_def i s)
[SMTPat (S.machine_eval_code_ins i s)]
=
reveal_opaque (`%S.machine_eval_code_ins) S.machine_eval_code_ins
let rec check_if_consumes_fixed_time_args
(args:list instr_operand) (oprs:instr_operands_t_args args) (ts:analysis_taints)
: Pure bool
(requires True)
(ensures fun b -> b ==> (forall (s1 s2:S.machine_state).{:pattern (constTimeInvariant ts.lts s1 s2)}
constTimeInvariant ts.lts s1 s2 ==> obs_args args oprs s1 == obs_args args oprs s2))
=
allow_inversion maddr;
allow_inversion tmaddr;
match args with
| [] -> true
| (IOpEx i)::args ->
let ((o:instr_operand_t i), (oprs:instr_operands_t_args args)) = coerce oprs in
let b' =
match i with
| IOp64 -> operand_does_not_use_secrets #nat64 #reg_64 o ts
| IOpXmm -> operand_does_not_use_secrets #quad32 #reg_xmm o ts
in
let b'' = check_if_consumes_fixed_time_args args oprs ts in
b' && b''
| (IOpIm i)::args ->
let b' =
match i with
| IOp64One o -> operand_does_not_use_secrets o ts
| IOpXmmOne o -> operand_does_not_use_secrets o ts
| IOpFlagsCf -> true
| IOpFlagsOf -> true
in
let b'' = check_if_consumes_fixed_time_args args (coerce oprs) ts in
b' && b''
let check_if_consumes_fixed_time_outs_explicit
(i:instr_operand_explicit) (o:instr_operand_t i)
(ts:analysis_taints) (t_out:taint)
: bool
=
match i with
| IOp64 -> operand_does_not_use_secrets #nat64 #reg_64 o ts && operand_taint_allowed #nat64 #reg_64 o t_out
| IOpXmm -> operand_does_not_use_secrets #quad32 #reg_xmm o ts && operand_taint_allowed #quad32 #reg_xmm o t_out
let check_if_consumes_fixed_time_outs_implicit
(i:instr_operand_implicit) (ts:analysis_taints) (t_out:taint)
: bool
=
match i with
| IOp64One o -> operand_does_not_use_secrets o ts && operand_taint_allowed o t_out
| IOpXmmOne o -> operand_does_not_use_secrets o ts && operand_taint_allowed o t_out
| IOpFlagsCf -> true
| IOpFlagsOf -> true
let rec check_if_consumes_fixed_time_outs
(outs:list instr_out) (args:list instr_operand) (oprs:instr_operands_t outs args)
(ts:analysis_taints) (t_out:taint)
: Pure bool
(requires True)
(ensures fun b -> b ==> (forall (s1 s2:S.machine_state).{:pattern (constTimeInvariant ts.lts s1 s2)}
constTimeInvariant ts.lts s1 s2 ==> obs_inouts outs args oprs s1 == obs_inouts outs args oprs s2))
=
allow_inversion maddr;
allow_inversion tmaddr;
allow_inversion operand64;
allow_inversion operand128;
match outs with
| [] -> check_if_consumes_fixed_time_args args oprs ts
| (_, IOpEx i)::outs ->
let ((o:instr_operand_t i), (oprs:instr_operands_t outs args)) = coerce oprs in
let b' = check_if_consumes_fixed_time_outs_explicit i o ts t_out in
let b'' = check_if_consumes_fixed_time_outs outs args oprs ts t_out in
b' && b''
| (_, IOpIm i)::outs ->
let b' = check_if_consumes_fixed_time_outs_implicit i ts t_out in
let b'' = check_if_consumes_fixed_time_outs outs args (coerce oprs) ts t_out in
b' && b''
#restart-solver
#reset-options "--z3rlimit 300"
let rec lemma_args_taint
(outs:list instr_out) (args:list instr_operand)
(f:instr_args_t outs args) (oprs:instr_operands_t_args args)
(ts:analysis_taints) (s1 s2:S.machine_state)
: Lemma
(requires
constTimeInvariant ts.lts s1 s2 /\
Some? (S.instr_apply_eval_args outs args f oprs s1) /\
Some? (S.instr_apply_eval_args outs args f oprs s2) /\
check_if_consumes_fixed_time_args args oprs ts /\
args_taint args oprs ts == Public)
(ensures
S.instr_apply_eval_args outs args f oprs s1 ==
S.instr_apply_eval_args outs args f oprs s2)
=
allow_inversion maddr;
allow_inversion tmaddr;
allow_inversion operand64;
allow_inversion operand128;
match args with
| [] -> ()
| i::args ->
let (v1, v2, oprs) : option (instr_val_t i) & option (instr_val_t i) & instr_operands_t_args args =
match i with
| IOpEx i ->
let (o, (oprs:instr_operands_t_args args)) = coerce oprs in
(
S.instr_eval_operand_explicit i o s1,
S.instr_eval_operand_explicit i o s2,
oprs)
| IOpIm i ->
let oprs = coerce oprs in (
S.instr_eval_operand_implicit i s1,
S.instr_eval_operand_implicit i s2,
oprs)
in
let f:arrow (instr_val_t i) (instr_args_t outs args) = coerce f in
S.get_heap_val32_reveal ();
S.get_heap_val64_reveal ();
S.get_heap_val128_reveal ();
assert (v1 == v2);
let Some v = v1 in
lemma_args_taint outs args (f v) oprs ts s1 s2
#restart-solver
let rec lemma_inouts_taint
(outs inouts:list instr_out) (args:list instr_operand)
(f:instr_inouts_t outs inouts args) (oprs:instr_operands_t inouts args)
(ts:analysis_taints) (s1 s2:S.machine_state)
: Lemma
(requires
constTimeInvariant ts.lts s1 s2 /\
Some? (S.instr_apply_eval_inouts outs inouts args f oprs s1) /\
Some? (S.instr_apply_eval_inouts outs inouts args f oprs s2) /\
check_if_consumes_fixed_time_outs inouts args oprs ts Public /\
inouts_taint inouts args oprs ts == Public)
(ensures
S.instr_apply_eval_inouts outs inouts args f oprs s1 ==
S.instr_apply_eval_inouts outs inouts args f oprs s2)
=
allow_inversion maddr;
allow_inversion tmaddr;
allow_inversion operand64;
allow_inversion operand128;
match inouts with
| [] -> lemma_args_taint outs args f oprs ts s1 s2
| (Out, i)::inouts ->
let oprs =
match i with
| IOpEx i -> snd #(instr_operand_t i) (coerce oprs)
| IOpIm i -> coerce oprs
in
lemma_inouts_taint outs inouts args (coerce f) oprs ts s1 s2
| (InOut, i)::inouts ->
let (v1, v2, oprs) : option (instr_val_t i) & option (instr_val_t i) & instr_operands_t inouts args =
match i with
| IOpEx i ->
let (o, (oprs:instr_operands_t inouts args)) = coerce oprs in
let oprs = coerce oprs in (
S.instr_eval_operand_explicit i o s1,
S.instr_eval_operand_explicit i o s2,
oprs)
| IOpIm i ->
let oprs = coerce oprs in (
S.instr_eval_operand_implicit i s1,
S.instr_eval_operand_implicit i s2,
oprs)
in
let f:arrow (instr_val_t i) (instr_inouts_t outs inouts args) = coerce f in
S.get_heap_val32_reveal ();
S.get_heap_val64_reveal ();
S.get_heap_val128_reveal ();
assert (v1 == v2);
let Some v = v1 in
lemma_inouts_taint outs inouts args (f v) oprs ts s1 s2
let instr_set_taint_explicit
(i:instr_operand_explicit) (o:instr_operand_t i) (ts:analysis_taints) (t:taint)
: analysis_taints =
match i with
| IOp64 -> set_taint 0 (o <: operand64) ts t
| IOpXmm -> set_taint 1 (o <: operand128) ts t
[@instr_attr]
let instr_set_taint_implicit (i:instr_operand_implicit) (ts:analysis_taints) (t:taint) : analysis_taints =
match i with
| IOp64One o -> set_taint 0 o ts t
| IOpXmmOne o -> set_taint 1 o ts t
| IOpFlagsCf -> set_taint_cf_and_flags ts t
| IOpFlagsOf -> set_taint_of_and_flags ts t
let rec instr_set_taints
(outs:list instr_out) (args:list instr_operand)
(oprs:instr_operands_t outs args) (ts:analysis_taints) (t:taint)
: analysis_taints =
match outs with
| [] -> ts
| (_, i)::outs ->
(
match i with
| IOpEx i ->
let oprs:instr_operand_t i & instr_operands_t outs args = coerce oprs in
instr_set_taints outs args (snd oprs) (instr_set_taint_explicit i (fst oprs) ts t) t
| IOpIm i -> instr_set_taints outs args (coerce oprs) (instr_set_taint_implicit i ts t) t
)
let rec lemma_instr_write_outputs_ok
(outs:list instr_out) (args:list instr_operand)
(vs:instr_ret_t outs) (oprs:instr_operands_t outs args) (s_orig s:S.machine_state)
: Lemma
(requires (S.instr_write_outputs outs args vs oprs s_orig s).S.ms_ok)
(ensures s.S.ms_ok)
=
match outs with
| [] -> ()
| (_, i)::outs ->
(
let ((v:instr_val_t i), (vs:instr_ret_t outs)) =
match outs with
| [] -> (vs, ())
| _::_ -> let vs = coerce vs in (fst vs, snd vs)
in
match i with
| IOpEx i ->
let oprs:instr_operand_t i & instr_operands_t outs args = coerce oprs in
let s' = S.instr_write_output_explicit i v (fst oprs) s_orig s in
lemma_instr_write_outputs_ok outs args vs (snd oprs) s_orig s'
| IOpIm i ->
let s' = S.instr_write_output_implicit i v s_orig s in
lemma_instr_write_outputs_ok outs args vs (coerce oprs) s_orig s'
)
[@"opaque_to_smt"]
let update_heap32_val (ptr:int) (v:Vale.Def.Types_s.nat32) (i:int) : Vale.Def.Types_s.nat8 =
let open Vale.Def.Words_s in
let open Vale.Def.Words.Four_s in
let v = nat_to_four 8 v in
match (i - ptr) with
| 0 -> v.lo0
| 1 -> v.lo1
| 2 -> v.hi2
| 3 -> v.hi3
| _ -> 0
let valid_addr32 (ptr:int) (mem:S.machine_heap) : bool =
S.valid_addr (ptr + 0) mem &&
S.valid_addr (ptr + 1) mem &&
S.valid_addr (ptr + 2) mem &&
S.valid_addr (ptr + 3) mem
let lemma_update_heap32_val (ptr:int) (v:Vale.Def.Types_s.nat32) (mem:S.machine_heap) (i:int) : Lemma
(requires True)
(ensures (S.update_heap32 ptr v mem).[i] ==
(if ptr <= i && i < ptr + 4 then update_heap32_val ptr v i else mem.[i]))
[SMTPat ((S.update_heap32 ptr v mem).[i])]
=
S.update_heap32_reveal ();
reveal_opaque (`%update_heap32_val) update_heap32_val
let lemma_update_heap32_domain (ptr:int) (v:Vale.Def.Types_s.nat32) (mem:S.machine_heap) : Lemma
(requires valid_addr32 ptr mem)
(ensures Map.domain (S.update_heap32 ptr v mem) == Map.domain mem)
[SMTPat (Map.domain (S.update_heap32 ptr v mem))]
=
S.update_heap32_reveal ();
assert (Set.equal (Map.domain (S.update_heap32 ptr v mem)) (Map.domain mem))
[@"opaque_to_smt"]
let update_heap64_val (ptr:int) (v:nat64) (i:int) : Vale.Def.Types_s.nat8 =
let open Vale.Def.Words_s in
let open Vale.Def.Words.Two_s in
let open Vale.Def.Words.Four_s in
let v = nat_to_two 32 v in
let lo = nat_to_four 8 v.lo in
let hi = nat_to_four 8 v.hi in
match (i - ptr) with
| 0 -> lo.lo0
| 1 -> lo.lo1
| 2 -> lo.hi2
| 3 -> lo.hi3
| 4 -> hi.lo0
| 5 -> hi.lo1
| 6 -> hi.hi2
| 7 -> hi.hi3
| _ -> 0
let lemma_update_heap64_val (ptr:int) (v:nat64) (mem:S.machine_heap) (i:int) : Lemma
(requires True)
(ensures
(S.update_heap64 ptr v mem).[i] ==
(if ptr <= i && i < ptr + 8 then update_heap64_val ptr v i else mem.[i])
)
[SMTPat ((S.update_heap64 ptr v mem).[i])]
=
S.update_heap64_reveal ();
reveal_opaque (`%update_heap64_val) update_heap64_val
let lemma_update_heap64_domain (ptr:int) (v:nat64) (mem:S.machine_heap) : Lemma
(requires S.valid_addr64 ptr mem)
(ensures Map.domain (S.update_heap64 ptr v mem) == Map.domain mem)
[SMTPat (Map.domain (S.update_heap64 ptr v mem))]
=
reveal_opaque (`%S.valid_addr64) S.valid_addr64;
S.update_heap64_reveal ();
assert (Set.equal (Map.domain (S.update_heap64 ptr v mem)) (Map.domain mem))
[@"opaque_to_smt"]
let update_heap128_val (ptr:int) (v:Vale.Def.Types_s.quad32) (i:int) : Vale.Def.Types_s.nat8 =
let open Vale.Def.Words_s in
let j = i - ptr in
if 0 <= j && j < 4 then update_heap32_val (ptr + 0 ) v.lo0 i else
if 4 <= j && j < 8 then update_heap32_val (ptr + 4 ) v.lo1 i else
if 8 <= j && j < 12 then update_heap32_val (ptr + 8 ) v.hi2 i else
if 12 <= j && j < 16 then update_heap32_val (ptr + 12) v.hi3 i else
0
let valid_addr128 (ptr:int) (mem:S.machine_heap) : bool =
valid_addr32 (ptr + 0) mem &&
valid_addr32 (ptr + 4) mem &&
valid_addr32 (ptr + 8) mem &&
valid_addr32 (ptr + 12) mem
let lemma_update_heap128_val (ptr:int) (v:Vale.Def.Types_s.quad32) (mem:S.machine_heap) (i:int) : Lemma
(requires True)
(ensures
(S.update_heap128 ptr v mem).[i] ==
(if ptr <= i && i < ptr + 16 then update_heap128_val ptr v i else mem.[i])
)
[SMTPat ((S.update_heap128 ptr v mem).[i])]
=
S.update_heap128_reveal ();
reveal_opaque (`%update_heap128_val) update_heap128_val
let lemma_update_heap128_domain (ptr:int) (v:Vale.Def.Types_s.quad32) (mem:S.machine_heap) : Lemma
(requires valid_addr128 ptr mem)
(ensures Map.domain (S.update_heap128 ptr v mem) == Map.domain mem)
[SMTPat (S.update_heap128 ptr v mem)]
=
S.update_heap128_reveal ();
assert (Set.equal (Map.domain (S.update_heap128 ptr v mem)) (Map.domain mem))
let lemma_preserve_valid64 (m m':S.machine_heap) : Lemma
(requires Set.equal (Map.domain m) (Map.domain m'))
(ensures (forall (i:int).{:pattern (S.valid_addr64 i m')}
S.valid_addr64 i m ==> S.valid_addr64 i m'))
=
reveal_opaque (`%S.valid_addr64) S.valid_addr64
let lemma_preserve_valid128 (m m':S.machine_heap) : Lemma
(requires Set.equal (Map.domain m) (Map.domain m'))
(ensures (forall (i:int).{:pattern (S.valid_addr128 i m')}
S.valid_addr128 i m ==> S.valid_addr128 i m'))
=
reveal_opaque (`%S.valid_addr128) S.valid_addr128
let lemma_instr_set_taints_explicit
(i:instr_operand_explicit) (v1 v2:instr_val_t (IOpEx i)) (o:instr_operand_t i)
(ts_orig ts:analysis_taints) (t_out:taint)
(s1_orig s1 s2_orig s2:S.machine_state)
: Lemma
(requires (
let s1' = S.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = S.instr_write_output_explicit i v2 o s2_orig s2 in
s1'.S.ms_ok /\ s2'.S.ms_ok /\
(t_out == Public ==> v1 == v2) /\
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2.S.ms_heap)) /\
check_if_consumes_fixed_time_outs_explicit i o ts_orig t_out /\
publicValuesAreSame ts_orig.lts s1_orig s2_orig /\
publicValuesAreSame ts.lts s1 s2
))
(ensures (
let s1' = S.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = S.instr_write_output_explicit i v2 o s2_orig s2 in
let ts' = instr_set_taint_explicit i o ts t_out in
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1'.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2'.S.ms_heap)) /\
publicValuesAreSame ts'.lts s1' s2'
))
=
allow_inversion maddr;
allow_inversion tmaddr;
lemma_preserve_valid64 (heap_get s1_orig.S.ms_heap) (heap_get s1.S.ms_heap);
lemma_preserve_valid64 (heap_get s2_orig.S.ms_heap) (heap_get s2.S.ms_heap);
lemma_preserve_valid128 (heap_get s1_orig.S.ms_heap) (heap_get s1.S.ms_heap);
lemma_preserve_valid128 (heap_get s2_orig.S.ms_heap) (heap_get s2.S.ms_heap);
reveal_opaque (`%S.valid_addr128) S.valid_addr128;
()
let lemma_instr_set_taints_implicit
(i:instr_operand_implicit) (v1 v2:instr_val_t (IOpIm i))
(ts_orig ts:analysis_taints) (t_out:taint)
(s1_orig s1 s2_orig s2:S.machine_state)
: Lemma
(requires (
let s1' = S.instr_write_output_implicit i v1 s1_orig s1 in
let s2' = S.instr_write_output_implicit i v2 s2_orig s2 in
s1'.S.ms_ok /\ s2'.S.ms_ok /\
(t_out == Public ==> v1 == v2) /\
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2.S.ms_heap)) /\
check_if_consumes_fixed_time_outs_implicit i ts_orig t_out /\
publicValuesAreSame ts_orig.lts s1_orig s2_orig /\
publicValuesAreSame ts.lts s1 s2
))
(ensures (
let s1' = S.instr_write_output_implicit i v1 s1_orig s1 in
let s2' = S.instr_write_output_implicit i v2 s2_orig s2 in
let ts' = instr_set_taint_implicit i ts t_out in
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1'.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2'.S.ms_heap)) /\
publicValuesAreSame ts'.lts s1' s2'
))
=
allow_inversion maddr;
allow_inversion tmaddr;
allow_inversion operand64;
allow_inversion operand128;
lemma_preserve_valid64 (heap_get s1_orig.S.ms_heap) (heap_get s1.S.ms_heap);
lemma_preserve_valid64 (heap_get s2_orig.S.ms_heap) (heap_get s2.S.ms_heap);
lemma_preserve_valid128 (heap_get s1_orig.S.ms_heap) (heap_get s1.S.ms_heap);
lemma_preserve_valid128 (heap_get s2_orig.S.ms_heap) (heap_get s2.S.ms_heap);
reveal_opaque (`%S.valid_addr128) S.valid_addr128;
()
#reset-options "--z3rlimit 80"
let rec lemma_instr_set_taints
(outs:list instr_out) (args:list instr_operand)
(vs1 vs2:instr_ret_t outs) (oprs:instr_operands_t outs args)
(ts_orig ts:analysis_taints) (t_out:taint)
(s1_orig s1 s2_orig s2:S.machine_state)
: Lemma
(requires (
let s1_state' = S.instr_write_outputs outs args vs1 oprs s1_orig s1 in
let s2_state' = S.instr_write_outputs outs args vs2 oprs s2_orig s2 in
s1_state'.S.ms_ok /\ s2_state'.S.ms_ok /\
(t_out == Public ==> vs1 == vs2) /\
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2.S.ms_heap)) /\
check_if_consumes_fixed_time_outs outs args oprs ts_orig t_out /\
publicValuesAreSame ts_orig.lts s1_orig s2_orig /\
publicValuesAreSame ts.lts s1 s2
))
(ensures (
let s1' = S.instr_write_outputs outs args vs1 oprs s1_orig s1 in
let s2' = S.instr_write_outputs outs args vs2 oprs s2_orig s2 in
let ts' = instr_set_taints outs args oprs ts t_out in
publicValuesAreSame ts'.lts s1' s2'
))
=
match outs with
| [] -> ()
| (_, i)::outs ->
(
let ((v1:instr_val_t i), (vs1:instr_ret_t outs)) =
match outs with
| [] -> (vs1, ())
| _::_ -> let vs1 = coerce vs1 in (fst vs1, snd vs1)
in
let ((v2:instr_val_t i), (vs2:instr_ret_t outs)) =
match outs with
| [] -> (vs2, ())
| _::_ -> let vs2 = coerce vs2 in (fst vs2, snd vs2)
in
match i with
| IOpEx i ->
let (o, oprs):instr_operand_t i & instr_operands_t outs args = coerce oprs in
let s1' = S.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = S.instr_write_output_explicit i v2 o s2_orig s2 in
lemma_instr_write_outputs_ok outs args vs1 oprs s1_orig s1';
lemma_instr_write_outputs_ok outs args vs2 oprs s2_orig s2';
let ts' = instr_set_taint_explicit i o ts t_out in
lemma_instr_set_taints_explicit i v1 v2 o ts_orig ts t_out s1_orig s1 s2_orig s2;
lemma_instr_set_taints outs args vs1 vs2 oprs ts_orig ts' t_out s1_orig s1' s2_orig s2'
| IOpIm i ->
let s1' = S.instr_write_output_implicit i v1 s1_orig s1 in
let s2' = S.instr_write_output_implicit i v2 s2_orig s2 in
lemma_instr_write_outputs_ok outs args vs1 (coerce oprs) s1_orig s1';
lemma_instr_write_outputs_ok outs args vs2 (coerce oprs) s2_orig s2';
let ts' = instr_set_taint_implicit i ts t_out in
lemma_instr_set_taints_implicit i v1 v2 ts_orig ts t_out s1_orig s1 s2_orig s2;
lemma_instr_set_taints outs args vs1 vs2 (coerce oprs) ts_orig ts' t_out s1_orig s1' s2_orig s2'
)
let check_if_instr_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Instr? ins)
(ensures ins_consumes_fixed_time ins ts)
=
let BC.Instr (InstrTypeRecord #outs #args #havoc_flags iins) oprs _ = ins in
let t = inouts_taint outs args oprs ts in
let b = check_if_consumes_fixed_time_outs outs args oprs ts t in
let AnalysisTaints (LeakageTaints rs flags cf ovf) rts = ts in
let flags = match havoc_flags with | HavocFlags -> Secret | PreserveFlags -> flags in
let cf = match havoc_flags with | HavocFlags -> Secret | PreserveFlags -> cf in
let ovf = match havoc_flags with | HavocFlags -> Secret | PreserveFlags -> ovf in
let ts = AnalysisTaints (LeakageTaints rs flags cf ovf) rts in
(b, instr_set_taints outs args oprs ts t)
let coerce_to_normal (#a:Type0) (x:a) : y:(normal a){x == y} = x
let check_if_xor_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Instr? ins /\ S.AnnotateXor64? (BC.Instr?.annotation ins))
(ensures ins_consumes_fixed_time ins ts)
=
let BC.Instr (InstrTypeRecord #outs #args #havoc_flags iins) oprs (S.AnnotateXor64 eq) = ins in
let oprs:normal (instr_operands_t [inOut op64; out opFlagsCf; out opFlagsOf] [op64]) =
coerce_to_normal #(instr_operands_t [inOut op64; out opFlagsCf; out opFlagsOf] [op64]) oprs in
let (o1, (o2, ())) = oprs in
if o1 = o2 then
let t = Public in
let b = check_if_consumes_fixed_time_outs outs args oprs ts t in
let AnalysisTaints (LeakageTaints rs _ _ _) rts = ts in
let ts = AnalysisTaints (LeakageTaints rs Secret Public Public) rts in
(b, instr_set_taints outs args oprs ts t)
else
check_if_instr_consumes_fixed_time ins ts
let check_if_pxor_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Instr? ins /\ S.AnnotatePxor? (BC.Instr?.annotation ins))
(ensures ins_consumes_fixed_time ins ts)
=
let BC.Instr (InstrTypeRecord #outs #args #havoc_flags iins) oprs (S.AnnotatePxor eq) = ins in
let oprs:normal (instr_operands_t [inOut opXmm] [opXmm]) =
coerce_to_normal #(instr_operands_t [inOut opXmm] [opXmm]) oprs in
let (o1, (o2, ())) = oprs in
if o1 = o2 then
let t = Public in
let b = check_if_consumes_fixed_time_outs outs args oprs ts t in
let AnalysisTaints (LeakageTaints rs ft cft oft) rts = ts in
let ts = AnalysisTaints (LeakageTaints rs ft cft oft) rts in
(b, instr_set_taints outs args oprs ts t)
else
check_if_instr_consumes_fixed_time ins ts
let check_if_vpxor_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Instr? ins /\ S.AnnotateVPxor? (BC.Instr?.annotation ins))
(ensures ins_consumes_fixed_time ins ts)
=
let BC.Instr (InstrTypeRecord #outs #args #havoc_flags iins) oprs (S.AnnotateVPxor eq) = ins in
let oprs:normal (instr_operands_t [out opXmm] [opXmm; opXmm]) =
coerce_to_normal #(instr_operands_t [out opXmm] [opXmm; opXmm]) oprs in
let (_, (o2, (o3, ()))) = oprs in
if o2 = o3 then
let t = Public in
let b = check_if_consumes_fixed_time_outs outs args oprs ts t in
let AnalysisTaints (LeakageTaints rs ft cft oft) rts = ts in
let ts = AnalysisTaints (LeakageTaints rs ft cft oft) rts in
(b, instr_set_taints outs args oprs ts t)
else
check_if_instr_consumes_fixed_time ins ts
let check_if_alloc_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Alloc? ins)
(ensures ins_consumes_fixed_time ins ts)
=
(true, ts)
let check_if_dealloc_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Dealloc? ins)
(ensures ins_consumes_fixed_time ins ts)
=
(true, ts)
#reset-options "--initial_ifuel 3 --max_ifuel 3 --initial_fuel 4 --max_fuel 4 --z3rlimit 80"
let check_if_push_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Push? ins)
(ensures ins_consumes_fixed_time ins ts)
=
let BC.Push src t_stk = ins in
let t_out = operand_taint 0 src ts in
(Public? (Vale.Lib.MapTree.sel ts.rts reg_Rsp) && operand_does_not_use_secrets src ts && (t_out = Public || t_stk = Secret), ts)
let check_if_pop_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Pop? ins)
(ensures ins_consumes_fixed_time ins ts)
=
let BC.Pop dst t_stk = ins in
let allowed = operand_taint_allowed dst t_stk in
(Public? (Vale.Lib.MapTree.sel ts.rts reg_Rsp) && operand_does_not_use_secrets dst ts && allowed, set_taint 0 dst ts t_stk)
let check_if_ins_consumes_fixed_time ins ts =
match ins with
| BC.Instr _ _ (S.AnnotateXor64 _) -> check_if_xor_consumes_fixed_time ins ts
| BC.Instr _ _ (S.AnnotatePxor _) -> check_if_pxor_consumes_fixed_time ins ts
| BC.Instr _ _ (S.AnnotateVPxor _) -> check_if_vpxor_consumes_fixed_time ins ts
| BC.Instr _ _ _ -> check_if_instr_consumes_fixed_time ins ts
| BC.Push _ _ -> check_if_push_consumes_fixed_time ins ts
| BC.Pop _ _ -> check_if_pop_consumes_fixed_time ins ts
| BC.Alloc _ -> check_if_alloc_consumes_fixed_time ins ts
| BC.Dealloc _ -> check_if_dealloc_consumes_fixed_time ins ts
#reset-options "--initial_ifuel 1 --max_ifuel 1 --initial_fuel 1 --max_fuel 1 --z3rlimit 100"
let lemma_instr_leakage_free (ts:analysis_taints) (ins:S.ins) : Lemma
(requires BC.Instr? ins)
(ensures (
let (b, ts') = check_if_instr_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts
))
=
let (b, ts') = check_if_instr_consumes_fixed_time ins ts in
if b then
(
let code = Ins ins in
let lem (s1 s2:S.machine_state) (fuel:nat) : Lemma
(requires is_explicit_leakage_free_lhs code fuel ts.lts ts'.lts s1 s2)
(ensures is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)
[SMTPat (is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)]
=
let BC.Instr (InstrTypeRecord #outs #args #havoc_flags i) oprs _ = ins in
let t_out = inouts_taint outs args oprs ts in
let s1 = {s1 with S.ms_trace = []} in
let s2 = {s2 with S.ms_trace = []} in
let Some vs1 = S.instr_apply_eval outs args (instr_eval i) oprs s1 in
let Some vs2 = S.instr_apply_eval outs args (instr_eval i) oprs s2 in
let s1' =
match havoc_flags with
| HavocFlags -> {s1 with S.ms_flags = S.havoc_flags}
| PreserveFlags -> s1
in
let s2' =
match havoc_flags with
| HavocFlags -> {s2 with S.ms_flags = S.havoc_flags}
| PreserveFlags -> s2
in
let AnalysisTaints (LeakageTaints rs flags cf ovf) rts = ts in
let flags = match havoc_flags with | HavocFlags -> Secret | PreserveFlags -> flags in
let cf = match havoc_flags with | HavocFlags -> Secret | PreserveFlags -> cf in
let ovf = match havoc_flags with | HavocFlags -> Secret | PreserveFlags -> ovf in
let ts_havoc = AnalysisTaints (LeakageTaints rs flags cf ovf) rts in
if t_out = Secret then
(
lemma_instr_set_taints outs args vs1 vs2 oprs ts ts_havoc t_out s1 s1' s2 s2';
()
)
else
(
let vs = vs1 in
lemma_inouts_taint outs outs args (instr_eval i) oprs ts s1 s2;
lemma_instr_set_taints outs args vs vs oprs ts ts_havoc t_out s1 s1' s2 s2';
()
)
in
// assert (isExplicitLeakageFree (Ins ins) ts ts');
()
)
let lemma_dealloc_leakage_free (ts:analysis_taints) (ins:S.ins) : Lemma
(requires BC.Dealloc? ins)
(ensures (
let (b, ts') = check_if_dealloc_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts
))
=
let (b, ts') = check_if_dealloc_consumes_fixed_time ins ts in
if b then
(
let code = Ins ins in
let lem (s1 s2:S.machine_state) (fuel:nat) : Lemma
(requires is_explicit_leakage_free_lhs code fuel ts.lts ts'.lts s1 s2)
(ensures is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)
[SMTPat (is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)]
=
let BC.Dealloc n = ins in
let s1' = Some?.v (machine_eval_code code fuel s1) in
let s2' = Some?.v (machine_eval_code code fuel s2) in
let S.Machine_stack _ stack1 = s1.S.ms_stack in
let S.Machine_stack _ stack2 = s2.S.ms_stack in
let S.Machine_stack _ stack1' = s1'.S.ms_stack in
let S.Machine_stack _ stack2' = s2'.S.ms_stack in
let aux (x:int) : Lemma
(requires publicStackValueIsSame stack1 stack2 s1.S.ms_stackTaint s2.S.ms_stackTaint x)
(ensures publicStackValueIsSame stack1' stack2' s1'.S.ms_stackTaint s2'.S.ms_stackTaint x)
=
Classical.forall_intro (fun s -> Vale.Lib.Set.lemma_sel_restrict s stack1 x);
Classical.forall_intro (fun s -> Vale.Lib.Set.lemma_sel_restrict s stack2 x)
in Classical.forall_intro (Classical.move_requires aux)
in
()
)
let lemma_push_leakage_free (ts:analysis_taints) (ins:S.ins) : Lemma
(requires BC.Push? ins)
(ensures (
let (b, ts') = check_if_push_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts | false | false | Vale.X64.Leakage_Ins.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_push_leakage_free (ts: analysis_taints) (ins: S.ins)
: Lemma (requires BC.Push? ins)
(ensures
(let b, ts' = check_if_push_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts)) | [] | Vale.X64.Leakage_Ins.lemma_push_leakage_free | {
"file_name": "vale/code/arch/x64/Vale.X64.Leakage_Ins.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | ts: Vale.X64.Leakage_Helpers.analysis_taints -> ins: Vale.X64.Machine_Semantics_s.ins
-> FStar.Pervasives.Lemma (requires Push? ins)
(ensures
(let _ = Vale.X64.Leakage_Ins.check_if_push_consumes_fixed_time ins ts in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ b ts' = _ in
b ==>
Vale.X64.Leakage_s.isConstantTime (Vale.X64.Machine_s.Ins ins) (AnalysisTaints?.lts ts) /\
Vale.X64.Leakage_s.isLeakageFree (Vale.X64.Machine_s.Ins ins)
(AnalysisTaints?.lts ts)
(AnalysisTaints?.lts ts'))
<:
Type0)) | {
"end_col": 3,
"end_line": 744,
"start_col": 3,
"start_line": 710
} |
FStar.Pervasives.Lemma | val lemma_vpxor_leakage_free (ts: analysis_taints) (ins: S.ins)
: Lemma (requires BC.Instr? ins /\ S.AnnotateVPxor? (BC.Instr?.annotation ins))
(ensures
(let b, ts' = check_if_vpxor_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts)) | [
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_vpxor_leakage_free (ts:analysis_taints) (ins:S.ins) : Lemma
(requires BC.Instr? ins /\ S.AnnotateVPxor? (BC.Instr?.annotation ins))
(ensures (
let (b, ts') = check_if_vpxor_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts
))
=
let BC.Instr (InstrTypeRecord #outs #args #havoc_flags iins) oprs (S.AnnotateVPxor eq) = ins in
let oprs:normal (instr_operands_t [out opXmm] [opXmm; opXmm]) =
coerce_to_normal #(instr_operands_t [out opXmm] [opXmm; opXmm]) oprs in
let (_, (o1, (o2, ()))) = oprs in
if o1 = o2 then
Vale.Arch.Types.lemma_quad32_xor()
else
lemma_instr_leakage_free ts ins | val lemma_vpxor_leakage_free (ts: analysis_taints) (ins: S.ins)
: Lemma (requires BC.Instr? ins /\ S.AnnotateVPxor? (BC.Instr?.annotation ins))
(ensures
(let b, ts' = check_if_vpxor_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts))
let lemma_vpxor_leakage_free (ts: analysis_taints) (ins: S.ins)
: Lemma (requires BC.Instr? ins /\ S.AnnotateVPxor? (BC.Instr?.annotation ins))
(ensures
(let b, ts' = check_if_vpxor_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts)) = | false | null | true | let BC.Instr (InstrTypeRecord #outs #args #havoc_flags iins) oprs (S.AnnotateVPxor eq) = ins in
let oprs:normal (instr_operands_t [out opXmm] [opXmm; opXmm]) =
coerce_to_normal #(instr_operands_t [out opXmm] [opXmm; opXmm]) oprs
in
let _, (o1, (o2, ())) = oprs in
if o1 = o2 then Vale.Arch.Types.lemma_quad32_xor () else lemma_instr_leakage_free ts ins | {
"checked_file": "Vale.X64.Leakage_Ins.fst.checked",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Leakage_s.fst.checked",
"Vale.X64.Leakage_Helpers.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Lib.MapTree.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Leakage_Ins.fst"
} | [
"lemma"
] | [
"Vale.X64.Leakage_Helpers.analysis_taints",
"Vale.X64.Machine_Semantics_s.ins",
"Prims.list",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.flag_havoc",
"Vale.X64.Instruction_s.instr_t",
"Vale.X64.Instruction_s.instr_operands_t",
"Vale.X64.Instruction_s.__proj__InstrTypeRecord__item__outs",
"Vale.X64.Instruction_s.InstrTypeRecord",
"Vale.X64.Instruction_s.__proj__InstrTypeRecord__item__args",
"Vale.X64.Machine_Semantics_s.equals_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_VPxor",
"Vale.X64.Machine_s.operand128",
"Prims.op_Equality",
"Vale.Arch.Types.lemma_quad32_xor",
"Prims.bool",
"Vale.X64.Leakage_Ins.lemma_instr_leakage_free",
"Prims.unit",
"FStar.Pervasives.norm",
"FStar.Pervasives.norm_step",
"FStar.Pervasives.zeta",
"FStar.Pervasives.iota",
"FStar.Pervasives.delta_attr",
"Prims.string",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Instruction_s.instr_operand_inout",
"Vale.X64.Instruction_s.Out",
"Vale.X64.Instruction_s.IOpEx",
"Vale.X64.Instruction_s.IOpXmm",
"Vale.X64.Leakage_Ins.coerce_to_normal",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Bytes_Code_s.uu___is_Instr",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Vale.X64.Machine_Semantics_s.uu___is_AnnotateVPxor",
"Vale.X64.Bytes_Code_s.__proj__Instr__item__i",
"Vale.X64.Bytes_Code_s.__proj__Instr__item__annotation",
"Prims.squash",
"Prims.l_imp",
"Vale.X64.Leakage_s.isConstantTime",
"Vale.X64.Machine_s.Ins",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Bytes_Code_s.ocmp",
"Vale.X64.Leakage_Helpers.__proj__AnalysisTaints__item__lts",
"Vale.X64.Leakage_s.isLeakageFree",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.Leakage_Ins.check_if_vpxor_consumes_fixed_time",
"FStar.Pervasives.pattern"
] | [] | module Vale.X64.Leakage_Ins
open FStar.Mul
open Vale.Arch.MachineHeap_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
module BC = Vale.X64.Bytes_Code_s
module S = Vale.X64.Machine_Semantics_s
open Vale.X64.Leakage_s
open Vale.X64.Leakage_Helpers
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
unfold let obs_args = S.obs_args
unfold let obs_inouts = S.obs_inouts
unfold let machine_eval_code = S.machine_eval_code
let reveal_machine_eval_code_ins (i:S.ins) (s:S.machine_state) : Lemma
(requires True)
(ensures S.machine_eval_code_ins i s == S.machine_eval_code_ins_def i s)
[SMTPat (S.machine_eval_code_ins i s)]
=
reveal_opaque (`%S.machine_eval_code_ins) S.machine_eval_code_ins
let rec check_if_consumes_fixed_time_args
(args:list instr_operand) (oprs:instr_operands_t_args args) (ts:analysis_taints)
: Pure bool
(requires True)
(ensures fun b -> b ==> (forall (s1 s2:S.machine_state).{:pattern (constTimeInvariant ts.lts s1 s2)}
constTimeInvariant ts.lts s1 s2 ==> obs_args args oprs s1 == obs_args args oprs s2))
=
allow_inversion maddr;
allow_inversion tmaddr;
match args with
| [] -> true
| (IOpEx i)::args ->
let ((o:instr_operand_t i), (oprs:instr_operands_t_args args)) = coerce oprs in
let b' =
match i with
| IOp64 -> operand_does_not_use_secrets #nat64 #reg_64 o ts
| IOpXmm -> operand_does_not_use_secrets #quad32 #reg_xmm o ts
in
let b'' = check_if_consumes_fixed_time_args args oprs ts in
b' && b''
| (IOpIm i)::args ->
let b' =
match i with
| IOp64One o -> operand_does_not_use_secrets o ts
| IOpXmmOne o -> operand_does_not_use_secrets o ts
| IOpFlagsCf -> true
| IOpFlagsOf -> true
in
let b'' = check_if_consumes_fixed_time_args args (coerce oprs) ts in
b' && b''
let check_if_consumes_fixed_time_outs_explicit
(i:instr_operand_explicit) (o:instr_operand_t i)
(ts:analysis_taints) (t_out:taint)
: bool
=
match i with
| IOp64 -> operand_does_not_use_secrets #nat64 #reg_64 o ts && operand_taint_allowed #nat64 #reg_64 o t_out
| IOpXmm -> operand_does_not_use_secrets #quad32 #reg_xmm o ts && operand_taint_allowed #quad32 #reg_xmm o t_out
let check_if_consumes_fixed_time_outs_implicit
(i:instr_operand_implicit) (ts:analysis_taints) (t_out:taint)
: bool
=
match i with
| IOp64One o -> operand_does_not_use_secrets o ts && operand_taint_allowed o t_out
| IOpXmmOne o -> operand_does_not_use_secrets o ts && operand_taint_allowed o t_out
| IOpFlagsCf -> true
| IOpFlagsOf -> true
let rec check_if_consumes_fixed_time_outs
(outs:list instr_out) (args:list instr_operand) (oprs:instr_operands_t outs args)
(ts:analysis_taints) (t_out:taint)
: Pure bool
(requires True)
(ensures fun b -> b ==> (forall (s1 s2:S.machine_state).{:pattern (constTimeInvariant ts.lts s1 s2)}
constTimeInvariant ts.lts s1 s2 ==> obs_inouts outs args oprs s1 == obs_inouts outs args oprs s2))
=
allow_inversion maddr;
allow_inversion tmaddr;
allow_inversion operand64;
allow_inversion operand128;
match outs with
| [] -> check_if_consumes_fixed_time_args args oprs ts
| (_, IOpEx i)::outs ->
let ((o:instr_operand_t i), (oprs:instr_operands_t outs args)) = coerce oprs in
let b' = check_if_consumes_fixed_time_outs_explicit i o ts t_out in
let b'' = check_if_consumes_fixed_time_outs outs args oprs ts t_out in
b' && b''
| (_, IOpIm i)::outs ->
let b' = check_if_consumes_fixed_time_outs_implicit i ts t_out in
let b'' = check_if_consumes_fixed_time_outs outs args (coerce oprs) ts t_out in
b' && b''
#restart-solver
#reset-options "--z3rlimit 300"
let rec lemma_args_taint
(outs:list instr_out) (args:list instr_operand)
(f:instr_args_t outs args) (oprs:instr_operands_t_args args)
(ts:analysis_taints) (s1 s2:S.machine_state)
: Lemma
(requires
constTimeInvariant ts.lts s1 s2 /\
Some? (S.instr_apply_eval_args outs args f oprs s1) /\
Some? (S.instr_apply_eval_args outs args f oprs s2) /\
check_if_consumes_fixed_time_args args oprs ts /\
args_taint args oprs ts == Public)
(ensures
S.instr_apply_eval_args outs args f oprs s1 ==
S.instr_apply_eval_args outs args f oprs s2)
=
allow_inversion maddr;
allow_inversion tmaddr;
allow_inversion operand64;
allow_inversion operand128;
match args with
| [] -> ()
| i::args ->
let (v1, v2, oprs) : option (instr_val_t i) & option (instr_val_t i) & instr_operands_t_args args =
match i with
| IOpEx i ->
let (o, (oprs:instr_operands_t_args args)) = coerce oprs in
(
S.instr_eval_operand_explicit i o s1,
S.instr_eval_operand_explicit i o s2,
oprs)
| IOpIm i ->
let oprs = coerce oprs in (
S.instr_eval_operand_implicit i s1,
S.instr_eval_operand_implicit i s2,
oprs)
in
let f:arrow (instr_val_t i) (instr_args_t outs args) = coerce f in
S.get_heap_val32_reveal ();
S.get_heap_val64_reveal ();
S.get_heap_val128_reveal ();
assert (v1 == v2);
let Some v = v1 in
lemma_args_taint outs args (f v) oprs ts s1 s2
#restart-solver
let rec lemma_inouts_taint
(outs inouts:list instr_out) (args:list instr_operand)
(f:instr_inouts_t outs inouts args) (oprs:instr_operands_t inouts args)
(ts:analysis_taints) (s1 s2:S.machine_state)
: Lemma
(requires
constTimeInvariant ts.lts s1 s2 /\
Some? (S.instr_apply_eval_inouts outs inouts args f oprs s1) /\
Some? (S.instr_apply_eval_inouts outs inouts args f oprs s2) /\
check_if_consumes_fixed_time_outs inouts args oprs ts Public /\
inouts_taint inouts args oprs ts == Public)
(ensures
S.instr_apply_eval_inouts outs inouts args f oprs s1 ==
S.instr_apply_eval_inouts outs inouts args f oprs s2)
=
allow_inversion maddr;
allow_inversion tmaddr;
allow_inversion operand64;
allow_inversion operand128;
match inouts with
| [] -> lemma_args_taint outs args f oprs ts s1 s2
| (Out, i)::inouts ->
let oprs =
match i with
| IOpEx i -> snd #(instr_operand_t i) (coerce oprs)
| IOpIm i -> coerce oprs
in
lemma_inouts_taint outs inouts args (coerce f) oprs ts s1 s2
| (InOut, i)::inouts ->
let (v1, v2, oprs) : option (instr_val_t i) & option (instr_val_t i) & instr_operands_t inouts args =
match i with
| IOpEx i ->
let (o, (oprs:instr_operands_t inouts args)) = coerce oprs in
let oprs = coerce oprs in (
S.instr_eval_operand_explicit i o s1,
S.instr_eval_operand_explicit i o s2,
oprs)
| IOpIm i ->
let oprs = coerce oprs in (
S.instr_eval_operand_implicit i s1,
S.instr_eval_operand_implicit i s2,
oprs)
in
let f:arrow (instr_val_t i) (instr_inouts_t outs inouts args) = coerce f in
S.get_heap_val32_reveal ();
S.get_heap_val64_reveal ();
S.get_heap_val128_reveal ();
assert (v1 == v2);
let Some v = v1 in
lemma_inouts_taint outs inouts args (f v) oprs ts s1 s2
let instr_set_taint_explicit
(i:instr_operand_explicit) (o:instr_operand_t i) (ts:analysis_taints) (t:taint)
: analysis_taints =
match i with
| IOp64 -> set_taint 0 (o <: operand64) ts t
| IOpXmm -> set_taint 1 (o <: operand128) ts t
[@instr_attr]
let instr_set_taint_implicit (i:instr_operand_implicit) (ts:analysis_taints) (t:taint) : analysis_taints =
match i with
| IOp64One o -> set_taint 0 o ts t
| IOpXmmOne o -> set_taint 1 o ts t
| IOpFlagsCf -> set_taint_cf_and_flags ts t
| IOpFlagsOf -> set_taint_of_and_flags ts t
let rec instr_set_taints
(outs:list instr_out) (args:list instr_operand)
(oprs:instr_operands_t outs args) (ts:analysis_taints) (t:taint)
: analysis_taints =
match outs with
| [] -> ts
| (_, i)::outs ->
(
match i with
| IOpEx i ->
let oprs:instr_operand_t i & instr_operands_t outs args = coerce oprs in
instr_set_taints outs args (snd oprs) (instr_set_taint_explicit i (fst oprs) ts t) t
| IOpIm i -> instr_set_taints outs args (coerce oprs) (instr_set_taint_implicit i ts t) t
)
let rec lemma_instr_write_outputs_ok
(outs:list instr_out) (args:list instr_operand)
(vs:instr_ret_t outs) (oprs:instr_operands_t outs args) (s_orig s:S.machine_state)
: Lemma
(requires (S.instr_write_outputs outs args vs oprs s_orig s).S.ms_ok)
(ensures s.S.ms_ok)
=
match outs with
| [] -> ()
| (_, i)::outs ->
(
let ((v:instr_val_t i), (vs:instr_ret_t outs)) =
match outs with
| [] -> (vs, ())
| _::_ -> let vs = coerce vs in (fst vs, snd vs)
in
match i with
| IOpEx i ->
let oprs:instr_operand_t i & instr_operands_t outs args = coerce oprs in
let s' = S.instr_write_output_explicit i v (fst oprs) s_orig s in
lemma_instr_write_outputs_ok outs args vs (snd oprs) s_orig s'
| IOpIm i ->
let s' = S.instr_write_output_implicit i v s_orig s in
lemma_instr_write_outputs_ok outs args vs (coerce oprs) s_orig s'
)
[@"opaque_to_smt"]
let update_heap32_val (ptr:int) (v:Vale.Def.Types_s.nat32) (i:int) : Vale.Def.Types_s.nat8 =
let open Vale.Def.Words_s in
let open Vale.Def.Words.Four_s in
let v = nat_to_four 8 v in
match (i - ptr) with
| 0 -> v.lo0
| 1 -> v.lo1
| 2 -> v.hi2
| 3 -> v.hi3
| _ -> 0
let valid_addr32 (ptr:int) (mem:S.machine_heap) : bool =
S.valid_addr (ptr + 0) mem &&
S.valid_addr (ptr + 1) mem &&
S.valid_addr (ptr + 2) mem &&
S.valid_addr (ptr + 3) mem
let lemma_update_heap32_val (ptr:int) (v:Vale.Def.Types_s.nat32) (mem:S.machine_heap) (i:int) : Lemma
(requires True)
(ensures (S.update_heap32 ptr v mem).[i] ==
(if ptr <= i && i < ptr + 4 then update_heap32_val ptr v i else mem.[i]))
[SMTPat ((S.update_heap32 ptr v mem).[i])]
=
S.update_heap32_reveal ();
reveal_opaque (`%update_heap32_val) update_heap32_val
let lemma_update_heap32_domain (ptr:int) (v:Vale.Def.Types_s.nat32) (mem:S.machine_heap) : Lemma
(requires valid_addr32 ptr mem)
(ensures Map.domain (S.update_heap32 ptr v mem) == Map.domain mem)
[SMTPat (Map.domain (S.update_heap32 ptr v mem))]
=
S.update_heap32_reveal ();
assert (Set.equal (Map.domain (S.update_heap32 ptr v mem)) (Map.domain mem))
[@"opaque_to_smt"]
let update_heap64_val (ptr:int) (v:nat64) (i:int) : Vale.Def.Types_s.nat8 =
let open Vale.Def.Words_s in
let open Vale.Def.Words.Two_s in
let open Vale.Def.Words.Four_s in
let v = nat_to_two 32 v in
let lo = nat_to_four 8 v.lo in
let hi = nat_to_four 8 v.hi in
match (i - ptr) with
| 0 -> lo.lo0
| 1 -> lo.lo1
| 2 -> lo.hi2
| 3 -> lo.hi3
| 4 -> hi.lo0
| 5 -> hi.lo1
| 6 -> hi.hi2
| 7 -> hi.hi3
| _ -> 0
let lemma_update_heap64_val (ptr:int) (v:nat64) (mem:S.machine_heap) (i:int) : Lemma
(requires True)
(ensures
(S.update_heap64 ptr v mem).[i] ==
(if ptr <= i && i < ptr + 8 then update_heap64_val ptr v i else mem.[i])
)
[SMTPat ((S.update_heap64 ptr v mem).[i])]
=
S.update_heap64_reveal ();
reveal_opaque (`%update_heap64_val) update_heap64_val
let lemma_update_heap64_domain (ptr:int) (v:nat64) (mem:S.machine_heap) : Lemma
(requires S.valid_addr64 ptr mem)
(ensures Map.domain (S.update_heap64 ptr v mem) == Map.domain mem)
[SMTPat (Map.domain (S.update_heap64 ptr v mem))]
=
reveal_opaque (`%S.valid_addr64) S.valid_addr64;
S.update_heap64_reveal ();
assert (Set.equal (Map.domain (S.update_heap64 ptr v mem)) (Map.domain mem))
[@"opaque_to_smt"]
let update_heap128_val (ptr:int) (v:Vale.Def.Types_s.quad32) (i:int) : Vale.Def.Types_s.nat8 =
let open Vale.Def.Words_s in
let j = i - ptr in
if 0 <= j && j < 4 then update_heap32_val (ptr + 0 ) v.lo0 i else
if 4 <= j && j < 8 then update_heap32_val (ptr + 4 ) v.lo1 i else
if 8 <= j && j < 12 then update_heap32_val (ptr + 8 ) v.hi2 i else
if 12 <= j && j < 16 then update_heap32_val (ptr + 12) v.hi3 i else
0
let valid_addr128 (ptr:int) (mem:S.machine_heap) : bool =
valid_addr32 (ptr + 0) mem &&
valid_addr32 (ptr + 4) mem &&
valid_addr32 (ptr + 8) mem &&
valid_addr32 (ptr + 12) mem
let lemma_update_heap128_val (ptr:int) (v:Vale.Def.Types_s.quad32) (mem:S.machine_heap) (i:int) : Lemma
(requires True)
(ensures
(S.update_heap128 ptr v mem).[i] ==
(if ptr <= i && i < ptr + 16 then update_heap128_val ptr v i else mem.[i])
)
[SMTPat ((S.update_heap128 ptr v mem).[i])]
=
S.update_heap128_reveal ();
reveal_opaque (`%update_heap128_val) update_heap128_val
let lemma_update_heap128_domain (ptr:int) (v:Vale.Def.Types_s.quad32) (mem:S.machine_heap) : Lemma
(requires valid_addr128 ptr mem)
(ensures Map.domain (S.update_heap128 ptr v mem) == Map.domain mem)
[SMTPat (S.update_heap128 ptr v mem)]
=
S.update_heap128_reveal ();
assert (Set.equal (Map.domain (S.update_heap128 ptr v mem)) (Map.domain mem))
let lemma_preserve_valid64 (m m':S.machine_heap) : Lemma
(requires Set.equal (Map.domain m) (Map.domain m'))
(ensures (forall (i:int).{:pattern (S.valid_addr64 i m')}
S.valid_addr64 i m ==> S.valid_addr64 i m'))
=
reveal_opaque (`%S.valid_addr64) S.valid_addr64
let lemma_preserve_valid128 (m m':S.machine_heap) : Lemma
(requires Set.equal (Map.domain m) (Map.domain m'))
(ensures (forall (i:int).{:pattern (S.valid_addr128 i m')}
S.valid_addr128 i m ==> S.valid_addr128 i m'))
=
reveal_opaque (`%S.valid_addr128) S.valid_addr128
let lemma_instr_set_taints_explicit
(i:instr_operand_explicit) (v1 v2:instr_val_t (IOpEx i)) (o:instr_operand_t i)
(ts_orig ts:analysis_taints) (t_out:taint)
(s1_orig s1 s2_orig s2:S.machine_state)
: Lemma
(requires (
let s1' = S.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = S.instr_write_output_explicit i v2 o s2_orig s2 in
s1'.S.ms_ok /\ s2'.S.ms_ok /\
(t_out == Public ==> v1 == v2) /\
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2.S.ms_heap)) /\
check_if_consumes_fixed_time_outs_explicit i o ts_orig t_out /\
publicValuesAreSame ts_orig.lts s1_orig s2_orig /\
publicValuesAreSame ts.lts s1 s2
))
(ensures (
let s1' = S.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = S.instr_write_output_explicit i v2 o s2_orig s2 in
let ts' = instr_set_taint_explicit i o ts t_out in
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1'.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2'.S.ms_heap)) /\
publicValuesAreSame ts'.lts s1' s2'
))
=
allow_inversion maddr;
allow_inversion tmaddr;
lemma_preserve_valid64 (heap_get s1_orig.S.ms_heap) (heap_get s1.S.ms_heap);
lemma_preserve_valid64 (heap_get s2_orig.S.ms_heap) (heap_get s2.S.ms_heap);
lemma_preserve_valid128 (heap_get s1_orig.S.ms_heap) (heap_get s1.S.ms_heap);
lemma_preserve_valid128 (heap_get s2_orig.S.ms_heap) (heap_get s2.S.ms_heap);
reveal_opaque (`%S.valid_addr128) S.valid_addr128;
()
let lemma_instr_set_taints_implicit
(i:instr_operand_implicit) (v1 v2:instr_val_t (IOpIm i))
(ts_orig ts:analysis_taints) (t_out:taint)
(s1_orig s1 s2_orig s2:S.machine_state)
: Lemma
(requires (
let s1' = S.instr_write_output_implicit i v1 s1_orig s1 in
let s2' = S.instr_write_output_implicit i v2 s2_orig s2 in
s1'.S.ms_ok /\ s2'.S.ms_ok /\
(t_out == Public ==> v1 == v2) /\
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2.S.ms_heap)) /\
check_if_consumes_fixed_time_outs_implicit i ts_orig t_out /\
publicValuesAreSame ts_orig.lts s1_orig s2_orig /\
publicValuesAreSame ts.lts s1 s2
))
(ensures (
let s1' = S.instr_write_output_implicit i v1 s1_orig s1 in
let s2' = S.instr_write_output_implicit i v2 s2_orig s2 in
let ts' = instr_set_taint_implicit i ts t_out in
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1'.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2'.S.ms_heap)) /\
publicValuesAreSame ts'.lts s1' s2'
))
=
allow_inversion maddr;
allow_inversion tmaddr;
allow_inversion operand64;
allow_inversion operand128;
lemma_preserve_valid64 (heap_get s1_orig.S.ms_heap) (heap_get s1.S.ms_heap);
lemma_preserve_valid64 (heap_get s2_orig.S.ms_heap) (heap_get s2.S.ms_heap);
lemma_preserve_valid128 (heap_get s1_orig.S.ms_heap) (heap_get s1.S.ms_heap);
lemma_preserve_valid128 (heap_get s2_orig.S.ms_heap) (heap_get s2.S.ms_heap);
reveal_opaque (`%S.valid_addr128) S.valid_addr128;
()
#reset-options "--z3rlimit 80"
let rec lemma_instr_set_taints
(outs:list instr_out) (args:list instr_operand)
(vs1 vs2:instr_ret_t outs) (oprs:instr_operands_t outs args)
(ts_orig ts:analysis_taints) (t_out:taint)
(s1_orig s1 s2_orig s2:S.machine_state)
: Lemma
(requires (
let s1_state' = S.instr_write_outputs outs args vs1 oprs s1_orig s1 in
let s2_state' = S.instr_write_outputs outs args vs2 oprs s2_orig s2 in
s1_state'.S.ms_ok /\ s2_state'.S.ms_ok /\
(t_out == Public ==> vs1 == vs2) /\
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2.S.ms_heap)) /\
check_if_consumes_fixed_time_outs outs args oprs ts_orig t_out /\
publicValuesAreSame ts_orig.lts s1_orig s2_orig /\
publicValuesAreSame ts.lts s1 s2
))
(ensures (
let s1' = S.instr_write_outputs outs args vs1 oprs s1_orig s1 in
let s2' = S.instr_write_outputs outs args vs2 oprs s2_orig s2 in
let ts' = instr_set_taints outs args oprs ts t_out in
publicValuesAreSame ts'.lts s1' s2'
))
=
match outs with
| [] -> ()
| (_, i)::outs ->
(
let ((v1:instr_val_t i), (vs1:instr_ret_t outs)) =
match outs with
| [] -> (vs1, ())
| _::_ -> let vs1 = coerce vs1 in (fst vs1, snd vs1)
in
let ((v2:instr_val_t i), (vs2:instr_ret_t outs)) =
match outs with
| [] -> (vs2, ())
| _::_ -> let vs2 = coerce vs2 in (fst vs2, snd vs2)
in
match i with
| IOpEx i ->
let (o, oprs):instr_operand_t i & instr_operands_t outs args = coerce oprs in
let s1' = S.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = S.instr_write_output_explicit i v2 o s2_orig s2 in
lemma_instr_write_outputs_ok outs args vs1 oprs s1_orig s1';
lemma_instr_write_outputs_ok outs args vs2 oprs s2_orig s2';
let ts' = instr_set_taint_explicit i o ts t_out in
lemma_instr_set_taints_explicit i v1 v2 o ts_orig ts t_out s1_orig s1 s2_orig s2;
lemma_instr_set_taints outs args vs1 vs2 oprs ts_orig ts' t_out s1_orig s1' s2_orig s2'
| IOpIm i ->
let s1' = S.instr_write_output_implicit i v1 s1_orig s1 in
let s2' = S.instr_write_output_implicit i v2 s2_orig s2 in
lemma_instr_write_outputs_ok outs args vs1 (coerce oprs) s1_orig s1';
lemma_instr_write_outputs_ok outs args vs2 (coerce oprs) s2_orig s2';
let ts' = instr_set_taint_implicit i ts t_out in
lemma_instr_set_taints_implicit i v1 v2 ts_orig ts t_out s1_orig s1 s2_orig s2;
lemma_instr_set_taints outs args vs1 vs2 (coerce oprs) ts_orig ts' t_out s1_orig s1' s2_orig s2'
)
let check_if_instr_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Instr? ins)
(ensures ins_consumes_fixed_time ins ts)
=
let BC.Instr (InstrTypeRecord #outs #args #havoc_flags iins) oprs _ = ins in
let t = inouts_taint outs args oprs ts in
let b = check_if_consumes_fixed_time_outs outs args oprs ts t in
let AnalysisTaints (LeakageTaints rs flags cf ovf) rts = ts in
let flags = match havoc_flags with | HavocFlags -> Secret | PreserveFlags -> flags in
let cf = match havoc_flags with | HavocFlags -> Secret | PreserveFlags -> cf in
let ovf = match havoc_flags with | HavocFlags -> Secret | PreserveFlags -> ovf in
let ts = AnalysisTaints (LeakageTaints rs flags cf ovf) rts in
(b, instr_set_taints outs args oprs ts t)
let coerce_to_normal (#a:Type0) (x:a) : y:(normal a){x == y} = x
let check_if_xor_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Instr? ins /\ S.AnnotateXor64? (BC.Instr?.annotation ins))
(ensures ins_consumes_fixed_time ins ts)
=
let BC.Instr (InstrTypeRecord #outs #args #havoc_flags iins) oprs (S.AnnotateXor64 eq) = ins in
let oprs:normal (instr_operands_t [inOut op64; out opFlagsCf; out opFlagsOf] [op64]) =
coerce_to_normal #(instr_operands_t [inOut op64; out opFlagsCf; out opFlagsOf] [op64]) oprs in
let (o1, (o2, ())) = oprs in
if o1 = o2 then
let t = Public in
let b = check_if_consumes_fixed_time_outs outs args oprs ts t in
let AnalysisTaints (LeakageTaints rs _ _ _) rts = ts in
let ts = AnalysisTaints (LeakageTaints rs Secret Public Public) rts in
(b, instr_set_taints outs args oprs ts t)
else
check_if_instr_consumes_fixed_time ins ts
let check_if_pxor_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Instr? ins /\ S.AnnotatePxor? (BC.Instr?.annotation ins))
(ensures ins_consumes_fixed_time ins ts)
=
let BC.Instr (InstrTypeRecord #outs #args #havoc_flags iins) oprs (S.AnnotatePxor eq) = ins in
let oprs:normal (instr_operands_t [inOut opXmm] [opXmm]) =
coerce_to_normal #(instr_operands_t [inOut opXmm] [opXmm]) oprs in
let (o1, (o2, ())) = oprs in
if o1 = o2 then
let t = Public in
let b = check_if_consumes_fixed_time_outs outs args oprs ts t in
let AnalysisTaints (LeakageTaints rs ft cft oft) rts = ts in
let ts = AnalysisTaints (LeakageTaints rs ft cft oft) rts in
(b, instr_set_taints outs args oprs ts t)
else
check_if_instr_consumes_fixed_time ins ts
let check_if_vpxor_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Instr? ins /\ S.AnnotateVPxor? (BC.Instr?.annotation ins))
(ensures ins_consumes_fixed_time ins ts)
=
let BC.Instr (InstrTypeRecord #outs #args #havoc_flags iins) oprs (S.AnnotateVPxor eq) = ins in
let oprs:normal (instr_operands_t [out opXmm] [opXmm; opXmm]) =
coerce_to_normal #(instr_operands_t [out opXmm] [opXmm; opXmm]) oprs in
let (_, (o2, (o3, ()))) = oprs in
if o2 = o3 then
let t = Public in
let b = check_if_consumes_fixed_time_outs outs args oprs ts t in
let AnalysisTaints (LeakageTaints rs ft cft oft) rts = ts in
let ts = AnalysisTaints (LeakageTaints rs ft cft oft) rts in
(b, instr_set_taints outs args oprs ts t)
else
check_if_instr_consumes_fixed_time ins ts
let check_if_alloc_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Alloc? ins)
(ensures ins_consumes_fixed_time ins ts)
=
(true, ts)
let check_if_dealloc_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Dealloc? ins)
(ensures ins_consumes_fixed_time ins ts)
=
(true, ts)
#reset-options "--initial_ifuel 3 --max_ifuel 3 --initial_fuel 4 --max_fuel 4 --z3rlimit 80"
let check_if_push_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Push? ins)
(ensures ins_consumes_fixed_time ins ts)
=
let BC.Push src t_stk = ins in
let t_out = operand_taint 0 src ts in
(Public? (Vale.Lib.MapTree.sel ts.rts reg_Rsp) && operand_does_not_use_secrets src ts && (t_out = Public || t_stk = Secret), ts)
let check_if_pop_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Pop? ins)
(ensures ins_consumes_fixed_time ins ts)
=
let BC.Pop dst t_stk = ins in
let allowed = operand_taint_allowed dst t_stk in
(Public? (Vale.Lib.MapTree.sel ts.rts reg_Rsp) && operand_does_not_use_secrets dst ts && allowed, set_taint 0 dst ts t_stk)
let check_if_ins_consumes_fixed_time ins ts =
match ins with
| BC.Instr _ _ (S.AnnotateXor64 _) -> check_if_xor_consumes_fixed_time ins ts
| BC.Instr _ _ (S.AnnotatePxor _) -> check_if_pxor_consumes_fixed_time ins ts
| BC.Instr _ _ (S.AnnotateVPxor _) -> check_if_vpxor_consumes_fixed_time ins ts
| BC.Instr _ _ _ -> check_if_instr_consumes_fixed_time ins ts
| BC.Push _ _ -> check_if_push_consumes_fixed_time ins ts
| BC.Pop _ _ -> check_if_pop_consumes_fixed_time ins ts
| BC.Alloc _ -> check_if_alloc_consumes_fixed_time ins ts
| BC.Dealloc _ -> check_if_dealloc_consumes_fixed_time ins ts
#reset-options "--initial_ifuel 1 --max_ifuel 1 --initial_fuel 1 --max_fuel 1 --z3rlimit 100"
let lemma_instr_leakage_free (ts:analysis_taints) (ins:S.ins) : Lemma
(requires BC.Instr? ins)
(ensures (
let (b, ts') = check_if_instr_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts
))
=
let (b, ts') = check_if_instr_consumes_fixed_time ins ts in
if b then
(
let code = Ins ins in
let lem (s1 s2:S.machine_state) (fuel:nat) : Lemma
(requires is_explicit_leakage_free_lhs code fuel ts.lts ts'.lts s1 s2)
(ensures is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)
[SMTPat (is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)]
=
let BC.Instr (InstrTypeRecord #outs #args #havoc_flags i) oprs _ = ins in
let t_out = inouts_taint outs args oprs ts in
let s1 = {s1 with S.ms_trace = []} in
let s2 = {s2 with S.ms_trace = []} in
let Some vs1 = S.instr_apply_eval outs args (instr_eval i) oprs s1 in
let Some vs2 = S.instr_apply_eval outs args (instr_eval i) oprs s2 in
let s1' =
match havoc_flags with
| HavocFlags -> {s1 with S.ms_flags = S.havoc_flags}
| PreserveFlags -> s1
in
let s2' =
match havoc_flags with
| HavocFlags -> {s2 with S.ms_flags = S.havoc_flags}
| PreserveFlags -> s2
in
let AnalysisTaints (LeakageTaints rs flags cf ovf) rts = ts in
let flags = match havoc_flags with | HavocFlags -> Secret | PreserveFlags -> flags in
let cf = match havoc_flags with | HavocFlags -> Secret | PreserveFlags -> cf in
let ovf = match havoc_flags with | HavocFlags -> Secret | PreserveFlags -> ovf in
let ts_havoc = AnalysisTaints (LeakageTaints rs flags cf ovf) rts in
if t_out = Secret then
(
lemma_instr_set_taints outs args vs1 vs2 oprs ts ts_havoc t_out s1 s1' s2 s2';
()
)
else
(
let vs = vs1 in
lemma_inouts_taint outs outs args (instr_eval i) oprs ts s1 s2;
lemma_instr_set_taints outs args vs vs oprs ts ts_havoc t_out s1 s1' s2 s2';
()
)
in
// assert (isExplicitLeakageFree (Ins ins) ts ts');
()
)
let lemma_dealloc_leakage_free (ts:analysis_taints) (ins:S.ins) : Lemma
(requires BC.Dealloc? ins)
(ensures (
let (b, ts') = check_if_dealloc_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts
))
=
let (b, ts') = check_if_dealloc_consumes_fixed_time ins ts in
if b then
(
let code = Ins ins in
let lem (s1 s2:S.machine_state) (fuel:nat) : Lemma
(requires is_explicit_leakage_free_lhs code fuel ts.lts ts'.lts s1 s2)
(ensures is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)
[SMTPat (is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)]
=
let BC.Dealloc n = ins in
let s1' = Some?.v (machine_eval_code code fuel s1) in
let s2' = Some?.v (machine_eval_code code fuel s2) in
let S.Machine_stack _ stack1 = s1.S.ms_stack in
let S.Machine_stack _ stack2 = s2.S.ms_stack in
let S.Machine_stack _ stack1' = s1'.S.ms_stack in
let S.Machine_stack _ stack2' = s2'.S.ms_stack in
let aux (x:int) : Lemma
(requires publicStackValueIsSame stack1 stack2 s1.S.ms_stackTaint s2.S.ms_stackTaint x)
(ensures publicStackValueIsSame stack1' stack2' s1'.S.ms_stackTaint s2'.S.ms_stackTaint x)
=
Classical.forall_intro (fun s -> Vale.Lib.Set.lemma_sel_restrict s stack1 x);
Classical.forall_intro (fun s -> Vale.Lib.Set.lemma_sel_restrict s stack2 x)
in Classical.forall_intro (Classical.move_requires aux)
in
()
)
let lemma_push_leakage_free (ts:analysis_taints) (ins:S.ins) : Lemma
(requires BC.Push? ins)
(ensures (
let (b, ts') = check_if_push_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts
))
=
let (b, ts') = check_if_push_consumes_fixed_time ins ts in
if b then
(
let code = Ins ins in
let lem (s1 s2:S.machine_state) (fuel:nat) : Lemma
(requires is_explicit_leakage_free_lhs code fuel ts.lts ts'.lts s1 s2)
(ensures is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)
[SMTPat (is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)]
=
let BC.Push src t_stk = ins in
let t_out = operand_taint 0 src ts in
let s1' = Some?.v (machine_eval_code code fuel s1) in
let s2' = Some?.v (machine_eval_code code fuel s2) in
let S.Machine_stack _ stack1 = s1.S.ms_stack in
let S.Machine_stack _ stack2 = s2.S.ms_stack in
let S.Machine_stack _ stack1' = s1'.S.ms_stack in
let S.Machine_stack _ stack2' = s2'.S.ms_stack in
let ptr1 = S.eval_reg_64 rRsp s1 - 8 in
let ptr2 = S.eval_reg_64 rRsp s2 - 8 in
let v1 = S.eval_operand src s1 in
let v2 = S.eval_operand src s2 in
assert (ptr1 == ptr2);
if t_out = Secret then ()
else (
let aux () : Lemma (v1 == v2)
= match src with
| OConst _ | OReg _ -> ()
| OMem (_, _) | OStack (_, _) -> S.get_heap_val64_reveal ()
in
aux()
)
in
()
)
#reset-options "--initial_ifuel 1 --max_ifuel 1 --initial_fuel 1 --max_fuel 1 --z3rlimit 100"
let lemma_pop_leakage_free (ts:analysis_taints) (ins:S.ins) : Lemma
(requires BC.Pop? ins)
(ensures (
let (b, ts') = check_if_pop_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts
))
=
let (b, ts') = check_if_pop_consumes_fixed_time ins ts in
if b then
(
let code = Ins ins in
let lem (s1 s2:S.machine_state) (fuel:nat) : Lemma
(requires is_explicit_leakage_free_lhs code fuel ts.lts ts'.lts s1 s2)
(ensures is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)
[SMTPat (is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)]
=
allow_inversion maddr;
allow_inversion tmaddr;
let BC.Pop dst t_stk = ins in
let s1' = Some?.v (machine_eval_code code fuel s1) in
let s2' = Some?.v (machine_eval_code code fuel s2) in
let stack_op = OStack (MReg reg_Rsp 0, Public) in
let v1 = S.eval_operand stack_op s1 in
let v2 = S.eval_operand stack_op s2 in
if t_stk = Public then (
S.get_heap_val64_reveal ();
assert (v1 == v2)
);
Classical.forall_intro_3 (fun s x (stack1:S.machine_heap) -> Vale.Lib.Set.lemma_sel_restrict s stack1 x);
Classical.forall_intro_3 (fun s x (stack2:S.machine_heap) -> Vale.Lib.Set.lemma_sel_restrict s stack2 x)
in
()
)
#reset-options "--initial_ifuel 2 --max_ifuel 2 --initial_fuel 4 --max_fuel 4 --z3rlimit 40"
let lemma_xor_leakage_free (ts:analysis_taints) (ins:S.ins) : Lemma
(requires BC.Instr? ins /\ S.AnnotateXor64? (BC.Instr?.annotation ins))
(ensures (
let (b, ts') = check_if_xor_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts
))
=
let BC.Instr (InstrTypeRecord #outs #args #havoc_flags iins) oprs (S.AnnotateXor64 eq) = ins in
let oprs:normal (instr_operands_t [inOut op64; out opFlagsCf; out opFlagsOf] [op64]) =
coerce_to_normal #(instr_operands_t [inOut op64; out opFlagsCf; out opFlagsOf] [op64]) oprs in
let (o1, (o2, ())) = oprs in
if o1 = o2 then
FStar.Classical.forall_intro_with_pat (fun n -> Vale.Def.Types_s.ixor n n) Vale.Arch.Types.lemma_BitwiseXorCancel64
else
lemma_instr_leakage_free ts ins
let lemma_pxor_leakage_free (ts:analysis_taints) (ins:S.ins) : Lemma
(requires BC.Instr? ins /\ S.AnnotatePxor? (BC.Instr?.annotation ins))
(ensures (
let (b, ts') = check_if_pxor_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts
))
=
let BC.Instr (InstrTypeRecord #outs #args #havoc_flags iins) oprs (S.AnnotatePxor eq) = ins in
let oprs:normal (instr_operands_t [inOut opXmm] [opXmm]) =
coerce_to_normal #(instr_operands_t [inOut opXmm] [opXmm]) oprs in
let (o1, (o2, ())) = oprs in
if o1 = o2 then
Vale.Arch.Types.lemma_quad32_xor()
else
lemma_instr_leakage_free ts ins
let lemma_vpxor_leakage_free (ts:analysis_taints) (ins:S.ins) : Lemma
(requires BC.Instr? ins /\ S.AnnotateVPxor? (BC.Instr?.annotation ins))
(ensures (
let (b, ts') = check_if_vpxor_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts | false | false | Vale.X64.Leakage_Ins.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 2,
"max_fuel": 4,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 40,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_vpxor_leakage_free (ts: analysis_taints) (ins: S.ins)
: Lemma (requires BC.Instr? ins /\ S.AnnotateVPxor? (BC.Instr?.annotation ins))
(ensures
(let b, ts' = check_if_vpxor_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts)) | [] | Vale.X64.Leakage_Ins.lemma_vpxor_leakage_free | {
"file_name": "vale/code/arch/x64/Vale.X64.Leakage_Ins.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | ts: Vale.X64.Leakage_Helpers.analysis_taints -> ins: Vale.X64.Machine_Semantics_s.ins
-> FStar.Pervasives.Lemma (requires Instr? ins /\ AnnotateVPxor? (Instr?.annotation ins))
(ensures
(let _ = Vale.X64.Leakage_Ins.check_if_vpxor_consumes_fixed_time ins ts in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ b ts' = _ in
b ==>
Vale.X64.Leakage_s.isConstantTime (Vale.X64.Machine_s.Ins ins) (AnalysisTaints?.lts ts) /\
Vale.X64.Leakage_s.isLeakageFree (Vale.X64.Machine_s.Ins ins)
(AnalysisTaints?.lts ts)
(AnalysisTaints?.lts ts'))
<:
Type0)) | {
"end_col": 35,
"end_line": 828,
"start_col": 3,
"start_line": 820
} |
FStar.Pervasives.Lemma | val lemma_xor_leakage_free (ts: analysis_taints) (ins: S.ins)
: Lemma (requires BC.Instr? ins /\ S.AnnotateXor64? (BC.Instr?.annotation ins))
(ensures
(let b, ts' = check_if_xor_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts)) | [
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_xor_leakage_free (ts:analysis_taints) (ins:S.ins) : Lemma
(requires BC.Instr? ins /\ S.AnnotateXor64? (BC.Instr?.annotation ins))
(ensures (
let (b, ts') = check_if_xor_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts
))
=
let BC.Instr (InstrTypeRecord #outs #args #havoc_flags iins) oprs (S.AnnotateXor64 eq) = ins in
let oprs:normal (instr_operands_t [inOut op64; out opFlagsCf; out opFlagsOf] [op64]) =
coerce_to_normal #(instr_operands_t [inOut op64; out opFlagsCf; out opFlagsOf] [op64]) oprs in
let (o1, (o2, ())) = oprs in
if o1 = o2 then
FStar.Classical.forall_intro_with_pat (fun n -> Vale.Def.Types_s.ixor n n) Vale.Arch.Types.lemma_BitwiseXorCancel64
else
lemma_instr_leakage_free ts ins | val lemma_xor_leakage_free (ts: analysis_taints) (ins: S.ins)
: Lemma (requires BC.Instr? ins /\ S.AnnotateXor64? (BC.Instr?.annotation ins))
(ensures
(let b, ts' = check_if_xor_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts))
let lemma_xor_leakage_free (ts: analysis_taints) (ins: S.ins)
: Lemma (requires BC.Instr? ins /\ S.AnnotateXor64? (BC.Instr?.annotation ins))
(ensures
(let b, ts' = check_if_xor_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts)) = | false | null | true | let BC.Instr (InstrTypeRecord #outs #args #havoc_flags iins) oprs (S.AnnotateXor64 eq) = ins in
let oprs:normal (instr_operands_t [inOut op64; out opFlagsCf; out opFlagsOf] [op64]) =
coerce_to_normal #(instr_operands_t [inOut op64; out opFlagsCf; out opFlagsOf] [op64]) oprs
in
let o1, (o2, ()) = oprs in
if o1 = o2
then
FStar.Classical.forall_intro_with_pat (fun n -> Vale.Def.Types_s.ixor n n)
Vale.Arch.Types.lemma_BitwiseXorCancel64
else lemma_instr_leakage_free ts ins | {
"checked_file": "Vale.X64.Leakage_Ins.fst.checked",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Leakage_s.fst.checked",
"Vale.X64.Leakage_Helpers.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Lib.MapTree.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Leakage_Ins.fst"
} | [
"lemma"
] | [
"Vale.X64.Leakage_Helpers.analysis_taints",
"Vale.X64.Machine_Semantics_s.ins",
"Prims.list",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.flag_havoc",
"Vale.X64.Instruction_s.instr_t",
"Vale.X64.Instruction_s.instr_operands_t",
"Vale.X64.Instruction_s.__proj__InstrTypeRecord__item__outs",
"Vale.X64.Instruction_s.InstrTypeRecord",
"Vale.X64.Instruction_s.__proj__InstrTypeRecord__item__args",
"Vale.X64.Machine_Semantics_s.equals_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.op64",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.opFlagsCf",
"Vale.X64.Instruction_s.opFlagsOf",
"Prims.Nil",
"Vale.X64.Instruction_s.HavocFlags",
"Vale.X64.Instructions_s.ins_Xor64",
"Vale.X64.Machine_s.operand64",
"Prims.op_Equality",
"FStar.Classical.forall_intro_with_pat",
"Vale.Def.Words_s.natN",
"Vale.Def.Words_s.pow2_64",
"Vale.Def.Words_s.nat64",
"Prims.eq2",
"Prims.int",
"Vale.Def.Types_s.ixor",
"Vale.Arch.Types.lemma_BitwiseXorCancel64",
"Prims.bool",
"Vale.X64.Leakage_Ins.lemma_instr_leakage_free",
"Prims.unit",
"FStar.Pervasives.norm",
"FStar.Pervasives.norm_step",
"FStar.Pervasives.zeta",
"FStar.Pervasives.iota",
"FStar.Pervasives.delta_attr",
"Prims.string",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Instruction_s.instr_operand_inout",
"Vale.X64.Instruction_s.InOut",
"Vale.X64.Instruction_s.IOpEx",
"Vale.X64.Instruction_s.IOp64",
"Vale.X64.Instruction_s.Out",
"Vale.X64.Instruction_s.IOpIm",
"Vale.X64.Instruction_s.IOpFlagsCf",
"Vale.X64.Instruction_s.IOpFlagsOf",
"Vale.X64.Leakage_Ins.coerce_to_normal",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Bytes_Code_s.uu___is_Instr",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Vale.X64.Machine_Semantics_s.uu___is_AnnotateXor64",
"Vale.X64.Bytes_Code_s.__proj__Instr__item__i",
"Vale.X64.Bytes_Code_s.__proj__Instr__item__annotation",
"Prims.squash",
"Prims.l_imp",
"Vale.X64.Leakage_s.isConstantTime",
"Vale.X64.Machine_s.Ins",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Bytes_Code_s.ocmp",
"Vale.X64.Leakage_Helpers.__proj__AnalysisTaints__item__lts",
"Vale.X64.Leakage_s.isLeakageFree",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.Leakage_Ins.check_if_xor_consumes_fixed_time",
"FStar.Pervasives.pattern"
] | [] | module Vale.X64.Leakage_Ins
open FStar.Mul
open Vale.Arch.MachineHeap_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
module BC = Vale.X64.Bytes_Code_s
module S = Vale.X64.Machine_Semantics_s
open Vale.X64.Leakage_s
open Vale.X64.Leakage_Helpers
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
unfold let obs_args = S.obs_args
unfold let obs_inouts = S.obs_inouts
unfold let machine_eval_code = S.machine_eval_code
let reveal_machine_eval_code_ins (i:S.ins) (s:S.machine_state) : Lemma
(requires True)
(ensures S.machine_eval_code_ins i s == S.machine_eval_code_ins_def i s)
[SMTPat (S.machine_eval_code_ins i s)]
=
reveal_opaque (`%S.machine_eval_code_ins) S.machine_eval_code_ins
let rec check_if_consumes_fixed_time_args
(args:list instr_operand) (oprs:instr_operands_t_args args) (ts:analysis_taints)
: Pure bool
(requires True)
(ensures fun b -> b ==> (forall (s1 s2:S.machine_state).{:pattern (constTimeInvariant ts.lts s1 s2)}
constTimeInvariant ts.lts s1 s2 ==> obs_args args oprs s1 == obs_args args oprs s2))
=
allow_inversion maddr;
allow_inversion tmaddr;
match args with
| [] -> true
| (IOpEx i)::args ->
let ((o:instr_operand_t i), (oprs:instr_operands_t_args args)) = coerce oprs in
let b' =
match i with
| IOp64 -> operand_does_not_use_secrets #nat64 #reg_64 o ts
| IOpXmm -> operand_does_not_use_secrets #quad32 #reg_xmm o ts
in
let b'' = check_if_consumes_fixed_time_args args oprs ts in
b' && b''
| (IOpIm i)::args ->
let b' =
match i with
| IOp64One o -> operand_does_not_use_secrets o ts
| IOpXmmOne o -> operand_does_not_use_secrets o ts
| IOpFlagsCf -> true
| IOpFlagsOf -> true
in
let b'' = check_if_consumes_fixed_time_args args (coerce oprs) ts in
b' && b''
let check_if_consumes_fixed_time_outs_explicit
(i:instr_operand_explicit) (o:instr_operand_t i)
(ts:analysis_taints) (t_out:taint)
: bool
=
match i with
| IOp64 -> operand_does_not_use_secrets #nat64 #reg_64 o ts && operand_taint_allowed #nat64 #reg_64 o t_out
| IOpXmm -> operand_does_not_use_secrets #quad32 #reg_xmm o ts && operand_taint_allowed #quad32 #reg_xmm o t_out
let check_if_consumes_fixed_time_outs_implicit
(i:instr_operand_implicit) (ts:analysis_taints) (t_out:taint)
: bool
=
match i with
| IOp64One o -> operand_does_not_use_secrets o ts && operand_taint_allowed o t_out
| IOpXmmOne o -> operand_does_not_use_secrets o ts && operand_taint_allowed o t_out
| IOpFlagsCf -> true
| IOpFlagsOf -> true
let rec check_if_consumes_fixed_time_outs
(outs:list instr_out) (args:list instr_operand) (oprs:instr_operands_t outs args)
(ts:analysis_taints) (t_out:taint)
: Pure bool
(requires True)
(ensures fun b -> b ==> (forall (s1 s2:S.machine_state).{:pattern (constTimeInvariant ts.lts s1 s2)}
constTimeInvariant ts.lts s1 s2 ==> obs_inouts outs args oprs s1 == obs_inouts outs args oprs s2))
=
allow_inversion maddr;
allow_inversion tmaddr;
allow_inversion operand64;
allow_inversion operand128;
match outs with
| [] -> check_if_consumes_fixed_time_args args oprs ts
| (_, IOpEx i)::outs ->
let ((o:instr_operand_t i), (oprs:instr_operands_t outs args)) = coerce oprs in
let b' = check_if_consumes_fixed_time_outs_explicit i o ts t_out in
let b'' = check_if_consumes_fixed_time_outs outs args oprs ts t_out in
b' && b''
| (_, IOpIm i)::outs ->
let b' = check_if_consumes_fixed_time_outs_implicit i ts t_out in
let b'' = check_if_consumes_fixed_time_outs outs args (coerce oprs) ts t_out in
b' && b''
#restart-solver
#reset-options "--z3rlimit 300"
let rec lemma_args_taint
(outs:list instr_out) (args:list instr_operand)
(f:instr_args_t outs args) (oprs:instr_operands_t_args args)
(ts:analysis_taints) (s1 s2:S.machine_state)
: Lemma
(requires
constTimeInvariant ts.lts s1 s2 /\
Some? (S.instr_apply_eval_args outs args f oprs s1) /\
Some? (S.instr_apply_eval_args outs args f oprs s2) /\
check_if_consumes_fixed_time_args args oprs ts /\
args_taint args oprs ts == Public)
(ensures
S.instr_apply_eval_args outs args f oprs s1 ==
S.instr_apply_eval_args outs args f oprs s2)
=
allow_inversion maddr;
allow_inversion tmaddr;
allow_inversion operand64;
allow_inversion operand128;
match args with
| [] -> ()
| i::args ->
let (v1, v2, oprs) : option (instr_val_t i) & option (instr_val_t i) & instr_operands_t_args args =
match i with
| IOpEx i ->
let (o, (oprs:instr_operands_t_args args)) = coerce oprs in
(
S.instr_eval_operand_explicit i o s1,
S.instr_eval_operand_explicit i o s2,
oprs)
| IOpIm i ->
let oprs = coerce oprs in (
S.instr_eval_operand_implicit i s1,
S.instr_eval_operand_implicit i s2,
oprs)
in
let f:arrow (instr_val_t i) (instr_args_t outs args) = coerce f in
S.get_heap_val32_reveal ();
S.get_heap_val64_reveal ();
S.get_heap_val128_reveal ();
assert (v1 == v2);
let Some v = v1 in
lemma_args_taint outs args (f v) oprs ts s1 s2
#restart-solver
let rec lemma_inouts_taint
(outs inouts:list instr_out) (args:list instr_operand)
(f:instr_inouts_t outs inouts args) (oprs:instr_operands_t inouts args)
(ts:analysis_taints) (s1 s2:S.machine_state)
: Lemma
(requires
constTimeInvariant ts.lts s1 s2 /\
Some? (S.instr_apply_eval_inouts outs inouts args f oprs s1) /\
Some? (S.instr_apply_eval_inouts outs inouts args f oprs s2) /\
check_if_consumes_fixed_time_outs inouts args oprs ts Public /\
inouts_taint inouts args oprs ts == Public)
(ensures
S.instr_apply_eval_inouts outs inouts args f oprs s1 ==
S.instr_apply_eval_inouts outs inouts args f oprs s2)
=
allow_inversion maddr;
allow_inversion tmaddr;
allow_inversion operand64;
allow_inversion operand128;
match inouts with
| [] -> lemma_args_taint outs args f oprs ts s1 s2
| (Out, i)::inouts ->
let oprs =
match i with
| IOpEx i -> snd #(instr_operand_t i) (coerce oprs)
| IOpIm i -> coerce oprs
in
lemma_inouts_taint outs inouts args (coerce f) oprs ts s1 s2
| (InOut, i)::inouts ->
let (v1, v2, oprs) : option (instr_val_t i) & option (instr_val_t i) & instr_operands_t inouts args =
match i with
| IOpEx i ->
let (o, (oprs:instr_operands_t inouts args)) = coerce oprs in
let oprs = coerce oprs in (
S.instr_eval_operand_explicit i o s1,
S.instr_eval_operand_explicit i o s2,
oprs)
| IOpIm i ->
let oprs = coerce oprs in (
S.instr_eval_operand_implicit i s1,
S.instr_eval_operand_implicit i s2,
oprs)
in
let f:arrow (instr_val_t i) (instr_inouts_t outs inouts args) = coerce f in
S.get_heap_val32_reveal ();
S.get_heap_val64_reveal ();
S.get_heap_val128_reveal ();
assert (v1 == v2);
let Some v = v1 in
lemma_inouts_taint outs inouts args (f v) oprs ts s1 s2
let instr_set_taint_explicit
(i:instr_operand_explicit) (o:instr_operand_t i) (ts:analysis_taints) (t:taint)
: analysis_taints =
match i with
| IOp64 -> set_taint 0 (o <: operand64) ts t
| IOpXmm -> set_taint 1 (o <: operand128) ts t
[@instr_attr]
let instr_set_taint_implicit (i:instr_operand_implicit) (ts:analysis_taints) (t:taint) : analysis_taints =
match i with
| IOp64One o -> set_taint 0 o ts t
| IOpXmmOne o -> set_taint 1 o ts t
| IOpFlagsCf -> set_taint_cf_and_flags ts t
| IOpFlagsOf -> set_taint_of_and_flags ts t
let rec instr_set_taints
(outs:list instr_out) (args:list instr_operand)
(oprs:instr_operands_t outs args) (ts:analysis_taints) (t:taint)
: analysis_taints =
match outs with
| [] -> ts
| (_, i)::outs ->
(
match i with
| IOpEx i ->
let oprs:instr_operand_t i & instr_operands_t outs args = coerce oprs in
instr_set_taints outs args (snd oprs) (instr_set_taint_explicit i (fst oprs) ts t) t
| IOpIm i -> instr_set_taints outs args (coerce oprs) (instr_set_taint_implicit i ts t) t
)
let rec lemma_instr_write_outputs_ok
(outs:list instr_out) (args:list instr_operand)
(vs:instr_ret_t outs) (oprs:instr_operands_t outs args) (s_orig s:S.machine_state)
: Lemma
(requires (S.instr_write_outputs outs args vs oprs s_orig s).S.ms_ok)
(ensures s.S.ms_ok)
=
match outs with
| [] -> ()
| (_, i)::outs ->
(
let ((v:instr_val_t i), (vs:instr_ret_t outs)) =
match outs with
| [] -> (vs, ())
| _::_ -> let vs = coerce vs in (fst vs, snd vs)
in
match i with
| IOpEx i ->
let oprs:instr_operand_t i & instr_operands_t outs args = coerce oprs in
let s' = S.instr_write_output_explicit i v (fst oprs) s_orig s in
lemma_instr_write_outputs_ok outs args vs (snd oprs) s_orig s'
| IOpIm i ->
let s' = S.instr_write_output_implicit i v s_orig s in
lemma_instr_write_outputs_ok outs args vs (coerce oprs) s_orig s'
)
[@"opaque_to_smt"]
let update_heap32_val (ptr:int) (v:Vale.Def.Types_s.nat32) (i:int) : Vale.Def.Types_s.nat8 =
let open Vale.Def.Words_s in
let open Vale.Def.Words.Four_s in
let v = nat_to_four 8 v in
match (i - ptr) with
| 0 -> v.lo0
| 1 -> v.lo1
| 2 -> v.hi2
| 3 -> v.hi3
| _ -> 0
let valid_addr32 (ptr:int) (mem:S.machine_heap) : bool =
S.valid_addr (ptr + 0) mem &&
S.valid_addr (ptr + 1) mem &&
S.valid_addr (ptr + 2) mem &&
S.valid_addr (ptr + 3) mem
let lemma_update_heap32_val (ptr:int) (v:Vale.Def.Types_s.nat32) (mem:S.machine_heap) (i:int) : Lemma
(requires True)
(ensures (S.update_heap32 ptr v mem).[i] ==
(if ptr <= i && i < ptr + 4 then update_heap32_val ptr v i else mem.[i]))
[SMTPat ((S.update_heap32 ptr v mem).[i])]
=
S.update_heap32_reveal ();
reveal_opaque (`%update_heap32_val) update_heap32_val
let lemma_update_heap32_domain (ptr:int) (v:Vale.Def.Types_s.nat32) (mem:S.machine_heap) : Lemma
(requires valid_addr32 ptr mem)
(ensures Map.domain (S.update_heap32 ptr v mem) == Map.domain mem)
[SMTPat (Map.domain (S.update_heap32 ptr v mem))]
=
S.update_heap32_reveal ();
assert (Set.equal (Map.domain (S.update_heap32 ptr v mem)) (Map.domain mem))
[@"opaque_to_smt"]
let update_heap64_val (ptr:int) (v:nat64) (i:int) : Vale.Def.Types_s.nat8 =
let open Vale.Def.Words_s in
let open Vale.Def.Words.Two_s in
let open Vale.Def.Words.Four_s in
let v = nat_to_two 32 v in
let lo = nat_to_four 8 v.lo in
let hi = nat_to_four 8 v.hi in
match (i - ptr) with
| 0 -> lo.lo0
| 1 -> lo.lo1
| 2 -> lo.hi2
| 3 -> lo.hi3
| 4 -> hi.lo0
| 5 -> hi.lo1
| 6 -> hi.hi2
| 7 -> hi.hi3
| _ -> 0
let lemma_update_heap64_val (ptr:int) (v:nat64) (mem:S.machine_heap) (i:int) : Lemma
(requires True)
(ensures
(S.update_heap64 ptr v mem).[i] ==
(if ptr <= i && i < ptr + 8 then update_heap64_val ptr v i else mem.[i])
)
[SMTPat ((S.update_heap64 ptr v mem).[i])]
=
S.update_heap64_reveal ();
reveal_opaque (`%update_heap64_val) update_heap64_val
let lemma_update_heap64_domain (ptr:int) (v:nat64) (mem:S.machine_heap) : Lemma
(requires S.valid_addr64 ptr mem)
(ensures Map.domain (S.update_heap64 ptr v mem) == Map.domain mem)
[SMTPat (Map.domain (S.update_heap64 ptr v mem))]
=
reveal_opaque (`%S.valid_addr64) S.valid_addr64;
S.update_heap64_reveal ();
assert (Set.equal (Map.domain (S.update_heap64 ptr v mem)) (Map.domain mem))
[@"opaque_to_smt"]
let update_heap128_val (ptr:int) (v:Vale.Def.Types_s.quad32) (i:int) : Vale.Def.Types_s.nat8 =
let open Vale.Def.Words_s in
let j = i - ptr in
if 0 <= j && j < 4 then update_heap32_val (ptr + 0 ) v.lo0 i else
if 4 <= j && j < 8 then update_heap32_val (ptr + 4 ) v.lo1 i else
if 8 <= j && j < 12 then update_heap32_val (ptr + 8 ) v.hi2 i else
if 12 <= j && j < 16 then update_heap32_val (ptr + 12) v.hi3 i else
0
let valid_addr128 (ptr:int) (mem:S.machine_heap) : bool =
valid_addr32 (ptr + 0) mem &&
valid_addr32 (ptr + 4) mem &&
valid_addr32 (ptr + 8) mem &&
valid_addr32 (ptr + 12) mem
let lemma_update_heap128_val (ptr:int) (v:Vale.Def.Types_s.quad32) (mem:S.machine_heap) (i:int) : Lemma
(requires True)
(ensures
(S.update_heap128 ptr v mem).[i] ==
(if ptr <= i && i < ptr + 16 then update_heap128_val ptr v i else mem.[i])
)
[SMTPat ((S.update_heap128 ptr v mem).[i])]
=
S.update_heap128_reveal ();
reveal_opaque (`%update_heap128_val) update_heap128_val
let lemma_update_heap128_domain (ptr:int) (v:Vale.Def.Types_s.quad32) (mem:S.machine_heap) : Lemma
(requires valid_addr128 ptr mem)
(ensures Map.domain (S.update_heap128 ptr v mem) == Map.domain mem)
[SMTPat (S.update_heap128 ptr v mem)]
=
S.update_heap128_reveal ();
assert (Set.equal (Map.domain (S.update_heap128 ptr v mem)) (Map.domain mem))
let lemma_preserve_valid64 (m m':S.machine_heap) : Lemma
(requires Set.equal (Map.domain m) (Map.domain m'))
(ensures (forall (i:int).{:pattern (S.valid_addr64 i m')}
S.valid_addr64 i m ==> S.valid_addr64 i m'))
=
reveal_opaque (`%S.valid_addr64) S.valid_addr64
let lemma_preserve_valid128 (m m':S.machine_heap) : Lemma
(requires Set.equal (Map.domain m) (Map.domain m'))
(ensures (forall (i:int).{:pattern (S.valid_addr128 i m')}
S.valid_addr128 i m ==> S.valid_addr128 i m'))
=
reveal_opaque (`%S.valid_addr128) S.valid_addr128
let lemma_instr_set_taints_explicit
(i:instr_operand_explicit) (v1 v2:instr_val_t (IOpEx i)) (o:instr_operand_t i)
(ts_orig ts:analysis_taints) (t_out:taint)
(s1_orig s1 s2_orig s2:S.machine_state)
: Lemma
(requires (
let s1' = S.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = S.instr_write_output_explicit i v2 o s2_orig s2 in
s1'.S.ms_ok /\ s2'.S.ms_ok /\
(t_out == Public ==> v1 == v2) /\
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2.S.ms_heap)) /\
check_if_consumes_fixed_time_outs_explicit i o ts_orig t_out /\
publicValuesAreSame ts_orig.lts s1_orig s2_orig /\
publicValuesAreSame ts.lts s1 s2
))
(ensures (
let s1' = S.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = S.instr_write_output_explicit i v2 o s2_orig s2 in
let ts' = instr_set_taint_explicit i o ts t_out in
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1'.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2'.S.ms_heap)) /\
publicValuesAreSame ts'.lts s1' s2'
))
=
allow_inversion maddr;
allow_inversion tmaddr;
lemma_preserve_valid64 (heap_get s1_orig.S.ms_heap) (heap_get s1.S.ms_heap);
lemma_preserve_valid64 (heap_get s2_orig.S.ms_heap) (heap_get s2.S.ms_heap);
lemma_preserve_valid128 (heap_get s1_orig.S.ms_heap) (heap_get s1.S.ms_heap);
lemma_preserve_valid128 (heap_get s2_orig.S.ms_heap) (heap_get s2.S.ms_heap);
reveal_opaque (`%S.valid_addr128) S.valid_addr128;
()
let lemma_instr_set_taints_implicit
(i:instr_operand_implicit) (v1 v2:instr_val_t (IOpIm i))
(ts_orig ts:analysis_taints) (t_out:taint)
(s1_orig s1 s2_orig s2:S.machine_state)
: Lemma
(requires (
let s1' = S.instr_write_output_implicit i v1 s1_orig s1 in
let s2' = S.instr_write_output_implicit i v2 s2_orig s2 in
s1'.S.ms_ok /\ s2'.S.ms_ok /\
(t_out == Public ==> v1 == v2) /\
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2.S.ms_heap)) /\
check_if_consumes_fixed_time_outs_implicit i ts_orig t_out /\
publicValuesAreSame ts_orig.lts s1_orig s2_orig /\
publicValuesAreSame ts.lts s1 s2
))
(ensures (
let s1' = S.instr_write_output_implicit i v1 s1_orig s1 in
let s2' = S.instr_write_output_implicit i v2 s2_orig s2 in
let ts' = instr_set_taint_implicit i ts t_out in
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1'.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2'.S.ms_heap)) /\
publicValuesAreSame ts'.lts s1' s2'
))
=
allow_inversion maddr;
allow_inversion tmaddr;
allow_inversion operand64;
allow_inversion operand128;
lemma_preserve_valid64 (heap_get s1_orig.S.ms_heap) (heap_get s1.S.ms_heap);
lemma_preserve_valid64 (heap_get s2_orig.S.ms_heap) (heap_get s2.S.ms_heap);
lemma_preserve_valid128 (heap_get s1_orig.S.ms_heap) (heap_get s1.S.ms_heap);
lemma_preserve_valid128 (heap_get s2_orig.S.ms_heap) (heap_get s2.S.ms_heap);
reveal_opaque (`%S.valid_addr128) S.valid_addr128;
()
#reset-options "--z3rlimit 80"
let rec lemma_instr_set_taints
(outs:list instr_out) (args:list instr_operand)
(vs1 vs2:instr_ret_t outs) (oprs:instr_operands_t outs args)
(ts_orig ts:analysis_taints) (t_out:taint)
(s1_orig s1 s2_orig s2:S.machine_state)
: Lemma
(requires (
let s1_state' = S.instr_write_outputs outs args vs1 oprs s1_orig s1 in
let s2_state' = S.instr_write_outputs outs args vs2 oprs s2_orig s2 in
s1_state'.S.ms_ok /\ s2_state'.S.ms_ok /\
(t_out == Public ==> vs1 == vs2) /\
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2.S.ms_heap)) /\
check_if_consumes_fixed_time_outs outs args oprs ts_orig t_out /\
publicValuesAreSame ts_orig.lts s1_orig s2_orig /\
publicValuesAreSame ts.lts s1 s2
))
(ensures (
let s1' = S.instr_write_outputs outs args vs1 oprs s1_orig s1 in
let s2' = S.instr_write_outputs outs args vs2 oprs s2_orig s2 in
let ts' = instr_set_taints outs args oprs ts t_out in
publicValuesAreSame ts'.lts s1' s2'
))
=
match outs with
| [] -> ()
| (_, i)::outs ->
(
let ((v1:instr_val_t i), (vs1:instr_ret_t outs)) =
match outs with
| [] -> (vs1, ())
| _::_ -> let vs1 = coerce vs1 in (fst vs1, snd vs1)
in
let ((v2:instr_val_t i), (vs2:instr_ret_t outs)) =
match outs with
| [] -> (vs2, ())
| _::_ -> let vs2 = coerce vs2 in (fst vs2, snd vs2)
in
match i with
| IOpEx i ->
let (o, oprs):instr_operand_t i & instr_operands_t outs args = coerce oprs in
let s1' = S.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = S.instr_write_output_explicit i v2 o s2_orig s2 in
lemma_instr_write_outputs_ok outs args vs1 oprs s1_orig s1';
lemma_instr_write_outputs_ok outs args vs2 oprs s2_orig s2';
let ts' = instr_set_taint_explicit i o ts t_out in
lemma_instr_set_taints_explicit i v1 v2 o ts_orig ts t_out s1_orig s1 s2_orig s2;
lemma_instr_set_taints outs args vs1 vs2 oprs ts_orig ts' t_out s1_orig s1' s2_orig s2'
| IOpIm i ->
let s1' = S.instr_write_output_implicit i v1 s1_orig s1 in
let s2' = S.instr_write_output_implicit i v2 s2_orig s2 in
lemma_instr_write_outputs_ok outs args vs1 (coerce oprs) s1_orig s1';
lemma_instr_write_outputs_ok outs args vs2 (coerce oprs) s2_orig s2';
let ts' = instr_set_taint_implicit i ts t_out in
lemma_instr_set_taints_implicit i v1 v2 ts_orig ts t_out s1_orig s1 s2_orig s2;
lemma_instr_set_taints outs args vs1 vs2 (coerce oprs) ts_orig ts' t_out s1_orig s1' s2_orig s2'
)
let check_if_instr_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Instr? ins)
(ensures ins_consumes_fixed_time ins ts)
=
let BC.Instr (InstrTypeRecord #outs #args #havoc_flags iins) oprs _ = ins in
let t = inouts_taint outs args oprs ts in
let b = check_if_consumes_fixed_time_outs outs args oprs ts t in
let AnalysisTaints (LeakageTaints rs flags cf ovf) rts = ts in
let flags = match havoc_flags with | HavocFlags -> Secret | PreserveFlags -> flags in
let cf = match havoc_flags with | HavocFlags -> Secret | PreserveFlags -> cf in
let ovf = match havoc_flags with | HavocFlags -> Secret | PreserveFlags -> ovf in
let ts = AnalysisTaints (LeakageTaints rs flags cf ovf) rts in
(b, instr_set_taints outs args oprs ts t)
let coerce_to_normal (#a:Type0) (x:a) : y:(normal a){x == y} = x
let check_if_xor_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Instr? ins /\ S.AnnotateXor64? (BC.Instr?.annotation ins))
(ensures ins_consumes_fixed_time ins ts)
=
let BC.Instr (InstrTypeRecord #outs #args #havoc_flags iins) oprs (S.AnnotateXor64 eq) = ins in
let oprs:normal (instr_operands_t [inOut op64; out opFlagsCf; out opFlagsOf] [op64]) =
coerce_to_normal #(instr_operands_t [inOut op64; out opFlagsCf; out opFlagsOf] [op64]) oprs in
let (o1, (o2, ())) = oprs in
if o1 = o2 then
let t = Public in
let b = check_if_consumes_fixed_time_outs outs args oprs ts t in
let AnalysisTaints (LeakageTaints rs _ _ _) rts = ts in
let ts = AnalysisTaints (LeakageTaints rs Secret Public Public) rts in
(b, instr_set_taints outs args oprs ts t)
else
check_if_instr_consumes_fixed_time ins ts
let check_if_pxor_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Instr? ins /\ S.AnnotatePxor? (BC.Instr?.annotation ins))
(ensures ins_consumes_fixed_time ins ts)
=
let BC.Instr (InstrTypeRecord #outs #args #havoc_flags iins) oprs (S.AnnotatePxor eq) = ins in
let oprs:normal (instr_operands_t [inOut opXmm] [opXmm]) =
coerce_to_normal #(instr_operands_t [inOut opXmm] [opXmm]) oprs in
let (o1, (o2, ())) = oprs in
if o1 = o2 then
let t = Public in
let b = check_if_consumes_fixed_time_outs outs args oprs ts t in
let AnalysisTaints (LeakageTaints rs ft cft oft) rts = ts in
let ts = AnalysisTaints (LeakageTaints rs ft cft oft) rts in
(b, instr_set_taints outs args oprs ts t)
else
check_if_instr_consumes_fixed_time ins ts
let check_if_vpxor_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Instr? ins /\ S.AnnotateVPxor? (BC.Instr?.annotation ins))
(ensures ins_consumes_fixed_time ins ts)
=
let BC.Instr (InstrTypeRecord #outs #args #havoc_flags iins) oprs (S.AnnotateVPxor eq) = ins in
let oprs:normal (instr_operands_t [out opXmm] [opXmm; opXmm]) =
coerce_to_normal #(instr_operands_t [out opXmm] [opXmm; opXmm]) oprs in
let (_, (o2, (o3, ()))) = oprs in
if o2 = o3 then
let t = Public in
let b = check_if_consumes_fixed_time_outs outs args oprs ts t in
let AnalysisTaints (LeakageTaints rs ft cft oft) rts = ts in
let ts = AnalysisTaints (LeakageTaints rs ft cft oft) rts in
(b, instr_set_taints outs args oprs ts t)
else
check_if_instr_consumes_fixed_time ins ts
let check_if_alloc_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Alloc? ins)
(ensures ins_consumes_fixed_time ins ts)
=
(true, ts)
let check_if_dealloc_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Dealloc? ins)
(ensures ins_consumes_fixed_time ins ts)
=
(true, ts)
#reset-options "--initial_ifuel 3 --max_ifuel 3 --initial_fuel 4 --max_fuel 4 --z3rlimit 80"
let check_if_push_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Push? ins)
(ensures ins_consumes_fixed_time ins ts)
=
let BC.Push src t_stk = ins in
let t_out = operand_taint 0 src ts in
(Public? (Vale.Lib.MapTree.sel ts.rts reg_Rsp) && operand_does_not_use_secrets src ts && (t_out = Public || t_stk = Secret), ts)
let check_if_pop_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Pop? ins)
(ensures ins_consumes_fixed_time ins ts)
=
let BC.Pop dst t_stk = ins in
let allowed = operand_taint_allowed dst t_stk in
(Public? (Vale.Lib.MapTree.sel ts.rts reg_Rsp) && operand_does_not_use_secrets dst ts && allowed, set_taint 0 dst ts t_stk)
let check_if_ins_consumes_fixed_time ins ts =
match ins with
| BC.Instr _ _ (S.AnnotateXor64 _) -> check_if_xor_consumes_fixed_time ins ts
| BC.Instr _ _ (S.AnnotatePxor _) -> check_if_pxor_consumes_fixed_time ins ts
| BC.Instr _ _ (S.AnnotateVPxor _) -> check_if_vpxor_consumes_fixed_time ins ts
| BC.Instr _ _ _ -> check_if_instr_consumes_fixed_time ins ts
| BC.Push _ _ -> check_if_push_consumes_fixed_time ins ts
| BC.Pop _ _ -> check_if_pop_consumes_fixed_time ins ts
| BC.Alloc _ -> check_if_alloc_consumes_fixed_time ins ts
| BC.Dealloc _ -> check_if_dealloc_consumes_fixed_time ins ts
#reset-options "--initial_ifuel 1 --max_ifuel 1 --initial_fuel 1 --max_fuel 1 --z3rlimit 100"
let lemma_instr_leakage_free (ts:analysis_taints) (ins:S.ins) : Lemma
(requires BC.Instr? ins)
(ensures (
let (b, ts') = check_if_instr_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts
))
=
let (b, ts') = check_if_instr_consumes_fixed_time ins ts in
if b then
(
let code = Ins ins in
let lem (s1 s2:S.machine_state) (fuel:nat) : Lemma
(requires is_explicit_leakage_free_lhs code fuel ts.lts ts'.lts s1 s2)
(ensures is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)
[SMTPat (is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)]
=
let BC.Instr (InstrTypeRecord #outs #args #havoc_flags i) oprs _ = ins in
let t_out = inouts_taint outs args oprs ts in
let s1 = {s1 with S.ms_trace = []} in
let s2 = {s2 with S.ms_trace = []} in
let Some vs1 = S.instr_apply_eval outs args (instr_eval i) oprs s1 in
let Some vs2 = S.instr_apply_eval outs args (instr_eval i) oprs s2 in
let s1' =
match havoc_flags with
| HavocFlags -> {s1 with S.ms_flags = S.havoc_flags}
| PreserveFlags -> s1
in
let s2' =
match havoc_flags with
| HavocFlags -> {s2 with S.ms_flags = S.havoc_flags}
| PreserveFlags -> s2
in
let AnalysisTaints (LeakageTaints rs flags cf ovf) rts = ts in
let flags = match havoc_flags with | HavocFlags -> Secret | PreserveFlags -> flags in
let cf = match havoc_flags with | HavocFlags -> Secret | PreserveFlags -> cf in
let ovf = match havoc_flags with | HavocFlags -> Secret | PreserveFlags -> ovf in
let ts_havoc = AnalysisTaints (LeakageTaints rs flags cf ovf) rts in
if t_out = Secret then
(
lemma_instr_set_taints outs args vs1 vs2 oprs ts ts_havoc t_out s1 s1' s2 s2';
()
)
else
(
let vs = vs1 in
lemma_inouts_taint outs outs args (instr_eval i) oprs ts s1 s2;
lemma_instr_set_taints outs args vs vs oprs ts ts_havoc t_out s1 s1' s2 s2';
()
)
in
// assert (isExplicitLeakageFree (Ins ins) ts ts');
()
)
let lemma_dealloc_leakage_free (ts:analysis_taints) (ins:S.ins) : Lemma
(requires BC.Dealloc? ins)
(ensures (
let (b, ts') = check_if_dealloc_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts
))
=
let (b, ts') = check_if_dealloc_consumes_fixed_time ins ts in
if b then
(
let code = Ins ins in
let lem (s1 s2:S.machine_state) (fuel:nat) : Lemma
(requires is_explicit_leakage_free_lhs code fuel ts.lts ts'.lts s1 s2)
(ensures is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)
[SMTPat (is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)]
=
let BC.Dealloc n = ins in
let s1' = Some?.v (machine_eval_code code fuel s1) in
let s2' = Some?.v (machine_eval_code code fuel s2) in
let S.Machine_stack _ stack1 = s1.S.ms_stack in
let S.Machine_stack _ stack2 = s2.S.ms_stack in
let S.Machine_stack _ stack1' = s1'.S.ms_stack in
let S.Machine_stack _ stack2' = s2'.S.ms_stack in
let aux (x:int) : Lemma
(requires publicStackValueIsSame stack1 stack2 s1.S.ms_stackTaint s2.S.ms_stackTaint x)
(ensures publicStackValueIsSame stack1' stack2' s1'.S.ms_stackTaint s2'.S.ms_stackTaint x)
=
Classical.forall_intro (fun s -> Vale.Lib.Set.lemma_sel_restrict s stack1 x);
Classical.forall_intro (fun s -> Vale.Lib.Set.lemma_sel_restrict s stack2 x)
in Classical.forall_intro (Classical.move_requires aux)
in
()
)
let lemma_push_leakage_free (ts:analysis_taints) (ins:S.ins) : Lemma
(requires BC.Push? ins)
(ensures (
let (b, ts') = check_if_push_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts
))
=
let (b, ts') = check_if_push_consumes_fixed_time ins ts in
if b then
(
let code = Ins ins in
let lem (s1 s2:S.machine_state) (fuel:nat) : Lemma
(requires is_explicit_leakage_free_lhs code fuel ts.lts ts'.lts s1 s2)
(ensures is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)
[SMTPat (is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)]
=
let BC.Push src t_stk = ins in
let t_out = operand_taint 0 src ts in
let s1' = Some?.v (machine_eval_code code fuel s1) in
let s2' = Some?.v (machine_eval_code code fuel s2) in
let S.Machine_stack _ stack1 = s1.S.ms_stack in
let S.Machine_stack _ stack2 = s2.S.ms_stack in
let S.Machine_stack _ stack1' = s1'.S.ms_stack in
let S.Machine_stack _ stack2' = s2'.S.ms_stack in
let ptr1 = S.eval_reg_64 rRsp s1 - 8 in
let ptr2 = S.eval_reg_64 rRsp s2 - 8 in
let v1 = S.eval_operand src s1 in
let v2 = S.eval_operand src s2 in
assert (ptr1 == ptr2);
if t_out = Secret then ()
else (
let aux () : Lemma (v1 == v2)
= match src with
| OConst _ | OReg _ -> ()
| OMem (_, _) | OStack (_, _) -> S.get_heap_val64_reveal ()
in
aux()
)
in
()
)
#reset-options "--initial_ifuel 1 --max_ifuel 1 --initial_fuel 1 --max_fuel 1 --z3rlimit 100"
let lemma_pop_leakage_free (ts:analysis_taints) (ins:S.ins) : Lemma
(requires BC.Pop? ins)
(ensures (
let (b, ts') = check_if_pop_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts
))
=
let (b, ts') = check_if_pop_consumes_fixed_time ins ts in
if b then
(
let code = Ins ins in
let lem (s1 s2:S.machine_state) (fuel:nat) : Lemma
(requires is_explicit_leakage_free_lhs code fuel ts.lts ts'.lts s1 s2)
(ensures is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)
[SMTPat (is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)]
=
allow_inversion maddr;
allow_inversion tmaddr;
let BC.Pop dst t_stk = ins in
let s1' = Some?.v (machine_eval_code code fuel s1) in
let s2' = Some?.v (machine_eval_code code fuel s2) in
let stack_op = OStack (MReg reg_Rsp 0, Public) in
let v1 = S.eval_operand stack_op s1 in
let v2 = S.eval_operand stack_op s2 in
if t_stk = Public then (
S.get_heap_val64_reveal ();
assert (v1 == v2)
);
Classical.forall_intro_3 (fun s x (stack1:S.machine_heap) -> Vale.Lib.Set.lemma_sel_restrict s stack1 x);
Classical.forall_intro_3 (fun s x (stack2:S.machine_heap) -> Vale.Lib.Set.lemma_sel_restrict s stack2 x)
in
()
)
#reset-options "--initial_ifuel 2 --max_ifuel 2 --initial_fuel 4 --max_fuel 4 --z3rlimit 40"
let lemma_xor_leakage_free (ts:analysis_taints) (ins:S.ins) : Lemma
(requires BC.Instr? ins /\ S.AnnotateXor64? (BC.Instr?.annotation ins))
(ensures (
let (b, ts') = check_if_xor_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts | false | false | Vale.X64.Leakage_Ins.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 2,
"max_fuel": 4,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 40,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_xor_leakage_free (ts: analysis_taints) (ins: S.ins)
: Lemma (requires BC.Instr? ins /\ S.AnnotateXor64? (BC.Instr?.annotation ins))
(ensures
(let b, ts' = check_if_xor_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts)) | [] | Vale.X64.Leakage_Ins.lemma_xor_leakage_free | {
"file_name": "vale/code/arch/x64/Vale.X64.Leakage_Ins.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | ts: Vale.X64.Leakage_Helpers.analysis_taints -> ins: Vale.X64.Machine_Semantics_s.ins
-> FStar.Pervasives.Lemma (requires Instr? ins /\ AnnotateXor64? (Instr?.annotation ins))
(ensures
(let _ = Vale.X64.Leakage_Ins.check_if_xor_consumes_fixed_time ins ts in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ b ts' = _ in
b ==>
Vale.X64.Leakage_s.isConstantTime (Vale.X64.Machine_s.Ins ins) (AnalysisTaints?.lts ts) /\
Vale.X64.Leakage_s.isLeakageFree (Vale.X64.Machine_s.Ins ins)
(AnalysisTaints?.lts ts)
(AnalysisTaints?.lts ts'))
<:
Type0)) | {
"end_col": 35,
"end_line": 796,
"start_col": 3,
"start_line": 788
} |
FStar.Pervasives.Lemma | val lemma_instr_set_taints_implicit
(i: instr_operand_implicit)
(v1 v2: instr_val_t (IOpIm i))
(ts_orig ts: analysis_taints)
(t_out: taint)
(s1_orig s1 s2_orig s2: S.machine_state)
: Lemma
(requires
(let s1' = S.instr_write_output_implicit i v1 s1_orig s1 in
let s2' = S.instr_write_output_implicit i v2 s2_orig s2 in
s1'.S.ms_ok /\ s2'.S.ms_ok /\ (t_out == Public ==> v1 == v2) /\
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2.S.ms_heap)) /\
check_if_consumes_fixed_time_outs_implicit i ts_orig t_out /\
publicValuesAreSame ts_orig.lts s1_orig s2_orig /\ publicValuesAreSame ts.lts s1 s2))
(ensures
(let s1' = S.instr_write_output_implicit i v1 s1_orig s1 in
let s2' = S.instr_write_output_implicit i v2 s2_orig s2 in
let ts' = instr_set_taint_implicit i ts t_out in
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1'.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2'.S.ms_heap)) /\
publicValuesAreSame ts'.lts s1' s2')) | [
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_instr_set_taints_implicit
(i:instr_operand_implicit) (v1 v2:instr_val_t (IOpIm i))
(ts_orig ts:analysis_taints) (t_out:taint)
(s1_orig s1 s2_orig s2:S.machine_state)
: Lemma
(requires (
let s1' = S.instr_write_output_implicit i v1 s1_orig s1 in
let s2' = S.instr_write_output_implicit i v2 s2_orig s2 in
s1'.S.ms_ok /\ s2'.S.ms_ok /\
(t_out == Public ==> v1 == v2) /\
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2.S.ms_heap)) /\
check_if_consumes_fixed_time_outs_implicit i ts_orig t_out /\
publicValuesAreSame ts_orig.lts s1_orig s2_orig /\
publicValuesAreSame ts.lts s1 s2
))
(ensures (
let s1' = S.instr_write_output_implicit i v1 s1_orig s1 in
let s2' = S.instr_write_output_implicit i v2 s2_orig s2 in
let ts' = instr_set_taint_implicit i ts t_out in
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1'.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2'.S.ms_heap)) /\
publicValuesAreSame ts'.lts s1' s2'
))
=
allow_inversion maddr;
allow_inversion tmaddr;
allow_inversion operand64;
allow_inversion operand128;
lemma_preserve_valid64 (heap_get s1_orig.S.ms_heap) (heap_get s1.S.ms_heap);
lemma_preserve_valid64 (heap_get s2_orig.S.ms_heap) (heap_get s2.S.ms_heap);
lemma_preserve_valid128 (heap_get s1_orig.S.ms_heap) (heap_get s1.S.ms_heap);
lemma_preserve_valid128 (heap_get s2_orig.S.ms_heap) (heap_get s2.S.ms_heap);
reveal_opaque (`%S.valid_addr128) S.valid_addr128;
() | val lemma_instr_set_taints_implicit
(i: instr_operand_implicit)
(v1 v2: instr_val_t (IOpIm i))
(ts_orig ts: analysis_taints)
(t_out: taint)
(s1_orig s1 s2_orig s2: S.machine_state)
: Lemma
(requires
(let s1' = S.instr_write_output_implicit i v1 s1_orig s1 in
let s2' = S.instr_write_output_implicit i v2 s2_orig s2 in
s1'.S.ms_ok /\ s2'.S.ms_ok /\ (t_out == Public ==> v1 == v2) /\
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2.S.ms_heap)) /\
check_if_consumes_fixed_time_outs_implicit i ts_orig t_out /\
publicValuesAreSame ts_orig.lts s1_orig s2_orig /\ publicValuesAreSame ts.lts s1 s2))
(ensures
(let s1' = S.instr_write_output_implicit i v1 s1_orig s1 in
let s2' = S.instr_write_output_implicit i v2 s2_orig s2 in
let ts' = instr_set_taint_implicit i ts t_out in
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1'.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2'.S.ms_heap)) /\
publicValuesAreSame ts'.lts s1' s2'))
let lemma_instr_set_taints_implicit
(i: instr_operand_implicit)
(v1 v2: instr_val_t (IOpIm i))
(ts_orig ts: analysis_taints)
(t_out: taint)
(s1_orig s1 s2_orig s2: S.machine_state)
: Lemma
(requires
(let s1' = S.instr_write_output_implicit i v1 s1_orig s1 in
let s2' = S.instr_write_output_implicit i v2 s2_orig s2 in
s1'.S.ms_ok /\ s2'.S.ms_ok /\ (t_out == Public ==> v1 == v2) /\
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2.S.ms_heap)) /\
check_if_consumes_fixed_time_outs_implicit i ts_orig t_out /\
publicValuesAreSame ts_orig.lts s1_orig s2_orig /\ publicValuesAreSame ts.lts s1 s2))
(ensures
(let s1' = S.instr_write_output_implicit i v1 s1_orig s1 in
let s2' = S.instr_write_output_implicit i v2 s2_orig s2 in
let ts' = instr_set_taint_implicit i ts t_out in
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1'.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2'.S.ms_heap)) /\
publicValuesAreSame ts'.lts s1' s2')) = | false | null | true | allow_inversion maddr;
allow_inversion tmaddr;
allow_inversion operand64;
allow_inversion operand128;
lemma_preserve_valid64 (heap_get s1_orig.S.ms_heap) (heap_get s1.S.ms_heap);
lemma_preserve_valid64 (heap_get s2_orig.S.ms_heap) (heap_get s2.S.ms_heap);
lemma_preserve_valid128 (heap_get s1_orig.S.ms_heap) (heap_get s1.S.ms_heap);
lemma_preserve_valid128 (heap_get s2_orig.S.ms_heap) (heap_get s2.S.ms_heap);
reveal_opaque (`%S.valid_addr128) S.valid_addr128;
() | {
"checked_file": "Vale.X64.Leakage_Ins.fst.checked",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Leakage_s.fst.checked",
"Vale.X64.Leakage_Helpers.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Lib.MapTree.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Leakage_Ins.fst"
} | [
"lemma"
] | [
"Vale.X64.Instruction_s.instr_operand_implicit",
"Vale.X64.Instruction_s.instr_val_t",
"Vale.X64.Instruction_s.IOpIm",
"Vale.X64.Leakage_Helpers.analysis_taints",
"Vale.Arch.HeapTypes_s.taint",
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.unit",
"FStar.Pervasives.reveal_opaque",
"Prims.int",
"Vale.Arch.MachineHeap_s.machine_heap",
"Prims.bool",
"Vale.Arch.MachineHeap_s.valid_addr128",
"Vale.X64.Leakage_Ins.lemma_preserve_valid128",
"Vale.Arch.Heap.heap_get",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_heap",
"Vale.X64.Leakage_Ins.lemma_preserve_valid64",
"FStar.Pervasives.allow_inversion",
"Vale.X64.Machine_s.operand128",
"Vale.X64.Machine_s.operand64",
"Vale.X64.Machine_s.tmaddr",
"Vale.X64.Machine_s.maddr",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_ok",
"Prims.l_imp",
"Prims.eq2",
"Vale.Arch.HeapTypes_s.Public",
"FStar.Set.equal",
"FStar.Map.domain",
"Vale.Def.Types_s.nat8",
"Vale.X64.Leakage_Ins.check_if_consumes_fixed_time_outs_implicit",
"Vale.X64.Leakage_s.publicValuesAreSame",
"Vale.X64.Leakage_Helpers.__proj__AnalysisTaints__item__lts",
"Vale.X64.Machine_Semantics_s.instr_write_output_implicit",
"Prims.squash",
"Vale.X64.Leakage_Ins.instr_set_taint_implicit",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Vale.X64.Leakage_Ins
open FStar.Mul
open Vale.Arch.MachineHeap_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
module BC = Vale.X64.Bytes_Code_s
module S = Vale.X64.Machine_Semantics_s
open Vale.X64.Leakage_s
open Vale.X64.Leakage_Helpers
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
unfold let obs_args = S.obs_args
unfold let obs_inouts = S.obs_inouts
unfold let machine_eval_code = S.machine_eval_code
let reveal_machine_eval_code_ins (i:S.ins) (s:S.machine_state) : Lemma
(requires True)
(ensures S.machine_eval_code_ins i s == S.machine_eval_code_ins_def i s)
[SMTPat (S.machine_eval_code_ins i s)]
=
reveal_opaque (`%S.machine_eval_code_ins) S.machine_eval_code_ins
let rec check_if_consumes_fixed_time_args
(args:list instr_operand) (oprs:instr_operands_t_args args) (ts:analysis_taints)
: Pure bool
(requires True)
(ensures fun b -> b ==> (forall (s1 s2:S.machine_state).{:pattern (constTimeInvariant ts.lts s1 s2)}
constTimeInvariant ts.lts s1 s2 ==> obs_args args oprs s1 == obs_args args oprs s2))
=
allow_inversion maddr;
allow_inversion tmaddr;
match args with
| [] -> true
| (IOpEx i)::args ->
let ((o:instr_operand_t i), (oprs:instr_operands_t_args args)) = coerce oprs in
let b' =
match i with
| IOp64 -> operand_does_not_use_secrets #nat64 #reg_64 o ts
| IOpXmm -> operand_does_not_use_secrets #quad32 #reg_xmm o ts
in
let b'' = check_if_consumes_fixed_time_args args oprs ts in
b' && b''
| (IOpIm i)::args ->
let b' =
match i with
| IOp64One o -> operand_does_not_use_secrets o ts
| IOpXmmOne o -> operand_does_not_use_secrets o ts
| IOpFlagsCf -> true
| IOpFlagsOf -> true
in
let b'' = check_if_consumes_fixed_time_args args (coerce oprs) ts in
b' && b''
let check_if_consumes_fixed_time_outs_explicit
(i:instr_operand_explicit) (o:instr_operand_t i)
(ts:analysis_taints) (t_out:taint)
: bool
=
match i with
| IOp64 -> operand_does_not_use_secrets #nat64 #reg_64 o ts && operand_taint_allowed #nat64 #reg_64 o t_out
| IOpXmm -> operand_does_not_use_secrets #quad32 #reg_xmm o ts && operand_taint_allowed #quad32 #reg_xmm o t_out
let check_if_consumes_fixed_time_outs_implicit
(i:instr_operand_implicit) (ts:analysis_taints) (t_out:taint)
: bool
=
match i with
| IOp64One o -> operand_does_not_use_secrets o ts && operand_taint_allowed o t_out
| IOpXmmOne o -> operand_does_not_use_secrets o ts && operand_taint_allowed o t_out
| IOpFlagsCf -> true
| IOpFlagsOf -> true
let rec check_if_consumes_fixed_time_outs
(outs:list instr_out) (args:list instr_operand) (oprs:instr_operands_t outs args)
(ts:analysis_taints) (t_out:taint)
: Pure bool
(requires True)
(ensures fun b -> b ==> (forall (s1 s2:S.machine_state).{:pattern (constTimeInvariant ts.lts s1 s2)}
constTimeInvariant ts.lts s1 s2 ==> obs_inouts outs args oprs s1 == obs_inouts outs args oprs s2))
=
allow_inversion maddr;
allow_inversion tmaddr;
allow_inversion operand64;
allow_inversion operand128;
match outs with
| [] -> check_if_consumes_fixed_time_args args oprs ts
| (_, IOpEx i)::outs ->
let ((o:instr_operand_t i), (oprs:instr_operands_t outs args)) = coerce oprs in
let b' = check_if_consumes_fixed_time_outs_explicit i o ts t_out in
let b'' = check_if_consumes_fixed_time_outs outs args oprs ts t_out in
b' && b''
| (_, IOpIm i)::outs ->
let b' = check_if_consumes_fixed_time_outs_implicit i ts t_out in
let b'' = check_if_consumes_fixed_time_outs outs args (coerce oprs) ts t_out in
b' && b''
#restart-solver
#reset-options "--z3rlimit 300"
let rec lemma_args_taint
(outs:list instr_out) (args:list instr_operand)
(f:instr_args_t outs args) (oprs:instr_operands_t_args args)
(ts:analysis_taints) (s1 s2:S.machine_state)
: Lemma
(requires
constTimeInvariant ts.lts s1 s2 /\
Some? (S.instr_apply_eval_args outs args f oprs s1) /\
Some? (S.instr_apply_eval_args outs args f oprs s2) /\
check_if_consumes_fixed_time_args args oprs ts /\
args_taint args oprs ts == Public)
(ensures
S.instr_apply_eval_args outs args f oprs s1 ==
S.instr_apply_eval_args outs args f oprs s2)
=
allow_inversion maddr;
allow_inversion tmaddr;
allow_inversion operand64;
allow_inversion operand128;
match args with
| [] -> ()
| i::args ->
let (v1, v2, oprs) : option (instr_val_t i) & option (instr_val_t i) & instr_operands_t_args args =
match i with
| IOpEx i ->
let (o, (oprs:instr_operands_t_args args)) = coerce oprs in
(
S.instr_eval_operand_explicit i o s1,
S.instr_eval_operand_explicit i o s2,
oprs)
| IOpIm i ->
let oprs = coerce oprs in (
S.instr_eval_operand_implicit i s1,
S.instr_eval_operand_implicit i s2,
oprs)
in
let f:arrow (instr_val_t i) (instr_args_t outs args) = coerce f in
S.get_heap_val32_reveal ();
S.get_heap_val64_reveal ();
S.get_heap_val128_reveal ();
assert (v1 == v2);
let Some v = v1 in
lemma_args_taint outs args (f v) oprs ts s1 s2
#restart-solver
let rec lemma_inouts_taint
(outs inouts:list instr_out) (args:list instr_operand)
(f:instr_inouts_t outs inouts args) (oprs:instr_operands_t inouts args)
(ts:analysis_taints) (s1 s2:S.machine_state)
: Lemma
(requires
constTimeInvariant ts.lts s1 s2 /\
Some? (S.instr_apply_eval_inouts outs inouts args f oprs s1) /\
Some? (S.instr_apply_eval_inouts outs inouts args f oprs s2) /\
check_if_consumes_fixed_time_outs inouts args oprs ts Public /\
inouts_taint inouts args oprs ts == Public)
(ensures
S.instr_apply_eval_inouts outs inouts args f oprs s1 ==
S.instr_apply_eval_inouts outs inouts args f oprs s2)
=
allow_inversion maddr;
allow_inversion tmaddr;
allow_inversion operand64;
allow_inversion operand128;
match inouts with
| [] -> lemma_args_taint outs args f oprs ts s1 s2
| (Out, i)::inouts ->
let oprs =
match i with
| IOpEx i -> snd #(instr_operand_t i) (coerce oprs)
| IOpIm i -> coerce oprs
in
lemma_inouts_taint outs inouts args (coerce f) oprs ts s1 s2
| (InOut, i)::inouts ->
let (v1, v2, oprs) : option (instr_val_t i) & option (instr_val_t i) & instr_operands_t inouts args =
match i with
| IOpEx i ->
let (o, (oprs:instr_operands_t inouts args)) = coerce oprs in
let oprs = coerce oprs in (
S.instr_eval_operand_explicit i o s1,
S.instr_eval_operand_explicit i o s2,
oprs)
| IOpIm i ->
let oprs = coerce oprs in (
S.instr_eval_operand_implicit i s1,
S.instr_eval_operand_implicit i s2,
oprs)
in
let f:arrow (instr_val_t i) (instr_inouts_t outs inouts args) = coerce f in
S.get_heap_val32_reveal ();
S.get_heap_val64_reveal ();
S.get_heap_val128_reveal ();
assert (v1 == v2);
let Some v = v1 in
lemma_inouts_taint outs inouts args (f v) oprs ts s1 s2
let instr_set_taint_explicit
(i:instr_operand_explicit) (o:instr_operand_t i) (ts:analysis_taints) (t:taint)
: analysis_taints =
match i with
| IOp64 -> set_taint 0 (o <: operand64) ts t
| IOpXmm -> set_taint 1 (o <: operand128) ts t
[@instr_attr]
let instr_set_taint_implicit (i:instr_operand_implicit) (ts:analysis_taints) (t:taint) : analysis_taints =
match i with
| IOp64One o -> set_taint 0 o ts t
| IOpXmmOne o -> set_taint 1 o ts t
| IOpFlagsCf -> set_taint_cf_and_flags ts t
| IOpFlagsOf -> set_taint_of_and_flags ts t
let rec instr_set_taints
(outs:list instr_out) (args:list instr_operand)
(oprs:instr_operands_t outs args) (ts:analysis_taints) (t:taint)
: analysis_taints =
match outs with
| [] -> ts
| (_, i)::outs ->
(
match i with
| IOpEx i ->
let oprs:instr_operand_t i & instr_operands_t outs args = coerce oprs in
instr_set_taints outs args (snd oprs) (instr_set_taint_explicit i (fst oprs) ts t) t
| IOpIm i -> instr_set_taints outs args (coerce oprs) (instr_set_taint_implicit i ts t) t
)
let rec lemma_instr_write_outputs_ok
(outs:list instr_out) (args:list instr_operand)
(vs:instr_ret_t outs) (oprs:instr_operands_t outs args) (s_orig s:S.machine_state)
: Lemma
(requires (S.instr_write_outputs outs args vs oprs s_orig s).S.ms_ok)
(ensures s.S.ms_ok)
=
match outs with
| [] -> ()
| (_, i)::outs ->
(
let ((v:instr_val_t i), (vs:instr_ret_t outs)) =
match outs with
| [] -> (vs, ())
| _::_ -> let vs = coerce vs in (fst vs, snd vs)
in
match i with
| IOpEx i ->
let oprs:instr_operand_t i & instr_operands_t outs args = coerce oprs in
let s' = S.instr_write_output_explicit i v (fst oprs) s_orig s in
lemma_instr_write_outputs_ok outs args vs (snd oprs) s_orig s'
| IOpIm i ->
let s' = S.instr_write_output_implicit i v s_orig s in
lemma_instr_write_outputs_ok outs args vs (coerce oprs) s_orig s'
)
[@"opaque_to_smt"]
let update_heap32_val (ptr:int) (v:Vale.Def.Types_s.nat32) (i:int) : Vale.Def.Types_s.nat8 =
let open Vale.Def.Words_s in
let open Vale.Def.Words.Four_s in
let v = nat_to_four 8 v in
match (i - ptr) with
| 0 -> v.lo0
| 1 -> v.lo1
| 2 -> v.hi2
| 3 -> v.hi3
| _ -> 0
let valid_addr32 (ptr:int) (mem:S.machine_heap) : bool =
S.valid_addr (ptr + 0) mem &&
S.valid_addr (ptr + 1) mem &&
S.valid_addr (ptr + 2) mem &&
S.valid_addr (ptr + 3) mem
let lemma_update_heap32_val (ptr:int) (v:Vale.Def.Types_s.nat32) (mem:S.machine_heap) (i:int) : Lemma
(requires True)
(ensures (S.update_heap32 ptr v mem).[i] ==
(if ptr <= i && i < ptr + 4 then update_heap32_val ptr v i else mem.[i]))
[SMTPat ((S.update_heap32 ptr v mem).[i])]
=
S.update_heap32_reveal ();
reveal_opaque (`%update_heap32_val) update_heap32_val
let lemma_update_heap32_domain (ptr:int) (v:Vale.Def.Types_s.nat32) (mem:S.machine_heap) : Lemma
(requires valid_addr32 ptr mem)
(ensures Map.domain (S.update_heap32 ptr v mem) == Map.domain mem)
[SMTPat (Map.domain (S.update_heap32 ptr v mem))]
=
S.update_heap32_reveal ();
assert (Set.equal (Map.domain (S.update_heap32 ptr v mem)) (Map.domain mem))
[@"opaque_to_smt"]
let update_heap64_val (ptr:int) (v:nat64) (i:int) : Vale.Def.Types_s.nat8 =
let open Vale.Def.Words_s in
let open Vale.Def.Words.Two_s in
let open Vale.Def.Words.Four_s in
let v = nat_to_two 32 v in
let lo = nat_to_four 8 v.lo in
let hi = nat_to_four 8 v.hi in
match (i - ptr) with
| 0 -> lo.lo0
| 1 -> lo.lo1
| 2 -> lo.hi2
| 3 -> lo.hi3
| 4 -> hi.lo0
| 5 -> hi.lo1
| 6 -> hi.hi2
| 7 -> hi.hi3
| _ -> 0
let lemma_update_heap64_val (ptr:int) (v:nat64) (mem:S.machine_heap) (i:int) : Lemma
(requires True)
(ensures
(S.update_heap64 ptr v mem).[i] ==
(if ptr <= i && i < ptr + 8 then update_heap64_val ptr v i else mem.[i])
)
[SMTPat ((S.update_heap64 ptr v mem).[i])]
=
S.update_heap64_reveal ();
reveal_opaque (`%update_heap64_val) update_heap64_val
let lemma_update_heap64_domain (ptr:int) (v:nat64) (mem:S.machine_heap) : Lemma
(requires S.valid_addr64 ptr mem)
(ensures Map.domain (S.update_heap64 ptr v mem) == Map.domain mem)
[SMTPat (Map.domain (S.update_heap64 ptr v mem))]
=
reveal_opaque (`%S.valid_addr64) S.valid_addr64;
S.update_heap64_reveal ();
assert (Set.equal (Map.domain (S.update_heap64 ptr v mem)) (Map.domain mem))
[@"opaque_to_smt"]
let update_heap128_val (ptr:int) (v:Vale.Def.Types_s.quad32) (i:int) : Vale.Def.Types_s.nat8 =
let open Vale.Def.Words_s in
let j = i - ptr in
if 0 <= j && j < 4 then update_heap32_val (ptr + 0 ) v.lo0 i else
if 4 <= j && j < 8 then update_heap32_val (ptr + 4 ) v.lo1 i else
if 8 <= j && j < 12 then update_heap32_val (ptr + 8 ) v.hi2 i else
if 12 <= j && j < 16 then update_heap32_val (ptr + 12) v.hi3 i else
0
let valid_addr128 (ptr:int) (mem:S.machine_heap) : bool =
valid_addr32 (ptr + 0) mem &&
valid_addr32 (ptr + 4) mem &&
valid_addr32 (ptr + 8) mem &&
valid_addr32 (ptr + 12) mem
let lemma_update_heap128_val (ptr:int) (v:Vale.Def.Types_s.quad32) (mem:S.machine_heap) (i:int) : Lemma
(requires True)
(ensures
(S.update_heap128 ptr v mem).[i] ==
(if ptr <= i && i < ptr + 16 then update_heap128_val ptr v i else mem.[i])
)
[SMTPat ((S.update_heap128 ptr v mem).[i])]
=
S.update_heap128_reveal ();
reveal_opaque (`%update_heap128_val) update_heap128_val
let lemma_update_heap128_domain (ptr:int) (v:Vale.Def.Types_s.quad32) (mem:S.machine_heap) : Lemma
(requires valid_addr128 ptr mem)
(ensures Map.domain (S.update_heap128 ptr v mem) == Map.domain mem)
[SMTPat (S.update_heap128 ptr v mem)]
=
S.update_heap128_reveal ();
assert (Set.equal (Map.domain (S.update_heap128 ptr v mem)) (Map.domain mem))
let lemma_preserve_valid64 (m m':S.machine_heap) : Lemma
(requires Set.equal (Map.domain m) (Map.domain m'))
(ensures (forall (i:int).{:pattern (S.valid_addr64 i m')}
S.valid_addr64 i m ==> S.valid_addr64 i m'))
=
reveal_opaque (`%S.valid_addr64) S.valid_addr64
let lemma_preserve_valid128 (m m':S.machine_heap) : Lemma
(requires Set.equal (Map.domain m) (Map.domain m'))
(ensures (forall (i:int).{:pattern (S.valid_addr128 i m')}
S.valid_addr128 i m ==> S.valid_addr128 i m'))
=
reveal_opaque (`%S.valid_addr128) S.valid_addr128
let lemma_instr_set_taints_explicit
(i:instr_operand_explicit) (v1 v2:instr_val_t (IOpEx i)) (o:instr_operand_t i)
(ts_orig ts:analysis_taints) (t_out:taint)
(s1_orig s1 s2_orig s2:S.machine_state)
: Lemma
(requires (
let s1' = S.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = S.instr_write_output_explicit i v2 o s2_orig s2 in
s1'.S.ms_ok /\ s2'.S.ms_ok /\
(t_out == Public ==> v1 == v2) /\
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2.S.ms_heap)) /\
check_if_consumes_fixed_time_outs_explicit i o ts_orig t_out /\
publicValuesAreSame ts_orig.lts s1_orig s2_orig /\
publicValuesAreSame ts.lts s1 s2
))
(ensures (
let s1' = S.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = S.instr_write_output_explicit i v2 o s2_orig s2 in
let ts' = instr_set_taint_explicit i o ts t_out in
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1'.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2'.S.ms_heap)) /\
publicValuesAreSame ts'.lts s1' s2'
))
=
allow_inversion maddr;
allow_inversion tmaddr;
lemma_preserve_valid64 (heap_get s1_orig.S.ms_heap) (heap_get s1.S.ms_heap);
lemma_preserve_valid64 (heap_get s2_orig.S.ms_heap) (heap_get s2.S.ms_heap);
lemma_preserve_valid128 (heap_get s1_orig.S.ms_heap) (heap_get s1.S.ms_heap);
lemma_preserve_valid128 (heap_get s2_orig.S.ms_heap) (heap_get s2.S.ms_heap);
reveal_opaque (`%S.valid_addr128) S.valid_addr128;
()
let lemma_instr_set_taints_implicit
(i:instr_operand_implicit) (v1 v2:instr_val_t (IOpIm i))
(ts_orig ts:analysis_taints) (t_out:taint)
(s1_orig s1 s2_orig s2:S.machine_state)
: Lemma
(requires (
let s1' = S.instr_write_output_implicit i v1 s1_orig s1 in
let s2' = S.instr_write_output_implicit i v2 s2_orig s2 in
s1'.S.ms_ok /\ s2'.S.ms_ok /\
(t_out == Public ==> v1 == v2) /\
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2.S.ms_heap)) /\
check_if_consumes_fixed_time_outs_implicit i ts_orig t_out /\
publicValuesAreSame ts_orig.lts s1_orig s2_orig /\
publicValuesAreSame ts.lts s1 s2
))
(ensures (
let s1' = S.instr_write_output_implicit i v1 s1_orig s1 in
let s2' = S.instr_write_output_implicit i v2 s2_orig s2 in
let ts' = instr_set_taint_implicit i ts t_out in
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1'.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2'.S.ms_heap)) /\
publicValuesAreSame ts'.lts s1' s2'
)) | false | false | Vale.X64.Leakage_Ins.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 300,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_instr_set_taints_implicit
(i: instr_operand_implicit)
(v1 v2: instr_val_t (IOpIm i))
(ts_orig ts: analysis_taints)
(t_out: taint)
(s1_orig s1 s2_orig s2: S.machine_state)
: Lemma
(requires
(let s1' = S.instr_write_output_implicit i v1 s1_orig s1 in
let s2' = S.instr_write_output_implicit i v2 s2_orig s2 in
s1'.S.ms_ok /\ s2'.S.ms_ok /\ (t_out == Public ==> v1 == v2) /\
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2.S.ms_heap)) /\
check_if_consumes_fixed_time_outs_implicit i ts_orig t_out /\
publicValuesAreSame ts_orig.lts s1_orig s2_orig /\ publicValuesAreSame ts.lts s1 s2))
(ensures
(let s1' = S.instr_write_output_implicit i v1 s1_orig s1 in
let s2' = S.instr_write_output_implicit i v2 s2_orig s2 in
let ts' = instr_set_taint_implicit i ts t_out in
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1'.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2'.S.ms_heap)) /\
publicValuesAreSame ts'.lts s1' s2')) | [] | Vale.X64.Leakage_Ins.lemma_instr_set_taints_implicit | {
"file_name": "vale/code/arch/x64/Vale.X64.Leakage_Ins.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
i: Vale.X64.Instruction_s.instr_operand_implicit ->
v1: Vale.X64.Instruction_s.instr_val_t (Vale.X64.Instruction_s.IOpIm i) ->
v2: Vale.X64.Instruction_s.instr_val_t (Vale.X64.Instruction_s.IOpIm i) ->
ts_orig: Vale.X64.Leakage_Helpers.analysis_taints ->
ts: Vale.X64.Leakage_Helpers.analysis_taints ->
t_out: Vale.Arch.HeapTypes_s.taint ->
s1_orig: Vale.X64.Machine_Semantics_s.machine_state ->
s1: Vale.X64.Machine_Semantics_s.machine_state ->
s2_orig: Vale.X64.Machine_Semantics_s.machine_state ->
s2: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma
(requires
(let s1' = Vale.X64.Machine_Semantics_s.instr_write_output_implicit i v1 s1_orig s1 in
let s2' = Vale.X64.Machine_Semantics_s.instr_write_output_implicit i v2 s2_orig s2 in
Mkmachine_state?.ms_ok s1' /\ Mkmachine_state?.ms_ok s2' /\
(t_out == Vale.Arch.HeapTypes_s.Public ==> v1 == v2) /\
FStar.Set.equal (FStar.Map.domain (Vale.Arch.Heap.heap_get (Mkmachine_state?.ms_heap s1_orig
)))
(FStar.Map.domain (Vale.Arch.Heap.heap_get (Mkmachine_state?.ms_heap s1))) /\
FStar.Set.equal (FStar.Map.domain (Vale.Arch.Heap.heap_get (Mkmachine_state?.ms_heap s2_orig
)))
(FStar.Map.domain (Vale.Arch.Heap.heap_get (Mkmachine_state?.ms_heap s2))) /\
Vale.X64.Leakage_Ins.check_if_consumes_fixed_time_outs_implicit i ts_orig t_out /\
Vale.X64.Leakage_s.publicValuesAreSame (AnalysisTaints?.lts ts_orig) s1_orig s2_orig /\
Vale.X64.Leakage_s.publicValuesAreSame (AnalysisTaints?.lts ts) s1 s2))
(ensures
(let s1' = Vale.X64.Machine_Semantics_s.instr_write_output_implicit i v1 s1_orig s1 in
let s2' = Vale.X64.Machine_Semantics_s.instr_write_output_implicit i v2 s2_orig s2 in
let ts' = Vale.X64.Leakage_Ins.instr_set_taint_implicit i ts t_out in
FStar.Set.equal (FStar.Map.domain (Vale.Arch.Heap.heap_get (Mkmachine_state?.ms_heap s1_orig
)))
(FStar.Map.domain (Vale.Arch.Heap.heap_get (Mkmachine_state?.ms_heap s1'))) /\
FStar.Set.equal (FStar.Map.domain (Vale.Arch.Heap.heap_get (Mkmachine_state?.ms_heap s2_orig
)))
(FStar.Map.domain (Vale.Arch.Heap.heap_get (Mkmachine_state?.ms_heap s2'))) /\
Vale.X64.Leakage_s.publicValuesAreSame (AnalysisTaints?.lts ts') s1' s2')) | {
"end_col": 4,
"end_line": 445,
"start_col": 2,
"start_line": 436
} |
FStar.Pervasives.Lemma | val lemma_instr_set_taints_explicit
(i: instr_operand_explicit)
(v1 v2: instr_val_t (IOpEx i))
(o: instr_operand_t i)
(ts_orig ts: analysis_taints)
(t_out: taint)
(s1_orig s1 s2_orig s2: S.machine_state)
: Lemma
(requires
(let s1' = S.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = S.instr_write_output_explicit i v2 o s2_orig s2 in
s1'.S.ms_ok /\ s2'.S.ms_ok /\ (t_out == Public ==> v1 == v2) /\
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2.S.ms_heap)) /\
check_if_consumes_fixed_time_outs_explicit i o ts_orig t_out /\
publicValuesAreSame ts_orig.lts s1_orig s2_orig /\ publicValuesAreSame ts.lts s1 s2))
(ensures
(let s1' = S.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = S.instr_write_output_explicit i v2 o s2_orig s2 in
let ts' = instr_set_taint_explicit i o ts t_out in
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1'.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2'.S.ms_heap)) /\
publicValuesAreSame ts'.lts s1' s2')) | [
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_instr_set_taints_explicit
(i:instr_operand_explicit) (v1 v2:instr_val_t (IOpEx i)) (o:instr_operand_t i)
(ts_orig ts:analysis_taints) (t_out:taint)
(s1_orig s1 s2_orig s2:S.machine_state)
: Lemma
(requires (
let s1' = S.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = S.instr_write_output_explicit i v2 o s2_orig s2 in
s1'.S.ms_ok /\ s2'.S.ms_ok /\
(t_out == Public ==> v1 == v2) /\
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2.S.ms_heap)) /\
check_if_consumes_fixed_time_outs_explicit i o ts_orig t_out /\
publicValuesAreSame ts_orig.lts s1_orig s2_orig /\
publicValuesAreSame ts.lts s1 s2
))
(ensures (
let s1' = S.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = S.instr_write_output_explicit i v2 o s2_orig s2 in
let ts' = instr_set_taint_explicit i o ts t_out in
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1'.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2'.S.ms_heap)) /\
publicValuesAreSame ts'.lts s1' s2'
))
=
allow_inversion maddr;
allow_inversion tmaddr;
lemma_preserve_valid64 (heap_get s1_orig.S.ms_heap) (heap_get s1.S.ms_heap);
lemma_preserve_valid64 (heap_get s2_orig.S.ms_heap) (heap_get s2.S.ms_heap);
lemma_preserve_valid128 (heap_get s1_orig.S.ms_heap) (heap_get s1.S.ms_heap);
lemma_preserve_valid128 (heap_get s2_orig.S.ms_heap) (heap_get s2.S.ms_heap);
reveal_opaque (`%S.valid_addr128) S.valid_addr128;
() | val lemma_instr_set_taints_explicit
(i: instr_operand_explicit)
(v1 v2: instr_val_t (IOpEx i))
(o: instr_operand_t i)
(ts_orig ts: analysis_taints)
(t_out: taint)
(s1_orig s1 s2_orig s2: S.machine_state)
: Lemma
(requires
(let s1' = S.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = S.instr_write_output_explicit i v2 o s2_orig s2 in
s1'.S.ms_ok /\ s2'.S.ms_ok /\ (t_out == Public ==> v1 == v2) /\
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2.S.ms_heap)) /\
check_if_consumes_fixed_time_outs_explicit i o ts_orig t_out /\
publicValuesAreSame ts_orig.lts s1_orig s2_orig /\ publicValuesAreSame ts.lts s1 s2))
(ensures
(let s1' = S.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = S.instr_write_output_explicit i v2 o s2_orig s2 in
let ts' = instr_set_taint_explicit i o ts t_out in
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1'.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2'.S.ms_heap)) /\
publicValuesAreSame ts'.lts s1' s2'))
let lemma_instr_set_taints_explicit
(i: instr_operand_explicit)
(v1 v2: instr_val_t (IOpEx i))
(o: instr_operand_t i)
(ts_orig ts: analysis_taints)
(t_out: taint)
(s1_orig s1 s2_orig s2: S.machine_state)
: Lemma
(requires
(let s1' = S.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = S.instr_write_output_explicit i v2 o s2_orig s2 in
s1'.S.ms_ok /\ s2'.S.ms_ok /\ (t_out == Public ==> v1 == v2) /\
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2.S.ms_heap)) /\
check_if_consumes_fixed_time_outs_explicit i o ts_orig t_out /\
publicValuesAreSame ts_orig.lts s1_orig s2_orig /\ publicValuesAreSame ts.lts s1 s2))
(ensures
(let s1' = S.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = S.instr_write_output_explicit i v2 o s2_orig s2 in
let ts' = instr_set_taint_explicit i o ts t_out in
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1'.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2'.S.ms_heap)) /\
publicValuesAreSame ts'.lts s1' s2')) = | false | null | true | allow_inversion maddr;
allow_inversion tmaddr;
lemma_preserve_valid64 (heap_get s1_orig.S.ms_heap) (heap_get s1.S.ms_heap);
lemma_preserve_valid64 (heap_get s2_orig.S.ms_heap) (heap_get s2.S.ms_heap);
lemma_preserve_valid128 (heap_get s1_orig.S.ms_heap) (heap_get s1.S.ms_heap);
lemma_preserve_valid128 (heap_get s2_orig.S.ms_heap) (heap_get s2.S.ms_heap);
reveal_opaque (`%S.valid_addr128) S.valid_addr128;
() | {
"checked_file": "Vale.X64.Leakage_Ins.fst.checked",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Leakage_s.fst.checked",
"Vale.X64.Leakage_Helpers.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Lib.MapTree.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Leakage_Ins.fst"
} | [
"lemma"
] | [
"Vale.X64.Instruction_s.instr_operand_explicit",
"Vale.X64.Instruction_s.instr_val_t",
"Vale.X64.Instruction_s.IOpEx",
"Vale.X64.Instruction_s.instr_operand_t",
"Vale.X64.Leakage_Helpers.analysis_taints",
"Vale.Arch.HeapTypes_s.taint",
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.unit",
"FStar.Pervasives.reveal_opaque",
"Prims.int",
"Vale.Arch.MachineHeap_s.machine_heap",
"Prims.bool",
"Vale.Arch.MachineHeap_s.valid_addr128",
"Vale.X64.Leakage_Ins.lemma_preserve_valid128",
"Vale.Arch.Heap.heap_get",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_heap",
"Vale.X64.Leakage_Ins.lemma_preserve_valid64",
"FStar.Pervasives.allow_inversion",
"Vale.X64.Machine_s.tmaddr",
"Vale.X64.Machine_s.maddr",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_ok",
"Prims.l_imp",
"Prims.eq2",
"Vale.Arch.HeapTypes_s.Public",
"FStar.Set.equal",
"FStar.Map.domain",
"Vale.Def.Types_s.nat8",
"Vale.X64.Leakage_Ins.check_if_consumes_fixed_time_outs_explicit",
"Vale.X64.Leakage_s.publicValuesAreSame",
"Vale.X64.Leakage_Helpers.__proj__AnalysisTaints__item__lts",
"Vale.X64.Machine_Semantics_s.instr_write_output_explicit",
"Prims.squash",
"Vale.X64.Leakage_Ins.instr_set_taint_explicit",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Vale.X64.Leakage_Ins
open FStar.Mul
open Vale.Arch.MachineHeap_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
module BC = Vale.X64.Bytes_Code_s
module S = Vale.X64.Machine_Semantics_s
open Vale.X64.Leakage_s
open Vale.X64.Leakage_Helpers
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
unfold let obs_args = S.obs_args
unfold let obs_inouts = S.obs_inouts
unfold let machine_eval_code = S.machine_eval_code
let reveal_machine_eval_code_ins (i:S.ins) (s:S.machine_state) : Lemma
(requires True)
(ensures S.machine_eval_code_ins i s == S.machine_eval_code_ins_def i s)
[SMTPat (S.machine_eval_code_ins i s)]
=
reveal_opaque (`%S.machine_eval_code_ins) S.machine_eval_code_ins
let rec check_if_consumes_fixed_time_args
(args:list instr_operand) (oprs:instr_operands_t_args args) (ts:analysis_taints)
: Pure bool
(requires True)
(ensures fun b -> b ==> (forall (s1 s2:S.machine_state).{:pattern (constTimeInvariant ts.lts s1 s2)}
constTimeInvariant ts.lts s1 s2 ==> obs_args args oprs s1 == obs_args args oprs s2))
=
allow_inversion maddr;
allow_inversion tmaddr;
match args with
| [] -> true
| (IOpEx i)::args ->
let ((o:instr_operand_t i), (oprs:instr_operands_t_args args)) = coerce oprs in
let b' =
match i with
| IOp64 -> operand_does_not_use_secrets #nat64 #reg_64 o ts
| IOpXmm -> operand_does_not_use_secrets #quad32 #reg_xmm o ts
in
let b'' = check_if_consumes_fixed_time_args args oprs ts in
b' && b''
| (IOpIm i)::args ->
let b' =
match i with
| IOp64One o -> operand_does_not_use_secrets o ts
| IOpXmmOne o -> operand_does_not_use_secrets o ts
| IOpFlagsCf -> true
| IOpFlagsOf -> true
in
let b'' = check_if_consumes_fixed_time_args args (coerce oprs) ts in
b' && b''
let check_if_consumes_fixed_time_outs_explicit
(i:instr_operand_explicit) (o:instr_operand_t i)
(ts:analysis_taints) (t_out:taint)
: bool
=
match i with
| IOp64 -> operand_does_not_use_secrets #nat64 #reg_64 o ts && operand_taint_allowed #nat64 #reg_64 o t_out
| IOpXmm -> operand_does_not_use_secrets #quad32 #reg_xmm o ts && operand_taint_allowed #quad32 #reg_xmm o t_out
let check_if_consumes_fixed_time_outs_implicit
(i:instr_operand_implicit) (ts:analysis_taints) (t_out:taint)
: bool
=
match i with
| IOp64One o -> operand_does_not_use_secrets o ts && operand_taint_allowed o t_out
| IOpXmmOne o -> operand_does_not_use_secrets o ts && operand_taint_allowed o t_out
| IOpFlagsCf -> true
| IOpFlagsOf -> true
let rec check_if_consumes_fixed_time_outs
(outs:list instr_out) (args:list instr_operand) (oprs:instr_operands_t outs args)
(ts:analysis_taints) (t_out:taint)
: Pure bool
(requires True)
(ensures fun b -> b ==> (forall (s1 s2:S.machine_state).{:pattern (constTimeInvariant ts.lts s1 s2)}
constTimeInvariant ts.lts s1 s2 ==> obs_inouts outs args oprs s1 == obs_inouts outs args oprs s2))
=
allow_inversion maddr;
allow_inversion tmaddr;
allow_inversion operand64;
allow_inversion operand128;
match outs with
| [] -> check_if_consumes_fixed_time_args args oprs ts
| (_, IOpEx i)::outs ->
let ((o:instr_operand_t i), (oprs:instr_operands_t outs args)) = coerce oprs in
let b' = check_if_consumes_fixed_time_outs_explicit i o ts t_out in
let b'' = check_if_consumes_fixed_time_outs outs args oprs ts t_out in
b' && b''
| (_, IOpIm i)::outs ->
let b' = check_if_consumes_fixed_time_outs_implicit i ts t_out in
let b'' = check_if_consumes_fixed_time_outs outs args (coerce oprs) ts t_out in
b' && b''
#restart-solver
#reset-options "--z3rlimit 300"
let rec lemma_args_taint
(outs:list instr_out) (args:list instr_operand)
(f:instr_args_t outs args) (oprs:instr_operands_t_args args)
(ts:analysis_taints) (s1 s2:S.machine_state)
: Lemma
(requires
constTimeInvariant ts.lts s1 s2 /\
Some? (S.instr_apply_eval_args outs args f oprs s1) /\
Some? (S.instr_apply_eval_args outs args f oprs s2) /\
check_if_consumes_fixed_time_args args oprs ts /\
args_taint args oprs ts == Public)
(ensures
S.instr_apply_eval_args outs args f oprs s1 ==
S.instr_apply_eval_args outs args f oprs s2)
=
allow_inversion maddr;
allow_inversion tmaddr;
allow_inversion operand64;
allow_inversion operand128;
match args with
| [] -> ()
| i::args ->
let (v1, v2, oprs) : option (instr_val_t i) & option (instr_val_t i) & instr_operands_t_args args =
match i with
| IOpEx i ->
let (o, (oprs:instr_operands_t_args args)) = coerce oprs in
(
S.instr_eval_operand_explicit i o s1,
S.instr_eval_operand_explicit i o s2,
oprs)
| IOpIm i ->
let oprs = coerce oprs in (
S.instr_eval_operand_implicit i s1,
S.instr_eval_operand_implicit i s2,
oprs)
in
let f:arrow (instr_val_t i) (instr_args_t outs args) = coerce f in
S.get_heap_val32_reveal ();
S.get_heap_val64_reveal ();
S.get_heap_val128_reveal ();
assert (v1 == v2);
let Some v = v1 in
lemma_args_taint outs args (f v) oprs ts s1 s2
#restart-solver
let rec lemma_inouts_taint
(outs inouts:list instr_out) (args:list instr_operand)
(f:instr_inouts_t outs inouts args) (oprs:instr_operands_t inouts args)
(ts:analysis_taints) (s1 s2:S.machine_state)
: Lemma
(requires
constTimeInvariant ts.lts s1 s2 /\
Some? (S.instr_apply_eval_inouts outs inouts args f oprs s1) /\
Some? (S.instr_apply_eval_inouts outs inouts args f oprs s2) /\
check_if_consumes_fixed_time_outs inouts args oprs ts Public /\
inouts_taint inouts args oprs ts == Public)
(ensures
S.instr_apply_eval_inouts outs inouts args f oprs s1 ==
S.instr_apply_eval_inouts outs inouts args f oprs s2)
=
allow_inversion maddr;
allow_inversion tmaddr;
allow_inversion operand64;
allow_inversion operand128;
match inouts with
| [] -> lemma_args_taint outs args f oprs ts s1 s2
| (Out, i)::inouts ->
let oprs =
match i with
| IOpEx i -> snd #(instr_operand_t i) (coerce oprs)
| IOpIm i -> coerce oprs
in
lemma_inouts_taint outs inouts args (coerce f) oprs ts s1 s2
| (InOut, i)::inouts ->
let (v1, v2, oprs) : option (instr_val_t i) & option (instr_val_t i) & instr_operands_t inouts args =
match i with
| IOpEx i ->
let (o, (oprs:instr_operands_t inouts args)) = coerce oprs in
let oprs = coerce oprs in (
S.instr_eval_operand_explicit i o s1,
S.instr_eval_operand_explicit i o s2,
oprs)
| IOpIm i ->
let oprs = coerce oprs in (
S.instr_eval_operand_implicit i s1,
S.instr_eval_operand_implicit i s2,
oprs)
in
let f:arrow (instr_val_t i) (instr_inouts_t outs inouts args) = coerce f in
S.get_heap_val32_reveal ();
S.get_heap_val64_reveal ();
S.get_heap_val128_reveal ();
assert (v1 == v2);
let Some v = v1 in
lemma_inouts_taint outs inouts args (f v) oprs ts s1 s2
let instr_set_taint_explicit
(i:instr_operand_explicit) (o:instr_operand_t i) (ts:analysis_taints) (t:taint)
: analysis_taints =
match i with
| IOp64 -> set_taint 0 (o <: operand64) ts t
| IOpXmm -> set_taint 1 (o <: operand128) ts t
[@instr_attr]
let instr_set_taint_implicit (i:instr_operand_implicit) (ts:analysis_taints) (t:taint) : analysis_taints =
match i with
| IOp64One o -> set_taint 0 o ts t
| IOpXmmOne o -> set_taint 1 o ts t
| IOpFlagsCf -> set_taint_cf_and_flags ts t
| IOpFlagsOf -> set_taint_of_and_flags ts t
let rec instr_set_taints
(outs:list instr_out) (args:list instr_operand)
(oprs:instr_operands_t outs args) (ts:analysis_taints) (t:taint)
: analysis_taints =
match outs with
| [] -> ts
| (_, i)::outs ->
(
match i with
| IOpEx i ->
let oprs:instr_operand_t i & instr_operands_t outs args = coerce oprs in
instr_set_taints outs args (snd oprs) (instr_set_taint_explicit i (fst oprs) ts t) t
| IOpIm i -> instr_set_taints outs args (coerce oprs) (instr_set_taint_implicit i ts t) t
)
let rec lemma_instr_write_outputs_ok
(outs:list instr_out) (args:list instr_operand)
(vs:instr_ret_t outs) (oprs:instr_operands_t outs args) (s_orig s:S.machine_state)
: Lemma
(requires (S.instr_write_outputs outs args vs oprs s_orig s).S.ms_ok)
(ensures s.S.ms_ok)
=
match outs with
| [] -> ()
| (_, i)::outs ->
(
let ((v:instr_val_t i), (vs:instr_ret_t outs)) =
match outs with
| [] -> (vs, ())
| _::_ -> let vs = coerce vs in (fst vs, snd vs)
in
match i with
| IOpEx i ->
let oprs:instr_operand_t i & instr_operands_t outs args = coerce oprs in
let s' = S.instr_write_output_explicit i v (fst oprs) s_orig s in
lemma_instr_write_outputs_ok outs args vs (snd oprs) s_orig s'
| IOpIm i ->
let s' = S.instr_write_output_implicit i v s_orig s in
lemma_instr_write_outputs_ok outs args vs (coerce oprs) s_orig s'
)
[@"opaque_to_smt"]
let update_heap32_val (ptr:int) (v:Vale.Def.Types_s.nat32) (i:int) : Vale.Def.Types_s.nat8 =
let open Vale.Def.Words_s in
let open Vale.Def.Words.Four_s in
let v = nat_to_four 8 v in
match (i - ptr) with
| 0 -> v.lo0
| 1 -> v.lo1
| 2 -> v.hi2
| 3 -> v.hi3
| _ -> 0
let valid_addr32 (ptr:int) (mem:S.machine_heap) : bool =
S.valid_addr (ptr + 0) mem &&
S.valid_addr (ptr + 1) mem &&
S.valid_addr (ptr + 2) mem &&
S.valid_addr (ptr + 3) mem
let lemma_update_heap32_val (ptr:int) (v:Vale.Def.Types_s.nat32) (mem:S.machine_heap) (i:int) : Lemma
(requires True)
(ensures (S.update_heap32 ptr v mem).[i] ==
(if ptr <= i && i < ptr + 4 then update_heap32_val ptr v i else mem.[i]))
[SMTPat ((S.update_heap32 ptr v mem).[i])]
=
S.update_heap32_reveal ();
reveal_opaque (`%update_heap32_val) update_heap32_val
let lemma_update_heap32_domain (ptr:int) (v:Vale.Def.Types_s.nat32) (mem:S.machine_heap) : Lemma
(requires valid_addr32 ptr mem)
(ensures Map.domain (S.update_heap32 ptr v mem) == Map.domain mem)
[SMTPat (Map.domain (S.update_heap32 ptr v mem))]
=
S.update_heap32_reveal ();
assert (Set.equal (Map.domain (S.update_heap32 ptr v mem)) (Map.domain mem))
[@"opaque_to_smt"]
let update_heap64_val (ptr:int) (v:nat64) (i:int) : Vale.Def.Types_s.nat8 =
let open Vale.Def.Words_s in
let open Vale.Def.Words.Two_s in
let open Vale.Def.Words.Four_s in
let v = nat_to_two 32 v in
let lo = nat_to_four 8 v.lo in
let hi = nat_to_four 8 v.hi in
match (i - ptr) with
| 0 -> lo.lo0
| 1 -> lo.lo1
| 2 -> lo.hi2
| 3 -> lo.hi3
| 4 -> hi.lo0
| 5 -> hi.lo1
| 6 -> hi.hi2
| 7 -> hi.hi3
| _ -> 0
let lemma_update_heap64_val (ptr:int) (v:nat64) (mem:S.machine_heap) (i:int) : Lemma
(requires True)
(ensures
(S.update_heap64 ptr v mem).[i] ==
(if ptr <= i && i < ptr + 8 then update_heap64_val ptr v i else mem.[i])
)
[SMTPat ((S.update_heap64 ptr v mem).[i])]
=
S.update_heap64_reveal ();
reveal_opaque (`%update_heap64_val) update_heap64_val
let lemma_update_heap64_domain (ptr:int) (v:nat64) (mem:S.machine_heap) : Lemma
(requires S.valid_addr64 ptr mem)
(ensures Map.domain (S.update_heap64 ptr v mem) == Map.domain mem)
[SMTPat (Map.domain (S.update_heap64 ptr v mem))]
=
reveal_opaque (`%S.valid_addr64) S.valid_addr64;
S.update_heap64_reveal ();
assert (Set.equal (Map.domain (S.update_heap64 ptr v mem)) (Map.domain mem))
[@"opaque_to_smt"]
let update_heap128_val (ptr:int) (v:Vale.Def.Types_s.quad32) (i:int) : Vale.Def.Types_s.nat8 =
let open Vale.Def.Words_s in
let j = i - ptr in
if 0 <= j && j < 4 then update_heap32_val (ptr + 0 ) v.lo0 i else
if 4 <= j && j < 8 then update_heap32_val (ptr + 4 ) v.lo1 i else
if 8 <= j && j < 12 then update_heap32_val (ptr + 8 ) v.hi2 i else
if 12 <= j && j < 16 then update_heap32_val (ptr + 12) v.hi3 i else
0
let valid_addr128 (ptr:int) (mem:S.machine_heap) : bool =
valid_addr32 (ptr + 0) mem &&
valid_addr32 (ptr + 4) mem &&
valid_addr32 (ptr + 8) mem &&
valid_addr32 (ptr + 12) mem
let lemma_update_heap128_val (ptr:int) (v:Vale.Def.Types_s.quad32) (mem:S.machine_heap) (i:int) : Lemma
(requires True)
(ensures
(S.update_heap128 ptr v mem).[i] ==
(if ptr <= i && i < ptr + 16 then update_heap128_val ptr v i else mem.[i])
)
[SMTPat ((S.update_heap128 ptr v mem).[i])]
=
S.update_heap128_reveal ();
reveal_opaque (`%update_heap128_val) update_heap128_val
let lemma_update_heap128_domain (ptr:int) (v:Vale.Def.Types_s.quad32) (mem:S.machine_heap) : Lemma
(requires valid_addr128 ptr mem)
(ensures Map.domain (S.update_heap128 ptr v mem) == Map.domain mem)
[SMTPat (S.update_heap128 ptr v mem)]
=
S.update_heap128_reveal ();
assert (Set.equal (Map.domain (S.update_heap128 ptr v mem)) (Map.domain mem))
let lemma_preserve_valid64 (m m':S.machine_heap) : Lemma
(requires Set.equal (Map.domain m) (Map.domain m'))
(ensures (forall (i:int).{:pattern (S.valid_addr64 i m')}
S.valid_addr64 i m ==> S.valid_addr64 i m'))
=
reveal_opaque (`%S.valid_addr64) S.valid_addr64
let lemma_preserve_valid128 (m m':S.machine_heap) : Lemma
(requires Set.equal (Map.domain m) (Map.domain m'))
(ensures (forall (i:int).{:pattern (S.valid_addr128 i m')}
S.valid_addr128 i m ==> S.valid_addr128 i m'))
=
reveal_opaque (`%S.valid_addr128) S.valid_addr128
let lemma_instr_set_taints_explicit
(i:instr_operand_explicit) (v1 v2:instr_val_t (IOpEx i)) (o:instr_operand_t i)
(ts_orig ts:analysis_taints) (t_out:taint)
(s1_orig s1 s2_orig s2:S.machine_state)
: Lemma
(requires (
let s1' = S.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = S.instr_write_output_explicit i v2 o s2_orig s2 in
s1'.S.ms_ok /\ s2'.S.ms_ok /\
(t_out == Public ==> v1 == v2) /\
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2.S.ms_heap)) /\
check_if_consumes_fixed_time_outs_explicit i o ts_orig t_out /\
publicValuesAreSame ts_orig.lts s1_orig s2_orig /\
publicValuesAreSame ts.lts s1 s2
))
(ensures (
let s1' = S.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = S.instr_write_output_explicit i v2 o s2_orig s2 in
let ts' = instr_set_taint_explicit i o ts t_out in
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1'.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2'.S.ms_heap)) /\
publicValuesAreSame ts'.lts s1' s2'
)) | false | false | Vale.X64.Leakage_Ins.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 300,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_instr_set_taints_explicit
(i: instr_operand_explicit)
(v1 v2: instr_val_t (IOpEx i))
(o: instr_operand_t i)
(ts_orig ts: analysis_taints)
(t_out: taint)
(s1_orig s1 s2_orig s2: S.machine_state)
: Lemma
(requires
(let s1' = S.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = S.instr_write_output_explicit i v2 o s2_orig s2 in
s1'.S.ms_ok /\ s2'.S.ms_ok /\ (t_out == Public ==> v1 == v2) /\
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2.S.ms_heap)) /\
check_if_consumes_fixed_time_outs_explicit i o ts_orig t_out /\
publicValuesAreSame ts_orig.lts s1_orig s2_orig /\ publicValuesAreSame ts.lts s1 s2))
(ensures
(let s1' = S.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = S.instr_write_output_explicit i v2 o s2_orig s2 in
let ts' = instr_set_taint_explicit i o ts t_out in
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1'.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2'.S.ms_heap)) /\
publicValuesAreSame ts'.lts s1' s2')) | [] | Vale.X64.Leakage_Ins.lemma_instr_set_taints_explicit | {
"file_name": "vale/code/arch/x64/Vale.X64.Leakage_Ins.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
i: Vale.X64.Instruction_s.instr_operand_explicit ->
v1: Vale.X64.Instruction_s.instr_val_t (Vale.X64.Instruction_s.IOpEx i) ->
v2: Vale.X64.Instruction_s.instr_val_t (Vale.X64.Instruction_s.IOpEx i) ->
o: Vale.X64.Instruction_s.instr_operand_t i ->
ts_orig: Vale.X64.Leakage_Helpers.analysis_taints ->
ts: Vale.X64.Leakage_Helpers.analysis_taints ->
t_out: Vale.Arch.HeapTypes_s.taint ->
s1_orig: Vale.X64.Machine_Semantics_s.machine_state ->
s1: Vale.X64.Machine_Semantics_s.machine_state ->
s2_orig: Vale.X64.Machine_Semantics_s.machine_state ->
s2: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma
(requires
(let s1' = Vale.X64.Machine_Semantics_s.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = Vale.X64.Machine_Semantics_s.instr_write_output_explicit i v2 o s2_orig s2 in
Mkmachine_state?.ms_ok s1' /\ Mkmachine_state?.ms_ok s2' /\
(t_out == Vale.Arch.HeapTypes_s.Public ==> v1 == v2) /\
FStar.Set.equal (FStar.Map.domain (Vale.Arch.Heap.heap_get (Mkmachine_state?.ms_heap s1_orig
)))
(FStar.Map.domain (Vale.Arch.Heap.heap_get (Mkmachine_state?.ms_heap s1))) /\
FStar.Set.equal (FStar.Map.domain (Vale.Arch.Heap.heap_get (Mkmachine_state?.ms_heap s2_orig
)))
(FStar.Map.domain (Vale.Arch.Heap.heap_get (Mkmachine_state?.ms_heap s2))) /\
Vale.X64.Leakage_Ins.check_if_consumes_fixed_time_outs_explicit i o ts_orig t_out /\
Vale.X64.Leakage_s.publicValuesAreSame (AnalysisTaints?.lts ts_orig) s1_orig s2_orig /\
Vale.X64.Leakage_s.publicValuesAreSame (AnalysisTaints?.lts ts) s1 s2))
(ensures
(let s1' = Vale.X64.Machine_Semantics_s.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = Vale.X64.Machine_Semantics_s.instr_write_output_explicit i v2 o s2_orig s2 in
let ts' = Vale.X64.Leakage_Ins.instr_set_taint_explicit i o ts t_out in
FStar.Set.equal (FStar.Map.domain (Vale.Arch.Heap.heap_get (Mkmachine_state?.ms_heap s1_orig
)))
(FStar.Map.domain (Vale.Arch.Heap.heap_get (Mkmachine_state?.ms_heap s1'))) /\
FStar.Set.equal (FStar.Map.domain (Vale.Arch.Heap.heap_get (Mkmachine_state?.ms_heap s2_orig
)))
(FStar.Map.domain (Vale.Arch.Heap.heap_get (Mkmachine_state?.ms_heap s2'))) /\
Vale.X64.Leakage_s.publicValuesAreSame (AnalysisTaints?.lts ts') s1' s2')) | {
"end_col": 4,
"end_line": 409,
"start_col": 2,
"start_line": 402
} |
FStar.Pervasives.Lemma | val lemma_pop_leakage_free (ts: analysis_taints) (ins: S.ins)
: Lemma (requires BC.Pop? ins)
(ensures
(let b, ts' = check_if_pop_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts)) | [
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": "BC"
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_pop_leakage_free (ts:analysis_taints) (ins:S.ins) : Lemma
(requires BC.Pop? ins)
(ensures (
let (b, ts') = check_if_pop_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts
))
=
let (b, ts') = check_if_pop_consumes_fixed_time ins ts in
if b then
(
let code = Ins ins in
let lem (s1 s2:S.machine_state) (fuel:nat) : Lemma
(requires is_explicit_leakage_free_lhs code fuel ts.lts ts'.lts s1 s2)
(ensures is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)
[SMTPat (is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)]
=
allow_inversion maddr;
allow_inversion tmaddr;
let BC.Pop dst t_stk = ins in
let s1' = Some?.v (machine_eval_code code fuel s1) in
let s2' = Some?.v (machine_eval_code code fuel s2) in
let stack_op = OStack (MReg reg_Rsp 0, Public) in
let v1 = S.eval_operand stack_op s1 in
let v2 = S.eval_operand stack_op s2 in
if t_stk = Public then (
S.get_heap_val64_reveal ();
assert (v1 == v2)
);
Classical.forall_intro_3 (fun s x (stack1:S.machine_heap) -> Vale.Lib.Set.lemma_sel_restrict s stack1 x);
Classical.forall_intro_3 (fun s x (stack2:S.machine_heap) -> Vale.Lib.Set.lemma_sel_restrict s stack2 x)
in
()
) | val lemma_pop_leakage_free (ts: analysis_taints) (ins: S.ins)
: Lemma (requires BC.Pop? ins)
(ensures
(let b, ts' = check_if_pop_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts))
let lemma_pop_leakage_free (ts: analysis_taints) (ins: S.ins)
: Lemma (requires BC.Pop? ins)
(ensures
(let b, ts' = check_if_pop_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts)) = | false | null | true | let b, ts' = check_if_pop_consumes_fixed_time ins ts in
if b
then
(let code = Ins ins in
let lem (s1 s2: S.machine_state) (fuel: nat)
: Lemma (requires is_explicit_leakage_free_lhs code fuel ts.lts ts'.lts s1 s2)
(ensures is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)
[SMTPat (is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)] =
allow_inversion maddr;
allow_inversion tmaddr;
let BC.Pop dst t_stk = ins in
let s1' = Some?.v (machine_eval_code code fuel s1) in
let s2' = Some?.v (machine_eval_code code fuel s2) in
let stack_op = OStack (MReg reg_Rsp 0, Public) in
let v1 = S.eval_operand stack_op s1 in
let v2 = S.eval_operand stack_op s2 in
if t_stk = Public
then
(S.get_heap_val64_reveal ();
assert (v1 == v2));
Classical.forall_intro_3 (fun s x (stack1: S.machine_heap) ->
Vale.Lib.Set.lemma_sel_restrict s stack1 x);
Classical.forall_intro_3 (fun s x (stack2: S.machine_heap) ->
Vale.Lib.Set.lemma_sel_restrict s stack2 x)
in
()) | {
"checked_file": "Vale.X64.Leakage_Ins.fst.checked",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Leakage_s.fst.checked",
"Vale.X64.Leakage_Helpers.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Set.fsti.checked",
"Vale.Lib.MapTree.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.MachineHeap_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Leakage_Ins.fst"
} | [
"lemma"
] | [
"Vale.X64.Leakage_Helpers.analysis_taints",
"Vale.X64.Machine_Semantics_s.ins",
"Prims.bool",
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.nat",
"Prims.unit",
"Vale.X64.Leakage_s.is_explicit_leakage_free_lhs",
"Vale.X64.Leakage_Helpers.__proj__AnalysisTaints__item__lts",
"Prims.squash",
"Vale.X64.Leakage_s.is_explicit_leakage_free_rhs",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.logical",
"Prims.Nil",
"Vale.X64.Machine_s.operand64",
"Vale.Arch.HeapTypes_s.taint",
"FStar.Classical.forall_intro_3",
"FStar.Set.set",
"Prims.int",
"Vale.Arch.MachineHeap_s.machine_heap",
"Prims.eq2",
"Vale.Def.Words_s.nat8",
"FStar.Map.sel",
"FStar.Map.restrict",
"Vale.Lib.Set.lemma_sel_restrict",
"Vale.Def.Types_s.nat8",
"Prims.op_Equality",
"Vale.Arch.HeapTypes_s.Public",
"Prims._assert",
"Vale.Def.Types_s.nat64",
"Vale.Arch.MachineHeap_s.get_heap_val64_reveal",
"Vale.Def.Words_s.nat64",
"Vale.X64.Machine_Semantics_s.eval_operand",
"Vale.X64.Machine_s.operand",
"Vale.X64.Machine_s.reg_64",
"Vale.X64.Machine_s.OStack",
"Vale.X64.Machine_s.nat64",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Machine_s.maddr",
"Vale.X64.Machine_s.MReg",
"Vale.X64.Machine_s.reg_Rsp",
"FStar.Pervasives.Native.__proj__Some__item__v",
"Vale.X64.Leakage_Ins.machine_eval_code",
"FStar.Pervasives.allow_inversion",
"Vale.X64.Machine_s.tmaddr",
"Vale.X64.Machine_s.precode",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Vale.X64.Bytes_Code_s.ocmp",
"Vale.X64.Machine_s.Ins",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.Leakage_Ins.check_if_pop_consumes_fixed_time",
"Prims.b2t",
"Vale.X64.Bytes_Code_s.uu___is_Pop",
"Prims.l_imp",
"Prims.l_and",
"Vale.X64.Leakage_s.isConstantTime",
"Vale.X64.Leakage_s.isLeakageFree"
] | [] | module Vale.X64.Leakage_Ins
open FStar.Mul
open Vale.Arch.MachineHeap_s
open Vale.Arch.Heap
open Vale.X64.Machine_s
open Vale.X64.Instruction_s
module BC = Vale.X64.Bytes_Code_s
module S = Vale.X64.Machine_Semantics_s
open Vale.X64.Leakage_s
open Vale.X64.Leakage_Helpers
unfold let (.[]) = Map.sel
unfold let (.[]<-) = Map.upd
unfold let obs_args = S.obs_args
unfold let obs_inouts = S.obs_inouts
unfold let machine_eval_code = S.machine_eval_code
let reveal_machine_eval_code_ins (i:S.ins) (s:S.machine_state) : Lemma
(requires True)
(ensures S.machine_eval_code_ins i s == S.machine_eval_code_ins_def i s)
[SMTPat (S.machine_eval_code_ins i s)]
=
reveal_opaque (`%S.machine_eval_code_ins) S.machine_eval_code_ins
let rec check_if_consumes_fixed_time_args
(args:list instr_operand) (oprs:instr_operands_t_args args) (ts:analysis_taints)
: Pure bool
(requires True)
(ensures fun b -> b ==> (forall (s1 s2:S.machine_state).{:pattern (constTimeInvariant ts.lts s1 s2)}
constTimeInvariant ts.lts s1 s2 ==> obs_args args oprs s1 == obs_args args oprs s2))
=
allow_inversion maddr;
allow_inversion tmaddr;
match args with
| [] -> true
| (IOpEx i)::args ->
let ((o:instr_operand_t i), (oprs:instr_operands_t_args args)) = coerce oprs in
let b' =
match i with
| IOp64 -> operand_does_not_use_secrets #nat64 #reg_64 o ts
| IOpXmm -> operand_does_not_use_secrets #quad32 #reg_xmm o ts
in
let b'' = check_if_consumes_fixed_time_args args oprs ts in
b' && b''
| (IOpIm i)::args ->
let b' =
match i with
| IOp64One o -> operand_does_not_use_secrets o ts
| IOpXmmOne o -> operand_does_not_use_secrets o ts
| IOpFlagsCf -> true
| IOpFlagsOf -> true
in
let b'' = check_if_consumes_fixed_time_args args (coerce oprs) ts in
b' && b''
let check_if_consumes_fixed_time_outs_explicit
(i:instr_operand_explicit) (o:instr_operand_t i)
(ts:analysis_taints) (t_out:taint)
: bool
=
match i with
| IOp64 -> operand_does_not_use_secrets #nat64 #reg_64 o ts && operand_taint_allowed #nat64 #reg_64 o t_out
| IOpXmm -> operand_does_not_use_secrets #quad32 #reg_xmm o ts && operand_taint_allowed #quad32 #reg_xmm o t_out
let check_if_consumes_fixed_time_outs_implicit
(i:instr_operand_implicit) (ts:analysis_taints) (t_out:taint)
: bool
=
match i with
| IOp64One o -> operand_does_not_use_secrets o ts && operand_taint_allowed o t_out
| IOpXmmOne o -> operand_does_not_use_secrets o ts && operand_taint_allowed o t_out
| IOpFlagsCf -> true
| IOpFlagsOf -> true
let rec check_if_consumes_fixed_time_outs
(outs:list instr_out) (args:list instr_operand) (oprs:instr_operands_t outs args)
(ts:analysis_taints) (t_out:taint)
: Pure bool
(requires True)
(ensures fun b -> b ==> (forall (s1 s2:S.machine_state).{:pattern (constTimeInvariant ts.lts s1 s2)}
constTimeInvariant ts.lts s1 s2 ==> obs_inouts outs args oprs s1 == obs_inouts outs args oprs s2))
=
allow_inversion maddr;
allow_inversion tmaddr;
allow_inversion operand64;
allow_inversion operand128;
match outs with
| [] -> check_if_consumes_fixed_time_args args oprs ts
| (_, IOpEx i)::outs ->
let ((o:instr_operand_t i), (oprs:instr_operands_t outs args)) = coerce oprs in
let b' = check_if_consumes_fixed_time_outs_explicit i o ts t_out in
let b'' = check_if_consumes_fixed_time_outs outs args oprs ts t_out in
b' && b''
| (_, IOpIm i)::outs ->
let b' = check_if_consumes_fixed_time_outs_implicit i ts t_out in
let b'' = check_if_consumes_fixed_time_outs outs args (coerce oprs) ts t_out in
b' && b''
#restart-solver
#reset-options "--z3rlimit 300"
let rec lemma_args_taint
(outs:list instr_out) (args:list instr_operand)
(f:instr_args_t outs args) (oprs:instr_operands_t_args args)
(ts:analysis_taints) (s1 s2:S.machine_state)
: Lemma
(requires
constTimeInvariant ts.lts s1 s2 /\
Some? (S.instr_apply_eval_args outs args f oprs s1) /\
Some? (S.instr_apply_eval_args outs args f oprs s2) /\
check_if_consumes_fixed_time_args args oprs ts /\
args_taint args oprs ts == Public)
(ensures
S.instr_apply_eval_args outs args f oprs s1 ==
S.instr_apply_eval_args outs args f oprs s2)
=
allow_inversion maddr;
allow_inversion tmaddr;
allow_inversion operand64;
allow_inversion operand128;
match args with
| [] -> ()
| i::args ->
let (v1, v2, oprs) : option (instr_val_t i) & option (instr_val_t i) & instr_operands_t_args args =
match i with
| IOpEx i ->
let (o, (oprs:instr_operands_t_args args)) = coerce oprs in
(
S.instr_eval_operand_explicit i o s1,
S.instr_eval_operand_explicit i o s2,
oprs)
| IOpIm i ->
let oprs = coerce oprs in (
S.instr_eval_operand_implicit i s1,
S.instr_eval_operand_implicit i s2,
oprs)
in
let f:arrow (instr_val_t i) (instr_args_t outs args) = coerce f in
S.get_heap_val32_reveal ();
S.get_heap_val64_reveal ();
S.get_heap_val128_reveal ();
assert (v1 == v2);
let Some v = v1 in
lemma_args_taint outs args (f v) oprs ts s1 s2
#restart-solver
let rec lemma_inouts_taint
(outs inouts:list instr_out) (args:list instr_operand)
(f:instr_inouts_t outs inouts args) (oprs:instr_operands_t inouts args)
(ts:analysis_taints) (s1 s2:S.machine_state)
: Lemma
(requires
constTimeInvariant ts.lts s1 s2 /\
Some? (S.instr_apply_eval_inouts outs inouts args f oprs s1) /\
Some? (S.instr_apply_eval_inouts outs inouts args f oprs s2) /\
check_if_consumes_fixed_time_outs inouts args oprs ts Public /\
inouts_taint inouts args oprs ts == Public)
(ensures
S.instr_apply_eval_inouts outs inouts args f oprs s1 ==
S.instr_apply_eval_inouts outs inouts args f oprs s2)
=
allow_inversion maddr;
allow_inversion tmaddr;
allow_inversion operand64;
allow_inversion operand128;
match inouts with
| [] -> lemma_args_taint outs args f oprs ts s1 s2
| (Out, i)::inouts ->
let oprs =
match i with
| IOpEx i -> snd #(instr_operand_t i) (coerce oprs)
| IOpIm i -> coerce oprs
in
lemma_inouts_taint outs inouts args (coerce f) oprs ts s1 s2
| (InOut, i)::inouts ->
let (v1, v2, oprs) : option (instr_val_t i) & option (instr_val_t i) & instr_operands_t inouts args =
match i with
| IOpEx i ->
let (o, (oprs:instr_operands_t inouts args)) = coerce oprs in
let oprs = coerce oprs in (
S.instr_eval_operand_explicit i o s1,
S.instr_eval_operand_explicit i o s2,
oprs)
| IOpIm i ->
let oprs = coerce oprs in (
S.instr_eval_operand_implicit i s1,
S.instr_eval_operand_implicit i s2,
oprs)
in
let f:arrow (instr_val_t i) (instr_inouts_t outs inouts args) = coerce f in
S.get_heap_val32_reveal ();
S.get_heap_val64_reveal ();
S.get_heap_val128_reveal ();
assert (v1 == v2);
let Some v = v1 in
lemma_inouts_taint outs inouts args (f v) oprs ts s1 s2
let instr_set_taint_explicit
(i:instr_operand_explicit) (o:instr_operand_t i) (ts:analysis_taints) (t:taint)
: analysis_taints =
match i with
| IOp64 -> set_taint 0 (o <: operand64) ts t
| IOpXmm -> set_taint 1 (o <: operand128) ts t
[@instr_attr]
let instr_set_taint_implicit (i:instr_operand_implicit) (ts:analysis_taints) (t:taint) : analysis_taints =
match i with
| IOp64One o -> set_taint 0 o ts t
| IOpXmmOne o -> set_taint 1 o ts t
| IOpFlagsCf -> set_taint_cf_and_flags ts t
| IOpFlagsOf -> set_taint_of_and_flags ts t
let rec instr_set_taints
(outs:list instr_out) (args:list instr_operand)
(oprs:instr_operands_t outs args) (ts:analysis_taints) (t:taint)
: analysis_taints =
match outs with
| [] -> ts
| (_, i)::outs ->
(
match i with
| IOpEx i ->
let oprs:instr_operand_t i & instr_operands_t outs args = coerce oprs in
instr_set_taints outs args (snd oprs) (instr_set_taint_explicit i (fst oprs) ts t) t
| IOpIm i -> instr_set_taints outs args (coerce oprs) (instr_set_taint_implicit i ts t) t
)
let rec lemma_instr_write_outputs_ok
(outs:list instr_out) (args:list instr_operand)
(vs:instr_ret_t outs) (oprs:instr_operands_t outs args) (s_orig s:S.machine_state)
: Lemma
(requires (S.instr_write_outputs outs args vs oprs s_orig s).S.ms_ok)
(ensures s.S.ms_ok)
=
match outs with
| [] -> ()
| (_, i)::outs ->
(
let ((v:instr_val_t i), (vs:instr_ret_t outs)) =
match outs with
| [] -> (vs, ())
| _::_ -> let vs = coerce vs in (fst vs, snd vs)
in
match i with
| IOpEx i ->
let oprs:instr_operand_t i & instr_operands_t outs args = coerce oprs in
let s' = S.instr_write_output_explicit i v (fst oprs) s_orig s in
lemma_instr_write_outputs_ok outs args vs (snd oprs) s_orig s'
| IOpIm i ->
let s' = S.instr_write_output_implicit i v s_orig s in
lemma_instr_write_outputs_ok outs args vs (coerce oprs) s_orig s'
)
[@"opaque_to_smt"]
let update_heap32_val (ptr:int) (v:Vale.Def.Types_s.nat32) (i:int) : Vale.Def.Types_s.nat8 =
let open Vale.Def.Words_s in
let open Vale.Def.Words.Four_s in
let v = nat_to_four 8 v in
match (i - ptr) with
| 0 -> v.lo0
| 1 -> v.lo1
| 2 -> v.hi2
| 3 -> v.hi3
| _ -> 0
let valid_addr32 (ptr:int) (mem:S.machine_heap) : bool =
S.valid_addr (ptr + 0) mem &&
S.valid_addr (ptr + 1) mem &&
S.valid_addr (ptr + 2) mem &&
S.valid_addr (ptr + 3) mem
let lemma_update_heap32_val (ptr:int) (v:Vale.Def.Types_s.nat32) (mem:S.machine_heap) (i:int) : Lemma
(requires True)
(ensures (S.update_heap32 ptr v mem).[i] ==
(if ptr <= i && i < ptr + 4 then update_heap32_val ptr v i else mem.[i]))
[SMTPat ((S.update_heap32 ptr v mem).[i])]
=
S.update_heap32_reveal ();
reveal_opaque (`%update_heap32_val) update_heap32_val
let lemma_update_heap32_domain (ptr:int) (v:Vale.Def.Types_s.nat32) (mem:S.machine_heap) : Lemma
(requires valid_addr32 ptr mem)
(ensures Map.domain (S.update_heap32 ptr v mem) == Map.domain mem)
[SMTPat (Map.domain (S.update_heap32 ptr v mem))]
=
S.update_heap32_reveal ();
assert (Set.equal (Map.domain (S.update_heap32 ptr v mem)) (Map.domain mem))
[@"opaque_to_smt"]
let update_heap64_val (ptr:int) (v:nat64) (i:int) : Vale.Def.Types_s.nat8 =
let open Vale.Def.Words_s in
let open Vale.Def.Words.Two_s in
let open Vale.Def.Words.Four_s in
let v = nat_to_two 32 v in
let lo = nat_to_four 8 v.lo in
let hi = nat_to_four 8 v.hi in
match (i - ptr) with
| 0 -> lo.lo0
| 1 -> lo.lo1
| 2 -> lo.hi2
| 3 -> lo.hi3
| 4 -> hi.lo0
| 5 -> hi.lo1
| 6 -> hi.hi2
| 7 -> hi.hi3
| _ -> 0
let lemma_update_heap64_val (ptr:int) (v:nat64) (mem:S.machine_heap) (i:int) : Lemma
(requires True)
(ensures
(S.update_heap64 ptr v mem).[i] ==
(if ptr <= i && i < ptr + 8 then update_heap64_val ptr v i else mem.[i])
)
[SMTPat ((S.update_heap64 ptr v mem).[i])]
=
S.update_heap64_reveal ();
reveal_opaque (`%update_heap64_val) update_heap64_val
let lemma_update_heap64_domain (ptr:int) (v:nat64) (mem:S.machine_heap) : Lemma
(requires S.valid_addr64 ptr mem)
(ensures Map.domain (S.update_heap64 ptr v mem) == Map.domain mem)
[SMTPat (Map.domain (S.update_heap64 ptr v mem))]
=
reveal_opaque (`%S.valid_addr64) S.valid_addr64;
S.update_heap64_reveal ();
assert (Set.equal (Map.domain (S.update_heap64 ptr v mem)) (Map.domain mem))
[@"opaque_to_smt"]
let update_heap128_val (ptr:int) (v:Vale.Def.Types_s.quad32) (i:int) : Vale.Def.Types_s.nat8 =
let open Vale.Def.Words_s in
let j = i - ptr in
if 0 <= j && j < 4 then update_heap32_val (ptr + 0 ) v.lo0 i else
if 4 <= j && j < 8 then update_heap32_val (ptr + 4 ) v.lo1 i else
if 8 <= j && j < 12 then update_heap32_val (ptr + 8 ) v.hi2 i else
if 12 <= j && j < 16 then update_heap32_val (ptr + 12) v.hi3 i else
0
let valid_addr128 (ptr:int) (mem:S.machine_heap) : bool =
valid_addr32 (ptr + 0) mem &&
valid_addr32 (ptr + 4) mem &&
valid_addr32 (ptr + 8) mem &&
valid_addr32 (ptr + 12) mem
let lemma_update_heap128_val (ptr:int) (v:Vale.Def.Types_s.quad32) (mem:S.machine_heap) (i:int) : Lemma
(requires True)
(ensures
(S.update_heap128 ptr v mem).[i] ==
(if ptr <= i && i < ptr + 16 then update_heap128_val ptr v i else mem.[i])
)
[SMTPat ((S.update_heap128 ptr v mem).[i])]
=
S.update_heap128_reveal ();
reveal_opaque (`%update_heap128_val) update_heap128_val
let lemma_update_heap128_domain (ptr:int) (v:Vale.Def.Types_s.quad32) (mem:S.machine_heap) : Lemma
(requires valid_addr128 ptr mem)
(ensures Map.domain (S.update_heap128 ptr v mem) == Map.domain mem)
[SMTPat (S.update_heap128 ptr v mem)]
=
S.update_heap128_reveal ();
assert (Set.equal (Map.domain (S.update_heap128 ptr v mem)) (Map.domain mem))
let lemma_preserve_valid64 (m m':S.machine_heap) : Lemma
(requires Set.equal (Map.domain m) (Map.domain m'))
(ensures (forall (i:int).{:pattern (S.valid_addr64 i m')}
S.valid_addr64 i m ==> S.valid_addr64 i m'))
=
reveal_opaque (`%S.valid_addr64) S.valid_addr64
let lemma_preserve_valid128 (m m':S.machine_heap) : Lemma
(requires Set.equal (Map.domain m) (Map.domain m'))
(ensures (forall (i:int).{:pattern (S.valid_addr128 i m')}
S.valid_addr128 i m ==> S.valid_addr128 i m'))
=
reveal_opaque (`%S.valid_addr128) S.valid_addr128
let lemma_instr_set_taints_explicit
(i:instr_operand_explicit) (v1 v2:instr_val_t (IOpEx i)) (o:instr_operand_t i)
(ts_orig ts:analysis_taints) (t_out:taint)
(s1_orig s1 s2_orig s2:S.machine_state)
: Lemma
(requires (
let s1' = S.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = S.instr_write_output_explicit i v2 o s2_orig s2 in
s1'.S.ms_ok /\ s2'.S.ms_ok /\
(t_out == Public ==> v1 == v2) /\
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2.S.ms_heap)) /\
check_if_consumes_fixed_time_outs_explicit i o ts_orig t_out /\
publicValuesAreSame ts_orig.lts s1_orig s2_orig /\
publicValuesAreSame ts.lts s1 s2
))
(ensures (
let s1' = S.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = S.instr_write_output_explicit i v2 o s2_orig s2 in
let ts' = instr_set_taint_explicit i o ts t_out in
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1'.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2'.S.ms_heap)) /\
publicValuesAreSame ts'.lts s1' s2'
))
=
allow_inversion maddr;
allow_inversion tmaddr;
lemma_preserve_valid64 (heap_get s1_orig.S.ms_heap) (heap_get s1.S.ms_heap);
lemma_preserve_valid64 (heap_get s2_orig.S.ms_heap) (heap_get s2.S.ms_heap);
lemma_preserve_valid128 (heap_get s1_orig.S.ms_heap) (heap_get s1.S.ms_heap);
lemma_preserve_valid128 (heap_get s2_orig.S.ms_heap) (heap_get s2.S.ms_heap);
reveal_opaque (`%S.valid_addr128) S.valid_addr128;
()
let lemma_instr_set_taints_implicit
(i:instr_operand_implicit) (v1 v2:instr_val_t (IOpIm i))
(ts_orig ts:analysis_taints) (t_out:taint)
(s1_orig s1 s2_orig s2:S.machine_state)
: Lemma
(requires (
let s1' = S.instr_write_output_implicit i v1 s1_orig s1 in
let s2' = S.instr_write_output_implicit i v2 s2_orig s2 in
s1'.S.ms_ok /\ s2'.S.ms_ok /\
(t_out == Public ==> v1 == v2) /\
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2.S.ms_heap)) /\
check_if_consumes_fixed_time_outs_implicit i ts_orig t_out /\
publicValuesAreSame ts_orig.lts s1_orig s2_orig /\
publicValuesAreSame ts.lts s1 s2
))
(ensures (
let s1' = S.instr_write_output_implicit i v1 s1_orig s1 in
let s2' = S.instr_write_output_implicit i v2 s2_orig s2 in
let ts' = instr_set_taint_implicit i ts t_out in
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1'.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2'.S.ms_heap)) /\
publicValuesAreSame ts'.lts s1' s2'
))
=
allow_inversion maddr;
allow_inversion tmaddr;
allow_inversion operand64;
allow_inversion operand128;
lemma_preserve_valid64 (heap_get s1_orig.S.ms_heap) (heap_get s1.S.ms_heap);
lemma_preserve_valid64 (heap_get s2_orig.S.ms_heap) (heap_get s2.S.ms_heap);
lemma_preserve_valid128 (heap_get s1_orig.S.ms_heap) (heap_get s1.S.ms_heap);
lemma_preserve_valid128 (heap_get s2_orig.S.ms_heap) (heap_get s2.S.ms_heap);
reveal_opaque (`%S.valid_addr128) S.valid_addr128;
()
#reset-options "--z3rlimit 80"
let rec lemma_instr_set_taints
(outs:list instr_out) (args:list instr_operand)
(vs1 vs2:instr_ret_t outs) (oprs:instr_operands_t outs args)
(ts_orig ts:analysis_taints) (t_out:taint)
(s1_orig s1 s2_orig s2:S.machine_state)
: Lemma
(requires (
let s1_state' = S.instr_write_outputs outs args vs1 oprs s1_orig s1 in
let s2_state' = S.instr_write_outputs outs args vs2 oprs s2_orig s2 in
s1_state'.S.ms_ok /\ s2_state'.S.ms_ok /\
(t_out == Public ==> vs1 == vs2) /\
Set.equal (Map.domain (heap_get s1_orig.S.ms_heap)) (Map.domain (heap_get s1.S.ms_heap)) /\
Set.equal (Map.domain (heap_get s2_orig.S.ms_heap)) (Map.domain (heap_get s2.S.ms_heap)) /\
check_if_consumes_fixed_time_outs outs args oprs ts_orig t_out /\
publicValuesAreSame ts_orig.lts s1_orig s2_orig /\
publicValuesAreSame ts.lts s1 s2
))
(ensures (
let s1' = S.instr_write_outputs outs args vs1 oprs s1_orig s1 in
let s2' = S.instr_write_outputs outs args vs2 oprs s2_orig s2 in
let ts' = instr_set_taints outs args oprs ts t_out in
publicValuesAreSame ts'.lts s1' s2'
))
=
match outs with
| [] -> ()
| (_, i)::outs ->
(
let ((v1:instr_val_t i), (vs1:instr_ret_t outs)) =
match outs with
| [] -> (vs1, ())
| _::_ -> let vs1 = coerce vs1 in (fst vs1, snd vs1)
in
let ((v2:instr_val_t i), (vs2:instr_ret_t outs)) =
match outs with
| [] -> (vs2, ())
| _::_ -> let vs2 = coerce vs2 in (fst vs2, snd vs2)
in
match i with
| IOpEx i ->
let (o, oprs):instr_operand_t i & instr_operands_t outs args = coerce oprs in
let s1' = S.instr_write_output_explicit i v1 o s1_orig s1 in
let s2' = S.instr_write_output_explicit i v2 o s2_orig s2 in
lemma_instr_write_outputs_ok outs args vs1 oprs s1_orig s1';
lemma_instr_write_outputs_ok outs args vs2 oprs s2_orig s2';
let ts' = instr_set_taint_explicit i o ts t_out in
lemma_instr_set_taints_explicit i v1 v2 o ts_orig ts t_out s1_orig s1 s2_orig s2;
lemma_instr_set_taints outs args vs1 vs2 oprs ts_orig ts' t_out s1_orig s1' s2_orig s2'
| IOpIm i ->
let s1' = S.instr_write_output_implicit i v1 s1_orig s1 in
let s2' = S.instr_write_output_implicit i v2 s2_orig s2 in
lemma_instr_write_outputs_ok outs args vs1 (coerce oprs) s1_orig s1';
lemma_instr_write_outputs_ok outs args vs2 (coerce oprs) s2_orig s2';
let ts' = instr_set_taint_implicit i ts t_out in
lemma_instr_set_taints_implicit i v1 v2 ts_orig ts t_out s1_orig s1 s2_orig s2;
lemma_instr_set_taints outs args vs1 vs2 (coerce oprs) ts_orig ts' t_out s1_orig s1' s2_orig s2'
)
let check_if_instr_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Instr? ins)
(ensures ins_consumes_fixed_time ins ts)
=
let BC.Instr (InstrTypeRecord #outs #args #havoc_flags iins) oprs _ = ins in
let t = inouts_taint outs args oprs ts in
let b = check_if_consumes_fixed_time_outs outs args oprs ts t in
let AnalysisTaints (LeakageTaints rs flags cf ovf) rts = ts in
let flags = match havoc_flags with | HavocFlags -> Secret | PreserveFlags -> flags in
let cf = match havoc_flags with | HavocFlags -> Secret | PreserveFlags -> cf in
let ovf = match havoc_flags with | HavocFlags -> Secret | PreserveFlags -> ovf in
let ts = AnalysisTaints (LeakageTaints rs flags cf ovf) rts in
(b, instr_set_taints outs args oprs ts t)
let coerce_to_normal (#a:Type0) (x:a) : y:(normal a){x == y} = x
let check_if_xor_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Instr? ins /\ S.AnnotateXor64? (BC.Instr?.annotation ins))
(ensures ins_consumes_fixed_time ins ts)
=
let BC.Instr (InstrTypeRecord #outs #args #havoc_flags iins) oprs (S.AnnotateXor64 eq) = ins in
let oprs:normal (instr_operands_t [inOut op64; out opFlagsCf; out opFlagsOf] [op64]) =
coerce_to_normal #(instr_operands_t [inOut op64; out opFlagsCf; out opFlagsOf] [op64]) oprs in
let (o1, (o2, ())) = oprs in
if o1 = o2 then
let t = Public in
let b = check_if_consumes_fixed_time_outs outs args oprs ts t in
let AnalysisTaints (LeakageTaints rs _ _ _) rts = ts in
let ts = AnalysisTaints (LeakageTaints rs Secret Public Public) rts in
(b, instr_set_taints outs args oprs ts t)
else
check_if_instr_consumes_fixed_time ins ts
let check_if_pxor_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Instr? ins /\ S.AnnotatePxor? (BC.Instr?.annotation ins))
(ensures ins_consumes_fixed_time ins ts)
=
let BC.Instr (InstrTypeRecord #outs #args #havoc_flags iins) oprs (S.AnnotatePxor eq) = ins in
let oprs:normal (instr_operands_t [inOut opXmm] [opXmm]) =
coerce_to_normal #(instr_operands_t [inOut opXmm] [opXmm]) oprs in
let (o1, (o2, ())) = oprs in
if o1 = o2 then
let t = Public in
let b = check_if_consumes_fixed_time_outs outs args oprs ts t in
let AnalysisTaints (LeakageTaints rs ft cft oft) rts = ts in
let ts = AnalysisTaints (LeakageTaints rs ft cft oft) rts in
(b, instr_set_taints outs args oprs ts t)
else
check_if_instr_consumes_fixed_time ins ts
let check_if_vpxor_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Instr? ins /\ S.AnnotateVPxor? (BC.Instr?.annotation ins))
(ensures ins_consumes_fixed_time ins ts)
=
let BC.Instr (InstrTypeRecord #outs #args #havoc_flags iins) oprs (S.AnnotateVPxor eq) = ins in
let oprs:normal (instr_operands_t [out opXmm] [opXmm; opXmm]) =
coerce_to_normal #(instr_operands_t [out opXmm] [opXmm; opXmm]) oprs in
let (_, (o2, (o3, ()))) = oprs in
if o2 = o3 then
let t = Public in
let b = check_if_consumes_fixed_time_outs outs args oprs ts t in
let AnalysisTaints (LeakageTaints rs ft cft oft) rts = ts in
let ts = AnalysisTaints (LeakageTaints rs ft cft oft) rts in
(b, instr_set_taints outs args oprs ts t)
else
check_if_instr_consumes_fixed_time ins ts
let check_if_alloc_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Alloc? ins)
(ensures ins_consumes_fixed_time ins ts)
=
(true, ts)
let check_if_dealloc_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Dealloc? ins)
(ensures ins_consumes_fixed_time ins ts)
=
(true, ts)
#reset-options "--initial_ifuel 3 --max_ifuel 3 --initial_fuel 4 --max_fuel 4 --z3rlimit 80"
let check_if_push_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Push? ins)
(ensures ins_consumes_fixed_time ins ts)
=
let BC.Push src t_stk = ins in
let t_out = operand_taint 0 src ts in
(Public? (Vale.Lib.MapTree.sel ts.rts reg_Rsp) && operand_does_not_use_secrets src ts && (t_out = Public || t_stk = Secret), ts)
let check_if_pop_consumes_fixed_time (ins:S.ins) (ts:analysis_taints) : Pure (bool & analysis_taints)
(requires BC.Pop? ins)
(ensures ins_consumes_fixed_time ins ts)
=
let BC.Pop dst t_stk = ins in
let allowed = operand_taint_allowed dst t_stk in
(Public? (Vale.Lib.MapTree.sel ts.rts reg_Rsp) && operand_does_not_use_secrets dst ts && allowed, set_taint 0 dst ts t_stk)
let check_if_ins_consumes_fixed_time ins ts =
match ins with
| BC.Instr _ _ (S.AnnotateXor64 _) -> check_if_xor_consumes_fixed_time ins ts
| BC.Instr _ _ (S.AnnotatePxor _) -> check_if_pxor_consumes_fixed_time ins ts
| BC.Instr _ _ (S.AnnotateVPxor _) -> check_if_vpxor_consumes_fixed_time ins ts
| BC.Instr _ _ _ -> check_if_instr_consumes_fixed_time ins ts
| BC.Push _ _ -> check_if_push_consumes_fixed_time ins ts
| BC.Pop _ _ -> check_if_pop_consumes_fixed_time ins ts
| BC.Alloc _ -> check_if_alloc_consumes_fixed_time ins ts
| BC.Dealloc _ -> check_if_dealloc_consumes_fixed_time ins ts
#reset-options "--initial_ifuel 1 --max_ifuel 1 --initial_fuel 1 --max_fuel 1 --z3rlimit 100"
let lemma_instr_leakage_free (ts:analysis_taints) (ins:S.ins) : Lemma
(requires BC.Instr? ins)
(ensures (
let (b, ts') = check_if_instr_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts
))
=
let (b, ts') = check_if_instr_consumes_fixed_time ins ts in
if b then
(
let code = Ins ins in
let lem (s1 s2:S.machine_state) (fuel:nat) : Lemma
(requires is_explicit_leakage_free_lhs code fuel ts.lts ts'.lts s1 s2)
(ensures is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)
[SMTPat (is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)]
=
let BC.Instr (InstrTypeRecord #outs #args #havoc_flags i) oprs _ = ins in
let t_out = inouts_taint outs args oprs ts in
let s1 = {s1 with S.ms_trace = []} in
let s2 = {s2 with S.ms_trace = []} in
let Some vs1 = S.instr_apply_eval outs args (instr_eval i) oprs s1 in
let Some vs2 = S.instr_apply_eval outs args (instr_eval i) oprs s2 in
let s1' =
match havoc_flags with
| HavocFlags -> {s1 with S.ms_flags = S.havoc_flags}
| PreserveFlags -> s1
in
let s2' =
match havoc_flags with
| HavocFlags -> {s2 with S.ms_flags = S.havoc_flags}
| PreserveFlags -> s2
in
let AnalysisTaints (LeakageTaints rs flags cf ovf) rts = ts in
let flags = match havoc_flags with | HavocFlags -> Secret | PreserveFlags -> flags in
let cf = match havoc_flags with | HavocFlags -> Secret | PreserveFlags -> cf in
let ovf = match havoc_flags with | HavocFlags -> Secret | PreserveFlags -> ovf in
let ts_havoc = AnalysisTaints (LeakageTaints rs flags cf ovf) rts in
if t_out = Secret then
(
lemma_instr_set_taints outs args vs1 vs2 oprs ts ts_havoc t_out s1 s1' s2 s2';
()
)
else
(
let vs = vs1 in
lemma_inouts_taint outs outs args (instr_eval i) oprs ts s1 s2;
lemma_instr_set_taints outs args vs vs oprs ts ts_havoc t_out s1 s1' s2 s2';
()
)
in
// assert (isExplicitLeakageFree (Ins ins) ts ts');
()
)
let lemma_dealloc_leakage_free (ts:analysis_taints) (ins:S.ins) : Lemma
(requires BC.Dealloc? ins)
(ensures (
let (b, ts') = check_if_dealloc_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts
))
=
let (b, ts') = check_if_dealloc_consumes_fixed_time ins ts in
if b then
(
let code = Ins ins in
let lem (s1 s2:S.machine_state) (fuel:nat) : Lemma
(requires is_explicit_leakage_free_lhs code fuel ts.lts ts'.lts s1 s2)
(ensures is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)
[SMTPat (is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)]
=
let BC.Dealloc n = ins in
let s1' = Some?.v (machine_eval_code code fuel s1) in
let s2' = Some?.v (machine_eval_code code fuel s2) in
let S.Machine_stack _ stack1 = s1.S.ms_stack in
let S.Machine_stack _ stack2 = s2.S.ms_stack in
let S.Machine_stack _ stack1' = s1'.S.ms_stack in
let S.Machine_stack _ stack2' = s2'.S.ms_stack in
let aux (x:int) : Lemma
(requires publicStackValueIsSame stack1 stack2 s1.S.ms_stackTaint s2.S.ms_stackTaint x)
(ensures publicStackValueIsSame stack1' stack2' s1'.S.ms_stackTaint s2'.S.ms_stackTaint x)
=
Classical.forall_intro (fun s -> Vale.Lib.Set.lemma_sel_restrict s stack1 x);
Classical.forall_intro (fun s -> Vale.Lib.Set.lemma_sel_restrict s stack2 x)
in Classical.forall_intro (Classical.move_requires aux)
in
()
)
let lemma_push_leakage_free (ts:analysis_taints) (ins:S.ins) : Lemma
(requires BC.Push? ins)
(ensures (
let (b, ts') = check_if_push_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts
))
=
let (b, ts') = check_if_push_consumes_fixed_time ins ts in
if b then
(
let code = Ins ins in
let lem (s1 s2:S.machine_state) (fuel:nat) : Lemma
(requires is_explicit_leakage_free_lhs code fuel ts.lts ts'.lts s1 s2)
(ensures is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)
[SMTPat (is_explicit_leakage_free_rhs code fuel ts.lts ts'.lts s1 s2)]
=
let BC.Push src t_stk = ins in
let t_out = operand_taint 0 src ts in
let s1' = Some?.v (machine_eval_code code fuel s1) in
let s2' = Some?.v (machine_eval_code code fuel s2) in
let S.Machine_stack _ stack1 = s1.S.ms_stack in
let S.Machine_stack _ stack2 = s2.S.ms_stack in
let S.Machine_stack _ stack1' = s1'.S.ms_stack in
let S.Machine_stack _ stack2' = s2'.S.ms_stack in
let ptr1 = S.eval_reg_64 rRsp s1 - 8 in
let ptr2 = S.eval_reg_64 rRsp s2 - 8 in
let v1 = S.eval_operand src s1 in
let v2 = S.eval_operand src s2 in
assert (ptr1 == ptr2);
if t_out = Secret then ()
else (
let aux () : Lemma (v1 == v2)
= match src with
| OConst _ | OReg _ -> ()
| OMem (_, _) | OStack (_, _) -> S.get_heap_val64_reveal ()
in
aux()
)
in
()
)
#reset-options "--initial_ifuel 1 --max_ifuel 1 --initial_fuel 1 --max_fuel 1 --z3rlimit 100"
let lemma_pop_leakage_free (ts:analysis_taints) (ins:S.ins) : Lemma
(requires BC.Pop? ins)
(ensures (
let (b, ts') = check_if_pop_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts | false | false | Vale.X64.Leakage_Ins.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_pop_leakage_free (ts: analysis_taints) (ins: S.ins)
: Lemma (requires BC.Pop? ins)
(ensures
(let b, ts' = check_if_pop_consumes_fixed_time ins ts in
b2t b ==> isConstantTime (Ins ins) ts.lts /\ isLeakageFree (Ins ins) ts.lts ts'.lts)) | [] | Vale.X64.Leakage_Ins.lemma_pop_leakage_free | {
"file_name": "vale/code/arch/x64/Vale.X64.Leakage_Ins.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | ts: Vale.X64.Leakage_Helpers.analysis_taints -> ins: Vale.X64.Machine_Semantics_s.ins
-> FStar.Pervasives.Lemma (requires Pop? ins)
(ensures
(let _ = Vale.X64.Leakage_Ins.check_if_pop_consumes_fixed_time ins ts in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ b ts' = _ in
b ==>
Vale.X64.Leakage_s.isConstantTime (Vale.X64.Machine_s.Ins ins) (AnalysisTaints?.lts ts) /\
Vale.X64.Leakage_s.isLeakageFree (Vale.X64.Machine_s.Ins ins)
(AnalysisTaints?.lts ts)
(AnalysisTaints?.lts ts'))
<:
Type0)) | {
"end_col": 3,
"end_line": 779,
"start_col": 3,
"start_line": 753
} |
Prims.Tot | val prot:Type u#1 | [
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Channel.Protocol",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Channel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Channel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let prot : Type u#1 = protocol unit | val prot:Type u#1
let prot:Type u#1 = | false | null | false | protocol unit | {
"checked_file": "Steel.Channel.Simplex.fsti.checked",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.Effect.fsti.checked",
"Steel.Channel.Protocol.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.Channel.Simplex.fsti"
} | [
"total"
] | [
"Steel.Channel.Protocol.protocol",
"Prims.unit"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Channel.Simplex
open Steel.Channel.Protocol
open Steel.Memory
open Steel.Effect
/// This library provides a model of unidirectional, protocol-indexed channels.
/// One party is allowed to send messages on the channel, while the other is allowed
/// to receive messages on the same channel.
/// Protocols are specified using the structure in Steel.Channel.Protocol
/// Msg int (fun x -> Msg (y:int { y > x }) (fun _ -> Ret unit))
/// | false | true | Steel.Channel.Simplex.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val prot:Type u#1 | [] | Steel.Channel.Simplex.prot | {
"file_name": "lib/steel/Steel.Channel.Simplex.fsti",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | Type | {
"end_col": 35,
"end_line": 31,
"start_col": 22,
"start_line": 31
} |
FStar.Tactics.Effect.Tac | [
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fail (#a:Type) (m:string) = raise #a (TacticFailure m) | let fail (#a: Type) (m: string) = | true | null | false | raise #a (TacticFailure m) | {
"checked_file": "FStar.Tactics.V2.SyntaxHelpers.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.Builtins.fsti.checked",
"FStar.Tactics.Types.fsti.checked",
"FStar.Tactics.NamedView.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Base.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.V2.SyntaxHelpers.fst"
} | [] | [
"Prims.string",
"FStar.Tactics.Effect.raise",
"FStar.Tactics.Common.TacticFailure"
] | [] | module FStar.Tactics.V2.SyntaxHelpers
open FStar.Reflection.V2
open FStar.Tactics.Effect
open FStar.Tactics.V2.Builtins
open FStar.Tactics.Types
open FStar.Tactics.NamedView
(* These are fully-named variants of functions found in FStar.Reflection *)
private
let rec collect_arr' (bs : list binder) (c : comp) : Tac (list binder * comp) =
begin match c with
| C_Total t ->
begin match inspect t with
| Tv_Arrow b c ->
collect_arr' (b::bs) c
| _ ->
(bs, c)
end
| _ -> (bs, c)
end
val collect_arr_bs : typ -> Tac (list binder * comp)
let collect_arr_bs t =
let (bs, c) = collect_arr' [] (C_Total t) in
(List.Tot.Base.rev bs, c)
val collect_arr : typ -> Tac (list typ * comp)
let collect_arr t =
let (bs, c) = collect_arr' [] (C_Total t) in
let ts = List.Tot.Base.map (fun (b:binder) -> b.sort) bs in
(List.Tot.Base.rev ts, c)
private
let rec collect_abs' (bs : list binder) (t : term) : Tac (list binder * term) (decreases t) =
match inspect t with
| Tv_Abs b t' ->
collect_abs' (b::bs) t'
| _ -> (bs, t)
val collect_abs : term -> Tac (list binder * term)
let collect_abs t =
let (bs, t') = collect_abs' [] t in
(List.Tot.Base.rev bs, t')
(* Copied from FStar.Tactics.V2.Derived *) | false | false | FStar.Tactics.V2.SyntaxHelpers.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fail : m: Prims.string -> FStar.Tactics.Effect.Tac a | [] | FStar.Tactics.V2.SyntaxHelpers.fail | {
"file_name": "ulib/FStar.Tactics.V2.SyntaxHelpers.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | m: Prims.string -> FStar.Tactics.Effect.Tac a | {
"end_col": 58,
"end_line": 49,
"start_col": 32,
"start_line": 49
} |
|
FStar.Tactics.Effect.Tac | val collect_arr : typ -> Tac (list typ * comp) | [
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let collect_arr t =
let (bs, c) = collect_arr' [] (C_Total t) in
let ts = List.Tot.Base.map (fun (b:binder) -> b.sort) bs in
(List.Tot.Base.rev ts, c) | val collect_arr : typ -> Tac (list typ * comp)
let collect_arr t = | true | null | false | let bs, c = collect_arr' [] (C_Total t) in
let ts = List.Tot.Base.map (fun (b: binder) -> b.sort) bs in
(List.Tot.Base.rev ts, c) | {
"checked_file": "FStar.Tactics.V2.SyntaxHelpers.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.Builtins.fsti.checked",
"FStar.Tactics.Types.fsti.checked",
"FStar.Tactics.NamedView.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Base.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.V2.SyntaxHelpers.fst"
} | [] | [
"FStar.Reflection.Types.typ",
"Prims.list",
"FStar.Tactics.NamedView.binder",
"FStar.Tactics.NamedView.comp",
"FStar.Pervasives.Native.Mktuple2",
"FStar.List.Tot.Base.rev",
"FStar.List.Tot.Base.map",
"FStar.Tactics.NamedView.__proj__Mkbinder__item__sort",
"FStar.Pervasives.Native.tuple2",
"FStar.Tactics.V2.SyntaxHelpers.collect_arr'",
"Prims.Nil",
"FStar.Reflection.V2.Data.C_Total"
] | [] | module FStar.Tactics.V2.SyntaxHelpers
open FStar.Reflection.V2
open FStar.Tactics.Effect
open FStar.Tactics.V2.Builtins
open FStar.Tactics.Types
open FStar.Tactics.NamedView
(* These are fully-named variants of functions found in FStar.Reflection *)
private
let rec collect_arr' (bs : list binder) (c : comp) : Tac (list binder * comp) =
begin match c with
| C_Total t ->
begin match inspect t with
| Tv_Arrow b c ->
collect_arr' (b::bs) c
| _ ->
(bs, c)
end
| _ -> (bs, c)
end
val collect_arr_bs : typ -> Tac (list binder * comp)
let collect_arr_bs t =
let (bs, c) = collect_arr' [] (C_Total t) in
(List.Tot.Base.rev bs, c) | false | false | FStar.Tactics.V2.SyntaxHelpers.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val collect_arr : typ -> Tac (list typ * comp) | [] | FStar.Tactics.V2.SyntaxHelpers.collect_arr | {
"file_name": "ulib/FStar.Tactics.V2.SyntaxHelpers.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | t: FStar.Reflection.Types.typ
-> FStar.Tactics.Effect.Tac (Prims.list FStar.Reflection.Types.typ * FStar.Tactics.NamedView.comp) | {
"end_col": 29,
"end_line": 33,
"start_col": 19,
"start_line": 30
} |
FStar.Tactics.Effect.Tac | [
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let collect_app = collect_app' [] | let collect_app = | true | null | false | collect_app' [] | {
"checked_file": "FStar.Tactics.V2.SyntaxHelpers.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.Builtins.fsti.checked",
"FStar.Tactics.Types.fsti.checked",
"FStar.Tactics.NamedView.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Base.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.V2.SyntaxHelpers.fst"
} | [] | [
"FStar.Tactics.V2.SyntaxHelpers.collect_app'",
"Prims.Nil",
"FStar.Reflection.V2.Data.argv"
] | [] | module FStar.Tactics.V2.SyntaxHelpers
open FStar.Reflection.V2
open FStar.Tactics.Effect
open FStar.Tactics.V2.Builtins
open FStar.Tactics.Types
open FStar.Tactics.NamedView
(* These are fully-named variants of functions found in FStar.Reflection *)
private
let rec collect_arr' (bs : list binder) (c : comp) : Tac (list binder * comp) =
begin match c with
| C_Total t ->
begin match inspect t with
| Tv_Arrow b c ->
collect_arr' (b::bs) c
| _ ->
(bs, c)
end
| _ -> (bs, c)
end
val collect_arr_bs : typ -> Tac (list binder * comp)
let collect_arr_bs t =
let (bs, c) = collect_arr' [] (C_Total t) in
(List.Tot.Base.rev bs, c)
val collect_arr : typ -> Tac (list typ * comp)
let collect_arr t =
let (bs, c) = collect_arr' [] (C_Total t) in
let ts = List.Tot.Base.map (fun (b:binder) -> b.sort) bs in
(List.Tot.Base.rev ts, c)
private
let rec collect_abs' (bs : list binder) (t : term) : Tac (list binder * term) (decreases t) =
match inspect t with
| Tv_Abs b t' ->
collect_abs' (b::bs) t'
| _ -> (bs, t)
val collect_abs : term -> Tac (list binder * term)
let collect_abs t =
let (bs, t') = collect_abs' [] t in
(List.Tot.Base.rev bs, t')
(* Copied from FStar.Tactics.V2.Derived *)
private
let fail (#a:Type) (m:string) = raise #a (TacticFailure m)
let rec mk_arr (bs: list binder) (cod : comp) : Tac term =
match bs with
| [] -> fail "mk_arr, empty binders"
| [b] -> pack (Tv_Arrow b cod)
| (b::bs) ->
pack (Tv_Arrow b (C_Total (mk_arr bs cod)))
let rec mk_tot_arr (bs: list binder) (cod : term) : Tac term =
match bs with
| [] -> cod
| (b::bs) ->
pack (Tv_Arrow b (C_Total (mk_tot_arr bs cod)))
let lookup_lb (lbs:list letbinding) (nm:name) : Tac letbinding =
let o = FStar.List.Tot.Base.find
(fun lb -> (inspect_fv lb.lb_fv) = nm)
lbs
in
match o with
| Some lb -> lb
| None -> fail "lookup_letbinding: Name not in let group"
let rec inspect_unascribe (t:term) : Tac (tv:term_view{notAscription tv}) =
match inspect t with
| Tv_AscribedT t _ _ _
| Tv_AscribedC t _ _ _ ->
inspect_unascribe t
| tv -> tv
(* Helpers for dealing with nested applications and arrows *)
let rec collect_app' (args : list argv) (t : term)
: Tac (term * list argv) =
match inspect_unascribe t with
| Tv_App l r ->
collect_app' (r::args) l
| _ -> (t, args) | false | false | FStar.Tactics.V2.SyntaxHelpers.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val collect_app : t: FStar.Tactics.NamedView.term
-> FStar.Tactics.Effect.Tac
(FStar.Tactics.NamedView.term * Prims.list FStar.Reflection.V2.Data.argv) | [] | FStar.Tactics.V2.SyntaxHelpers.collect_app | {
"file_name": "ulib/FStar.Tactics.V2.SyntaxHelpers.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | t: FStar.Tactics.NamedView.term
-> FStar.Tactics.Effect.Tac
(FStar.Tactics.NamedView.term * Prims.list FStar.Reflection.V2.Data.argv) | {
"end_col": 33,
"end_line": 88,
"start_col": 18,
"start_line": 88
} |
|
FStar.Tactics.Effect.Tac | val collect_abs' (bs: list binder) (t: term) : Tac (list binder * term) (decreases t) | [
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec collect_abs' (bs : list binder) (t : term) : Tac (list binder * term) (decreases t) =
match inspect t with
| Tv_Abs b t' ->
collect_abs' (b::bs) t'
| _ -> (bs, t) | val collect_abs' (bs: list binder) (t: term) : Tac (list binder * term) (decreases t)
let rec collect_abs' (bs: list binder) (t: term) : Tac (list binder * term) (decreases t) = | true | null | false | match inspect t with
| Tv_Abs b t' -> collect_abs' (b :: bs) t'
| _ -> (bs, t) | {
"checked_file": "FStar.Tactics.V2.SyntaxHelpers.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.Builtins.fsti.checked",
"FStar.Tactics.Types.fsti.checked",
"FStar.Tactics.NamedView.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Base.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.V2.SyntaxHelpers.fst"
} | [
""
] | [
"Prims.list",
"FStar.Tactics.NamedView.binder",
"FStar.Tactics.NamedView.term",
"FStar.Tactics.V2.SyntaxHelpers.collect_abs'",
"Prims.Cons",
"FStar.Pervasives.Native.tuple2",
"FStar.Tactics.NamedView.named_term_view",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Tactics.NamedView.inspect"
] | [] | module FStar.Tactics.V2.SyntaxHelpers
open FStar.Reflection.V2
open FStar.Tactics.Effect
open FStar.Tactics.V2.Builtins
open FStar.Tactics.Types
open FStar.Tactics.NamedView
(* These are fully-named variants of functions found in FStar.Reflection *)
private
let rec collect_arr' (bs : list binder) (c : comp) : Tac (list binder * comp) =
begin match c with
| C_Total t ->
begin match inspect t with
| Tv_Arrow b c ->
collect_arr' (b::bs) c
| _ ->
(bs, c)
end
| _ -> (bs, c)
end
val collect_arr_bs : typ -> Tac (list binder * comp)
let collect_arr_bs t =
let (bs, c) = collect_arr' [] (C_Total t) in
(List.Tot.Base.rev bs, c)
val collect_arr : typ -> Tac (list typ * comp)
let collect_arr t =
let (bs, c) = collect_arr' [] (C_Total t) in
let ts = List.Tot.Base.map (fun (b:binder) -> b.sort) bs in
(List.Tot.Base.rev ts, c)
private | false | false | FStar.Tactics.V2.SyntaxHelpers.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val collect_abs' (bs: list binder) (t: term) : Tac (list binder * term) (decreases t) | [
"recursion"
] | FStar.Tactics.V2.SyntaxHelpers.collect_abs' | {
"file_name": "ulib/FStar.Tactics.V2.SyntaxHelpers.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | bs: Prims.list FStar.Tactics.NamedView.binder -> t: FStar.Tactics.NamedView.term
-> FStar.Tactics.Effect.Tac
(Prims.list FStar.Tactics.NamedView.binder * FStar.Tactics.NamedView.term) | {
"end_col": 18,
"end_line": 40,
"start_col": 4,
"start_line": 37
} |
FStar.Tactics.Effect.Tac | val collect_arr_bs : typ -> Tac (list binder * comp) | [
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let collect_arr_bs t =
let (bs, c) = collect_arr' [] (C_Total t) in
(List.Tot.Base.rev bs, c) | val collect_arr_bs : typ -> Tac (list binder * comp)
let collect_arr_bs t = | true | null | false | let bs, c = collect_arr' [] (C_Total t) in
(List.Tot.Base.rev bs, c) | {
"checked_file": "FStar.Tactics.V2.SyntaxHelpers.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.Builtins.fsti.checked",
"FStar.Tactics.Types.fsti.checked",
"FStar.Tactics.NamedView.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Base.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.V2.SyntaxHelpers.fst"
} | [] | [
"FStar.Reflection.Types.typ",
"Prims.list",
"FStar.Tactics.NamedView.binder",
"FStar.Tactics.NamedView.comp",
"FStar.Pervasives.Native.Mktuple2",
"FStar.List.Tot.Base.rev",
"FStar.Pervasives.Native.tuple2",
"FStar.Tactics.V2.SyntaxHelpers.collect_arr'",
"Prims.Nil",
"FStar.Reflection.V2.Data.C_Total"
] | [] | module FStar.Tactics.V2.SyntaxHelpers
open FStar.Reflection.V2
open FStar.Tactics.Effect
open FStar.Tactics.V2.Builtins
open FStar.Tactics.Types
open FStar.Tactics.NamedView
(* These are fully-named variants of functions found in FStar.Reflection *)
private
let rec collect_arr' (bs : list binder) (c : comp) : Tac (list binder * comp) =
begin match c with
| C_Total t ->
begin match inspect t with
| Tv_Arrow b c ->
collect_arr' (b::bs) c
| _ ->
(bs, c)
end
| _ -> (bs, c)
end | false | false | FStar.Tactics.V2.SyntaxHelpers.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val collect_arr_bs : typ -> Tac (list binder * comp) | [] | FStar.Tactics.V2.SyntaxHelpers.collect_arr_bs | {
"file_name": "ulib/FStar.Tactics.V2.SyntaxHelpers.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | t: FStar.Reflection.Types.typ
-> FStar.Tactics.Effect.Tac
(Prims.list FStar.Tactics.NamedView.binder * FStar.Tactics.NamedView.comp) | {
"end_col": 29,
"end_line": 27,
"start_col": 22,
"start_line": 25
} |
FStar.Tactics.Effect.Tac | val collect_abs : term -> Tac (list binder * term) | [
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let collect_abs t =
let (bs, t') = collect_abs' [] t in
(List.Tot.Base.rev bs, t') | val collect_abs : term -> Tac (list binder * term)
let collect_abs t = | true | null | false | let bs, t' = collect_abs' [] t in
(List.Tot.Base.rev bs, t') | {
"checked_file": "FStar.Tactics.V2.SyntaxHelpers.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.Builtins.fsti.checked",
"FStar.Tactics.Types.fsti.checked",
"FStar.Tactics.NamedView.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Base.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.V2.SyntaxHelpers.fst"
} | [] | [
"FStar.Tactics.NamedView.term",
"Prims.list",
"FStar.Tactics.NamedView.binder",
"FStar.Pervasives.Native.Mktuple2",
"FStar.List.Tot.Base.rev",
"FStar.Pervasives.Native.tuple2",
"FStar.Tactics.V2.SyntaxHelpers.collect_abs'",
"Prims.Nil"
] | [] | module FStar.Tactics.V2.SyntaxHelpers
open FStar.Reflection.V2
open FStar.Tactics.Effect
open FStar.Tactics.V2.Builtins
open FStar.Tactics.Types
open FStar.Tactics.NamedView
(* These are fully-named variants of functions found in FStar.Reflection *)
private
let rec collect_arr' (bs : list binder) (c : comp) : Tac (list binder * comp) =
begin match c with
| C_Total t ->
begin match inspect t with
| Tv_Arrow b c ->
collect_arr' (b::bs) c
| _ ->
(bs, c)
end
| _ -> (bs, c)
end
val collect_arr_bs : typ -> Tac (list binder * comp)
let collect_arr_bs t =
let (bs, c) = collect_arr' [] (C_Total t) in
(List.Tot.Base.rev bs, c)
val collect_arr : typ -> Tac (list typ * comp)
let collect_arr t =
let (bs, c) = collect_arr' [] (C_Total t) in
let ts = List.Tot.Base.map (fun (b:binder) -> b.sort) bs in
(List.Tot.Base.rev ts, c)
private
let rec collect_abs' (bs : list binder) (t : term) : Tac (list binder * term) (decreases t) =
match inspect t with
| Tv_Abs b t' ->
collect_abs' (b::bs) t'
| _ -> (bs, t) | false | false | FStar.Tactics.V2.SyntaxHelpers.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val collect_abs : term -> Tac (list binder * term) | [] | FStar.Tactics.V2.SyntaxHelpers.collect_abs | {
"file_name": "ulib/FStar.Tactics.V2.SyntaxHelpers.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | t: FStar.Tactics.NamedView.term
-> FStar.Tactics.Effect.Tac
(Prims.list FStar.Tactics.NamedView.binder * FStar.Tactics.NamedView.term) | {
"end_col": 30,
"end_line": 45,
"start_col": 19,
"start_line": 43
} |
FStar.Tactics.Effect.Tac | val collect_app' (args: list argv) (t: term) : Tac (term * list argv) | [
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec collect_app' (args : list argv) (t : term)
: Tac (term * list argv) =
match inspect_unascribe t with
| Tv_App l r ->
collect_app' (r::args) l
| _ -> (t, args) | val collect_app' (args: list argv) (t: term) : Tac (term * list argv)
let rec collect_app' (args: list argv) (t: term) : Tac (term * list argv) = | true | null | false | match inspect_unascribe t with
| Tv_App l r -> collect_app' (r :: args) l
| _ -> (t, args) | {
"checked_file": "FStar.Tactics.V2.SyntaxHelpers.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.Builtins.fsti.checked",
"FStar.Tactics.Types.fsti.checked",
"FStar.Tactics.NamedView.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Base.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.V2.SyntaxHelpers.fst"
} | [] | [
"Prims.list",
"FStar.Reflection.V2.Data.argv",
"FStar.Tactics.NamedView.term",
"FStar.Tactics.V2.SyntaxHelpers.collect_app'",
"Prims.Cons",
"FStar.Pervasives.Native.tuple2",
"FStar.Tactics.NamedView.named_term_view",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Tactics.NamedView.term_view",
"Prims.b2t",
"FStar.Tactics.NamedView.notAscription",
"FStar.Tactics.V2.SyntaxHelpers.inspect_unascribe"
] | [] | module FStar.Tactics.V2.SyntaxHelpers
open FStar.Reflection.V2
open FStar.Tactics.Effect
open FStar.Tactics.V2.Builtins
open FStar.Tactics.Types
open FStar.Tactics.NamedView
(* These are fully-named variants of functions found in FStar.Reflection *)
private
let rec collect_arr' (bs : list binder) (c : comp) : Tac (list binder * comp) =
begin match c with
| C_Total t ->
begin match inspect t with
| Tv_Arrow b c ->
collect_arr' (b::bs) c
| _ ->
(bs, c)
end
| _ -> (bs, c)
end
val collect_arr_bs : typ -> Tac (list binder * comp)
let collect_arr_bs t =
let (bs, c) = collect_arr' [] (C_Total t) in
(List.Tot.Base.rev bs, c)
val collect_arr : typ -> Tac (list typ * comp)
let collect_arr t =
let (bs, c) = collect_arr' [] (C_Total t) in
let ts = List.Tot.Base.map (fun (b:binder) -> b.sort) bs in
(List.Tot.Base.rev ts, c)
private
let rec collect_abs' (bs : list binder) (t : term) : Tac (list binder * term) (decreases t) =
match inspect t with
| Tv_Abs b t' ->
collect_abs' (b::bs) t'
| _ -> (bs, t)
val collect_abs : term -> Tac (list binder * term)
let collect_abs t =
let (bs, t') = collect_abs' [] t in
(List.Tot.Base.rev bs, t')
(* Copied from FStar.Tactics.V2.Derived *)
private
let fail (#a:Type) (m:string) = raise #a (TacticFailure m)
let rec mk_arr (bs: list binder) (cod : comp) : Tac term =
match bs with
| [] -> fail "mk_arr, empty binders"
| [b] -> pack (Tv_Arrow b cod)
| (b::bs) ->
pack (Tv_Arrow b (C_Total (mk_arr bs cod)))
let rec mk_tot_arr (bs: list binder) (cod : term) : Tac term =
match bs with
| [] -> cod
| (b::bs) ->
pack (Tv_Arrow b (C_Total (mk_tot_arr bs cod)))
let lookup_lb (lbs:list letbinding) (nm:name) : Tac letbinding =
let o = FStar.List.Tot.Base.find
(fun lb -> (inspect_fv lb.lb_fv) = nm)
lbs
in
match o with
| Some lb -> lb
| None -> fail "lookup_letbinding: Name not in let group"
let rec inspect_unascribe (t:term) : Tac (tv:term_view{notAscription tv}) =
match inspect t with
| Tv_AscribedT t _ _ _
| Tv_AscribedC t _ _ _ ->
inspect_unascribe t
| tv -> tv
(* Helpers for dealing with nested applications and arrows *)
let rec collect_app' (args : list argv) (t : term) | false | false | FStar.Tactics.V2.SyntaxHelpers.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val collect_app' (args: list argv) (t: term) : Tac (term * list argv) | [
"recursion"
] | FStar.Tactics.V2.SyntaxHelpers.collect_app' | {
"file_name": "ulib/FStar.Tactics.V2.SyntaxHelpers.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | args: Prims.list FStar.Reflection.V2.Data.argv -> t: FStar.Tactics.NamedView.term
-> FStar.Tactics.Effect.Tac
(FStar.Tactics.NamedView.term * Prims.list FStar.Reflection.V2.Data.argv) | {
"end_col": 20,
"end_line": 86,
"start_col": 4,
"start_line": 83
} |
FStar.Tactics.Effect.Tac | val collect_arr' (bs: list binder) (c: comp) : Tac (list binder * comp) | [
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec collect_arr' (bs : list binder) (c : comp) : Tac (list binder * comp) =
begin match c with
| C_Total t ->
begin match inspect t with
| Tv_Arrow b c ->
collect_arr' (b::bs) c
| _ ->
(bs, c)
end
| _ -> (bs, c)
end | val collect_arr' (bs: list binder) (c: comp) : Tac (list binder * comp)
let rec collect_arr' (bs: list binder) (c: comp) : Tac (list binder * comp) = | true | null | false | match c with
| C_Total t ->
(match inspect t with
| Tv_Arrow b c -> collect_arr' (b :: bs) c
| _ -> (bs, c))
| _ -> (bs, c) | {
"checked_file": "FStar.Tactics.V2.SyntaxHelpers.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.Builtins.fsti.checked",
"FStar.Tactics.Types.fsti.checked",
"FStar.Tactics.NamedView.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Base.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.V2.SyntaxHelpers.fst"
} | [] | [
"Prims.list",
"FStar.Tactics.NamedView.binder",
"FStar.Tactics.NamedView.comp",
"FStar.Reflection.Types.typ",
"FStar.Tactics.V2.SyntaxHelpers.collect_arr'",
"Prims.Cons",
"FStar.Pervasives.Native.tuple2",
"FStar.Tactics.NamedView.named_term_view",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Tactics.NamedView.inspect",
"FStar.Reflection.V2.Data.comp_view"
] | [] | module FStar.Tactics.V2.SyntaxHelpers
open FStar.Reflection.V2
open FStar.Tactics.Effect
open FStar.Tactics.V2.Builtins
open FStar.Tactics.Types
open FStar.Tactics.NamedView
(* These are fully-named variants of functions found in FStar.Reflection *)
private | false | false | FStar.Tactics.V2.SyntaxHelpers.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val collect_arr' (bs: list binder) (c: comp) : Tac (list binder * comp) | [
"recursion"
] | FStar.Tactics.V2.SyntaxHelpers.collect_arr' | {
"file_name": "ulib/FStar.Tactics.V2.SyntaxHelpers.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | bs: Prims.list FStar.Tactics.NamedView.binder -> c: FStar.Tactics.NamedView.comp
-> FStar.Tactics.Effect.Tac
(Prims.list FStar.Tactics.NamedView.binder * FStar.Tactics.NamedView.comp) | {
"end_col": 18,
"end_line": 21,
"start_col": 10,
"start_line": 13
} |
FStar.Tactics.Effect.Tac | val lookup_lb (lbs: list letbinding) (nm: name) : Tac letbinding | [
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lookup_lb (lbs:list letbinding) (nm:name) : Tac letbinding =
let o = FStar.List.Tot.Base.find
(fun lb -> (inspect_fv lb.lb_fv) = nm)
lbs
in
match o with
| Some lb -> lb
| None -> fail "lookup_letbinding: Name not in let group" | val lookup_lb (lbs: list letbinding) (nm: name) : Tac letbinding
let lookup_lb (lbs: list letbinding) (nm: name) : Tac letbinding = | true | null | false | let o = FStar.List.Tot.Base.find (fun lb -> (inspect_fv lb.lb_fv) = nm) lbs in
match o with
| Some lb -> lb
| None -> fail "lookup_letbinding: Name not in let group" | {
"checked_file": "FStar.Tactics.V2.SyntaxHelpers.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.Builtins.fsti.checked",
"FStar.Tactics.Types.fsti.checked",
"FStar.Tactics.NamedView.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Base.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.V2.SyntaxHelpers.fst"
} | [] | [
"Prims.list",
"FStar.Tactics.NamedView.letbinding",
"FStar.Reflection.Types.name",
"Prims.b2t",
"Prims.op_Equality",
"FStar.Reflection.V2.Builtins.inspect_fv",
"FStar.Tactics.NamedView.__proj__Mkletbinding__item__lb_fv",
"FStar.Tactics.V2.SyntaxHelpers.fail",
"FStar.Pervasives.Native.option",
"FStar.List.Tot.Base.find",
"Prims.bool"
] | [] | module FStar.Tactics.V2.SyntaxHelpers
open FStar.Reflection.V2
open FStar.Tactics.Effect
open FStar.Tactics.V2.Builtins
open FStar.Tactics.Types
open FStar.Tactics.NamedView
(* These are fully-named variants of functions found in FStar.Reflection *)
private
let rec collect_arr' (bs : list binder) (c : comp) : Tac (list binder * comp) =
begin match c with
| C_Total t ->
begin match inspect t with
| Tv_Arrow b c ->
collect_arr' (b::bs) c
| _ ->
(bs, c)
end
| _ -> (bs, c)
end
val collect_arr_bs : typ -> Tac (list binder * comp)
let collect_arr_bs t =
let (bs, c) = collect_arr' [] (C_Total t) in
(List.Tot.Base.rev bs, c)
val collect_arr : typ -> Tac (list typ * comp)
let collect_arr t =
let (bs, c) = collect_arr' [] (C_Total t) in
let ts = List.Tot.Base.map (fun (b:binder) -> b.sort) bs in
(List.Tot.Base.rev ts, c)
private
let rec collect_abs' (bs : list binder) (t : term) : Tac (list binder * term) (decreases t) =
match inspect t with
| Tv_Abs b t' ->
collect_abs' (b::bs) t'
| _ -> (bs, t)
val collect_abs : term -> Tac (list binder * term)
let collect_abs t =
let (bs, t') = collect_abs' [] t in
(List.Tot.Base.rev bs, t')
(* Copied from FStar.Tactics.V2.Derived *)
private
let fail (#a:Type) (m:string) = raise #a (TacticFailure m)
let rec mk_arr (bs: list binder) (cod : comp) : Tac term =
match bs with
| [] -> fail "mk_arr, empty binders"
| [b] -> pack (Tv_Arrow b cod)
| (b::bs) ->
pack (Tv_Arrow b (C_Total (mk_arr bs cod)))
let rec mk_tot_arr (bs: list binder) (cod : term) : Tac term =
match bs with
| [] -> cod
| (b::bs) ->
pack (Tv_Arrow b (C_Total (mk_tot_arr bs cod))) | false | false | FStar.Tactics.V2.SyntaxHelpers.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lookup_lb (lbs: list letbinding) (nm: name) : Tac letbinding | [] | FStar.Tactics.V2.SyntaxHelpers.lookup_lb | {
"file_name": "ulib/FStar.Tactics.V2.SyntaxHelpers.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | lbs: Prims.list FStar.Tactics.NamedView.letbinding -> nm: FStar.Reflection.Types.name
-> FStar.Tactics.Effect.Tac FStar.Tactics.NamedView.letbinding | {
"end_col": 59,
"end_line": 71,
"start_col": 64,
"start_line": 64
} |
FStar.Tactics.Effect.Tac | val mk_tot_arr (bs: list binder) (cod: term) : Tac term | [
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec mk_tot_arr (bs: list binder) (cod : term) : Tac term =
match bs with
| [] -> cod
| (b::bs) ->
pack (Tv_Arrow b (C_Total (mk_tot_arr bs cod))) | val mk_tot_arr (bs: list binder) (cod: term) : Tac term
let rec mk_tot_arr (bs: list binder) (cod: term) : Tac term = | true | null | false | match bs with
| [] -> cod
| b :: bs -> pack (Tv_Arrow b (C_Total (mk_tot_arr bs cod))) | {
"checked_file": "FStar.Tactics.V2.SyntaxHelpers.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.Builtins.fsti.checked",
"FStar.Tactics.Types.fsti.checked",
"FStar.Tactics.NamedView.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Base.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.V2.SyntaxHelpers.fst"
} | [] | [
"Prims.list",
"FStar.Tactics.NamedView.binder",
"FStar.Tactics.NamedView.term",
"FStar.Tactics.NamedView.pack",
"FStar.Tactics.NamedView.named_term_view",
"FStar.Tactics.NamedView.Tv_Arrow",
"FStar.Tactics.NamedView.comp",
"FStar.Reflection.V2.Data.C_Total",
"FStar.Reflection.Types.typ",
"FStar.Tactics.V2.SyntaxHelpers.mk_tot_arr"
] | [] | module FStar.Tactics.V2.SyntaxHelpers
open FStar.Reflection.V2
open FStar.Tactics.Effect
open FStar.Tactics.V2.Builtins
open FStar.Tactics.Types
open FStar.Tactics.NamedView
(* These are fully-named variants of functions found in FStar.Reflection *)
private
let rec collect_arr' (bs : list binder) (c : comp) : Tac (list binder * comp) =
begin match c with
| C_Total t ->
begin match inspect t with
| Tv_Arrow b c ->
collect_arr' (b::bs) c
| _ ->
(bs, c)
end
| _ -> (bs, c)
end
val collect_arr_bs : typ -> Tac (list binder * comp)
let collect_arr_bs t =
let (bs, c) = collect_arr' [] (C_Total t) in
(List.Tot.Base.rev bs, c)
val collect_arr : typ -> Tac (list typ * comp)
let collect_arr t =
let (bs, c) = collect_arr' [] (C_Total t) in
let ts = List.Tot.Base.map (fun (b:binder) -> b.sort) bs in
(List.Tot.Base.rev ts, c)
private
let rec collect_abs' (bs : list binder) (t : term) : Tac (list binder * term) (decreases t) =
match inspect t with
| Tv_Abs b t' ->
collect_abs' (b::bs) t'
| _ -> (bs, t)
val collect_abs : term -> Tac (list binder * term)
let collect_abs t =
let (bs, t') = collect_abs' [] t in
(List.Tot.Base.rev bs, t')
(* Copied from FStar.Tactics.V2.Derived *)
private
let fail (#a:Type) (m:string) = raise #a (TacticFailure m)
let rec mk_arr (bs: list binder) (cod : comp) : Tac term =
match bs with
| [] -> fail "mk_arr, empty binders"
| [b] -> pack (Tv_Arrow b cod)
| (b::bs) ->
pack (Tv_Arrow b (C_Total (mk_arr bs cod))) | false | false | FStar.Tactics.V2.SyntaxHelpers.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mk_tot_arr (bs: list binder) (cod: term) : Tac term | [
"recursion"
] | FStar.Tactics.V2.SyntaxHelpers.mk_tot_arr | {
"file_name": "ulib/FStar.Tactics.V2.SyntaxHelpers.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | bs: Prims.list FStar.Tactics.NamedView.binder -> cod: FStar.Tactics.NamedView.term
-> FStar.Tactics.Effect.Tac FStar.Tactics.NamedView.term | {
"end_col": 53,
"end_line": 62,
"start_col": 4,
"start_line": 59
} |
FStar.Tactics.Effect.Tac | val inspect_unascribe (t: term) : Tac (tv: term_view{notAscription tv}) | [
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec inspect_unascribe (t:term) : Tac (tv:term_view{notAscription tv}) =
match inspect t with
| Tv_AscribedT t _ _ _
| Tv_AscribedC t _ _ _ ->
inspect_unascribe t
| tv -> tv | val inspect_unascribe (t: term) : Tac (tv: term_view{notAscription tv})
let rec inspect_unascribe (t: term) : Tac (tv: term_view{notAscription tv}) = | true | null | false | match inspect t with
| Tv_AscribedT t _ _ _ | Tv_AscribedC t _ _ _ -> inspect_unascribe t
| tv -> tv | {
"checked_file": "FStar.Tactics.V2.SyntaxHelpers.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.Builtins.fsti.checked",
"FStar.Tactics.Types.fsti.checked",
"FStar.Tactics.NamedView.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Base.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.V2.SyntaxHelpers.fst"
} | [] | [
"FStar.Tactics.NamedView.term",
"FStar.Pervasives.Native.option",
"Prims.bool",
"FStar.Tactics.V2.SyntaxHelpers.inspect_unascribe",
"FStar.Tactics.NamedView.term_view",
"Prims.b2t",
"FStar.Tactics.NamedView.notAscription",
"FStar.Tactics.NamedView.comp",
"FStar.Tactics.NamedView.named_term_view",
"FStar.Tactics.NamedView.inspect"
] | [] | module FStar.Tactics.V2.SyntaxHelpers
open FStar.Reflection.V2
open FStar.Tactics.Effect
open FStar.Tactics.V2.Builtins
open FStar.Tactics.Types
open FStar.Tactics.NamedView
(* These are fully-named variants of functions found in FStar.Reflection *)
private
let rec collect_arr' (bs : list binder) (c : comp) : Tac (list binder * comp) =
begin match c with
| C_Total t ->
begin match inspect t with
| Tv_Arrow b c ->
collect_arr' (b::bs) c
| _ ->
(bs, c)
end
| _ -> (bs, c)
end
val collect_arr_bs : typ -> Tac (list binder * comp)
let collect_arr_bs t =
let (bs, c) = collect_arr' [] (C_Total t) in
(List.Tot.Base.rev bs, c)
val collect_arr : typ -> Tac (list typ * comp)
let collect_arr t =
let (bs, c) = collect_arr' [] (C_Total t) in
let ts = List.Tot.Base.map (fun (b:binder) -> b.sort) bs in
(List.Tot.Base.rev ts, c)
private
let rec collect_abs' (bs : list binder) (t : term) : Tac (list binder * term) (decreases t) =
match inspect t with
| Tv_Abs b t' ->
collect_abs' (b::bs) t'
| _ -> (bs, t)
val collect_abs : term -> Tac (list binder * term)
let collect_abs t =
let (bs, t') = collect_abs' [] t in
(List.Tot.Base.rev bs, t')
(* Copied from FStar.Tactics.V2.Derived *)
private
let fail (#a:Type) (m:string) = raise #a (TacticFailure m)
let rec mk_arr (bs: list binder) (cod : comp) : Tac term =
match bs with
| [] -> fail "mk_arr, empty binders"
| [b] -> pack (Tv_Arrow b cod)
| (b::bs) ->
pack (Tv_Arrow b (C_Total (mk_arr bs cod)))
let rec mk_tot_arr (bs: list binder) (cod : term) : Tac term =
match bs with
| [] -> cod
| (b::bs) ->
pack (Tv_Arrow b (C_Total (mk_tot_arr bs cod)))
let lookup_lb (lbs:list letbinding) (nm:name) : Tac letbinding =
let o = FStar.List.Tot.Base.find
(fun lb -> (inspect_fv lb.lb_fv) = nm)
lbs
in
match o with
| Some lb -> lb
| None -> fail "lookup_letbinding: Name not in let group" | false | false | FStar.Tactics.V2.SyntaxHelpers.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val inspect_unascribe (t: term) : Tac (tv: term_view{notAscription tv}) | [
"recursion"
] | FStar.Tactics.V2.SyntaxHelpers.inspect_unascribe | {
"file_name": "ulib/FStar.Tactics.V2.SyntaxHelpers.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | t: FStar.Tactics.NamedView.term
-> FStar.Tactics.Effect.Tac
(tv: FStar.Tactics.NamedView.term_view{FStar.Tactics.NamedView.notAscription tv}) | {
"end_col": 12,
"end_line": 78,
"start_col": 2,
"start_line": 74
} |
FStar.Tactics.Effect.Tac | val mk_arr (bs: list binder) (cod: comp) : Tac term | [
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec mk_arr (bs: list binder) (cod : comp) : Tac term =
match bs with
| [] -> fail "mk_arr, empty binders"
| [b] -> pack (Tv_Arrow b cod)
| (b::bs) ->
pack (Tv_Arrow b (C_Total (mk_arr bs cod))) | val mk_arr (bs: list binder) (cod: comp) : Tac term
let rec mk_arr (bs: list binder) (cod: comp) : Tac term = | true | null | false | match bs with
| [] -> fail "mk_arr, empty binders"
| [b] -> pack (Tv_Arrow b cod)
| b :: bs -> pack (Tv_Arrow b (C_Total (mk_arr bs cod))) | {
"checked_file": "FStar.Tactics.V2.SyntaxHelpers.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.Builtins.fsti.checked",
"FStar.Tactics.Types.fsti.checked",
"FStar.Tactics.NamedView.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Base.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.V2.SyntaxHelpers.fst"
} | [] | [
"Prims.list",
"FStar.Tactics.NamedView.binder",
"FStar.Tactics.NamedView.comp",
"FStar.Tactics.V2.SyntaxHelpers.fail",
"FStar.Tactics.NamedView.term",
"FStar.Tactics.NamedView.pack",
"FStar.Tactics.NamedView.Tv_Arrow",
"FStar.Tactics.NamedView.named_term_view",
"FStar.Reflection.V2.Data.C_Total",
"FStar.Reflection.Types.typ",
"FStar.Tactics.V2.SyntaxHelpers.mk_arr"
] | [] | module FStar.Tactics.V2.SyntaxHelpers
open FStar.Reflection.V2
open FStar.Tactics.Effect
open FStar.Tactics.V2.Builtins
open FStar.Tactics.Types
open FStar.Tactics.NamedView
(* These are fully-named variants of functions found in FStar.Reflection *)
private
let rec collect_arr' (bs : list binder) (c : comp) : Tac (list binder * comp) =
begin match c with
| C_Total t ->
begin match inspect t with
| Tv_Arrow b c ->
collect_arr' (b::bs) c
| _ ->
(bs, c)
end
| _ -> (bs, c)
end
val collect_arr_bs : typ -> Tac (list binder * comp)
let collect_arr_bs t =
let (bs, c) = collect_arr' [] (C_Total t) in
(List.Tot.Base.rev bs, c)
val collect_arr : typ -> Tac (list typ * comp)
let collect_arr t =
let (bs, c) = collect_arr' [] (C_Total t) in
let ts = List.Tot.Base.map (fun (b:binder) -> b.sort) bs in
(List.Tot.Base.rev ts, c)
private
let rec collect_abs' (bs : list binder) (t : term) : Tac (list binder * term) (decreases t) =
match inspect t with
| Tv_Abs b t' ->
collect_abs' (b::bs) t'
| _ -> (bs, t)
val collect_abs : term -> Tac (list binder * term)
let collect_abs t =
let (bs, t') = collect_abs' [] t in
(List.Tot.Base.rev bs, t')
(* Copied from FStar.Tactics.V2.Derived *)
private
let fail (#a:Type) (m:string) = raise #a (TacticFailure m) | false | false | FStar.Tactics.V2.SyntaxHelpers.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mk_arr (bs: list binder) (cod: comp) : Tac term | [
"recursion"
] | FStar.Tactics.V2.SyntaxHelpers.mk_arr | {
"file_name": "ulib/FStar.Tactics.V2.SyntaxHelpers.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | bs: Prims.list FStar.Tactics.NamedView.binder -> cod: FStar.Tactics.NamedView.comp
-> FStar.Tactics.Effect.Tac FStar.Tactics.NamedView.term | {
"end_col": 49,
"end_line": 56,
"start_col": 4,
"start_line": 52
} |
Prims.Tot | val jump_vlgen
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond (vmin) (vmax) k})
: Tot (jumper (parse_vlgen (vmin) (vmax) pk s)) | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let jump_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
: Tot (jumper (parse_vlgen (vmin) (vmax) pk s))
= jump_synth
(jump_bounded_vlgen vmin vmax vk rk s)
(synth_vlgen (vmin) (vmax) s)
() | val jump_vlgen
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond (vmin) (vmax) k})
: Tot (jumper (parse_vlgen (vmin) (vmax) pk s))
let jump_vlgen
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond (vmin) (vmax) k})
: Tot (jumper (parse_vlgen (vmin) (vmax) pk s)) = | false | null | false | jump_synth (jump_bounded_vlgen vmin vmax vk rk s) (synth_vlgen (vmin) (vmax) s) () | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"total"
] | [
"LowParse.Spec.DER.der_length_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Low.Base.jumper",
"LowParse.Low.Base.leaf_reader",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.VLGen.parse_vlgen_precond",
"LowParse.Low.Combinators.jump_synth",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Spec.VLGen.parse_bounded_vlgen",
"LowParse.Low.VLGen.jump_bounded_vlgen",
"LowParse.Spec.VLGen.synth_vlgen",
"LowParse.Spec.VLGen.parse_vlgen"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))
= valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth
h
(parse_bounded_vlgen vmin vmax pk s)
(synth_vlgen (vmin) (vmax) s)
input
pos
inline_for_extraction
let finalize_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_vlgen min max pk s input pos h
inline_for_extraction
let finalize_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (U32.v min) (U32.v max) k })
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s))
= validate_synth
(validate_bounded_vlgen vmin min vmax max vk rk s v)
(synth_vlgen (U32.v min) (U32.v max) s)
()
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (jumper (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
let n = vk input pos in
let len = rk input pos in
[@inline_let]
let _ = valid_facts (parse_fldata_strong s (U32.v len)) h input n in
jump_fldata_strong s (U32.v len) len input n
#pop-options
inline_for_extraction
let jump_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k }) | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val jump_vlgen
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond (vmin) (vmax) k})
: Tot (jumper (parse_vlgen (vmin) (vmax) pk s)) | [] | LowParse.Low.VLGen.jump_vlgen | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
vmin: LowParse.Spec.DER.der_length_t ->
vmax: LowParse.Spec.DER.der_length_t{vmin <= vmax /\ vmax < 4294967296} ->
vk: LowParse.Low.Base.jumper pk ->
rk: LowParse.Low.Base.leaf_reader pk ->
s: LowParse.Spec.Base.serializer p {LowParse.Spec.VLGen.parse_vlgen_precond vmin vmax k}
-> LowParse.Low.Base.jumper (LowParse.Spec.VLGen.parse_vlgen vmin vmax pk s) | {
"end_col": 6,
"end_line": 493,
"start_col": 2,
"start_line": 490
} |
Prims.Tot | val gaccessor_bounded_vlgen_payload
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot
(gaccessor (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s)) | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_no_lookahead_2 min max pk s);
Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_injective_2 min max pk s);
gaccessor_prop_equiv (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) (gaccessor_bounded_vlgen_payload' min max pk s);
gaccessor_bounded_vlgen_payload' min max pk s | val gaccessor_bounded_vlgen_payload
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot
(gaccessor (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
let gaccessor_bounded_vlgen_payload
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot
(gaccessor (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s)) = | false | null | false | Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_no_lookahead_2 min max pk s);
Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_injective_2 min max pk s);
gaccessor_prop_equiv (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
(gaccessor_bounded_vlgen_payload' min max pk s);
gaccessor_bounded_vlgen_payload' min max pk s | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"total"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Low.VLGen.gaccessor_bounded_vlgen_payload'",
"Prims.unit",
"LowParse.Low.Base.Spec.gaccessor_prop_equiv",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Spec.VLGen.parse_bounded_vlgen",
"LowParse.Low.VLData.clens_bounded_vldata_strong_payload",
"FStar.Classical.forall_intro_2",
"LowParse.Bytes.bytes",
"Prims.l_imp",
"LowParse.Low.Base.Spec.gaccessor_pre",
"LowParse.Spec.Base.injective_precond",
"LowParse.Low.VLGen.gaccessor_bounded_vlgen_payload_injective_2",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Base.no_lookahead_on_precond",
"LowParse.Low.VLGen.gaccessor_bounded_vlgen_payload_no_lookahead_2",
"LowParse.Low.Base.Spec.gaccessor"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))
= valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth
h
(parse_bounded_vlgen vmin vmax pk s)
(synth_vlgen (vmin) (vmax) s)
input
pos
inline_for_extraction
let finalize_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_vlgen min max pk s input pos h
inline_for_extraction
let finalize_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (U32.v min) (U32.v max) k })
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s))
= validate_synth
(validate_bounded_vlgen vmin min vmax max vk rk s v)
(synth_vlgen (U32.v min) (U32.v max) s)
()
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (jumper (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
let n = vk input pos in
let len = rk input pos in
[@inline_let]
let _ = valid_facts (parse_fldata_strong s (U32.v len)) h input n in
jump_fldata_strong s (U32.v len) len input n
#pop-options
inline_for_extraction
let jump_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
: Tot (jumper (parse_vlgen (vmin) (vmax) pk s))
= jump_synth
(jump_bounded_vlgen vmin vmax vk rk s)
(synth_vlgen (vmin) (vmax) s)
()
let gaccessor_bounded_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor' (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= fun input ->
parse_bounded_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_bounded_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_injective (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_no_lookahead_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong}) | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_bounded_vlgen_payload
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot
(gaccessor (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s)) | [] | LowParse.Low.VLGen.gaccessor_bounded_vlgen_payload | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
pk: LowParse.Spec.Base.parser sk (LowParse.Spec.BoundedInt.bounded_int32 min max) ->
s:
LowParse.Spec.Base.serializer p
{ Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong }
-> LowParse.Low.Base.Spec.gaccessor (LowParse.Spec.VLGen.parse_bounded_vlgen min max pk s)
p
(LowParse.Low.VLData.clens_bounded_vldata_strong_payload min max s) | {
"end_col": 47,
"end_line": 641,
"start_col": 2,
"start_line": 638
} |
Prims.Tot | val gaccessor_bounded_vlgen_payload'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot
(gaccessor' (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s)
) | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_bounded_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor' (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= fun input ->
parse_bounded_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res | val gaccessor_bounded_vlgen_payload'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot
(gaccessor' (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s)
)
let gaccessor_bounded_vlgen_payload'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot
(gaccessor' (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s)
) = | false | null | false | fun input ->
parse_bounded_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0)
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ =
match parse p input' with
| None -> ()
| Some _ -> parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"total"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Base.consumed_length",
"Prims.op_Addition",
"FStar.UInt32.v",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"Prims.unit",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.parse_strong_prefix",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.seq",
"Prims.bool",
"LowParse.Spec.VLGen.parse_bounded_vlgen_unfold",
"LowParse.Low.Base.Spec.gaccessor'",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Spec.VLGen.parse_bounded_vlgen",
"LowParse.Low.VLData.clens_bounded_vldata_strong_payload"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))
= valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth
h
(parse_bounded_vlgen vmin vmax pk s)
(synth_vlgen (vmin) (vmax) s)
input
pos
inline_for_extraction
let finalize_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_vlgen min max pk s input pos h
inline_for_extraction
let finalize_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (U32.v min) (U32.v max) k })
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s))
= validate_synth
(validate_bounded_vlgen vmin min vmax max vk rk s v)
(synth_vlgen (U32.v min) (U32.v max) s)
()
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (jumper (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
let n = vk input pos in
let len = rk input pos in
[@inline_let]
let _ = valid_facts (parse_fldata_strong s (U32.v len)) h input n in
jump_fldata_strong s (U32.v len) len input n
#pop-options
inline_for_extraction
let jump_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
: Tot (jumper (parse_vlgen (vmin) (vmax) pk s))
= jump_synth
(jump_bounded_vlgen vmin vmax vk rk s)
(synth_vlgen (vmin) (vmax) s)
()
let gaccessor_bounded_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong}) | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_bounded_vlgen_payload'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot
(gaccessor' (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s)
) | [] | LowParse.Low.VLGen.gaccessor_bounded_vlgen_payload' | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
pk: LowParse.Spec.Base.parser sk (LowParse.Spec.BoundedInt.bounded_int32 min max) ->
s:
LowParse.Spec.Base.serializer p
{ Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong }
-> LowParse.Low.Base.Spec.gaccessor' (LowParse.Spec.VLGen.parse_bounded_vlgen min max pk s)
p
(LowParse.Low.VLData.clens_bounded_vldata_strong_payload min max s) | {
"end_col": 5,
"end_line": 522,
"start_col": 2,
"start_line": 505
} |
Prims.Tot | val accessor_vlgen_payload
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong}
)
: Tot (accessor (gaccessor_vlgen_payload min max pk s)) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let accessor_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 ( min) ( max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong } )
: Tot (accessor (gaccessor_vlgen_payload min max pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
slice_access_eq h (gaccessor_vlgen_payload min max pk s) input pos;
valid_facts (parse_vlgen min max pk s) h input pos;
parse_vlgen_unfold min max pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
jk input pos | val accessor_vlgen_payload
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong}
)
: Tot (accessor (gaccessor_vlgen_payload min max pk s))
let accessor_vlgen_payload
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s:
serializer p {parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong}
)
: Tot (accessor (gaccessor_vlgen_payload min max pk s)) = | false | null | false | fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ =
slice_access_eq h (gaccessor_vlgen_payload min max pk s) input pos;
valid_facts (parse_vlgen min max pk s) h input pos;
parse_vlgen_unfold min max pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
jk input pos | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"total"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Low.Base.jumper",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.VLGen.parse_vlgen_precond",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.VLGen.parse_vlgen_unfold",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLGen.parse_vlgen",
"LowParse.Low.Base.Spec.slice_access_eq",
"LowParse.Low.Base.Spec.clens_id",
"LowParse.Low.VLGen.gaccessor_vlgen_payload",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Low.Base.accessor"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))
= valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth
h
(parse_bounded_vlgen vmin vmax pk s)
(synth_vlgen (vmin) (vmax) s)
input
pos
inline_for_extraction
let finalize_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_vlgen min max pk s input pos h
inline_for_extraction
let finalize_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (U32.v min) (U32.v max) k })
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s))
= validate_synth
(validate_bounded_vlgen vmin min vmax max vk rk s v)
(synth_vlgen (U32.v min) (U32.v max) s)
()
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (jumper (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
let n = vk input pos in
let len = rk input pos in
[@inline_let]
let _ = valid_facts (parse_fldata_strong s (U32.v len)) h input n in
jump_fldata_strong s (U32.v len) len input n
#pop-options
inline_for_extraction
let jump_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
: Tot (jumper (parse_vlgen (vmin) (vmax) pk s))
= jump_synth
(jump_bounded_vlgen vmin vmax vk rk s)
(synth_vlgen (vmin) (vmax) s)
()
let gaccessor_bounded_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor' (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= fun input ->
parse_bounded_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_bounded_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_injective (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_no_lookahead_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_no_lookahead_2 min max pk s);
Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_injective_2 min max pk s);
gaccessor_prop_equiv (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) (gaccessor_bounded_vlgen_payload' min max pk s);
gaccessor_bounded_vlgen_payload' min max pk s
module B = LowStar.Buffer
inline_for_extraction
let accessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 ( min) ( max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (accessor (gaccessor_bounded_vlgen_payload min max pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
slice_access_eq h (gaccessor_bounded_vlgen_payload min max pk s) input pos;
valid_facts (parse_bounded_vlgen min max pk s) h input pos;
parse_bounded_vlgen_unfold_aux min max pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
jk input pos
let gaccessor_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong } )
: Tot (gaccessor' (parse_vlgen min max pk s) p (clens_id _))
= fun input ->
parse_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
))
= parse_vlgen_unfold min max pk s sl;
parse_vlgen_unfold min max pk s sl' ;
parse_injective (parse_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
))
= parse_vlgen_unfold min max pk s sl;
parse_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_vlgen_payload_no_lookahead_1 min max pk s sl) sl'
let gaccessor_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor (parse_vlgen min max pk s) p (clens_id _))
= Classical.forall_intro_2 (gaccessor_vlgen_payload_no_lookahead_2 min max pk s);
Classical.forall_intro_2 (gaccessor_vlgen_payload_injective_2 min max pk s);
gaccessor_prop_equiv (parse_vlgen min max pk s) p (clens_id _) (gaccessor_vlgen_payload' min max pk s);
gaccessor_vlgen_payload' min max pk s
inline_for_extraction
let accessor_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 ( min) ( max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong } ) | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val accessor_vlgen_payload
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong}
)
: Tot (accessor (gaccessor_vlgen_payload min max pk s)) | [] | LowParse.Low.VLGen.accessor_vlgen_payload | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
jk: LowParse.Low.Base.jumper pk ->
s:
LowParse.Spec.Base.serializer p
{ LowParse.Spec.VLGen.parse_vlgen_precond min max k /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong }
-> LowParse.Low.Base.accessor (LowParse.Low.VLGen.gaccessor_vlgen_payload min max pk s) | {
"end_col": 14,
"end_line": 837,
"start_col": 2,
"start_line": 828
} |
Prims.Tot | val accessor_bounded_vlgen_payload
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (accessor (gaccessor_bounded_vlgen_payload min max pk s)) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let accessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 ( min) ( max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (accessor (gaccessor_bounded_vlgen_payload min max pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
slice_access_eq h (gaccessor_bounded_vlgen_payload min max pk s) input pos;
valid_facts (parse_bounded_vlgen min max pk s) h input pos;
parse_bounded_vlgen_unfold_aux min max pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
jk input pos | val accessor_bounded_vlgen_payload
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (accessor (gaccessor_bounded_vlgen_payload min max pk s))
let accessor_bounded_vlgen_payload
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (accessor (gaccessor_bounded_vlgen_payload min max pk s)) = | false | null | false | fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ =
slice_access_eq h (gaccessor_bounded_vlgen_payload min max pk s) input pos;
valid_facts (parse_bounded_vlgen min max pk s) h input pos;
parse_bounded_vlgen_unfold_aux min max pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
jk input pos | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"total"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Low.Base.jumper",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.VLGen.parse_bounded_vlgen_unfold_aux",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Spec.VLGen.parse_bounded_vlgen",
"LowParse.Low.Base.Spec.slice_access_eq",
"LowParse.Low.VLData.clens_bounded_vldata_strong_payload",
"LowParse.Low.VLGen.gaccessor_bounded_vlgen_payload",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Low.Base.accessor"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))
= valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth
h
(parse_bounded_vlgen vmin vmax pk s)
(synth_vlgen (vmin) (vmax) s)
input
pos
inline_for_extraction
let finalize_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_vlgen min max pk s input pos h
inline_for_extraction
let finalize_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (U32.v min) (U32.v max) k })
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s))
= validate_synth
(validate_bounded_vlgen vmin min vmax max vk rk s v)
(synth_vlgen (U32.v min) (U32.v max) s)
()
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (jumper (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
let n = vk input pos in
let len = rk input pos in
[@inline_let]
let _ = valid_facts (parse_fldata_strong s (U32.v len)) h input n in
jump_fldata_strong s (U32.v len) len input n
#pop-options
inline_for_extraction
let jump_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
: Tot (jumper (parse_vlgen (vmin) (vmax) pk s))
= jump_synth
(jump_bounded_vlgen vmin vmax vk rk s)
(synth_vlgen (vmin) (vmax) s)
()
let gaccessor_bounded_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor' (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= fun input ->
parse_bounded_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_bounded_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_injective (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_no_lookahead_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_no_lookahead_2 min max pk s);
Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_injective_2 min max pk s);
gaccessor_prop_equiv (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) (gaccessor_bounded_vlgen_payload' min max pk s);
gaccessor_bounded_vlgen_payload' min max pk s
module B = LowStar.Buffer
inline_for_extraction
let accessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 ( min) ( max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong}) | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val accessor_bounded_vlgen_payload
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (accessor (gaccessor_bounded_vlgen_payload min max pk s)) | [] | LowParse.Low.VLGen.accessor_bounded_vlgen_payload | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
jk: LowParse.Low.Base.jumper pk ->
s:
LowParse.Spec.Base.serializer p
{ Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong }
-> LowParse.Low.Base.accessor (LowParse.Low.VLGen.gaccessor_bounded_vlgen_payload min max pk s) | {
"end_col": 14,
"end_line": 666,
"start_col": 2,
"start_line": 657
} |
FStar.Pervasives.Lemma | val gaccessor_bounded_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl': bytes)
: Lemma
(ensures
((k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl' /\ no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl') ==>
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl ==
gaccessor_bounded_vlgen_payload' min max pk s sl'))) | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_bounded_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_no_lookahead_1 min max pk s sl) sl' | val gaccessor_bounded_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl': bytes)
: Lemma
(ensures
((k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl' /\ no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl') ==>
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl ==
gaccessor_bounded_vlgen_payload' min max pk s sl')))
let gaccessor_bounded_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl': bytes)
: Lemma
(ensures
((k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl' /\ no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl') ==>
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl ==
gaccessor_bounded_vlgen_payload' min max pk s sl'))) = | false | null | true | Classical.move_requires (gaccessor_bounded_vlgen_payload_no_lookahead_1 min max pk s sl) sl' | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"lemma"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Spec.Base.serializer",
"LowParse.Bytes.bytes",
"FStar.Classical.move_requires",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Low.Base.Spec.gaccessor_pre",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Spec.VLGen.parse_bounded_vlgen",
"LowParse.Low.VLData.clens_bounded_vldata_strong_payload",
"LowParse.Spec.Base.no_lookahead_on_precond",
"LowParse.Low.VLGen.gaccessor_bounded_vlgen_payload'",
"LowParse.Low.VLGen.gaccessor_bounded_vlgen_payload_no_lookahead_1",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_imp",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))
= valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth
h
(parse_bounded_vlgen vmin vmax pk s)
(synth_vlgen (vmin) (vmax) s)
input
pos
inline_for_extraction
let finalize_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_vlgen min max pk s input pos h
inline_for_extraction
let finalize_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (U32.v min) (U32.v max) k })
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s))
= validate_synth
(validate_bounded_vlgen vmin min vmax max vk rk s v)
(synth_vlgen (U32.v min) (U32.v max) s)
()
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (jumper (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
let n = vk input pos in
let len = rk input pos in
[@inline_let]
let _ = valid_facts (parse_fldata_strong s (U32.v len)) h input n in
jump_fldata_strong s (U32.v len) len input n
#pop-options
inline_for_extraction
let jump_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
: Tot (jumper (parse_vlgen (vmin) (vmax) pk s))
= jump_synth
(jump_bounded_vlgen vmin vmax vk rk s)
(synth_vlgen (vmin) (vmax) s)
()
let gaccessor_bounded_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor' (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= fun input ->
parse_bounded_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_bounded_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_injective (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl' | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_bounded_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl': bytes)
: Lemma
(ensures
((k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl' /\ no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl') ==>
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl ==
gaccessor_bounded_vlgen_payload' min max pk s sl'))) | [] | LowParse.Low.VLGen.gaccessor_bounded_vlgen_payload_no_lookahead_2 | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
pk: LowParse.Spec.Base.parser sk (LowParse.Spec.BoundedInt.bounded_int32 min max) ->
s: LowParse.Spec.Base.serializer p ->
sl: LowParse.Bytes.bytes ->
sl': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(ensures
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
Mkparser_kind'?.parser_kind_subkind (LowParse.Spec.Combinators.and_then_kind sk k) ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.VLGen.parse_bounded_vlgen min max pk s)
p
(LowParse.Low.VLData.clens_bounded_vldata_strong_payload min max s)
sl /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.VLGen.parse_bounded_vlgen min max pk s)
p
(LowParse.Low.VLData.clens_bounded_vldata_strong_payload min max s)
sl' /\
LowParse.Spec.Base.no_lookahead_on_precond (LowParse.Spec.VLGen.parse_bounded_vlgen min
max
pk
s)
sl
sl' ==>
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.VLGen.gaccessor_bounded_vlgen_payload' min max pk s sl ==
LowParse.Low.VLGen.gaccessor_bounded_vlgen_payload' min max pk s sl') | {
"end_col": 94,
"end_line": 626,
"start_col": 2,
"start_line": 626
} |
Prims.Tot | val gaccessor_vlgen_payload'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong}
)
: Tot (gaccessor' (parse_vlgen min max pk s) p (clens_id _)) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong } )
: Tot (gaccessor' (parse_vlgen min max pk s) p (clens_id _))
= fun input ->
parse_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res | val gaccessor_vlgen_payload'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong}
)
: Tot (gaccessor' (parse_vlgen min max pk s) p (clens_id _))
let gaccessor_vlgen_payload'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s:
serializer p {parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong}
)
: Tot (gaccessor' (parse_vlgen min max pk s) p (clens_id _)) = | false | null | false | fun input ->
parse_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0)
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ =
match parse p input' with
| None -> ()
| Some _ -> parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"total"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.VLGen.parse_vlgen_precond",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Base.consumed_length",
"Prims.op_Addition",
"FStar.UInt32.v",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"Prims.unit",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.parse_strong_prefix",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.seq",
"Prims.bool",
"LowParse.Spec.VLGen.parse_vlgen_unfold",
"LowParse.Low.Base.Spec.gaccessor'",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLGen.parse_vlgen",
"LowParse.Low.Base.Spec.clens_id"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))
= valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth
h
(parse_bounded_vlgen vmin vmax pk s)
(synth_vlgen (vmin) (vmax) s)
input
pos
inline_for_extraction
let finalize_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_vlgen min max pk s input pos h
inline_for_extraction
let finalize_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (U32.v min) (U32.v max) k })
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s))
= validate_synth
(validate_bounded_vlgen vmin min vmax max vk rk s v)
(synth_vlgen (U32.v min) (U32.v max) s)
()
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (jumper (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
let n = vk input pos in
let len = rk input pos in
[@inline_let]
let _ = valid_facts (parse_fldata_strong s (U32.v len)) h input n in
jump_fldata_strong s (U32.v len) len input n
#pop-options
inline_for_extraction
let jump_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
: Tot (jumper (parse_vlgen (vmin) (vmax) pk s))
= jump_synth
(jump_bounded_vlgen vmin vmax vk rk s)
(synth_vlgen (vmin) (vmax) s)
()
let gaccessor_bounded_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor' (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= fun input ->
parse_bounded_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_bounded_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_injective (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_no_lookahead_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_no_lookahead_2 min max pk s);
Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_injective_2 min max pk s);
gaccessor_prop_equiv (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) (gaccessor_bounded_vlgen_payload' min max pk s);
gaccessor_bounded_vlgen_payload' min max pk s
module B = LowStar.Buffer
inline_for_extraction
let accessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 ( min) ( max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (accessor (gaccessor_bounded_vlgen_payload min max pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
slice_access_eq h (gaccessor_bounded_vlgen_payload min max pk s) input pos;
valid_facts (parse_bounded_vlgen min max pk s) h input pos;
parse_bounded_vlgen_unfold_aux min max pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
jk input pos
let gaccessor_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong } ) | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_vlgen_payload'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong}
)
: Tot (gaccessor' (parse_vlgen min max pk s) p (clens_id _)) | [] | LowParse.Low.VLGen.gaccessor_vlgen_payload' | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
pk: LowParse.Spec.Base.parser sk (LowParse.Spec.BoundedInt.bounded_int32 min max) ->
s:
LowParse.Spec.Base.serializer p
{ LowParse.Spec.VLGen.parse_vlgen_precond min max k /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong }
-> LowParse.Low.Base.Spec.gaccessor' (LowParse.Spec.VLGen.parse_vlgen min max pk s)
p
(LowParse.Low.Base.Spec.clens_id t) | {
"end_col": 5,
"end_line": 695,
"start_col": 2,
"start_line": 678
} |
FStar.Pervasives.Lemma | val gaccessor_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond min max k})
(sl sl': bytes)
: Lemma
(ensures
((k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl') ==>
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'))) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_vlgen_payload_no_lookahead_1 min max pk s sl) sl' | val gaccessor_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond min max k})
(sl sl': bytes)
: Lemma
(ensures
((k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl') ==>
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl')))
let gaccessor_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond min max k})
(sl sl': bytes)
: Lemma
(ensures
((k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl') ==>
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'))) = | false | null | true | Classical.move_requires (gaccessor_vlgen_payload_no_lookahead_1 min max pk s sl) sl' | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"lemma"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.VLGen.parse_vlgen_precond",
"LowParse.Bytes.bytes",
"FStar.Classical.move_requires",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Low.Base.Spec.gaccessor_pre",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLGen.parse_vlgen",
"LowParse.Low.Base.Spec.clens_id",
"LowParse.Spec.Base.no_lookahead_on_precond",
"LowParse.Low.VLGen.gaccessor_vlgen_payload'",
"LowParse.Low.VLGen.gaccessor_vlgen_payload_no_lookahead_1",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_imp",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))
= valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth
h
(parse_bounded_vlgen vmin vmax pk s)
(synth_vlgen (vmin) (vmax) s)
input
pos
inline_for_extraction
let finalize_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_vlgen min max pk s input pos h
inline_for_extraction
let finalize_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (U32.v min) (U32.v max) k })
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s))
= validate_synth
(validate_bounded_vlgen vmin min vmax max vk rk s v)
(synth_vlgen (U32.v min) (U32.v max) s)
()
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (jumper (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
let n = vk input pos in
let len = rk input pos in
[@inline_let]
let _ = valid_facts (parse_fldata_strong s (U32.v len)) h input n in
jump_fldata_strong s (U32.v len) len input n
#pop-options
inline_for_extraction
let jump_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
: Tot (jumper (parse_vlgen (vmin) (vmax) pk s))
= jump_synth
(jump_bounded_vlgen vmin vmax vk rk s)
(synth_vlgen (vmin) (vmax) s)
()
let gaccessor_bounded_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor' (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= fun input ->
parse_bounded_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_bounded_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_injective (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_no_lookahead_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_no_lookahead_2 min max pk s);
Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_injective_2 min max pk s);
gaccessor_prop_equiv (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) (gaccessor_bounded_vlgen_payload' min max pk s);
gaccessor_bounded_vlgen_payload' min max pk s
module B = LowStar.Buffer
inline_for_extraction
let accessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 ( min) ( max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (accessor (gaccessor_bounded_vlgen_payload min max pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
slice_access_eq h (gaccessor_bounded_vlgen_payload min max pk s) input pos;
valid_facts (parse_bounded_vlgen min max pk s) h input pos;
parse_bounded_vlgen_unfold_aux min max pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
jk input pos
let gaccessor_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong } )
: Tot (gaccessor' (parse_vlgen min max pk s) p (clens_id _))
= fun input ->
parse_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
))
= parse_vlgen_unfold min max pk s sl;
parse_vlgen_unfold min max pk s sl' ;
parse_injective (parse_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
))
= parse_vlgen_unfold min max pk s sl;
parse_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl' | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond min max k})
(sl sl': bytes)
: Lemma
(ensures
((k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl') ==>
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'))) | [] | LowParse.Low.VLGen.gaccessor_vlgen_payload_no_lookahead_2 | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
pk: LowParse.Spec.Base.parser sk (LowParse.Spec.BoundedInt.bounded_int32 min max) ->
s: LowParse.Spec.Base.serializer p {LowParse.Spec.VLGen.parse_vlgen_precond min max k} ->
sl: LowParse.Bytes.bytes ->
sl': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(ensures
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
Mkparser_kind'?.parser_kind_subkind (LowParse.Spec.Combinators.and_then_kind sk k) ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.VLGen.parse_vlgen min max pk s)
p
(LowParse.Low.Base.Spec.clens_id t)
sl /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.VLGen.parse_vlgen min max pk s)
p
(LowParse.Low.Base.Spec.clens_id t)
sl' /\
LowParse.Spec.Base.no_lookahead_on_precond (LowParse.Spec.VLGen.parse_vlgen min max pk s)
sl
sl' ==>
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.VLGen.gaccessor_vlgen_payload' min max pk s sl ==
LowParse.Low.VLGen.gaccessor_vlgen_payload' min max pk s sl') | {
"end_col": 86,
"end_line": 799,
"start_col": 2,
"start_line": 799
} |
Prims.Tot | val gaccessor_vlgen_payload
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong}
)
: Tot (gaccessor (parse_vlgen min max pk s) p (clens_id _)) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor (parse_vlgen min max pk s) p (clens_id _))
= Classical.forall_intro_2 (gaccessor_vlgen_payload_no_lookahead_2 min max pk s);
Classical.forall_intro_2 (gaccessor_vlgen_payload_injective_2 min max pk s);
gaccessor_prop_equiv (parse_vlgen min max pk s) p (clens_id _) (gaccessor_vlgen_payload' min max pk s);
gaccessor_vlgen_payload' min max pk s | val gaccessor_vlgen_payload
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong}
)
: Tot (gaccessor (parse_vlgen min max pk s) p (clens_id _))
let gaccessor_vlgen_payload
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s:
serializer p {parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong}
)
: Tot (gaccessor (parse_vlgen min max pk s) p (clens_id _)) = | false | null | false | Classical.forall_intro_2 (gaccessor_vlgen_payload_no_lookahead_2 min max pk s);
Classical.forall_intro_2 (gaccessor_vlgen_payload_injective_2 min max pk s);
gaccessor_prop_equiv (parse_vlgen min max pk s)
p
(clens_id _)
(gaccessor_vlgen_payload' min max pk s);
gaccessor_vlgen_payload' min max pk s | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"total"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.VLGen.parse_vlgen_precond",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Low.VLGen.gaccessor_vlgen_payload'",
"Prims.unit",
"LowParse.Low.Base.Spec.gaccessor_prop_equiv",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLGen.parse_vlgen",
"LowParse.Low.Base.Spec.clens_id",
"FStar.Classical.forall_intro_2",
"LowParse.Bytes.bytes",
"Prims.l_imp",
"LowParse.Low.Base.Spec.gaccessor_pre",
"LowParse.Spec.Base.injective_precond",
"LowParse.Low.VLGen.gaccessor_vlgen_payload_injective_2",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Base.no_lookahead_on_precond",
"LowParse.Low.VLGen.gaccessor_vlgen_payload_no_lookahead_2",
"LowParse.Low.Base.Spec.gaccessor"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))
= valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth
h
(parse_bounded_vlgen vmin vmax pk s)
(synth_vlgen (vmin) (vmax) s)
input
pos
inline_for_extraction
let finalize_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_vlgen min max pk s input pos h
inline_for_extraction
let finalize_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (U32.v min) (U32.v max) k })
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s))
= validate_synth
(validate_bounded_vlgen vmin min vmax max vk rk s v)
(synth_vlgen (U32.v min) (U32.v max) s)
()
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (jumper (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
let n = vk input pos in
let len = rk input pos in
[@inline_let]
let _ = valid_facts (parse_fldata_strong s (U32.v len)) h input n in
jump_fldata_strong s (U32.v len) len input n
#pop-options
inline_for_extraction
let jump_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
: Tot (jumper (parse_vlgen (vmin) (vmax) pk s))
= jump_synth
(jump_bounded_vlgen vmin vmax vk rk s)
(synth_vlgen (vmin) (vmax) s)
()
let gaccessor_bounded_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor' (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= fun input ->
parse_bounded_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_bounded_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_injective (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_no_lookahead_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_no_lookahead_2 min max pk s);
Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_injective_2 min max pk s);
gaccessor_prop_equiv (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) (gaccessor_bounded_vlgen_payload' min max pk s);
gaccessor_bounded_vlgen_payload' min max pk s
module B = LowStar.Buffer
inline_for_extraction
let accessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 ( min) ( max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (accessor (gaccessor_bounded_vlgen_payload min max pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
slice_access_eq h (gaccessor_bounded_vlgen_payload min max pk s) input pos;
valid_facts (parse_bounded_vlgen min max pk s) h input pos;
parse_bounded_vlgen_unfold_aux min max pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
jk input pos
let gaccessor_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong } )
: Tot (gaccessor' (parse_vlgen min max pk s) p (clens_id _))
= fun input ->
parse_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
))
= parse_vlgen_unfold min max pk s sl;
parse_vlgen_unfold min max pk s sl' ;
parse_injective (parse_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
))
= parse_vlgen_unfold min max pk s sl;
parse_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_vlgen_payload_no_lookahead_1 min max pk s sl) sl'
let gaccessor_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong}) | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_vlgen_payload
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong}
)
: Tot (gaccessor (parse_vlgen min max pk s) p (clens_id _)) | [] | LowParse.Low.VLGen.gaccessor_vlgen_payload | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
pk: LowParse.Spec.Base.parser sk (LowParse.Spec.BoundedInt.bounded_int32 min max) ->
s:
LowParse.Spec.Base.serializer p
{ LowParse.Spec.VLGen.parse_vlgen_precond min max k /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong }
-> LowParse.Low.Base.Spec.gaccessor (LowParse.Spec.VLGen.parse_vlgen min max pk s)
p
(LowParse.Low.Base.Spec.clens_id t) | {
"end_col": 39,
"end_line": 814,
"start_col": 2,
"start_line": 811
} |
FStar.Pervasives.Lemma | val gaccessor_vlgen_payload_injective_2
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond min max k})
(sl sl': bytes)
: Lemma
(ensures
((k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl') ==>
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'))) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_vlgen_payload_injective_1 min max pk s sl) sl' | val gaccessor_vlgen_payload_injective_2
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond min max k})
(sl sl': bytes)
: Lemma
(ensures
((k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl') ==>
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl')))
let gaccessor_vlgen_payload_injective_2
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond min max k})
(sl sl': bytes)
: Lemma
(ensures
((k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl') ==>
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'))) = | false | null | true | Classical.move_requires (gaccessor_vlgen_payload_injective_1 min max pk s sl) sl' | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"lemma"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.VLGen.parse_vlgen_precond",
"LowParse.Bytes.bytes",
"FStar.Classical.move_requires",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Low.Base.Spec.gaccessor_pre",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLGen.parse_vlgen",
"LowParse.Low.Base.Spec.clens_id",
"LowParse.Spec.Base.injective_precond",
"LowParse.Low.VLGen.gaccessor_vlgen_payload'",
"LowParse.Low.VLGen.gaccessor_vlgen_payload_injective_1",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_imp",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))
= valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth
h
(parse_bounded_vlgen vmin vmax pk s)
(synth_vlgen (vmin) (vmax) s)
input
pos
inline_for_extraction
let finalize_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_vlgen min max pk s input pos h
inline_for_extraction
let finalize_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (U32.v min) (U32.v max) k })
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s))
= validate_synth
(validate_bounded_vlgen vmin min vmax max vk rk s v)
(synth_vlgen (U32.v min) (U32.v max) s)
()
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (jumper (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
let n = vk input pos in
let len = rk input pos in
[@inline_let]
let _ = valid_facts (parse_fldata_strong s (U32.v len)) h input n in
jump_fldata_strong s (U32.v len) len input n
#pop-options
inline_for_extraction
let jump_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
: Tot (jumper (parse_vlgen (vmin) (vmax) pk s))
= jump_synth
(jump_bounded_vlgen vmin vmax vk rk s)
(synth_vlgen (vmin) (vmax) s)
()
let gaccessor_bounded_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor' (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= fun input ->
parse_bounded_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_bounded_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_injective (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_no_lookahead_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_no_lookahead_2 min max pk s);
Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_injective_2 min max pk s);
gaccessor_prop_equiv (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) (gaccessor_bounded_vlgen_payload' min max pk s);
gaccessor_bounded_vlgen_payload' min max pk s
module B = LowStar.Buffer
inline_for_extraction
let accessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 ( min) ( max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (accessor (gaccessor_bounded_vlgen_payload min max pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
slice_access_eq h (gaccessor_bounded_vlgen_payload min max pk s) input pos;
valid_facts (parse_bounded_vlgen min max pk s) h input pos;
parse_bounded_vlgen_unfold_aux min max pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
jk input pos
let gaccessor_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong } )
: Tot (gaccessor' (parse_vlgen min max pk s) p (clens_id _))
= fun input ->
parse_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
))
= parse_vlgen_unfold min max pk s sl;
parse_vlgen_unfold min max pk s sl' ;
parse_injective (parse_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl' | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_vlgen_payload_injective_2
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond min max k})
(sl sl': bytes)
: Lemma
(ensures
((k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl') ==>
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'))) | [] | LowParse.Low.VLGen.gaccessor_vlgen_payload_injective_2 | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
pk: LowParse.Spec.Base.parser sk (LowParse.Spec.BoundedInt.bounded_int32 min max) ->
s: LowParse.Spec.Base.serializer p {LowParse.Spec.VLGen.parse_vlgen_precond min max k} ->
sl: LowParse.Bytes.bytes ->
sl': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(ensures
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.VLGen.parse_vlgen min max pk s)
p
(LowParse.Low.Base.Spec.clens_id t)
sl /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.VLGen.parse_vlgen min max pk s)
p
(LowParse.Low.Base.Spec.clens_id t)
sl' /\
LowParse.Spec.Base.injective_precond (LowParse.Spec.VLGen.parse_vlgen min max pk s) sl sl' ==>
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.VLGen.parse_vlgen min max pk s)
p
(LowParse.Low.Base.Spec.clens_id t)
sl /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.VLGen.parse_vlgen min max pk s)
p
(LowParse.Low.Base.Spec.clens_id t)
sl' /\
LowParse.Spec.Base.injective_precond (LowParse.Spec.VLGen.parse_vlgen min max pk s) sl sl' /\
LowParse.Low.VLGen.gaccessor_vlgen_payload' min max pk s sl ==
LowParse.Low.VLGen.gaccessor_vlgen_payload' min max pk s sl') | {
"end_col": 83,
"end_line": 749,
"start_col": 2,
"start_line": 749
} |
FStar.Pervasives.Lemma | val gaccessor_bounded_vlgen_payload_injective_2
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl': bytes)
: Lemma
(ensures
((k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl' /\ injective_precond (parse_bounded_vlgen min max pk s) sl sl') ==>
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl' /\ injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl ==
gaccessor_bounded_vlgen_payload' min max pk s sl'))) | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_bounded_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_injective_1 min max pk s sl) sl' | val gaccessor_bounded_vlgen_payload_injective_2
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl': bytes)
: Lemma
(ensures
((k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl' /\ injective_precond (parse_bounded_vlgen min max pk s) sl sl') ==>
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl' /\ injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl ==
gaccessor_bounded_vlgen_payload' min max pk s sl')))
let gaccessor_bounded_vlgen_payload_injective_2
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl': bytes)
: Lemma
(ensures
((k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl' /\ injective_precond (parse_bounded_vlgen min max pk s) sl sl') ==>
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl' /\ injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl ==
gaccessor_bounded_vlgen_payload' min max pk s sl'))) = | false | null | true | Classical.move_requires (gaccessor_bounded_vlgen_payload_injective_1 min max pk s sl) sl' | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"lemma"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Spec.Base.serializer",
"LowParse.Bytes.bytes",
"FStar.Classical.move_requires",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Low.Base.Spec.gaccessor_pre",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Spec.VLGen.parse_bounded_vlgen",
"LowParse.Low.VLData.clens_bounded_vldata_strong_payload",
"LowParse.Spec.Base.injective_precond",
"LowParse.Low.VLGen.gaccessor_bounded_vlgen_payload'",
"LowParse.Low.VLGen.gaccessor_bounded_vlgen_payload_injective_1",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_imp",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))
= valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth
h
(parse_bounded_vlgen vmin vmax pk s)
(synth_vlgen (vmin) (vmax) s)
input
pos
inline_for_extraction
let finalize_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_vlgen min max pk s input pos h
inline_for_extraction
let finalize_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (U32.v min) (U32.v max) k })
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s))
= validate_synth
(validate_bounded_vlgen vmin min vmax max vk rk s v)
(synth_vlgen (U32.v min) (U32.v max) s)
()
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (jumper (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
let n = vk input pos in
let len = rk input pos in
[@inline_let]
let _ = valid_facts (parse_fldata_strong s (U32.v len)) h input n in
jump_fldata_strong s (U32.v len) len input n
#pop-options
inline_for_extraction
let jump_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
: Tot (jumper (parse_vlgen (vmin) (vmax) pk s))
= jump_synth
(jump_bounded_vlgen vmin vmax vk rk s)
(synth_vlgen (vmin) (vmax) s)
()
let gaccessor_bounded_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor' (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= fun input ->
parse_bounded_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_bounded_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_injective (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl' | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_bounded_vlgen_payload_injective_2
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl': bytes)
: Lemma
(ensures
((k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl' /\ injective_precond (parse_bounded_vlgen min max pk s) sl sl') ==>
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl' /\ injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl ==
gaccessor_bounded_vlgen_payload' min max pk s sl'))) | [] | LowParse.Low.VLGen.gaccessor_bounded_vlgen_payload_injective_2 | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
pk: LowParse.Spec.Base.parser sk (LowParse.Spec.BoundedInt.bounded_int32 min max) ->
s: LowParse.Spec.Base.serializer p ->
sl: LowParse.Bytes.bytes ->
sl': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(ensures
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.VLGen.parse_bounded_vlgen min max pk s)
p
(LowParse.Low.VLData.clens_bounded_vldata_strong_payload min max s)
sl /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.VLGen.parse_bounded_vlgen min max pk s)
p
(LowParse.Low.VLData.clens_bounded_vldata_strong_payload min max s)
sl' /\
LowParse.Spec.Base.injective_precond (LowParse.Spec.VLGen.parse_bounded_vlgen min max pk s)
sl
sl' ==>
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.VLGen.parse_bounded_vlgen min max pk s)
p
(LowParse.Low.VLData.clens_bounded_vldata_strong_payload min max s)
sl /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.VLGen.parse_bounded_vlgen min max pk s)
p
(LowParse.Low.VLData.clens_bounded_vldata_strong_payload min max s)
sl' /\
LowParse.Spec.Base.injective_precond (LowParse.Spec.VLGen.parse_bounded_vlgen min max pk s)
sl
sl' /\
LowParse.Low.VLGen.gaccessor_bounded_vlgen_payload' min max pk s sl ==
LowParse.Low.VLGen.gaccessor_bounded_vlgen_payload' min max pk s sl') | {
"end_col": 91,
"end_line": 576,
"start_col": 2,
"start_line": 576
} |
FStar.Pervasives.Lemma | val valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond (vmin) (vmax) k})
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len)))
)
(ensures
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len))) | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))
= valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth
h
(parse_bounded_vlgen vmin vmax pk s)
(synth_vlgen (vmin) (vmax) s)
input
pos | val valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond (vmin) (vmax) k})
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len)))
)
(ensures
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)))
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond (vmin) (vmax) k})
#rrel
#rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len)))
)
(ensures
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len))) = | false | null | true | valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth h (parse_bounded_vlgen vmin vmax pk s) (synth_vlgen (vmin) (vmax) s) input pos | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"lemma"
] | [
"LowParse.Spec.DER.der_length_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.VLGen.parse_vlgen_precond",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Low.Combinators.valid_synth",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Spec.VLGen.parse_bounded_vlgen",
"LowParse.Spec.VLGen.synth_vlgen",
"Prims.unit",
"LowParse.Low.VLGen.valid_bounded_vlgen",
"LowParse.Low.Base.Spec.valid",
"Prims.op_Addition",
"FStar.UInt32.v",
"LowParse.Low.Base.Spec.valid_exact",
"FStar.UInt32.add",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Base.Spec.get_valid_pos",
"Prims.squash",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt.size",
"FStar.UInt32.n",
"FStar.Seq.Base.length",
"LowParse.Spec.Base.serialize",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Spec.VLGen.parse_vlgen",
"LowParse.Low.Base.Spec.contents_exact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len) | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond (vmin) (vmax) k})
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len)))
)
(ensures
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len))) | [] | LowParse.Low.VLGen.valid_vlgen | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
vmin: LowParse.Spec.DER.der_length_t ->
vmax: LowParse.Spec.DER.der_length_t{vmin <= vmax /\ vmax < 4294967296} ->
pk: LowParse.Spec.Base.parser sk (LowParse.Spec.BoundedInt.bounded_int32 vmin vmax) ->
s: LowParse.Spec.Base.serializer p {LowParse.Spec.VLGen.parse_vlgen_precond vmin vmax k} ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
h: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid pk h input pos /\
(let pos1 = LowParse.Low.Base.Spec.get_valid_pos pk h input pos in
let len = LowParse.Low.Base.Spec.contents pk h input pos in
FStar.UInt32.v pos1 + FStar.UInt32.v len < 4294967296 /\
LowParse.Low.Base.Spec.valid_exact p h input pos1 (FStar.UInt32.add pos1 len)))
(ensures
(let pos1 = LowParse.Low.Base.Spec.get_valid_pos pk h input pos in
let len = LowParse.Low.Base.Spec.contents pk h input pos in
let x =
LowParse.Low.Base.Spec.contents_exact p h input pos1 (FStar.UInt32.add pos1 len)
in
FStar.Seq.Base.length (LowParse.Spec.Base.serialize s x) == FStar.UInt32.v len /\
LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.VLGen.parse_vlgen vmin vmax pk s)
h
input
pos
x
(FStar.UInt32.add pos1 len))) | {
"end_col": 7,
"end_line": 329,
"start_col": 2,
"start_line": 323
} |
FStar.HyperStack.ST.Stack | val finalize_bounded_vlgen
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos pos': U32.t)
: HST.Stack unit
(requires
(fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\ sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\
(let pos_payload = pos `U32.add` (U32.uint_to_t sz) in
valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\
(let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/
(min <= len_ser /\ len_ser <= max))))))
(ensures
(fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos')) | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos' | val finalize_bounded_vlgen
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos pos': U32.t)
: HST.Stack unit
(requires
(fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\ sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\
(let pos_payload = pos `U32.add` (U32.uint_to_t sz) in
valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\
(let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/
(min <= len_ser /\ len_ser <= max))))))
(ensures
(fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'))
let finalize_bounded_vlgen
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos pos': U32.t)
: HST.Stack unit
(requires
(fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\ sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\
(let pos_payload = pos `U32.add` (U32.uint_to_t sz) in
valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\
(let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/
(min <= len_ser /\ len_ser <= max))))))
(ensures
(fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos')) = | true | null | false | let h = HST.get () in
[@@ inline_let ]let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos' | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"FStar.UInt32.t",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Spec.Base.serializer",
"LowParse.Low.Base.leaf_writer_strong",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"LowParse.Low.VLGen.finalize_bounded_vlgen_exact",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_pos_valid_exact",
"FStar.UInt32.add",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt.size",
"FStar.UInt32.n",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_high",
"FStar.Pervasives.Native.Some",
"Prims.op_Addition",
"FStar.UInt32.v",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Low.Base.Spec.valid_pos",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Low.Base.writable",
"LowParse.Slice.buffer_srel_of_srel",
"LowParse.Slice.__proj__Mkslice__item__base",
"FStar.Seq.Base.length",
"LowParse.Spec.Base.serialize",
"LowParse.Low.Base.Spec.contents",
"FStar.UInt32.sub",
"FStar.UInt32.uint_to_t",
"FStar.UInt.uint_t",
"LowStar.Monotonic.Buffer.modifies",
"LowParse.Slice.loc_slice_from_to",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_pred",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Spec.VLGen.parse_bounded_vlgen"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos' | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val finalize_bounded_vlgen
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos pos': U32.t)
: HST.Stack unit
(requires
(fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\ sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\
(let pos_payload = pos `U32.add` (U32.uint_to_t sz) in
valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\
(let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/
(min <= len_ser /\ len_ser <= max))))))
(ensures
(fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos')) | [] | LowParse.Low.VLGen.finalize_bounded_vlgen | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
sz32: FStar.UInt32.t ->
wk: LowParse.Low.Base.leaf_writer_strong ssk ->
s: LowParse.Spec.Base.serializer p ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 63,
"end_line": 263,
"start_col": 1,
"start_line": 257
} |
FStar.HyperStack.ST.Stack | val finalize_vlgen
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond (min) (max) k})
(#rrel #rel: _)
(input: slice rrel rel)
(pos pos': U32.t)
: HST.Stack unit
(requires
(fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\ sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\
(let pos_payload = pos `U32.add` (U32.uint_to_t sz) in
valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\
(let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/
(min <= len_ser /\ len_ser <= max))))))
(ensures
(fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos')) | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let finalize_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_vlgen_exact min max sz32 wk s input pos pos' | val finalize_vlgen
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond (min) (max) k})
(#rrel #rel: _)
(input: slice rrel rel)
(pos pos': U32.t)
: HST.Stack unit
(requires
(fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\ sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\
(let pos_payload = pos `U32.add` (U32.uint_to_t sz) in
valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\
(let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/
(min <= len_ser /\ len_ser <= max))))))
(ensures
(fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'))
let finalize_vlgen
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond (min) (max) k})
(#rrel #rel: _)
(input: slice rrel rel)
(pos pos': U32.t)
: HST.Stack unit
(requires
(fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\ sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\
(let pos_payload = pos `U32.add` (U32.uint_to_t sz) in
valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\
(let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/
(min <= len_ser /\ len_ser <= max))))))
(ensures
(fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos')) = | true | null | false | let h = HST.get () in
[@@ inline_let ]let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_vlgen_exact min max sz32 wk s input pos pos' | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"FStar.UInt32.t",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Spec.Base.serializer",
"LowParse.Low.Base.leaf_writer_strong",
"LowParse.Spec.VLGen.parse_vlgen_precond",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"LowParse.Low.VLGen.finalize_vlgen_exact",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_pos_valid_exact",
"FStar.UInt32.add",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt.size",
"FStar.UInt32.n",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_high",
"FStar.Pervasives.Native.Some",
"Prims.op_Addition",
"FStar.UInt32.v",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Low.Base.Spec.valid_pos",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Low.Base.writable",
"LowParse.Slice.buffer_srel_of_srel",
"LowParse.Slice.__proj__Mkslice__item__base",
"FStar.Seq.Base.length",
"LowParse.Spec.Base.serialize",
"LowParse.Low.Base.Spec.contents",
"FStar.UInt32.sub",
"FStar.UInt32.uint_to_t",
"FStar.UInt.uint_t",
"LowStar.Monotonic.Buffer.modifies",
"LowParse.Slice.loc_slice_from_to",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_pred",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLGen.parse_vlgen"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))
= valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth
h
(parse_bounded_vlgen vmin vmax pk s)
(synth_vlgen (vmin) (vmax) s)
input
pos
inline_for_extraction
let finalize_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_vlgen min max pk s input pos h
inline_for_extraction
let finalize_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos' | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val finalize_vlgen
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond (min) (max) k})
(#rrel #rel: _)
(input: slice rrel rel)
(pos pos': U32.t)
: HST.Stack unit
(requires
(fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\ sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\
(let pos_payload = pos `U32.add` (U32.uint_to_t sz) in
valid_pos p h input pos_payload pos' /\ k.parser_kind_subkind == Some ParserStrong /\
(let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/
(min <= len_ser /\ len_ser <= max))))))
(ensures
(fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos')) | [] | LowParse.Low.VLGen.finalize_vlgen | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
sz32: FStar.UInt32.t ->
wk: LowParse.Low.Base.leaf_writer_strong ssk ->
s: LowParse.Spec.Base.serializer p {LowParse.Spec.VLGen.parse_vlgen_precond min max k} ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 55,
"end_line": 424,
"start_col": 1,
"start_line": 418
} |
FStar.Pervasives.Lemma | val valid_bounded_vlgen_intro_strong_prefix
(min: nat)
(max: nat{min <= max /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len))))
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\
(let x = contents p h input pos1 in
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s)
h
input
pos
x
(pos1 `U32.add` len))))) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_bounded_vlgen_intro_strong_prefix
(min: nat)
(max: nat { min <= max /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents p h input pos1 in
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h input pos x (pos1 `U32.add` len)
))))
= let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_pos_valid_exact p h input pos1 (pos1 `U32.add` len);
valid_bounded_vlgen_intro min max pk s h input pos | val valid_bounded_vlgen_intro_strong_prefix
(min: nat)
(max: nat{min <= max /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len))))
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\
(let x = contents p h input pos1 in
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s)
h
input
pos
x
(pos1 `U32.add` len)))))
let valid_bounded_vlgen_intro_strong_prefix
(min: nat)
(max: nat{min <= max /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len))))
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\
(let x = contents p h input pos1 in
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s)
h
input
pos
x
(pos1 `U32.add` len))))) = | false | null | true | let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_pos_valid_exact p h input pos1 (pos1 `U32.add` len);
valid_bounded_vlgen_intro min max pk s h input pos | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"lemma"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Spec.Base.serializer",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.VLGen.valid_bounded_vlgen_intro",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_pos_valid_exact",
"FStar.UInt32.add",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Base.Spec.get_valid_pos",
"LowParse.Low.Base.Spec.valid",
"Prims.op_Addition",
"FStar.UInt32.v",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Low.Base.Spec.valid_pos",
"Prims.squash",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_pred",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Spec.VLGen.parse_bounded_vlgen",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))
= valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth
h
(parse_bounded_vlgen vmin vmax pk s)
(synth_vlgen (vmin) (vmax) s)
input
pos
inline_for_extraction
let finalize_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_vlgen min max pk s input pos h
inline_for_extraction
let finalize_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (U32.v min) (U32.v max) k })
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s))
= validate_synth
(validate_bounded_vlgen vmin min vmax max vk rk s v)
(synth_vlgen (U32.v min) (U32.v max) s)
()
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (jumper (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
let n = vk input pos in
let len = rk input pos in
[@inline_let]
let _ = valid_facts (parse_fldata_strong s (U32.v len)) h input n in
jump_fldata_strong s (U32.v len) len input n
#pop-options
inline_for_extraction
let jump_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
: Tot (jumper (parse_vlgen (vmin) (vmax) pk s))
= jump_synth
(jump_bounded_vlgen vmin vmax vk rk s)
(synth_vlgen (vmin) (vmax) s)
()
let gaccessor_bounded_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor' (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= fun input ->
parse_bounded_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_bounded_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_injective (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_no_lookahead_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_no_lookahead_2 min max pk s);
Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_injective_2 min max pk s);
gaccessor_prop_equiv (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) (gaccessor_bounded_vlgen_payload' min max pk s);
gaccessor_bounded_vlgen_payload' min max pk s
module B = LowStar.Buffer
inline_for_extraction
let accessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 ( min) ( max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (accessor (gaccessor_bounded_vlgen_payload min max pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
slice_access_eq h (gaccessor_bounded_vlgen_payload min max pk s) input pos;
valid_facts (parse_bounded_vlgen min max pk s) h input pos;
parse_bounded_vlgen_unfold_aux min max pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
jk input pos
let gaccessor_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong } )
: Tot (gaccessor' (parse_vlgen min max pk s) p (clens_id _))
= fun input ->
parse_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
))
= parse_vlgen_unfold min max pk s sl;
parse_vlgen_unfold min max pk s sl' ;
parse_injective (parse_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
))
= parse_vlgen_unfold min max pk s sl;
parse_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_vlgen_payload_no_lookahead_1 min max pk s sl) sl'
let gaccessor_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor (parse_vlgen min max pk s) p (clens_id _))
= Classical.forall_intro_2 (gaccessor_vlgen_payload_no_lookahead_2 min max pk s);
Classical.forall_intro_2 (gaccessor_vlgen_payload_injective_2 min max pk s);
gaccessor_prop_equiv (parse_vlgen min max pk s) p (clens_id _) (gaccessor_vlgen_payload' min max pk s);
gaccessor_vlgen_payload' min max pk s
inline_for_extraction
let accessor_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 ( min) ( max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong } )
: Tot (accessor (gaccessor_vlgen_payload min max pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
slice_access_eq h (gaccessor_vlgen_payload min max pk s) input pos;
valid_facts (parse_vlgen min max pk s) h input pos;
parse_vlgen_unfold min max pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
jk input pos
module HS = FStar.HyperStack
#push-options "--z3rlimit 16"
let valid_bounded_vlgen_intro
(min: nat)
(max: nat { min <= max /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_exact_equiv p h input pos1 (pos1 `U32.add` len);
contents_exact_eq p h input pos1 (pos1 `U32.add` len);
parse_bounded_vlgen_unfold min max pk s (bytes_of_slice_from h input pos);
valid_facts (parse_bounded_vlgen min max pk s) h input pos
#pop-options
let valid_bounded_vlgen_intro_strong_prefix
(min: nat)
(max: nat { min <= max /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents p h input pos1 in
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h input pos x (pos1 `U32.add` len) | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_bounded_vlgen_intro_strong_prefix
(min: nat)
(max: nat{min <= max /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len))))
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\
(let x = contents p h input pos1 in
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s)
h
input
pos
x
(pos1 `U32.add` len))))) | [] | LowParse.Low.VLGen.valid_bounded_vlgen_intro_strong_prefix | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max < 4294967296} ->
pk: LowParse.Spec.Base.parser sk (LowParse.Spec.BoundedInt.bounded_int32 min max) ->
s: LowParse.Spec.Base.serializer p ->
h: FStar.Monotonic.HyperStack.mem ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid pk h input pos /\
(let pos1 = LowParse.Low.Base.Spec.get_valid_pos pk h input pos in
let len = LowParse.Low.Base.Spec.contents pk h input pos in
FStar.UInt32.v pos1 + FStar.UInt32.v len < 4294967296 /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.valid_pos p h input pos1 (FStar.UInt32.add pos1 len)))
(ensures
LowParse.Low.Base.Spec.valid pk h input pos /\
(let pos1 = LowParse.Low.Base.Spec.get_valid_pos pk h input pos in
let len = LowParse.Low.Base.Spec.contents pk h input pos in
FStar.UInt32.v pos1 + FStar.UInt32.v len < 4294967296 /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.valid_pos p h input pos1 (FStar.UInt32.add pos1 len) /\
(let x = LowParse.Low.Base.Spec.contents p h input pos1 in
LowParse.Spec.VLData.parse_bounded_vldata_strong_pred min max s x /\
LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.VLGen.parse_bounded_vlgen min
max
pk
s)
h
input
pos
x
(FStar.UInt32.add pos1 len)))) | {
"end_col": 54,
"end_line": 920,
"start_col": 1,
"start_line": 917
} |
Prims.Tot | val validate_vlgen
(vmin: der_length_t)
(min: U32.t{U32.v min == vmin})
(vmax: der_length_t)
(max: U32.t{U32.v max == vmax /\ U32.v min <= U32.v max})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond (U32.v min) (U32.v max) k})
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s)) | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let validate_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (U32.v min) (U32.v max) k })
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s))
= validate_synth
(validate_bounded_vlgen vmin min vmax max vk rk s v)
(synth_vlgen (U32.v min) (U32.v max) s)
() | val validate_vlgen
(vmin: der_length_t)
(min: U32.t{U32.v min == vmin})
(vmax: der_length_t)
(max: U32.t{U32.v max == vmax /\ U32.v min <= U32.v max})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond (U32.v min) (U32.v max) k})
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s))
let validate_vlgen
(vmin: der_length_t)
(min: U32.t{U32.v min == vmin})
(vmax: der_length_t)
(max: U32.t{U32.v max == vmax /\ U32.v min <= U32.v max})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond (U32.v min) (U32.v max) k})
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s)) = | false | null | false | validate_synth (validate_bounded_vlgen vmin min vmax max vk rk s v)
(synth_vlgen (U32.v min) (U32.v max) s)
() | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"total"
] | [
"LowParse.Spec.DER.der_length_t",
"FStar.UInt32.t",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"FStar.UInt.size",
"FStar.UInt32.n",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Prims.op_LessThanOrEqual",
"LowParse.Spec.DER.der_length_max",
"FStar.UInt32.v",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Low.Base.validator",
"LowParse.Low.Base.leaf_reader",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.VLGen.parse_vlgen_precond",
"LowParse.Low.Combinators.validate_synth",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Spec.VLGen.parse_bounded_vlgen",
"LowParse.Low.VLGen.validate_bounded_vlgen",
"LowParse.Spec.VLGen.synth_vlgen",
"LowParse.Spec.VLGen.parse_vlgen"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))
= valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth
h
(parse_bounded_vlgen vmin vmax pk s)
(synth_vlgen (vmin) (vmax) s)
input
pos
inline_for_extraction
let finalize_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_vlgen min max pk s input pos h
inline_for_extraction
let finalize_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (U32.v min) (U32.v max) k })
(v: validator p) | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val validate_vlgen
(vmin: der_length_t)
(min: U32.t{U32.v min == vmin})
(vmax: der_length_t)
(max: U32.t{U32.v max == vmax /\ U32.v min <= U32.v max})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond (U32.v min) (U32.v max) k})
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s)) | [] | LowParse.Low.VLGen.validate_vlgen | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
vmin: LowParse.Spec.DER.der_length_t ->
min: FStar.UInt32.t{FStar.UInt32.v min == vmin} ->
vmax: LowParse.Spec.DER.der_length_t ->
max: FStar.UInt32.t{FStar.UInt32.v max == vmax /\ FStar.UInt32.v min <= FStar.UInt32.v max} ->
vk: LowParse.Low.Base.validator pk ->
rk: LowParse.Low.Base.leaf_reader pk ->
s:
LowParse.Spec.Base.serializer p
{LowParse.Spec.VLGen.parse_vlgen_precond (FStar.UInt32.v min) (FStar.UInt32.v max) k} ->
v: LowParse.Low.Base.validator p
-> LowParse.Low.Base.validator (LowParse.Spec.VLGen.parse_vlgen vmin vmax pk s) | {
"end_col": 6,
"end_line": 445,
"start_col": 2,
"start_line": 442
} |
FStar.Pervasives.Lemma | val valid_vlgen_intro_strong_prefix
(min: nat)
(max: nat{min <= max /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\ parse_vlgen_precond min max k)))
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\
(let x = contents p h input pos1 in
valid_content_pos (parse_vlgen min max pk s) h input pos x (pos1 `U32.add` len))))) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_vlgen_intro_strong_prefix
(min: nat)
(max: nat { min <= max /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\
parse_vlgen_precond min max k
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents p h input pos1 in
valid_content_pos (parse_vlgen min max pk s) h input pos x (pos1 `U32.add` len)
))))
= let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_pos_valid_exact p h input pos1 (pos1 `U32.add` len);
valid_vlgen_intro min max pk s h input pos | val valid_vlgen_intro_strong_prefix
(min: nat)
(max: nat{min <= max /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\ parse_vlgen_precond min max k)))
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\
(let x = contents p h input pos1 in
valid_content_pos (parse_vlgen min max pk s) h input pos x (pos1 `U32.add` len)))))
let valid_vlgen_intro_strong_prefix
(min: nat)
(max: nat{min <= max /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\ parse_vlgen_precond min max k)))
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\
(let x = contents p h input pos1 in
valid_content_pos (parse_vlgen min max pk s) h input pos x (pos1 `U32.add` len))))) = | false | null | true | let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_pos_valid_exact p h input pos1 (pos1 `U32.add` len);
valid_vlgen_intro min max pk s h input pos | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"lemma"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Spec.Base.serializer",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.VLGen.valid_vlgen_intro",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_pos_valid_exact",
"FStar.UInt32.add",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Base.Spec.get_valid_pos",
"LowParse.Low.Base.Spec.valid",
"Prims.op_Addition",
"FStar.UInt32.v",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Low.Base.Spec.valid_pos",
"LowParse.Spec.VLGen.parse_vlgen_precond",
"Prims.squash",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLGen.parse_vlgen",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))
= valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth
h
(parse_bounded_vlgen vmin vmax pk s)
(synth_vlgen (vmin) (vmax) s)
input
pos
inline_for_extraction
let finalize_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_vlgen min max pk s input pos h
inline_for_extraction
let finalize_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (U32.v min) (U32.v max) k })
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s))
= validate_synth
(validate_bounded_vlgen vmin min vmax max vk rk s v)
(synth_vlgen (U32.v min) (U32.v max) s)
()
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (jumper (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
let n = vk input pos in
let len = rk input pos in
[@inline_let]
let _ = valid_facts (parse_fldata_strong s (U32.v len)) h input n in
jump_fldata_strong s (U32.v len) len input n
#pop-options
inline_for_extraction
let jump_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
: Tot (jumper (parse_vlgen (vmin) (vmax) pk s))
= jump_synth
(jump_bounded_vlgen vmin vmax vk rk s)
(synth_vlgen (vmin) (vmax) s)
()
let gaccessor_bounded_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor' (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= fun input ->
parse_bounded_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_bounded_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_injective (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_no_lookahead_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_no_lookahead_2 min max pk s);
Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_injective_2 min max pk s);
gaccessor_prop_equiv (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) (gaccessor_bounded_vlgen_payload' min max pk s);
gaccessor_bounded_vlgen_payload' min max pk s
module B = LowStar.Buffer
inline_for_extraction
let accessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 ( min) ( max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (accessor (gaccessor_bounded_vlgen_payload min max pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
slice_access_eq h (gaccessor_bounded_vlgen_payload min max pk s) input pos;
valid_facts (parse_bounded_vlgen min max pk s) h input pos;
parse_bounded_vlgen_unfold_aux min max pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
jk input pos
let gaccessor_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong } )
: Tot (gaccessor' (parse_vlgen min max pk s) p (clens_id _))
= fun input ->
parse_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
))
= parse_vlgen_unfold min max pk s sl;
parse_vlgen_unfold min max pk s sl' ;
parse_injective (parse_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
))
= parse_vlgen_unfold min max pk s sl;
parse_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_vlgen_payload_no_lookahead_1 min max pk s sl) sl'
let gaccessor_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor (parse_vlgen min max pk s) p (clens_id _))
= Classical.forall_intro_2 (gaccessor_vlgen_payload_no_lookahead_2 min max pk s);
Classical.forall_intro_2 (gaccessor_vlgen_payload_injective_2 min max pk s);
gaccessor_prop_equiv (parse_vlgen min max pk s) p (clens_id _) (gaccessor_vlgen_payload' min max pk s);
gaccessor_vlgen_payload' min max pk s
inline_for_extraction
let accessor_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 ( min) ( max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong } )
: Tot (accessor (gaccessor_vlgen_payload min max pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
slice_access_eq h (gaccessor_vlgen_payload min max pk s) input pos;
valid_facts (parse_vlgen min max pk s) h input pos;
parse_vlgen_unfold min max pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
jk input pos
module HS = FStar.HyperStack
#push-options "--z3rlimit 16"
let valid_bounded_vlgen_intro
(min: nat)
(max: nat { min <= max /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_exact_equiv p h input pos1 (pos1 `U32.add` len);
contents_exact_eq p h input pos1 (pos1 `U32.add` len);
parse_bounded_vlgen_unfold min max pk s (bytes_of_slice_from h input pos);
valid_facts (parse_bounded_vlgen min max pk s) h input pos
#pop-options
let valid_bounded_vlgen_intro_strong_prefix
(min: nat)
(max: nat { min <= max /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents p h input pos1 in
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h input pos x (pos1 `U32.add` len)
))))
= let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_pos_valid_exact p h input pos1 (pos1 `U32.add` len);
valid_bounded_vlgen_intro min max pk s h input pos
let valid_vlgen_intro
(min: nat)
(max: nat { min <= max /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\
parse_vlgen_precond min max k
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
valid_content_pos (parse_vlgen min max pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_exact_equiv p h input pos1 (pos1 `U32.add` len);
contents_exact_eq p h input pos1 (pos1 `U32.add` len);
parse_vlgen_unfold min max pk s (bytes_of_slice_from h input pos);
valid_facts (parse_vlgen min max pk s) h input pos
let valid_vlgen_intro_strong_prefix
(min: nat)
(max: nat { min <= max /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\
parse_vlgen_precond min max k
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents p h input pos1 in
valid_content_pos (parse_vlgen min max pk s) h input pos x (pos1 `U32.add` len) | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_vlgen_intro_strong_prefix
(min: nat)
(max: nat{min <= max /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\ parse_vlgen_precond min max k)))
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\
(let x = contents p h input pos1 in
valid_content_pos (parse_vlgen min max pk s) h input pos x (pos1 `U32.add` len))))) | [] | LowParse.Low.VLGen.valid_vlgen_intro_strong_prefix | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max < 4294967296} ->
pk: LowParse.Spec.Base.parser sk (LowParse.Spec.BoundedInt.bounded_int32 min max) ->
s: LowParse.Spec.Base.serializer p ->
h: FStar.Monotonic.HyperStack.mem ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid pk h input pos /\
(let pos1 = LowParse.Low.Base.Spec.get_valid_pos pk h input pos in
let len = LowParse.Low.Base.Spec.contents pk h input pos in
FStar.UInt32.v pos1 + FStar.UInt32.v len < 4294967296 /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.valid_pos p h input pos1 (FStar.UInt32.add pos1 len) /\
LowParse.Spec.VLGen.parse_vlgen_precond min max k))
(ensures
LowParse.Low.Base.Spec.valid pk h input pos /\
(let pos1 = LowParse.Low.Base.Spec.get_valid_pos pk h input pos in
let len = LowParse.Low.Base.Spec.contents pk h input pos in
FStar.UInt32.v pos1 + FStar.UInt32.v len < 4294967296 /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.valid_pos p h input pos1 (FStar.UInt32.add pos1 len) /\
(let x = LowParse.Low.Base.Spec.contents p h input pos1 in
LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.VLGen.parse_vlgen min max pk s)
h
input
pos
x
(FStar.UInt32.add pos1 len)))) | {
"end_col": 46,
"end_line": 997,
"start_col": 1,
"start_line": 994
} |
FStar.Pervasives.Lemma | val valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len)))
)
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len) /\
(let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s)
h
input
pos
x
(pos1 `U32.add` len))))) | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2 | val valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len)))
)
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len) /\
(let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s)
h
input
pos
x
(pos1 `U32.add` len)))))
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel
#rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len)))
)
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len) /\
(let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s)
h
input
pos
x
(pos1 `U32.add` len))))) = | false | null | true | valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2 | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"lemma"
] | [
"LowParse.Spec.DER.der_length_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Spec.Base.serializer",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Low.Base.Spec.valid_exact_serialize",
"Prims.unit",
"LowParse.Low.Base.Spec.serialized_length_eq",
"LowParse.Low.FLData.valid_fldata_gen",
"FStar.UInt32.v",
"LowParse.Low.Base.Spec.contents_exact",
"FStar.UInt32.add",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Base.Spec.get_valid_pos",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.VLGen.parse_bounded_vlgen_unfold",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Spec.VLGen.parse_bounded_vlgen",
"LowParse.Low.Base.Spec.valid",
"Prims.op_Addition",
"LowParse.Low.Base.Spec.valid_exact",
"Prims.squash",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt.size",
"FStar.UInt32.n",
"FStar.Seq.Base.length",
"LowParse.Spec.Base.serialize",
"LowParse.Low.Base.Spec.valid_content_pos",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len) | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len)))
)
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len) /\
(let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s)
h
input
pos
x
(pos1 `U32.add` len))))) | [] | LowParse.Low.VLGen.valid_bounded_vlgen | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
vmin: LowParse.Spec.DER.der_length_t ->
vmax: LowParse.Spec.DER.der_length_t{vmin <= vmax /\ vmax < 4294967296} ->
pk: LowParse.Spec.Base.parser sk (LowParse.Spec.BoundedInt.bounded_int32 vmin vmax) ->
s: LowParse.Spec.Base.serializer p ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
h: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid pk h input pos /\
(let pos1 = LowParse.Low.Base.Spec.get_valid_pos pk h input pos in
let len = LowParse.Low.Base.Spec.contents pk h input pos in
FStar.UInt32.v pos1 + FStar.UInt32.v len < 4294967296 /\
LowParse.Low.Base.Spec.valid_exact p h input pos1 (FStar.UInt32.add pos1 len)))
(ensures
LowParse.Low.Base.Spec.valid pk h input pos /\
(let pos1 = LowParse.Low.Base.Spec.get_valid_pos pk h input pos in
let len = LowParse.Low.Base.Spec.contents pk h input pos in
FStar.UInt32.v pos1 + FStar.UInt32.v len < 4294967296 /\
LowParse.Low.Base.Spec.valid_exact p h input pos1 (FStar.UInt32.add pos1 len) /\
(let x =
LowParse.Low.Base.Spec.contents_exact p h input pos1 (FStar.UInt32.add pos1 len)
in
FStar.Seq.Base.length (LowParse.Spec.Base.serialize s x) == FStar.UInt32.v len /\
LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.VLGen.parse_bounded_vlgen vmin
vmax
pk
s)
h
input
pos
x
(FStar.UInt32.add pos1 len)))) | {
"end_col": 43,
"end_line": 91,
"start_col": 2,
"start_line": 82
} |
FStar.Pervasives.Lemma | val valid_bounded_vlgen_intro
(min: nat)
(max: nat{min <= max /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len)))
)
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len) /\
(let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s)
h
input
pos
x
(pos1 `U32.add` len))))) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_bounded_vlgen_intro
(min: nat)
(max: nat { min <= max /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_exact_equiv p h input pos1 (pos1 `U32.add` len);
contents_exact_eq p h input pos1 (pos1 `U32.add` len);
parse_bounded_vlgen_unfold min max pk s (bytes_of_slice_from h input pos);
valid_facts (parse_bounded_vlgen min max pk s) h input pos | val valid_bounded_vlgen_intro
(min: nat)
(max: nat{min <= max /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len)))
)
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len) /\
(let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s)
h
input
pos
x
(pos1 `U32.add` len)))))
let valid_bounded_vlgen_intro
(min: nat)
(max: nat{min <= max /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len)))
)
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len) /\
(let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s)
h
input
pos
x
(pos1 `U32.add` len))))) = | false | null | true | valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_exact_equiv p h input pos1 (pos1 `U32.add` len);
contents_exact_eq p h input pos1 (pos1 `U32.add` len);
parse_bounded_vlgen_unfold min max pk s (bytes_of_slice_from h input pos);
valid_facts (parse_bounded_vlgen min max pk s) h input pos | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"lemma"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Spec.Base.serializer",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Spec.VLGen.parse_bounded_vlgen",
"Prims.unit",
"LowParse.Spec.VLGen.parse_bounded_vlgen_unfold",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Low.Base.Spec.contents_exact_eq",
"FStar.UInt32.add",
"LowParse.Low.Base.Spec.valid_exact_equiv",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Base.Spec.get_valid_pos",
"LowParse.Low.Base.Spec.valid",
"Prims.op_Addition",
"FStar.UInt32.v",
"LowParse.Low.Base.Spec.valid_exact",
"Prims.squash",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_pred",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Low.Base.Spec.contents_exact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))
= valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth
h
(parse_bounded_vlgen vmin vmax pk s)
(synth_vlgen (vmin) (vmax) s)
input
pos
inline_for_extraction
let finalize_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_vlgen min max pk s input pos h
inline_for_extraction
let finalize_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (U32.v min) (U32.v max) k })
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s))
= validate_synth
(validate_bounded_vlgen vmin min vmax max vk rk s v)
(synth_vlgen (U32.v min) (U32.v max) s)
()
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (jumper (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
let n = vk input pos in
let len = rk input pos in
[@inline_let]
let _ = valid_facts (parse_fldata_strong s (U32.v len)) h input n in
jump_fldata_strong s (U32.v len) len input n
#pop-options
inline_for_extraction
let jump_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
: Tot (jumper (parse_vlgen (vmin) (vmax) pk s))
= jump_synth
(jump_bounded_vlgen vmin vmax vk rk s)
(synth_vlgen (vmin) (vmax) s)
()
let gaccessor_bounded_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor' (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= fun input ->
parse_bounded_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_bounded_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_injective (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_no_lookahead_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_no_lookahead_2 min max pk s);
Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_injective_2 min max pk s);
gaccessor_prop_equiv (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) (gaccessor_bounded_vlgen_payload' min max pk s);
gaccessor_bounded_vlgen_payload' min max pk s
module B = LowStar.Buffer
inline_for_extraction
let accessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 ( min) ( max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (accessor (gaccessor_bounded_vlgen_payload min max pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
slice_access_eq h (gaccessor_bounded_vlgen_payload min max pk s) input pos;
valid_facts (parse_bounded_vlgen min max pk s) h input pos;
parse_bounded_vlgen_unfold_aux min max pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
jk input pos
let gaccessor_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong } )
: Tot (gaccessor' (parse_vlgen min max pk s) p (clens_id _))
= fun input ->
parse_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
))
= parse_vlgen_unfold min max pk s sl;
parse_vlgen_unfold min max pk s sl' ;
parse_injective (parse_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
))
= parse_vlgen_unfold min max pk s sl;
parse_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_vlgen_payload_no_lookahead_1 min max pk s sl) sl'
let gaccessor_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor (parse_vlgen min max pk s) p (clens_id _))
= Classical.forall_intro_2 (gaccessor_vlgen_payload_no_lookahead_2 min max pk s);
Classical.forall_intro_2 (gaccessor_vlgen_payload_injective_2 min max pk s);
gaccessor_prop_equiv (parse_vlgen min max pk s) p (clens_id _) (gaccessor_vlgen_payload' min max pk s);
gaccessor_vlgen_payload' min max pk s
inline_for_extraction
let accessor_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 ( min) ( max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong } )
: Tot (accessor (gaccessor_vlgen_payload min max pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
slice_access_eq h (gaccessor_vlgen_payload min max pk s) input pos;
valid_facts (parse_vlgen min max pk s) h input pos;
parse_vlgen_unfold min max pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
jk input pos
module HS = FStar.HyperStack
#push-options "--z3rlimit 16"
let valid_bounded_vlgen_intro
(min: nat)
(max: nat { min <= max /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h input pos x (pos1 `U32.add` len) | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_bounded_vlgen_intro
(min: nat)
(max: nat{min <= max /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len)))
)
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len) /\
(let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s)
h
input
pos
x
(pos1 `U32.add` len))))) | [] | LowParse.Low.VLGen.valid_bounded_vlgen_intro | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max < 4294967296} ->
pk: LowParse.Spec.Base.parser sk (LowParse.Spec.BoundedInt.bounded_int32 min max) ->
s: LowParse.Spec.Base.serializer p ->
h: FStar.Monotonic.HyperStack.mem ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid pk h input pos /\
(let pos1 = LowParse.Low.Base.Spec.get_valid_pos pk h input pos in
let len = LowParse.Low.Base.Spec.contents pk h input pos in
FStar.UInt32.v pos1 + FStar.UInt32.v len < 4294967296 /\
LowParse.Low.Base.Spec.valid_exact p h input pos1 (FStar.UInt32.add pos1 len)))
(ensures
LowParse.Low.Base.Spec.valid pk h input pos /\
(let pos1 = LowParse.Low.Base.Spec.get_valid_pos pk h input pos in
let len = LowParse.Low.Base.Spec.contents pk h input pos in
FStar.UInt32.v pos1 + FStar.UInt32.v len < 4294967296 /\
LowParse.Low.Base.Spec.valid_exact p h input pos1 (FStar.UInt32.add pos1 len) /\
(let x =
LowParse.Low.Base.Spec.contents_exact p h input pos1 (FStar.UInt32.add pos1 len)
in
LowParse.Spec.VLData.parse_bounded_vldata_strong_pred min max s x /\
LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.VLGen.parse_bounded_vlgen min
max
pk
s)
h
input
pos
x
(FStar.UInt32.add pos1 len)))) | {
"end_col": 60,
"end_line": 880,
"start_col": 2,
"start_line": 874
} |
FStar.Pervasives.Lemma | val valid_vlgen_intro
(min: nat)
(max: nat{min <= max /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len) /\
parse_vlgen_precond min max k)))
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len) /\
(let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
valid_content_pos (parse_vlgen min max pk s) h input pos x (pos1 `U32.add` len))))) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_vlgen_intro
(min: nat)
(max: nat { min <= max /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\
parse_vlgen_precond min max k
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
valid_content_pos (parse_vlgen min max pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_exact_equiv p h input pos1 (pos1 `U32.add` len);
contents_exact_eq p h input pos1 (pos1 `U32.add` len);
parse_vlgen_unfold min max pk s (bytes_of_slice_from h input pos);
valid_facts (parse_vlgen min max pk s) h input pos | val valid_vlgen_intro
(min: nat)
(max: nat{min <= max /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len) /\
parse_vlgen_precond min max k)))
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len) /\
(let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
valid_content_pos (parse_vlgen min max pk s) h input pos x (pos1 `U32.add` len)))))
let valid_vlgen_intro
(min: nat)
(max: nat{min <= max /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len) /\
parse_vlgen_precond min max k)))
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len) /\
(let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
valid_content_pos (parse_vlgen min max pk s) h input pos x (pos1 `U32.add` len))))) = | false | null | true | valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_exact_equiv p h input pos1 (pos1 `U32.add` len);
contents_exact_eq p h input pos1 (pos1 `U32.add` len);
parse_vlgen_unfold min max pk s (bytes_of_slice_from h input pos);
valid_facts (parse_vlgen min max pk s) h input pos | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"lemma"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Spec.Base.serializer",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLGen.parse_vlgen",
"Prims.unit",
"LowParse.Spec.VLGen.parse_vlgen_unfold",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Low.Base.Spec.contents_exact_eq",
"FStar.UInt32.add",
"LowParse.Low.Base.Spec.valid_exact_equiv",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Base.Spec.get_valid_pos",
"LowParse.Low.Base.Spec.valid",
"Prims.op_Addition",
"FStar.UInt32.v",
"LowParse.Low.Base.Spec.valid_exact",
"LowParse.Spec.VLGen.parse_vlgen_precond",
"Prims.squash",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Low.Base.Spec.contents_exact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))
= valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth
h
(parse_bounded_vlgen vmin vmax pk s)
(synth_vlgen (vmin) (vmax) s)
input
pos
inline_for_extraction
let finalize_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_vlgen min max pk s input pos h
inline_for_extraction
let finalize_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (U32.v min) (U32.v max) k })
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s))
= validate_synth
(validate_bounded_vlgen vmin min vmax max vk rk s v)
(synth_vlgen (U32.v min) (U32.v max) s)
()
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (jumper (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
let n = vk input pos in
let len = rk input pos in
[@inline_let]
let _ = valid_facts (parse_fldata_strong s (U32.v len)) h input n in
jump_fldata_strong s (U32.v len) len input n
#pop-options
inline_for_extraction
let jump_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
: Tot (jumper (parse_vlgen (vmin) (vmax) pk s))
= jump_synth
(jump_bounded_vlgen vmin vmax vk rk s)
(synth_vlgen (vmin) (vmax) s)
()
let gaccessor_bounded_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor' (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= fun input ->
parse_bounded_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_bounded_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_injective (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_no_lookahead_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_no_lookahead_2 min max pk s);
Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_injective_2 min max pk s);
gaccessor_prop_equiv (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) (gaccessor_bounded_vlgen_payload' min max pk s);
gaccessor_bounded_vlgen_payload' min max pk s
module B = LowStar.Buffer
inline_for_extraction
let accessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 ( min) ( max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (accessor (gaccessor_bounded_vlgen_payload min max pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
slice_access_eq h (gaccessor_bounded_vlgen_payload min max pk s) input pos;
valid_facts (parse_bounded_vlgen min max pk s) h input pos;
parse_bounded_vlgen_unfold_aux min max pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
jk input pos
let gaccessor_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong } )
: Tot (gaccessor' (parse_vlgen min max pk s) p (clens_id _))
= fun input ->
parse_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
))
= parse_vlgen_unfold min max pk s sl;
parse_vlgen_unfold min max pk s sl' ;
parse_injective (parse_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
))
= parse_vlgen_unfold min max pk s sl;
parse_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_vlgen_payload_no_lookahead_1 min max pk s sl) sl'
let gaccessor_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor (parse_vlgen min max pk s) p (clens_id _))
= Classical.forall_intro_2 (gaccessor_vlgen_payload_no_lookahead_2 min max pk s);
Classical.forall_intro_2 (gaccessor_vlgen_payload_injective_2 min max pk s);
gaccessor_prop_equiv (parse_vlgen min max pk s) p (clens_id _) (gaccessor_vlgen_payload' min max pk s);
gaccessor_vlgen_payload' min max pk s
inline_for_extraction
let accessor_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 ( min) ( max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong } )
: Tot (accessor (gaccessor_vlgen_payload min max pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
slice_access_eq h (gaccessor_vlgen_payload min max pk s) input pos;
valid_facts (parse_vlgen min max pk s) h input pos;
parse_vlgen_unfold min max pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
jk input pos
module HS = FStar.HyperStack
#push-options "--z3rlimit 16"
let valid_bounded_vlgen_intro
(min: nat)
(max: nat { min <= max /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_exact_equiv p h input pos1 (pos1 `U32.add` len);
contents_exact_eq p h input pos1 (pos1 `U32.add` len);
parse_bounded_vlgen_unfold min max pk s (bytes_of_slice_from h input pos);
valid_facts (parse_bounded_vlgen min max pk s) h input pos
#pop-options
let valid_bounded_vlgen_intro_strong_prefix
(min: nat)
(max: nat { min <= max /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents p h input pos1 in
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h input pos x (pos1 `U32.add` len)
))))
= let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_pos_valid_exact p h input pos1 (pos1 `U32.add` len);
valid_bounded_vlgen_intro min max pk s h input pos
let valid_vlgen_intro
(min: nat)
(max: nat { min <= max /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\
parse_vlgen_precond min max k
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
valid_content_pos (parse_vlgen min max pk s) h input pos x (pos1 `U32.add` len) | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_vlgen_intro
(min: nat)
(max: nat{min <= max /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len) /\
parse_vlgen_precond min max k)))
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len) /\
(let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
valid_content_pos (parse_vlgen min max pk s) h input pos x (pos1 `U32.add` len))))) | [] | LowParse.Low.VLGen.valid_vlgen_intro | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max < 4294967296} ->
pk: LowParse.Spec.Base.parser sk (LowParse.Spec.BoundedInt.bounded_int32 min max) ->
s: LowParse.Spec.Base.serializer p ->
h: FStar.Monotonic.HyperStack.mem ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid pk h input pos /\
(let pos1 = LowParse.Low.Base.Spec.get_valid_pos pk h input pos in
let len = LowParse.Low.Base.Spec.contents pk h input pos in
FStar.UInt32.v pos1 + FStar.UInt32.v len < 4294967296 /\
LowParse.Low.Base.Spec.valid_exact p h input pos1 (FStar.UInt32.add pos1 len) /\
LowParse.Spec.VLGen.parse_vlgen_precond min max k))
(ensures
LowParse.Low.Base.Spec.valid pk h input pos /\
(let pos1 = LowParse.Low.Base.Spec.get_valid_pos pk h input pos in
let len = LowParse.Low.Base.Spec.contents pk h input pos in
FStar.UInt32.v pos1 + FStar.UInt32.v len < 4294967296 /\
LowParse.Low.Base.Spec.valid_exact p h input pos1 (FStar.UInt32.add pos1 len) /\
(let x =
LowParse.Low.Base.Spec.contents_exact p h input pos1 (FStar.UInt32.add pos1 len)
in
LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.VLGen.parse_vlgen min max pk s)
h
input
pos
x
(FStar.UInt32.add pos1 len)))) | {
"end_col": 52,
"end_line": 959,
"start_col": 2,
"start_line": 953
} |
FStar.Pervasives.Lemma | val gaccessor_bounded_vlgen_payload_injective_1
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl': bytes)
: Lemma
(requires
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl' /\ injective_precond (parse_bounded_vlgen min max pk s) sl sl'))
(ensures
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl' /\ injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl ==
gaccessor_bounded_vlgen_payload' min max pk s sl')) | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_bounded_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_injective (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl' | val gaccessor_bounded_vlgen_payload_injective_1
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl': bytes)
: Lemma
(requires
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl' /\ injective_precond (parse_bounded_vlgen min max pk s) sl sl'))
(ensures
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl' /\ injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl ==
gaccessor_bounded_vlgen_payload' min max pk s sl'))
let gaccessor_bounded_vlgen_payload_injective_1
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl': bytes)
: Lemma
(requires
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl' /\ injective_precond (parse_bounded_vlgen min max pk s) sl sl'))
(ensures
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl' /\ injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl ==
gaccessor_bounded_vlgen_payload' min max pk s sl')) = | false | null | true | parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl';
parse_injective (parse_bounded_vlgen min max pk s) sl sl';
parse_injective pk sl sl' | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"lemma"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Spec.Base.serializer",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.parse_injective",
"Prims.unit",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Spec.VLGen.parse_bounded_vlgen",
"LowParse.Spec.VLGen.parse_bounded_vlgen_unfold",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Low.Base.Spec.gaccessor_pre",
"LowParse.Low.VLData.clens_bounded_vldata_strong_payload",
"LowParse.Spec.Base.injective_precond",
"Prims.squash",
"LowParse.Low.VLGen.gaccessor_bounded_vlgen_payload'",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))
= valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth
h
(parse_bounded_vlgen vmin vmax pk s)
(synth_vlgen (vmin) (vmax) s)
input
pos
inline_for_extraction
let finalize_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_vlgen min max pk s input pos h
inline_for_extraction
let finalize_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (U32.v min) (U32.v max) k })
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s))
= validate_synth
(validate_bounded_vlgen vmin min vmax max vk rk s v)
(synth_vlgen (U32.v min) (U32.v max) s)
()
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (jumper (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
let n = vk input pos in
let len = rk input pos in
[@inline_let]
let _ = valid_facts (parse_fldata_strong s (U32.v len)) h input n in
jump_fldata_strong s (U32.v len) len input n
#pop-options
inline_for_extraction
let jump_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
: Tot (jumper (parse_vlgen (vmin) (vmax) pk s))
= jump_synth
(jump_bounded_vlgen vmin vmax vk rk s)
(synth_vlgen (vmin) (vmax) s)
()
let gaccessor_bounded_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor' (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= fun input ->
parse_bounded_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_bounded_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl' | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_bounded_vlgen_payload_injective_1
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl': bytes)
: Lemma
(requires
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl' /\ injective_precond (parse_bounded_vlgen min max pk s) sl sl'))
(ensures
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl' /\ injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl ==
gaccessor_bounded_vlgen_payload' min max pk s sl')) | [] | LowParse.Low.VLGen.gaccessor_bounded_vlgen_payload_injective_1 | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
pk: LowParse.Spec.Base.parser sk (LowParse.Spec.BoundedInt.bounded_int32 min max) ->
s: LowParse.Spec.Base.serializer p ->
sl: LowParse.Bytes.bytes ->
sl': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.VLGen.parse_bounded_vlgen min max pk s)
p
(LowParse.Low.VLData.clens_bounded_vldata_strong_payload min max s)
sl /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.VLGen.parse_bounded_vlgen min max pk s)
p
(LowParse.Low.VLData.clens_bounded_vldata_strong_payload min max s)
sl' /\
LowParse.Spec.Base.injective_precond (LowParse.Spec.VLGen.parse_bounded_vlgen min max pk s)
sl
sl')
(ensures
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.VLGen.parse_bounded_vlgen min max pk s)
p
(LowParse.Low.VLData.clens_bounded_vldata_strong_payload min max s)
sl /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.VLGen.parse_bounded_vlgen min max pk s)
p
(LowParse.Low.VLData.clens_bounded_vldata_strong_payload min max s)
sl' /\
LowParse.Spec.Base.injective_precond (LowParse.Spec.VLGen.parse_bounded_vlgen min max pk s)
sl
sl' /\
LowParse.Low.VLGen.gaccessor_bounded_vlgen_payload' min max pk s sl ==
LowParse.Low.VLGen.gaccessor_bounded_vlgen_payload' min max pk s sl') | {
"end_col": 27,
"end_line": 551,
"start_col": 2,
"start_line": 548
} |
FStar.HyperStack.ST.Stack | val finalize_bounded_vlgen_exact
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos pos': U32.t)
: HST.Stack unit
(requires
(fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\ sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\
(let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\
(let len_payload = pos' `U32.sub` pos_payload in
let len_ser =
Seq.length (serialize s (contents_exact p h input pos_payload pos'))
in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/
(min <= len_ser /\ len_ser <= max))))))
(ensures
(fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos')) | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h | val finalize_bounded_vlgen_exact
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos pos': U32.t)
: HST.Stack unit
(requires
(fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\ sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\
(let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\
(let len_payload = pos' `U32.sub` pos_payload in
let len_ser =
Seq.length (serialize s (contents_exact p h input pos_payload pos'))
in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/
(min <= len_ser /\ len_ser <= max))))))
(ensures
(fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'))
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos pos': U32.t)
: HST.Stack unit
(requires
(fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\ sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\
(let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\
(let len_payload = pos' `U32.sub` pos_payload in
let len_ser =
Seq.length (serialize s (contents_exact p h input pos_payload pos'))
in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/
(min <= len_ser /\ len_ser <= max))))))
(ensures
(fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos')) = | true | null | false | [@@ inline_let ]let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@@ inline_let ]let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"FStar.UInt32.t",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Spec.Base.serializer",
"LowParse.Low.Base.leaf_writer_strong",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"LowParse.Low.VLGen.valid_bounded_vlgen",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Low.Base.Spec.valid_exact_serialize",
"FStar.UInt32.add",
"LowParse.Low.Base.Spec.serialized_length_eq",
"LowParse.Low.Base.Spec.contents_exact",
"FStar.UInt32.sub",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt.size",
"FStar.UInt32.n",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_high",
"FStar.Pervasives.Native.Some",
"Prims.op_Addition",
"FStar.UInt32.v",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Low.Base.Spec.valid_exact",
"LowParse.Low.Base.writable",
"LowParse.Slice.buffer_srel_of_srel",
"LowParse.Slice.__proj__Mkslice__item__base",
"FStar.Seq.Base.length",
"LowParse.Spec.Base.serialize",
"FStar.UInt.uint_t",
"LowStar.Monotonic.Buffer.modifies",
"LowParse.Slice.loc_slice_from_to",
"Prims.op_Subtraction",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_pred",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Spec.VLGen.parse_bounded_vlgen"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos' | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val finalize_bounded_vlgen_exact
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos pos': U32.t)
: HST.Stack unit
(requires
(fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\ sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\
(let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\
(let len_payload = pos' `U32.sub` pos_payload in
let len_ser =
Seq.length (serialize s (contents_exact p h input pos_payload pos'))
in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/
(min <= len_ser /\ len_ser <= max))))))
(ensures
(fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos')) | [] | LowParse.Low.VLGen.finalize_bounded_vlgen_exact | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
sz32: FStar.UInt32.t ->
wk: LowParse.Low.Base.leaf_writer_strong ssk ->
s: LowParse.Spec.Base.serializer p ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 46,
"end_line": 218,
"start_col": 2,
"start_line": 208
} |
FStar.Pervasives.Lemma | val gaccessor_vlgen_payload_injective_1
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond min max k})
(sl sl': bytes)
: Lemma
(requires
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'))
(ensures
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl')) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
))
= parse_vlgen_unfold min max pk s sl;
parse_vlgen_unfold min max pk s sl' ;
parse_injective (parse_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl' | val gaccessor_vlgen_payload_injective_1
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond min max k})
(sl sl': bytes)
: Lemma
(requires
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'))
(ensures
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'))
let gaccessor_vlgen_payload_injective_1
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond min max k})
(sl sl': bytes)
: Lemma
(requires
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'))
(ensures
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl')) = | false | null | true | parse_vlgen_unfold min max pk s sl;
parse_vlgen_unfold min max pk s sl';
parse_injective (parse_vlgen min max pk s) sl sl';
parse_injective pk sl sl' | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"lemma"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.VLGen.parse_vlgen_precond",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.parse_injective",
"Prims.unit",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLGen.parse_vlgen",
"LowParse.Spec.VLGen.parse_vlgen_unfold",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Low.Base.Spec.gaccessor_pre",
"LowParse.Low.Base.Spec.clens_id",
"LowParse.Spec.Base.injective_precond",
"Prims.squash",
"LowParse.Low.VLGen.gaccessor_vlgen_payload'",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))
= valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth
h
(parse_bounded_vlgen vmin vmax pk s)
(synth_vlgen (vmin) (vmax) s)
input
pos
inline_for_extraction
let finalize_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_vlgen min max pk s input pos h
inline_for_extraction
let finalize_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (U32.v min) (U32.v max) k })
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s))
= validate_synth
(validate_bounded_vlgen vmin min vmax max vk rk s v)
(synth_vlgen (U32.v min) (U32.v max) s)
()
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (jumper (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
let n = vk input pos in
let len = rk input pos in
[@inline_let]
let _ = valid_facts (parse_fldata_strong s (U32.v len)) h input n in
jump_fldata_strong s (U32.v len) len input n
#pop-options
inline_for_extraction
let jump_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
: Tot (jumper (parse_vlgen (vmin) (vmax) pk s))
= jump_synth
(jump_bounded_vlgen vmin vmax vk rk s)
(synth_vlgen (vmin) (vmax) s)
()
let gaccessor_bounded_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor' (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= fun input ->
parse_bounded_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_bounded_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_injective (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_no_lookahead_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_no_lookahead_2 min max pk s);
Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_injective_2 min max pk s);
gaccessor_prop_equiv (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) (gaccessor_bounded_vlgen_payload' min max pk s);
gaccessor_bounded_vlgen_payload' min max pk s
module B = LowStar.Buffer
inline_for_extraction
let accessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 ( min) ( max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (accessor (gaccessor_bounded_vlgen_payload min max pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
slice_access_eq h (gaccessor_bounded_vlgen_payload min max pk s) input pos;
valid_facts (parse_bounded_vlgen min max pk s) h input pos;
parse_bounded_vlgen_unfold_aux min max pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
jk input pos
let gaccessor_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong } )
: Tot (gaccessor' (parse_vlgen min max pk s) p (clens_id _))
= fun input ->
parse_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl' | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_vlgen_payload_injective_1
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond min max k})
(sl sl': bytes)
: Lemma
(requires
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'))
(ensures
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl')) | [] | LowParse.Low.VLGen.gaccessor_vlgen_payload_injective_1 | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
pk: LowParse.Spec.Base.parser sk (LowParse.Spec.BoundedInt.bounded_int32 min max) ->
s: LowParse.Spec.Base.serializer p {LowParse.Spec.VLGen.parse_vlgen_precond min max k} ->
sl: LowParse.Bytes.bytes ->
sl': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.VLGen.parse_vlgen min max pk s)
p
(LowParse.Low.Base.Spec.clens_id t)
sl /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.VLGen.parse_vlgen min max pk s)
p
(LowParse.Low.Base.Spec.clens_id t)
sl' /\
LowParse.Spec.Base.injective_precond (LowParse.Spec.VLGen.parse_vlgen min max pk s) sl sl')
(ensures
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.VLGen.parse_vlgen min max pk s)
p
(LowParse.Low.Base.Spec.clens_id t)
sl /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.VLGen.parse_vlgen min max pk s)
p
(LowParse.Low.Base.Spec.clens_id t)
sl' /\
LowParse.Spec.Base.injective_precond (LowParse.Spec.VLGen.parse_vlgen min max pk s) sl sl' /\
LowParse.Low.VLGen.gaccessor_vlgen_payload' min max pk s sl ==
LowParse.Low.VLGen.gaccessor_vlgen_payload' min max pk s sl') | {
"end_col": 27,
"end_line": 724,
"start_col": 2,
"start_line": 721
} |
FStar.Pervasives.Lemma | val valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma (requires (valid (parse_bounded_vlgen vmin vmax pk s) h input pos))
(ensures
(valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\ valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s)
h
input
pos
x
(pos1 `U32.add` len))))) | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1 | val valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma (requires (valid (parse_bounded_vlgen vmin vmax pk s) h input pos))
(ensures
(valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\ valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s)
h
input
pos
x
(pos1 `U32.add` len)))))
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel
#rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma (requires (valid (parse_bounded_vlgen vmin vmax pk s) h input pos))
(ensures
(valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\ valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s)
h
input
pos
x
(pos1 `U32.add` len))))) = | false | null | true | valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1 | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"lemma"
] | [
"LowParse.Spec.DER.der_length_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Spec.Base.serializer",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.FLData.parse_fldata_kind",
"FStar.UInt32.v",
"LowParse.Spec.FLData.parse_fldata_strong_t",
"LowParse.Spec.FLData.parse_fldata_strong",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Base.Spec.get_valid_pos",
"Prims.unit",
"LowParse.Spec.VLGen.parse_bounded_vlgen_unfold_aux",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Spec.VLGen.parse_bounded_vlgen",
"LowParse.Low.Base.Spec.valid",
"Prims.squash",
"Prims.op_Addition",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt.size",
"FStar.UInt32.n",
"FStar.Seq.Base.length",
"LowParse.Spec.Base.serialize",
"LowParse.Low.Base.Spec.valid_content_pos",
"FStar.UInt32.add",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len) | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma (requires (valid (parse_bounded_vlgen vmin vmax pk s) h input pos))
(ensures
(valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\ valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s)
h
input
pos
x
(pos1 `U32.add` len))))) | [] | LowParse.Low.VLGen.valid_bounded_vlgen_elim' | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
vmin: LowParse.Spec.DER.der_length_t ->
vmax: LowParse.Spec.DER.der_length_t{vmin <= vmax /\ vmax < 4294967296} ->
pk: LowParse.Spec.Base.parser sk (LowParse.Spec.BoundedInt.bounded_int32 vmin vmax) ->
s: LowParse.Spec.Base.serializer p ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
h: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid (LowParse.Spec.VLGen.parse_bounded_vlgen vmin vmax pk s)
h
input
pos)
(ensures
LowParse.Low.Base.Spec.valid (LowParse.Spec.VLGen.parse_bounded_vlgen vmin vmax pk s)
h
input
pos /\ LowParse.Low.Base.Spec.valid pk h input pos /\
(let pos1 = LowParse.Low.Base.Spec.get_valid_pos pk h input pos in
let len = LowParse.Low.Base.Spec.contents pk h input pos in
FStar.UInt32.v pos1 + FStar.UInt32.v len < 4294967296 /\
LowParse.Low.Base.Spec.valid (LowParse.Spec.FLData.parse_fldata_strong s
(FStar.UInt32.v len))
h
input
pos1 /\
(let pos1 = LowParse.Low.Base.Spec.get_valid_pos pk h input pos in
let len = LowParse.Low.Base.Spec.contents pk h input pos in
let x =
LowParse.Low.Base.Spec.contents (LowParse.Spec.FLData.parse_fldata_strong s
(FStar.UInt32.v len))
h
input
pos1
in
FStar.Seq.Base.length (LowParse.Spec.Base.serialize s x) == FStar.UInt32.v len /\
LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.VLGen.parse_bounded_vlgen vmin
vmax
pk
s)
h
input
pos
x
(FStar.UInt32.add pos1 len)))) | {
"end_col": 62,
"end_line": 128,
"start_col": 2,
"start_line": 123
} |
FStar.Pervasives.Lemma | val gaccessor_bounded_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl': bytes)
: Lemma
(requires
(k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl' /\ no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'))
(ensures
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl ==
gaccessor_bounded_vlgen_payload' min max pk s sl')) | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_bounded_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl' | val gaccessor_bounded_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl': bytes)
: Lemma
(requires
(k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl' /\ no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'))
(ensures
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl ==
gaccessor_bounded_vlgen_payload' min max pk s sl'))
let gaccessor_bounded_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl': bytes)
: Lemma
(requires
(k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl' /\ no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'))
(ensures
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl ==
gaccessor_bounded_vlgen_payload' min max pk s sl')) = | false | null | true | parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl';
parse_strong_prefix (parse_bounded_vlgen min max pk s) sl sl';
parse_injective pk sl sl' | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"lemma"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Spec.Base.serializer",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.parse_injective",
"Prims.unit",
"LowParse.Spec.Base.parse_strong_prefix",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Spec.VLGen.parse_bounded_vlgen",
"LowParse.Spec.VLGen.parse_bounded_vlgen_unfold",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Low.Base.Spec.gaccessor_pre",
"LowParse.Low.VLData.clens_bounded_vldata_strong_payload",
"LowParse.Spec.Base.no_lookahead_on_precond",
"Prims.squash",
"LowParse.Low.VLGen.gaccessor_bounded_vlgen_payload'",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))
= valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth
h
(parse_bounded_vlgen vmin vmax pk s)
(synth_vlgen (vmin) (vmax) s)
input
pos
inline_for_extraction
let finalize_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_vlgen min max pk s input pos h
inline_for_extraction
let finalize_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (U32.v min) (U32.v max) k })
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s))
= validate_synth
(validate_bounded_vlgen vmin min vmax max vk rk s v)
(synth_vlgen (U32.v min) (U32.v max) s)
()
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (jumper (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
let n = vk input pos in
let len = rk input pos in
[@inline_let]
let _ = valid_facts (parse_fldata_strong s (U32.v len)) h input n in
jump_fldata_strong s (U32.v len) len input n
#pop-options
inline_for_extraction
let jump_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
: Tot (jumper (parse_vlgen (vmin) (vmax) pk s))
= jump_synth
(jump_bounded_vlgen vmin vmax vk rk s)
(synth_vlgen (vmin) (vmax) s)
()
let gaccessor_bounded_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor' (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= fun input ->
parse_bounded_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_bounded_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_injective (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl' | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_bounded_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl': bytes)
: Lemma
(requires
(k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s)
p
(clens_bounded_vldata_strong_payload min max s)
sl' /\ no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'))
(ensures
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl ==
gaccessor_bounded_vlgen_payload' min max pk s sl')) | [] | LowParse.Low.VLGen.gaccessor_bounded_vlgen_payload_no_lookahead_1 | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
pk: LowParse.Spec.Base.parser sk (LowParse.Spec.BoundedInt.bounded_int32 min max) ->
s: LowParse.Spec.Base.serializer p ->
sl: LowParse.Bytes.bytes ->
sl': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
Mkparser_kind'?.parser_kind_subkind (LowParse.Spec.Combinators.and_then_kind sk k) ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.VLGen.parse_bounded_vlgen min max pk s)
p
(LowParse.Low.VLData.clens_bounded_vldata_strong_payload min max s)
sl /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.VLGen.parse_bounded_vlgen min max pk s)
p
(LowParse.Low.VLData.clens_bounded_vldata_strong_payload min max s)
sl' /\
LowParse.Spec.Base.no_lookahead_on_precond (LowParse.Spec.VLGen.parse_bounded_vlgen min
max
pk
s)
sl
sl')
(ensures
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.VLGen.gaccessor_bounded_vlgen_payload' min max pk s sl ==
LowParse.Low.VLGen.gaccessor_bounded_vlgen_payload' min max pk s sl') | {
"end_col": 27,
"end_line": 603,
"start_col": 2,
"start_line": 600
} |
FStar.Pervasives.Lemma | val gaccessor_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond min max k})
(sl sl': bytes)
: Lemma
(requires
(k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl'))
(ensures
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl')) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
))
= parse_vlgen_unfold min max pk s sl;
parse_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl' | val gaccessor_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond min max k})
(sl sl': bytes)
: Lemma
(requires
(k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl'))
(ensures
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'))
let gaccessor_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond min max k})
(sl sl': bytes)
: Lemma
(requires
(k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl'))
(ensures
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl')) = | false | null | true | parse_vlgen_unfold min max pk s sl;
parse_vlgen_unfold min max pk s sl';
parse_strong_prefix (parse_vlgen min max pk s) sl sl';
parse_injective pk sl sl' | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"lemma"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.VLGen.parse_vlgen_precond",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.parse_injective",
"Prims.unit",
"LowParse.Spec.Base.parse_strong_prefix",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLGen.parse_vlgen",
"LowParse.Spec.VLGen.parse_vlgen_unfold",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Low.Base.Spec.gaccessor_pre",
"LowParse.Low.Base.Spec.clens_id",
"LowParse.Spec.Base.no_lookahead_on_precond",
"Prims.squash",
"LowParse.Low.VLGen.gaccessor_vlgen_payload'",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))
= valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth
h
(parse_bounded_vlgen vmin vmax pk s)
(synth_vlgen (vmin) (vmax) s)
input
pos
inline_for_extraction
let finalize_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_vlgen min max pk s input pos h
inline_for_extraction
let finalize_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (U32.v min) (U32.v max) k })
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s))
= validate_synth
(validate_bounded_vlgen vmin min vmax max vk rk s v)
(synth_vlgen (U32.v min) (U32.v max) s)
()
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (jumper (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
let n = vk input pos in
let len = rk input pos in
[@inline_let]
let _ = valid_facts (parse_fldata_strong s (U32.v len)) h input n in
jump_fldata_strong s (U32.v len) len input n
#pop-options
inline_for_extraction
let jump_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
: Tot (jumper (parse_vlgen (vmin) (vmax) pk s))
= jump_synth
(jump_bounded_vlgen vmin vmax vk rk s)
(synth_vlgen (vmin) (vmax) s)
()
let gaccessor_bounded_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor' (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= fun input ->
parse_bounded_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_bounded_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_injective (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_no_lookahead_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_no_lookahead_2 min max pk s);
Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_injective_2 min max pk s);
gaccessor_prop_equiv (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) (gaccessor_bounded_vlgen_payload' min max pk s);
gaccessor_bounded_vlgen_payload' min max pk s
module B = LowStar.Buffer
inline_for_extraction
let accessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 ( min) ( max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (accessor (gaccessor_bounded_vlgen_payload min max pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
slice_access_eq h (gaccessor_bounded_vlgen_payload min max pk s) input pos;
valid_facts (parse_bounded_vlgen min max pk s) h input pos;
parse_bounded_vlgen_unfold_aux min max pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
jk input pos
let gaccessor_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong } )
: Tot (gaccessor' (parse_vlgen min max pk s) p (clens_id _))
= fun input ->
parse_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
))
= parse_vlgen_unfold min max pk s sl;
parse_vlgen_unfold min max pk s sl' ;
parse_injective (parse_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl' | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond min max k})
(sl sl': bytes)
: Lemma
(requires
(k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl'))
(ensures
(k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl')) | [] | LowParse.Low.VLGen.gaccessor_vlgen_payload_no_lookahead_1 | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
pk: LowParse.Spec.Base.parser sk (LowParse.Spec.BoundedInt.bounded_int32 min max) ->
s: LowParse.Spec.Base.serializer p {LowParse.Spec.VLGen.parse_vlgen_precond min max k} ->
sl: LowParse.Bytes.bytes ->
sl': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
Mkparser_kind'?.parser_kind_subkind (LowParse.Spec.Combinators.and_then_kind sk k) ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.VLGen.parse_vlgen min max pk s)
p
(LowParse.Low.Base.Spec.clens_id t)
sl /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.VLGen.parse_vlgen min max pk s)
p
(LowParse.Low.Base.Spec.clens_id t)
sl' /\
LowParse.Spec.Base.no_lookahead_on_precond (LowParse.Spec.VLGen.parse_vlgen min max pk s)
sl
sl')
(ensures
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.VLGen.gaccessor_vlgen_payload' min max pk s sl ==
LowParse.Low.VLGen.gaccessor_vlgen_payload' min max pk s sl') | {
"end_col": 27,
"end_line": 776,
"start_col": 2,
"start_line": 773
} |
FStar.Pervasives.Lemma | val valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma (requires (valid (parse_bounded_vlgen vmin vmax pk s) h input pos))
(ensures
(valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\ valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len) /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s)
h
input
pos
x
(pos1 `U32.add` len))))) | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2 | val valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma (requires (valid (parse_bounded_vlgen vmin vmax pk s) h input pos))
(ensures
(valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\ valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len) /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s)
h
input
pos
x
(pos1 `U32.add` len)))))
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel
#rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma (requires (valid (parse_bounded_vlgen vmin vmax pk s) h input pos))
(ensures
(valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\ valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len) /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s)
h
input
pos
x
(pos1 `U32.add` len))))) = | false | null | true | valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2 | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"lemma"
] | [
"LowParse.Spec.DER.der_length_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Spec.Base.serializer",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Low.Base.Spec.valid_exact_serialize",
"Prims.unit",
"LowParse.Low.FLData.valid_fldata_gen_elim",
"FStar.UInt32.v",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.FLData.parse_fldata_kind",
"LowParse.Spec.FLData.parse_fldata",
"FStar.UInt32.add",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Base.Spec.get_valid_pos",
"LowParse.Spec.VLGen.parse_bounded_vlgen_unfold",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Spec.VLGen.parse_bounded_vlgen",
"LowParse.Low.Base.Spec.valid",
"Prims.squash",
"Prims.op_Addition",
"LowParse.Low.Base.Spec.valid_exact",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt.size",
"FStar.UInt32.n",
"FStar.Seq.Base.length",
"LowParse.Spec.Base.serialize",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Low.Base.Spec.contents_exact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len) | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma (requires (valid (parse_bounded_vlgen vmin vmax pk s) h input pos))
(ensures
(valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\ valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid_exact p h input pos1 (pos1 `U32.add` len) /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s)
h
input
pos
x
(pos1 `U32.add` len))))) | [] | LowParse.Low.VLGen.valid_bounded_vlgen_elim | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
vmin: LowParse.Spec.DER.der_length_t ->
vmax: LowParse.Spec.DER.der_length_t{vmin <= vmax /\ vmax < 4294967296} ->
pk: LowParse.Spec.Base.parser sk (LowParse.Spec.BoundedInt.bounded_int32 vmin vmax) ->
s: LowParse.Spec.Base.serializer p ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
h: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid (LowParse.Spec.VLGen.parse_bounded_vlgen vmin vmax pk s)
h
input
pos)
(ensures
LowParse.Low.Base.Spec.valid (LowParse.Spec.VLGen.parse_bounded_vlgen vmin vmax pk s)
h
input
pos /\ LowParse.Low.Base.Spec.valid pk h input pos /\
(let pos1 = LowParse.Low.Base.Spec.get_valid_pos pk h input pos in
let len = LowParse.Low.Base.Spec.contents pk h input pos in
FStar.UInt32.v pos1 + FStar.UInt32.v len < 4294967296 /\
LowParse.Low.Base.Spec.valid_exact p h input pos1 (FStar.UInt32.add pos1 len) /\
(let pos1 = LowParse.Low.Base.Spec.get_valid_pos pk h input pos in
let len = LowParse.Low.Base.Spec.contents pk h input pos in
let x =
LowParse.Low.Base.Spec.contents_exact p h input pos1 (FStar.UInt32.add pos1 len)
in
FStar.Seq.Base.length (LowParse.Spec.Base.serialize s x) == FStar.UInt32.v len /\
LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.VLGen.parse_bounded_vlgen vmin
vmax
pk
s)
h
input
pos
x
(FStar.UInt32.add pos1 len)))) | {
"end_col": 43,
"end_line": 168,
"start_col": 2,
"start_line": 160
} |
FStar.HyperStack.ST.Stack | val finalize_vlgen_exact
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond (min) (max) k})
(#rrel #rel: _)
(input: slice rrel rel)
(pos pos': U32.t)
: HST.Stack unit
(requires
(fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\ sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\
(let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\
(let len_payload = pos' `U32.sub` pos_payload in
let len_ser =
Seq.length (serialize s (contents_exact p h input pos_payload pos'))
in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/
(min <= len_ser /\ len_ser <= max))))))
(ensures
(fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos')) | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let finalize_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_vlgen min max pk s input pos h | val finalize_vlgen_exact
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond (min) (max) k})
(#rrel #rel: _)
(input: slice rrel rel)
(pos pos': U32.t)
: HST.Stack unit
(requires
(fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\ sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\
(let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\
(let len_payload = pos' `U32.sub` pos_payload in
let len_ser =
Seq.length (serialize s (contents_exact p h input pos_payload pos'))
in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/
(min <= len_ser /\ len_ser <= max))))))
(ensures
(fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'))
let finalize_vlgen_exact
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond (min) (max) k})
(#rrel #rel: _)
(input: slice rrel rel)
(pos pos': U32.t)
: HST.Stack unit
(requires
(fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\ sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\
(let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\
(let len_payload = pos' `U32.sub` pos_payload in
let len_ser =
Seq.length (serialize s (contents_exact p h input pos_payload pos'))
in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/
(min <= len_ser /\ len_ser <= max))))))
(ensures
(fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos')) = | true | null | false | [@@ inline_let ]let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@@ inline_let ]let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_vlgen min max pk s input pos h | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"FStar.UInt32.t",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Spec.Base.serializer",
"LowParse.Low.Base.leaf_writer_strong",
"LowParse.Spec.VLGen.parse_vlgen_precond",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"LowParse.Low.VLGen.valid_vlgen",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Low.Base.Spec.valid_exact_serialize",
"FStar.UInt32.add",
"LowParse.Low.Base.Spec.serialized_length_eq",
"LowParse.Low.Base.Spec.contents_exact",
"FStar.UInt32.sub",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt.size",
"FStar.UInt32.n",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_high",
"FStar.Pervasives.Native.Some",
"Prims.op_Addition",
"FStar.UInt32.v",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Low.Base.Spec.valid_exact",
"LowParse.Low.Base.writable",
"LowParse.Slice.buffer_srel_of_srel",
"LowParse.Slice.__proj__Mkslice__item__base",
"FStar.Seq.Base.length",
"LowParse.Spec.Base.serialize",
"FStar.UInt.uint_t",
"LowStar.Monotonic.Buffer.modifies",
"LowParse.Slice.loc_slice_from_to",
"Prims.op_Subtraction",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_pred",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLGen.parse_vlgen"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))
= valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth
h
(parse_bounded_vlgen vmin vmax pk s)
(synth_vlgen (vmin) (vmax) s)
input
pos
inline_for_extraction
let finalize_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos' | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val finalize_vlgen_exact
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {parse_vlgen_precond (min) (max) k})
(#rrel #rel: _)
(input: slice rrel rel)
(pos pos': U32.t)
: HST.Stack unit
(requires
(fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\ sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\
(let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\
(let len_payload = pos' `U32.sub` pos_payload in
let len_ser =
Seq.length (serialize s (contents_exact p h input pos_payload pos'))
in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/
(min <= len_ser /\ len_ser <= max))))))
(ensures
(fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos')) | [] | LowParse.Low.VLGen.finalize_vlgen_exact | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
sz32: FStar.UInt32.t ->
wk: LowParse.Low.Base.leaf_writer_strong ssk ->
s: LowParse.Spec.Base.serializer p {LowParse.Spec.VLGen.parse_vlgen_precond min max k} ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 38,
"end_line": 379,
"start_col": 2,
"start_line": 369
} |
FStar.Pervasives.Lemma | val valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1)))
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\
(let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s)
h
input
pos
x
(pos1 `U32.add` len))))) | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1 | val valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1)))
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\
(let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s)
h
input
pos
x
(pos1 `U32.add` len)))))
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel
#rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1)))
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\
(let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s)
h
input
pos
x
(pos1 `U32.add` len))))) = | false | null | true | valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1 | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"lemma"
] | [
"LowParse.Spec.DER.der_length_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Spec.Base.serializer",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.FLData.parse_fldata_kind",
"FStar.UInt32.v",
"LowParse.Spec.FLData.parse_fldata_strong_t",
"LowParse.Spec.FLData.parse_fldata_strong",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Base.Spec.get_valid_pos",
"Prims.unit",
"LowParse.Spec.VLGen.parse_bounded_vlgen_unfold_aux",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Spec.VLGen.parse_bounded_vlgen",
"LowParse.Low.Base.Spec.valid",
"Prims.op_Addition",
"Prims.squash",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt.size",
"FStar.UInt32.n",
"FStar.Seq.Base.length",
"LowParse.Spec.Base.serialize",
"LowParse.Low.Base.Spec.valid_content_pos",
"FStar.UInt32.add",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len) | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1)))
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\
(let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s)
h
input
pos
x
(pos1 `U32.add` len))))) | [] | LowParse.Low.VLGen.valid_bounded_vlgen' | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
vmin: LowParse.Spec.DER.der_length_t ->
vmax: LowParse.Spec.DER.der_length_t{vmin <= vmax /\ vmax < 4294967296} ->
pk: LowParse.Spec.Base.parser sk (LowParse.Spec.BoundedInt.bounded_int32 vmin vmax) ->
s: LowParse.Spec.Base.serializer p ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
h: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid pk h input pos /\
(let pos1 = LowParse.Low.Base.Spec.get_valid_pos pk h input pos in
let len = LowParse.Low.Base.Spec.contents pk h input pos in
FStar.UInt32.v pos1 + FStar.UInt32.v len < 4294967296 /\
LowParse.Low.Base.Spec.valid (LowParse.Spec.FLData.parse_fldata_strong s
(FStar.UInt32.v len))
h
input
pos1))
(ensures
LowParse.Low.Base.Spec.valid pk h input pos /\
(let pos1 = LowParse.Low.Base.Spec.get_valid_pos pk h input pos in
let len = LowParse.Low.Base.Spec.contents pk h input pos in
LowParse.Low.Base.Spec.valid (LowParse.Spec.FLData.parse_fldata_strong s
(FStar.UInt32.v len))
h
input
pos1 /\
(let x =
LowParse.Low.Base.Spec.contents (LowParse.Spec.FLData.parse_fldata_strong s
(FStar.UInt32.v len))
h
input
pos1
in
FStar.Seq.Base.length (LowParse.Spec.Base.serialize s x) == FStar.UInt32.v len /\
LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.VLGen.parse_bounded_vlgen vmin
vmax
pk
s)
h
input
pos
x
(FStar.UInt32.add pos1 len)))) | {
"end_col": 62,
"end_line": 49,
"start_col": 2,
"start_line": 44
} |
FStar.Pervasives.Lemma | val valid_vlgen_weak'
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid (parse_fldata p (U32.v len)) h input pos1))
)
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata p (U32.v len)) h input pos1 /\
(let x = contents (parse_fldata p (U32.v len)) h input pos1 in
valid_content_pos (parse_vlgen_weak vmin vmax pk p) h input pos x (pos1 `U32.add` len)
)))) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_vlgen_weak'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata p (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata p (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata p (U32.v len)) h input pos1 in
valid_content_pos (parse_vlgen_weak vmin vmax pk p) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_vlgen_weak (vmin) (vmax) pk p) h input pos;
parse_vlgen_weak_unfold (vmin) (vmax) pk p (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata p (U32.v len)) h input pos1 | val valid_vlgen_weak'
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid (parse_fldata p (U32.v len)) h input pos1))
)
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata p (U32.v len)) h input pos1 /\
(let x = contents (parse_fldata p (U32.v len)) h input pos1 in
valid_content_pos (parse_vlgen_weak vmin vmax pk p) h input pos x (pos1 `U32.add` len)
))))
let valid_vlgen_weak'
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
#rrel
#rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid (parse_fldata p (U32.v len)) h input pos1))
)
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata p (U32.v len)) h input pos1 /\
(let x = contents (parse_fldata p (U32.v len)) h input pos1 in
valid_content_pos (parse_vlgen_weak vmin vmax pk p) h input pos x (pos1 `U32.add` len)
)))) = | false | null | true | valid_facts (parse_vlgen_weak (vmin) (vmax) pk p) h input pos;
parse_vlgen_weak_unfold (vmin) (vmax) pk p (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata p (U32.v len)) h input pos1 | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"lemma"
] | [
"LowParse.Spec.DER.der_length_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.FLData.parse_fldata_kind",
"FStar.UInt32.v",
"LowParse.Spec.FLData.parse_fldata",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Base.Spec.get_valid_pos",
"Prims.unit",
"LowParse.Spec.VLGen.parse_vlgen_weak_unfold",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Spec.VLGen.parse_vlgen_weak_kind",
"LowParse.Spec.VLGen.parse_vlgen_weak",
"LowParse.Low.Base.Spec.valid",
"Prims.op_Addition",
"Prims.squash",
"LowParse.Low.Base.Spec.valid_content_pos",
"FStar.UInt32.add",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))
= valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth
h
(parse_bounded_vlgen vmin vmax pk s)
(synth_vlgen (vmin) (vmax) s)
input
pos
inline_for_extraction
let finalize_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_vlgen min max pk s input pos h
inline_for_extraction
let finalize_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (U32.v min) (U32.v max) k })
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s))
= validate_synth
(validate_bounded_vlgen vmin min vmax max vk rk s v)
(synth_vlgen (U32.v min) (U32.v max) s)
()
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (jumper (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
let n = vk input pos in
let len = rk input pos in
[@inline_let]
let _ = valid_facts (parse_fldata_strong s (U32.v len)) h input n in
jump_fldata_strong s (U32.v len) len input n
#pop-options
inline_for_extraction
let jump_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
: Tot (jumper (parse_vlgen (vmin) (vmax) pk s))
= jump_synth
(jump_bounded_vlgen vmin vmax vk rk s)
(synth_vlgen (vmin) (vmax) s)
()
let gaccessor_bounded_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor' (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= fun input ->
parse_bounded_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_bounded_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_injective (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_no_lookahead_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_no_lookahead_2 min max pk s);
Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_injective_2 min max pk s);
gaccessor_prop_equiv (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) (gaccessor_bounded_vlgen_payload' min max pk s);
gaccessor_bounded_vlgen_payload' min max pk s
module B = LowStar.Buffer
inline_for_extraction
let accessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 ( min) ( max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (accessor (gaccessor_bounded_vlgen_payload min max pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
slice_access_eq h (gaccessor_bounded_vlgen_payload min max pk s) input pos;
valid_facts (parse_bounded_vlgen min max pk s) h input pos;
parse_bounded_vlgen_unfold_aux min max pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
jk input pos
let gaccessor_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong } )
: Tot (gaccessor' (parse_vlgen min max pk s) p (clens_id _))
= fun input ->
parse_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
))
= parse_vlgen_unfold min max pk s sl;
parse_vlgen_unfold min max pk s sl' ;
parse_injective (parse_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
))
= parse_vlgen_unfold min max pk s sl;
parse_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_vlgen_payload_no_lookahead_1 min max pk s sl) sl'
let gaccessor_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor (parse_vlgen min max pk s) p (clens_id _))
= Classical.forall_intro_2 (gaccessor_vlgen_payload_no_lookahead_2 min max pk s);
Classical.forall_intro_2 (gaccessor_vlgen_payload_injective_2 min max pk s);
gaccessor_prop_equiv (parse_vlgen min max pk s) p (clens_id _) (gaccessor_vlgen_payload' min max pk s);
gaccessor_vlgen_payload' min max pk s
inline_for_extraction
let accessor_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 ( min) ( max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong } )
: Tot (accessor (gaccessor_vlgen_payload min max pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
slice_access_eq h (gaccessor_vlgen_payload min max pk s) input pos;
valid_facts (parse_vlgen min max pk s) h input pos;
parse_vlgen_unfold min max pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
jk input pos
module HS = FStar.HyperStack
#push-options "--z3rlimit 16"
let valid_bounded_vlgen_intro
(min: nat)
(max: nat { min <= max /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_exact_equiv p h input pos1 (pos1 `U32.add` len);
contents_exact_eq p h input pos1 (pos1 `U32.add` len);
parse_bounded_vlgen_unfold min max pk s (bytes_of_slice_from h input pos);
valid_facts (parse_bounded_vlgen min max pk s) h input pos
#pop-options
let valid_bounded_vlgen_intro_strong_prefix
(min: nat)
(max: nat { min <= max /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents p h input pos1 in
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h input pos x (pos1 `U32.add` len)
))))
= let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_pos_valid_exact p h input pos1 (pos1 `U32.add` len);
valid_bounded_vlgen_intro min max pk s h input pos
let valid_vlgen_intro
(min: nat)
(max: nat { min <= max /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\
parse_vlgen_precond min max k
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
valid_content_pos (parse_vlgen min max pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_exact_equiv p h input pos1 (pos1 `U32.add` len);
contents_exact_eq p h input pos1 (pos1 `U32.add` len);
parse_vlgen_unfold min max pk s (bytes_of_slice_from h input pos);
valid_facts (parse_vlgen min max pk s) h input pos
let valid_vlgen_intro_strong_prefix
(min: nat)
(max: nat { min <= max /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\
parse_vlgen_precond min max k
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents p h input pos1 in
valid_content_pos (parse_vlgen min max pk s) h input pos x (pos1 `U32.add` len)
))))
= let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_pos_valid_exact p h input pos1 (pos1 `U32.add` len);
valid_vlgen_intro min max pk s h input pos
let valid_vlgen_weak'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata p (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata p (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata p (U32.v len)) h input pos1 in
valid_content_pos (parse_vlgen_weak vmin vmax pk p) h input pos x (pos1 `U32.add` len) | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_vlgen_weak'
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid (parse_fldata p (U32.v len)) h input pos1))
)
(ensures
(valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata p (U32.v len)) h input pos1 /\
(let x = contents (parse_fldata p (U32.v len)) h input pos1 in
valid_content_pos (parse_vlgen_weak vmin vmax pk p) h input pos x (pos1 `U32.add` len)
)))) | [] | LowParse.Low.VLGen.valid_vlgen_weak' | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
vmin: LowParse.Spec.DER.der_length_t ->
vmax: LowParse.Spec.DER.der_length_t{vmin <= vmax /\ vmax < 4294967296} ->
pk: LowParse.Spec.Base.parser sk (LowParse.Spec.BoundedInt.bounded_int32 vmin vmax) ->
p: LowParse.Spec.Base.parser k t ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
h: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid pk h input pos /\
(let pos1 = LowParse.Low.Base.Spec.get_valid_pos pk h input pos in
let len = LowParse.Low.Base.Spec.contents pk h input pos in
FStar.UInt32.v pos1 + FStar.UInt32.v len < 4294967296 /\
LowParse.Low.Base.Spec.valid (LowParse.Spec.FLData.parse_fldata p (FStar.UInt32.v len))
h
input
pos1))
(ensures
LowParse.Low.Base.Spec.valid pk h input pos /\
(let pos1 = LowParse.Low.Base.Spec.get_valid_pos pk h input pos in
let len = LowParse.Low.Base.Spec.contents pk h input pos in
LowParse.Low.Base.Spec.valid (LowParse.Spec.FLData.parse_fldata p (FStar.UInt32.v len))
h
input
pos1 /\
(let x =
LowParse.Low.Base.Spec.contents (LowParse.Spec.FLData.parse_fldata p
(FStar.UInt32.v len))
h
input
pos1
in
LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.VLGen.parse_vlgen_weak vmin
vmax
pk
p)
h
input
pos
x
(FStar.UInt32.add pos1 len)))) | {
"end_col": 55,
"end_line": 1032,
"start_col": 2,
"start_line": 1027
} |
FStar.Pervasives.Lemma | val valid_vlgen_weak_elim'
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma (requires (valid (parse_vlgen_weak vmin vmax pk p) h input pos))
(ensures
(valid (parse_vlgen_weak vmin vmax pk p) h input pos /\ valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid (parse_fldata p (U32.v len)) h input pos1 /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata p (U32.v len)) h input pos1 in
valid_content_pos (parse_vlgen_weak vmin vmax pk p) h input pos x (pos1 `U32.add` len)
)))) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_vlgen_weak_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_vlgen_weak vmin vmax pk p) h input pos
))
(ensures (
valid (parse_vlgen_weak vmin vmax pk p) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata p (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata p (U32.v len)) h input pos1 in
valid_content_pos (parse_vlgen_weak vmin vmax pk p) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_vlgen_weak (vmin) (vmax) pk p) h input pos;
parse_vlgen_weak_unfold (vmin) (vmax) pk p (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata p (U32.v len)) h input pos1 | val valid_vlgen_weak_elim'
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma (requires (valid (parse_vlgen_weak vmin vmax pk p) h input pos))
(ensures
(valid (parse_vlgen_weak vmin vmax pk p) h input pos /\ valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid (parse_fldata p (U32.v len)) h input pos1 /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata p (U32.v len)) h input pos1 in
valid_content_pos (parse_vlgen_weak vmin vmax pk p) h input pos x (pos1 `U32.add` len)
))))
let valid_vlgen_weak_elim'
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
#rrel
#rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma (requires (valid (parse_vlgen_weak vmin vmax pk p) h input pos))
(ensures
(valid (parse_vlgen_weak vmin vmax pk p) h input pos /\ valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid (parse_fldata p (U32.v len)) h input pos1 /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata p (U32.v len)) h input pos1 in
valid_content_pos (parse_vlgen_weak vmin vmax pk p) h input pos x (pos1 `U32.add` len)
)))) = | false | null | true | valid_facts (parse_vlgen_weak (vmin) (vmax) pk p) h input pos;
parse_vlgen_weak_unfold (vmin) (vmax) pk p (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata p (U32.v len)) h input pos1 | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"lemma"
] | [
"LowParse.Spec.DER.der_length_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.FLData.parse_fldata_kind",
"FStar.UInt32.v",
"LowParse.Spec.FLData.parse_fldata",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Base.Spec.get_valid_pos",
"Prims.unit",
"LowParse.Spec.VLGen.parse_vlgen_weak_unfold",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Spec.VLGen.parse_vlgen_weak_kind",
"LowParse.Spec.VLGen.parse_vlgen_weak",
"LowParse.Low.Base.Spec.valid",
"Prims.squash",
"Prims.op_Addition",
"LowParse.Low.Base.Spec.valid_content_pos",
"FStar.UInt32.add",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))
= valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth
h
(parse_bounded_vlgen vmin vmax pk s)
(synth_vlgen (vmin) (vmax) s)
input
pos
inline_for_extraction
let finalize_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_vlgen min max pk s input pos h
inline_for_extraction
let finalize_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (U32.v min) (U32.v max) k })
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s))
= validate_synth
(validate_bounded_vlgen vmin min vmax max vk rk s v)
(synth_vlgen (U32.v min) (U32.v max) s)
()
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (jumper (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
let n = vk input pos in
let len = rk input pos in
[@inline_let]
let _ = valid_facts (parse_fldata_strong s (U32.v len)) h input n in
jump_fldata_strong s (U32.v len) len input n
#pop-options
inline_for_extraction
let jump_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
: Tot (jumper (parse_vlgen (vmin) (vmax) pk s))
= jump_synth
(jump_bounded_vlgen vmin vmax vk rk s)
(synth_vlgen (vmin) (vmax) s)
()
let gaccessor_bounded_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor' (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= fun input ->
parse_bounded_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_bounded_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_injective (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_no_lookahead_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_no_lookahead_2 min max pk s);
Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_injective_2 min max pk s);
gaccessor_prop_equiv (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) (gaccessor_bounded_vlgen_payload' min max pk s);
gaccessor_bounded_vlgen_payload' min max pk s
module B = LowStar.Buffer
inline_for_extraction
let accessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 ( min) ( max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (accessor (gaccessor_bounded_vlgen_payload min max pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
slice_access_eq h (gaccessor_bounded_vlgen_payload min max pk s) input pos;
valid_facts (parse_bounded_vlgen min max pk s) h input pos;
parse_bounded_vlgen_unfold_aux min max pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
jk input pos
let gaccessor_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong } )
: Tot (gaccessor' (parse_vlgen min max pk s) p (clens_id _))
= fun input ->
parse_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
))
= parse_vlgen_unfold min max pk s sl;
parse_vlgen_unfold min max pk s sl' ;
parse_injective (parse_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
))
= parse_vlgen_unfold min max pk s sl;
parse_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_vlgen_payload_no_lookahead_1 min max pk s sl) sl'
let gaccessor_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor (parse_vlgen min max pk s) p (clens_id _))
= Classical.forall_intro_2 (gaccessor_vlgen_payload_no_lookahead_2 min max pk s);
Classical.forall_intro_2 (gaccessor_vlgen_payload_injective_2 min max pk s);
gaccessor_prop_equiv (parse_vlgen min max pk s) p (clens_id _) (gaccessor_vlgen_payload' min max pk s);
gaccessor_vlgen_payload' min max pk s
inline_for_extraction
let accessor_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 ( min) ( max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong } )
: Tot (accessor (gaccessor_vlgen_payload min max pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
slice_access_eq h (gaccessor_vlgen_payload min max pk s) input pos;
valid_facts (parse_vlgen min max pk s) h input pos;
parse_vlgen_unfold min max pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
jk input pos
module HS = FStar.HyperStack
#push-options "--z3rlimit 16"
let valid_bounded_vlgen_intro
(min: nat)
(max: nat { min <= max /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_exact_equiv p h input pos1 (pos1 `U32.add` len);
contents_exact_eq p h input pos1 (pos1 `U32.add` len);
parse_bounded_vlgen_unfold min max pk s (bytes_of_slice_from h input pos);
valid_facts (parse_bounded_vlgen min max pk s) h input pos
#pop-options
let valid_bounded_vlgen_intro_strong_prefix
(min: nat)
(max: nat { min <= max /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents p h input pos1 in
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h input pos x (pos1 `U32.add` len)
))))
= let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_pos_valid_exact p h input pos1 (pos1 `U32.add` len);
valid_bounded_vlgen_intro min max pk s h input pos
let valid_vlgen_intro
(min: nat)
(max: nat { min <= max /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\
parse_vlgen_precond min max k
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
valid_content_pos (parse_vlgen min max pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_exact_equiv p h input pos1 (pos1 `U32.add` len);
contents_exact_eq p h input pos1 (pos1 `U32.add` len);
parse_vlgen_unfold min max pk s (bytes_of_slice_from h input pos);
valid_facts (parse_vlgen min max pk s) h input pos
let valid_vlgen_intro_strong_prefix
(min: nat)
(max: nat { min <= max /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\
parse_vlgen_precond min max k
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents p h input pos1 in
valid_content_pos (parse_vlgen min max pk s) h input pos x (pos1 `U32.add` len)
))))
= let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_pos_valid_exact p h input pos1 (pos1 `U32.add` len);
valid_vlgen_intro min max pk s h input pos
let valid_vlgen_weak'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata p (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata p (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata p (U32.v len)) h input pos1 in
valid_content_pos (parse_vlgen_weak vmin vmax pk p) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_vlgen_weak (vmin) (vmax) pk p) h input pos;
parse_vlgen_weak_unfold (vmin) (vmax) pk p (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata p (U32.v len)) h input pos1
let valid_vlgen_weak_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_vlgen_weak vmin vmax pk p) h input pos
))
(ensures (
valid (parse_vlgen_weak vmin vmax pk p) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata p (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata p (U32.v len)) h input pos1 in
valid_content_pos (parse_vlgen_weak vmin vmax pk p) h input pos x (pos1 `U32.add` len) | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_vlgen_weak_elim'
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma (requires (valid (parse_vlgen_weak vmin vmax pk p) h input pos))
(ensures
(valid (parse_vlgen_weak vmin vmax pk p) h input pos /\ valid pk h input pos /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\ valid (parse_fldata p (U32.v len)) h input pos1 /\
(let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata p (U32.v len)) h input pos1 in
valid_content_pos (parse_vlgen_weak vmin vmax pk p) h input pos x (pos1 `U32.add` len)
)))) | [] | LowParse.Low.VLGen.valid_vlgen_weak_elim' | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
vmin: LowParse.Spec.DER.der_length_t ->
vmax: LowParse.Spec.DER.der_length_t{vmin <= vmax /\ vmax < 4294967296} ->
pk: LowParse.Spec.Base.parser sk (LowParse.Spec.BoundedInt.bounded_int32 vmin vmax) ->
p: LowParse.Spec.Base.parser k t ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
h: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid (LowParse.Spec.VLGen.parse_vlgen_weak vmin vmax pk p)
h
input
pos)
(ensures
LowParse.Low.Base.Spec.valid (LowParse.Spec.VLGen.parse_vlgen_weak vmin vmax pk p)
h
input
pos /\ LowParse.Low.Base.Spec.valid pk h input pos /\
(let pos1 = LowParse.Low.Base.Spec.get_valid_pos pk h input pos in
let len = LowParse.Low.Base.Spec.contents pk h input pos in
FStar.UInt32.v pos1 + FStar.UInt32.v len < 4294967296 /\
LowParse.Low.Base.Spec.valid (LowParse.Spec.FLData.parse_fldata p (FStar.UInt32.v len))
h
input
pos1 /\
(let pos1 = LowParse.Low.Base.Spec.get_valid_pos pk h input pos in
let len = LowParse.Low.Base.Spec.contents pk h input pos in
let x =
LowParse.Low.Base.Spec.contents (LowParse.Spec.FLData.parse_fldata p
(FStar.UInt32.v len))
h
input
pos1
in
LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.VLGen.parse_vlgen_weak vmin
vmax
pk
p)
h
input
pos
x
(FStar.UInt32.add pos1 len)))) | {
"end_col": 55,
"end_line": 1067,
"start_col": 2,
"start_line": 1062
} |
Prims.Tot | val jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (jumper (parse_bounded_vlgen (vmin) (vmax) pk s)) | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (jumper (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
let n = vk input pos in
let len = rk input pos in
[@inline_let]
let _ = valid_facts (parse_fldata_strong s (U32.v len)) h input n in
jump_fldata_strong s (U32.v len) len input n | val jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (jumper (parse_bounded_vlgen (vmin) (vmax) pk s))
let jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (jumper (parse_bounded_vlgen (vmin) (vmax) pk s)) = | false | null | false | fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ =
valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
let n = vk input pos in
let len = rk input pos in
[@@ inline_let ]let _ = valid_facts (parse_fldata_strong s (U32.v len)) h input n in
jump_fldata_strong s (U32.v len) len input n | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"total"
] | [
"LowParse.Spec.DER.der_length_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Low.Base.jumper",
"LowParse.Low.Base.leaf_reader",
"LowParse.Spec.Base.serializer",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.FLData.jump_fldata_strong",
"FStar.UInt32.v",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.FLData.parse_fldata_kind",
"LowParse.Spec.FLData.parse_fldata_strong_t",
"LowParse.Spec.FLData.parse_fldata_strong",
"LowParse.Spec.VLGen.parse_bounded_vlgen_unfold",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Spec.VLGen.parse_bounded_vlgen",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))
= valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth
h
(parse_bounded_vlgen vmin vmax pk s)
(synth_vlgen (vmin) (vmax) s)
input
pos
inline_for_extraction
let finalize_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_vlgen min max pk s input pos h
inline_for_extraction
let finalize_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (U32.v min) (U32.v max) k })
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s))
= validate_synth
(validate_bounded_vlgen vmin min vmax max vk rk s v)
(synth_vlgen (U32.v min) (U32.v max) s)
()
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p) | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (jumper (parse_bounded_vlgen (vmin) (vmax) pk s)) | [] | LowParse.Low.VLGen.jump_bounded_vlgen | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
vmin: LowParse.Spec.DER.der_length_t ->
vmax: LowParse.Spec.DER.der_length_t{vmin <= vmax /\ vmax < 4294967296} ->
vk: LowParse.Low.Base.jumper pk ->
rk: LowParse.Low.Base.leaf_reader pk ->
s: LowParse.Spec.Base.serializer p
-> LowParse.Low.Base.jumper (LowParse.Spec.VLGen.parse_bounded_vlgen vmin vmax pk s) | {
"end_col": 46,
"end_line": 473,
"start_col": 2,
"start_line": 462
} |
Prims.Tot | val validate_vlgen_weak
(vmin: der_length_t)
(min: U32.t{U32.v min == vmin})
(vmax: der_length_t)
(max: U32.t{U32.v max == vmax /\ U32.v min <= U32.v max})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v: validator p)
: Tot (validator (parse_vlgen_weak (vmin) (vmax) pk p)) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let validate_vlgen_weak
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v: validator p)
: Tot (validator (parse_vlgen_weak (vmin) (vmax) pk p))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_vlgen_weak' vmin vmax pk p input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_vlgen_weak_elim' vmin vmax pk p input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata v (U32.v len) len input n
end | val validate_vlgen_weak
(vmin: der_length_t)
(min: U32.t{U32.v min == vmin})
(vmax: der_length_t)
(max: U32.t{U32.v max == vmax /\ U32.v min <= U32.v max})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v: validator p)
: Tot (validator (parse_vlgen_weak (vmin) (vmax) pk p))
let validate_vlgen_weak
(vmin: der_length_t)
(min: U32.t{U32.v min == vmin})
(vmax: der_length_t)
(max: U32.t{U32.v max == vmax /\ U32.v min <= U32.v max})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v: validator p)
: Tot (validator (parse_vlgen_weak (vmin) (vmax) pk p)) = | false | null | false | fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ =
Classical.move_requires (valid_vlgen_weak' vmin vmax pk p input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_vlgen_weak_elim' vmin vmax pk p input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else
let len = rk input (uint64_to_uint32 pos) in
validate_fldata v (U32.v len) len input n | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"total"
] | [
"LowParse.Spec.DER.der_length_t",
"FStar.UInt32.t",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"FStar.UInt.size",
"FStar.UInt32.n",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Prims.op_LessThanOrEqual",
"LowParse.Spec.DER.der_length_max",
"FStar.UInt32.v",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Low.Base.validator",
"LowParse.Low.Base.leaf_reader",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt64.t",
"LowParse.Low.ErrorCode.is_error",
"Prims.bool",
"LowParse.Low.FLData.validate_fldata",
"LowParse.Low.ErrorCode.uint64_to_uint32",
"Prims.unit",
"FStar.Classical.move_requires",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Low.Base.Spec.valid",
"LowParse.Spec.VLGen.parse_vlgen_weak_kind",
"LowParse.Spec.VLGen.parse_vlgen_weak",
"Prims.op_LessThan",
"Prims.op_Addition",
"LowParse.Low.Base.Spec.get_valid_pos",
"LowParse.Low.Base.Spec.contents",
"LowParse.Spec.FLData.parse_fldata_kind",
"LowParse.Spec.FLData.parse_fldata",
"LowParse.Low.Base.Spec.valid_content_pos",
"FStar.UInt32.add",
"LowParse.Low.VLGen.valid_vlgen_weak_elim'",
"LowParse.Low.VLGen.valid_vlgen_weak'",
"FStar.HyperStack.ST.get"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end
let valid_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))
= valid_bounded_vlgen vmin vmax pk s input pos h;
valid_synth
h
(parse_bounded_vlgen vmin vmax pk s)
(synth_vlgen (vmin) (vmax) s)
input
pos
inline_for_extraction
let finalize_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_vlgen min max pk s input pos h
inline_for_extraction
let finalize_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (min) (max) k })
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (U32.v min) (U32.v max) k })
(v: validator p)
: Tot (validator (parse_vlgen (vmin) (vmax) pk s))
= validate_synth
(validate_bounded_vlgen vmin min vmax max vk rk s v)
(synth_vlgen (U32.v min) (U32.v max) s)
()
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (jumper (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
let n = vk input pos in
let len = rk input pos in
[@inline_let]
let _ = valid_facts (parse_fldata_strong s (U32.v len)) h input n in
jump_fldata_strong s (U32.v len) len input n
#pop-options
inline_for_extraction
let jump_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: jumper pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond (vmin) (vmax) k })
: Tot (jumper (parse_vlgen (vmin) (vmax) pk s))
= jump_synth
(jump_bounded_vlgen vmin vmax vk rk s)
(synth_vlgen (vmin) (vmax) s)
()
let gaccessor_bounded_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor' (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= fun input ->
parse_bounded_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_bounded_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_injective (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
injective_precond (parse_bounded_vlgen min max pk s) sl sl' /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
))
= parse_bounded_vlgen_unfold min max pk s sl;
parse_bounded_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_bounded_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_bounded_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl /\
gaccessor_pre (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) sl' /\
no_lookahead_on_precond (parse_bounded_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_bounded_vlgen_payload' min max pk s sl == gaccessor_bounded_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_bounded_vlgen_payload_no_lookahead_1 min max pk s sl) sl'
let gaccessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s))
= Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_no_lookahead_2 min max pk s);
Classical.forall_intro_2 (gaccessor_bounded_vlgen_payload_injective_2 min max pk s);
gaccessor_prop_equiv (parse_bounded_vlgen min max pk s) p (clens_bounded_vldata_strong_payload min max s) (gaccessor_bounded_vlgen_payload' min max pk s);
gaccessor_bounded_vlgen_payload' min max pk s
module B = LowStar.Buffer
inline_for_extraction
let accessor_bounded_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 ( min) ( max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
: Tot (accessor (gaccessor_bounded_vlgen_payload min max pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
slice_access_eq h (gaccessor_bounded_vlgen_payload min max pk s) input pos;
valid_facts (parse_bounded_vlgen min max pk s) h input pos;
parse_bounded_vlgen_unfold_aux min max pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
jk input pos
let gaccessor_vlgen_payload'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong } )
: Tot (gaccessor' (parse_vlgen min max pk s) p (clens_id _))
= fun input ->
parse_vlgen_unfold min max pk s input;
let res =
match parse pk input with
| None -> (0) // dummy
| Some (len, sz) ->
if sz + U32.v len <= Seq.length input
then
let input' = Seq.slice input sz (sz + U32.v len) in
let _ = match parse p input' with
| None -> ()
| Some _ ->
parse_strong_prefix p input' (Seq.slice input sz (Seq.length input))
in
sz
else 0
in
res
let gaccessor_vlgen_payload_injective_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
))
= parse_vlgen_unfold min max pk s sl;
parse_vlgen_unfold min max pk s sl' ;
parse_injective (parse_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_vlgen_payload_injective_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
injective_precond (parse_vlgen min max pk s) sl sl' /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_vlgen_payload_injective_1 min max pk s sl) sl'
let gaccessor_vlgen_payload_no_lookahead_1
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(requires (
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl'
))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
))
= parse_vlgen_unfold min max pk s sl;
parse_vlgen_unfold min max pk s sl' ;
parse_strong_prefix (parse_vlgen min max pk s) sl sl' ;
parse_injective pk sl sl'
let gaccessor_vlgen_payload_no_lookahead_2
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k })
(sl sl' : bytes)
: Lemma
(ensures ((
k.parser_kind_subkind == Some ParserStrong /\
(and_then_kind sk k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl /\
gaccessor_pre (parse_vlgen min max pk s) p (clens_id _) sl' /\
no_lookahead_on_precond (parse_vlgen min max pk s) sl sl'
) ==> (
k.parser_kind_subkind == Some ParserStrong /\
gaccessor_vlgen_payload' min max pk s sl == gaccessor_vlgen_payload' min max pk s sl'
)))
= Classical.move_requires (gaccessor_vlgen_payload_no_lookahead_1 min max pk s sl) sl'
let gaccessor_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 ( min) ( max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong})
: Tot (gaccessor (parse_vlgen min max pk s) p (clens_id _))
= Classical.forall_intro_2 (gaccessor_vlgen_payload_no_lookahead_2 min max pk s);
Classical.forall_intro_2 (gaccessor_vlgen_payload_injective_2 min max pk s);
gaccessor_prop_equiv (parse_vlgen min max pk s) p (clens_id _) (gaccessor_vlgen_payload' min max pk s);
gaccessor_vlgen_payload' min max pk s
inline_for_extraction
let accessor_vlgen_payload
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 ( min) ( max)))
(jk: jumper pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { parse_vlgen_precond min max k /\ k.parser_kind_subkind == Some ParserStrong } )
: Tot (accessor (gaccessor_vlgen_payload min max pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
slice_access_eq h (gaccessor_vlgen_payload min max pk s) input pos;
valid_facts (parse_vlgen min max pk s) h input pos;
parse_vlgen_unfold min max pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos
in
jk input pos
module HS = FStar.HyperStack
#push-options "--z3rlimit 16"
let valid_bounded_vlgen_intro
(min: nat)
(max: nat { min <= max /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_exact_equiv p h input pos1 (pos1 `U32.add` len);
contents_exact_eq p h input pos1 (pos1 `U32.add` len);
parse_bounded_vlgen_unfold min max pk s (bytes_of_slice_from h input pos);
valid_facts (parse_bounded_vlgen min max pk s) h input pos
#pop-options
let valid_bounded_vlgen_intro_strong_prefix
(min: nat)
(max: nat { min <= max /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents p h input pos1 in
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h input pos x (pos1 `U32.add` len)
))))
= let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_pos_valid_exact p h input pos1 (pos1 `U32.add` len);
valid_bounded_vlgen_intro min max pk s h input pos
let valid_vlgen_intro
(min: nat)
(max: nat { min <= max /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\
parse_vlgen_precond min max k
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
valid_content_pos (parse_vlgen min max pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_exact_equiv p h input pos1 (pos1 `U32.add` len);
contents_exact_eq p h input pos1 (pos1 `U32.add` len);
parse_vlgen_unfold min max pk s (bytes_of_slice_from h input pos);
valid_facts (parse_vlgen min max pk s) h input pos
let valid_vlgen_intro_strong_prefix
(min: nat)
(max: nat { min <= max /\ max < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (min) (max)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\
parse_vlgen_precond min max k
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
k.parser_kind_subkind == Some ParserStrong /\
valid_pos p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents p h input pos1 in
valid_content_pos (parse_vlgen min max pk s) h input pos x (pos1 `U32.add` len)
))))
= let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_pos_valid_exact p h input pos1 (pos1 `U32.add` len);
valid_vlgen_intro min max pk s h input pos
let valid_vlgen_weak'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata p (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata p (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata p (U32.v len)) h input pos1 in
valid_content_pos (parse_vlgen_weak vmin vmax pk p) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_vlgen_weak (vmin) (vmax) pk p) h input pos;
parse_vlgen_weak_unfold (vmin) (vmax) pk p (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata p (U32.v len)) h input pos1
let valid_vlgen_weak_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_vlgen_weak vmin vmax pk p) h input pos
))
(ensures (
valid (parse_vlgen_weak vmin vmax pk p) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata p (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata p (U32.v len)) h input pos1 in
valid_content_pos (parse_vlgen_weak vmin vmax pk p) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_vlgen_weak (vmin) (vmax) pk p) h input pos;
parse_vlgen_weak_unfold (vmin) (vmax) pk p (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata p (U32.v len)) h input pos1
inline_for_extraction
let validate_vlgen_weak
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v: validator p) | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val validate_vlgen_weak
(vmin: der_length_t)
(min: U32.t{U32.v min == vmin})
(vmax: der_length_t)
(max: U32.t{U32.v max == vmax /\ U32.v min <= U32.v max})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v: validator p)
: Tot (validator (parse_vlgen_weak (vmin) (vmax) pk p)) | [] | LowParse.Low.VLGen.validate_vlgen_weak | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
vmin: LowParse.Spec.DER.der_length_t ->
min: FStar.UInt32.t{FStar.UInt32.v min == vmin} ->
vmax: LowParse.Spec.DER.der_length_t ->
max: FStar.UInt32.t{FStar.UInt32.v max == vmax /\ FStar.UInt32.v min <= FStar.UInt32.v max} ->
vk: LowParse.Low.Base.validator pk ->
rk: LowParse.Low.Base.leaf_reader pk ->
v: LowParse.Low.Base.validator p
-> LowParse.Low.Base.validator (LowParse.Spec.VLGen.parse_vlgen_weak vmin vmax pk p) | {
"end_col": 5,
"end_line": 1096,
"start_col": 2,
"start_line": 1084
} |
Prims.Tot | val validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t{U32.v min == vmin})
(vmax: der_length_t)
(max: U32.t{U32.v max == vmax /\ U32.v min <= U32.v max})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s)) | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Low.VLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.VLGen",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos)) h
in
let n = vk input pos in
if is_error n
then n
else begin
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n
end | val validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t{U32.v min == vmin})
(vmax: der_length_t)
(max: U32.t{U32.v max == vmax /\ U32.v min <= U32.v max})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s))
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t{U32.v min == vmin})
(vmax: der_length_t)
(max: U32.t{U32.v max == vmax /\ U32.v min <= U32.v max})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s)) = | false | null | false | fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ =
Classical.move_requires (valid_bounded_vlgen' vmin vmax pk s input (uint64_to_uint32 pos)) h;
Classical.move_requires (valid_bounded_vlgen_elim' vmin vmax pk s input (uint64_to_uint32 pos))
h
in
let n = vk input pos in
if is_error n
then n
else
let len = rk input (uint64_to_uint32 pos) in
validate_fldata_strong s v (U32.v len) len input n | {
"checked_file": "LowParse.Low.VLGen.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.VLGen.fst.checked",
"LowParse.Low.VLData.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.VLGen.fst"
} | [
"total"
] | [
"LowParse.Spec.DER.der_length_t",
"FStar.UInt32.t",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"FStar.UInt.size",
"FStar.UInt32.n",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Prims.op_LessThanOrEqual",
"LowParse.Spec.DER.der_length_max",
"FStar.UInt32.v",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Low.Base.validator",
"LowParse.Low.Base.leaf_reader",
"LowParse.Spec.Base.serializer",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt64.t",
"LowParse.Low.ErrorCode.is_error",
"Prims.bool",
"LowParse.Low.FLData.validate_fldata_strong",
"LowParse.Low.ErrorCode.uint64_to_uint32",
"Prims.unit",
"FStar.Classical.move_requires",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Low.Base.Spec.valid",
"LowParse.Spec.VLGen.parse_bounded_vlgen_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Spec.VLGen.parse_bounded_vlgen",
"Prims.op_LessThan",
"Prims.op_Addition",
"LowParse.Low.Base.Spec.get_valid_pos",
"LowParse.Low.Base.Spec.contents",
"LowParse.Spec.FLData.parse_fldata_kind",
"LowParse.Spec.FLData.parse_fldata_strong_t",
"LowParse.Spec.FLData.parse_fldata_strong",
"FStar.Seq.Base.length",
"LowParse.Spec.Base.serialize",
"LowParse.Low.Base.Spec.valid_content_pos",
"FStar.UInt32.add",
"LowParse.Low.VLGen.valid_bounded_vlgen_elim'",
"LowParse.Low.VLGen.valid_bounded_vlgen'",
"FStar.HyperStack.ST.get"
] | [] | module LowParse.Low.VLGen
include LowParse.Spec.VLGen
include LowParse.Low.VLData
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
#reset-options "--z3cliopt smt.arith.nl=false"
let valid_bounded_vlgen'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len)
)))
(ensures (
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
let x = contents_exact p h input pos1 pos2 in
valid_fldata_gen p (U32.v len) input pos1 h;
serialized_length_eq s x;
valid_exact_serialize s h input pos1 pos2
let valid_bounded_vlgen_elim'
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid (parse_fldata_strong s (U32.v len)) h input pos1 /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents (parse_fldata_strong s (U32.v len)) h input pos1 in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold_aux (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
valid_facts (parse_fldata_strong s (U32.v len)) h input pos1
let valid_bounded_vlgen_elim
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
(#sk: parser_kind)
(pk: parser sk (bounded_int32 (vmin) (vmax)))
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
(h: HS.mem)
: Lemma
(requires (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos
))
(ensures (
valid (parse_bounded_vlgen vmin vmax pk s) h input pos /\
valid pk h input pos /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
U32.v pos1 + U32.v len < 4294967296 /\
valid_exact p h input pos1 (pos1 `U32.add` len) /\ (
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let x = contents_exact p h input pos1 (pos1 `U32.add` len) in
Seq.length (serialize s x) == U32.v len /\
valid_content_pos (parse_bounded_vlgen vmin vmax pk s) h input pos x (pos1 `U32.add` len)
))))
= valid_facts (parse_bounded_vlgen (vmin) (vmax) pk s) h input pos;
parse_bounded_vlgen_unfold (vmin) (vmax) pk s (bytes_of_slice_from h input pos);
valid_facts pk h input pos;
let pos1 = get_valid_pos pk h input pos in
let len = contents pk h input pos in
let pos2 = pos1 `U32.add` len in
valid_facts (parse_fldata p (U32.v len)) h input pos1;
valid_fldata_gen_elim p (U32.v len) input pos1 h;
valid_exact_serialize s h input pos1 pos2
inline_for_extraction
let finalize_bounded_vlgen_exact
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` sz32 in
valid_exact p h input pos_payload pos' /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents_exact p h input pos_payload pos')) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let sz = U32.v sz32 in
let x = contents_exact p h input (pos `U32.add` sz32) pos' in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
Seq.length (serialize s x) == U32.v pos' - (U32.v pos + sz) /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= [@inline_let]
let len_payload = pos' `U32.sub` (pos `U32.add` sz32) in
let h = HST.get () in
[@inline_let]
let _ =
serialized_length_eq s (contents_exact p h input (pos `U32.add` sz32) pos');
valid_exact_serialize s h input (pos `U32.add` sz32) pos'
in
let _ = wk len_payload input pos in
let h = HST.get () in
valid_bounded_vlgen min max pk s input pos h
inline_for_extraction
let finalize_bounded_vlgen
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(sz32: U32.t)
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (min) (max)))
(#ssk: serializer pk)
(wk: leaf_writer_strong ssk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: HST.Stack unit
(requires (fun h ->
let sz = U32.v sz32 in
sk.parser_kind_low == sz /\
sk.parser_kind_high == Some sz /\
U32.v pos + sz <= U32.v input.len /\ (
let pos_payload = pos `U32.add` U32.uint_to_t sz in
valid_pos p h input pos_payload pos' /\
k.parser_kind_subkind == Some ParserStrong /\ (
let len_payload = pos' `U32.sub` pos_payload in
let len_ser = Seq.length (serialize s (contents p h input pos_payload)) in
writable input.base (U32.v pos) (U32.v pos + sz) h /\
((min <= U32.v len_payload /\ U32.v len_payload <= max) \/ (min <= len_ser /\ len_ser <= max))
))))
(ensures (fun h _ h' ->
let x = contents p h input (pos `U32.add` sz32) in
B.modifies (loc_slice_from_to input pos (pos `U32.add` sz32)) h h' /\
parse_bounded_vldata_strong_pred min max s x /\
valid_content_pos (parse_bounded_vlgen min max pk s) h' input pos x pos'
))
= let h = HST.get () in
[@inline_let]
let _ =
let pos_payload = pos `U32.add` sz32 in
valid_pos_valid_exact p h input pos_payload pos'
in
finalize_bounded_vlgen_exact min max sz32 wk s input pos pos'
inline_for_extraction
let validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t { U32.v min == vmin } )
(vmax: der_length_t)
(max: U32.t { U32.v max == vmax /\ U32.v min <= U32.v max } )
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p) | false | false | LowParse.Low.VLGen.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val validate_bounded_vlgen
(vmin: der_length_t)
(min: U32.t{U32.v min == vmin})
(vmax: der_length_t)
(max: U32.t{U32.v max == vmax /\ U32.v min <= U32.v max})
(#sk: parser_kind)
(#pk: parser sk (bounded_int32 (vmin) (vmax)))
(vk: validator pk)
(rk: leaf_reader pk)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(v: validator p)
: Tot (validator (parse_bounded_vlgen (vmin) (vmax) pk s)) | [] | LowParse.Low.VLGen.validate_bounded_vlgen | {
"file_name": "src/lowparse/LowParse.Low.VLGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
vmin: LowParse.Spec.DER.der_length_t ->
min: FStar.UInt32.t{FStar.UInt32.v min == vmin} ->
vmax: LowParse.Spec.DER.der_length_t ->
max: FStar.UInt32.t{FStar.UInt32.v max == vmax /\ FStar.UInt32.v min <= FStar.UInt32.v max} ->
vk: LowParse.Low.Base.validator pk ->
rk: LowParse.Low.Base.leaf_reader pk ->
s: LowParse.Spec.Base.serializer p ->
v: LowParse.Low.Base.validator p
-> LowParse.Low.Base.validator (LowParse.Spec.VLGen.parse_bounded_vlgen vmin vmax pk s) | {
"end_col": 5,
"end_line": 293,
"start_col": 2,
"start_line": 281
} |
Prims.GTot | val v (s: t) : GTot (s:Seq.seq C.char{well_formed s}) | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.Modifies",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.Modifies",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let v s = s.s | val v (s: t) : GTot (s:Seq.seq C.char{well_formed s})
let v s = | false | null | false | s.s | {
"checked_file": "C.String.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"C.fst.checked"
],
"interface_file": true,
"source_file": "C.String.fst"
} | [
"sometrivial"
] | [
"C.String.t",
"C.String.__proj__S__item__s",
"FStar.Seq.Base.seq",
"C.char",
"C.String.well_formed"
] | [] | module C.String
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module B = LowStar.Buffer
module M = LowStar.Modifies
open FStar.HyperStack.ST
[@@ no_auto_projectors]
type t = | S: s:Seq.seq C.char { well_formed s } -> t | false | false | C.String.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val v (s: t) : GTot (s:Seq.seq C.char{well_formed s}) | [] | C.String.v | {
"file_name": "krmllib/C.String.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | s: C.String.t -> Prims.GTot (s: FStar.Seq.Base.seq C.char {C.String.well_formed s}) | {
"end_col": 13,
"end_line": 14,
"start_col": 10,
"start_line": 14
} |
Prims.GTot | val length (s: t): GTot (n:nat{n > 0 /\ n == Seq.length (v s)}) | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.Modifies",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.Modifies",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let length s = Seq.length s.s | val length (s: t): GTot (n:nat{n > 0 /\ n == Seq.length (v s)})
let length s = | false | null | false | Seq.length s.s | {
"checked_file": "C.String.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"C.fst.checked"
],
"interface_file": true,
"source_file": "C.String.fst"
} | [
"sometrivial"
] | [
"C.String.t",
"FStar.Seq.Base.length",
"C.char",
"C.String.__proj__S__item__s",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.eq2",
"C.String.v"
] | [] | module C.String
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module B = LowStar.Buffer
module M = LowStar.Modifies
open FStar.HyperStack.ST
[@@ no_auto_projectors]
type t = | S: s:Seq.seq C.char { well_formed s } -> t
let v s = s.s | false | false | C.String.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val length (s: t): GTot (n:nat{n > 0 /\ n == Seq.length (v s)}) | [] | C.String.length | {
"file_name": "krmllib/C.String.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | s: C.String.t -> Prims.GTot (n: Prims.nat{n > 0 /\ n == FStar.Seq.Base.length (C.String.v s)}) | {
"end_col": 29,
"end_line": 16,
"start_col": 15,
"start_line": 16
} |
Prims.Pure | val get (s: t) (l: U32.t{ U32.v l < Seq.length (v s) }): Pure C.char
(requires True)
(ensures (fun c -> c = Seq.index (v s) (U32.v l))) | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.Modifies",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.Modifies",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let get s l = Seq.index s.s (U32.v l) | val get (s: t) (l: U32.t{ U32.v l < Seq.length (v s) }): Pure C.char
(requires True)
(ensures (fun c -> c = Seq.index (v s) (U32.v l)))
let get s l = | false | null | false | Seq.index s.s (U32.v l) | {
"checked_file": "C.String.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"C.fst.checked"
],
"interface_file": true,
"source_file": "C.String.fst"
} | [] | [
"C.String.t",
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.UInt32.v",
"FStar.Seq.Base.length",
"C.char",
"C.String.v",
"FStar.Seq.Base.index",
"C.String.__proj__S__item__s"
] | [] | module C.String
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module B = LowStar.Buffer
module M = LowStar.Modifies
open FStar.HyperStack.ST
[@@ no_auto_projectors]
type t = | S: s:Seq.seq C.char { well_formed s } -> t
let v s = s.s
let length s = Seq.length s.s | false | false | C.String.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val get (s: t) (l: U32.t{ U32.v l < Seq.length (v s) }): Pure C.char
(requires True)
(ensures (fun c -> c = Seq.index (v s) (U32.v l))) | [] | C.String.get | {
"file_name": "krmllib/C.String.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | s: C.String.t -> l: FStar.UInt32.t{FStar.UInt32.v l < FStar.Seq.Base.length (C.String.v s)}
-> Prims.Pure C.char | {
"end_col": 37,
"end_line": 18,
"start_col": 14,
"start_line": 18
} |
FStar.Pervasives.Lemma | val table_select_lemma:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len} ->
Lemma (Math.Lemmas.lemma_mult_le_right len (v i + 1) table_len;
table_select len table_len table i == sub table (v i * len) len) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let table_select_lemma #t len table_len table i =
let _ = table_select_loop_lemma len table_len table i in () | val table_select_lemma:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len} ->
Lemma (Math.Lemmas.lemma_mult_le_right len (v i + 1) table_len;
table_select len table_len table i == sub table (v i * len) len)
let table_select_lemma #t len table_len table i = | false | null | true | let _ = table_select_loop_lemma len table_len table i in
() | {
"checked_file": "Hacl.Spec.PrecompTable.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.PrecompTable.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.l_and",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.SEC",
"Lib.IntTypes.v",
"Lib.IntTypes.int_t",
"Hacl.Spec.PrecompTable.table_select_loop_lemma",
"Prims.unit"
] | [] | module Hacl.Spec.PrecompTable
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module SB = Hacl.Spec.Bignum.Base
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val table_select_f:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len}
-> j:size_nat{j < table_len - 1}
-> acc:lseq (uint_t t SEC) len ->
lseq (uint_t t SEC) len
let table_select_f #t len table_len table i j acc =
let c = eq_mask i (SB.size_to_limb (size j +! 1ul)) in
//assert (v c == (if v i = v j + 1 then ones_v a_t else 0));
Math.Lemmas.lemma_mult_le_right len (j + 2) table_len;
let res_j = sub table ((j + 1) * len) len in
let acc = map2 (SB.mask_select c) res_j acc in
acc
val table_select:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len} ->
lseq (uint_t t SEC) len
let table_select #a_t len table_len table i =
let res = sub table 0 len in
Loops.repeati (table_len - 1) (table_select_f #a_t len table_len table i) res
val table_select_f_lemma:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len}
-> j:size_nat{j < table_len - 1}
-> acc:lseq (uint_t t SEC) len ->
Lemma (
let res = table_select_f len table_len table i j acc in
Math.Lemmas.lemma_mult_le_right len (j + 2) table_len;
let res_j = sub table ((j + 1) * len) len in
res == (if v i = j + 1 then res_j else acc))
let table_select_f_lemma #t len table_len table i j acc =
let c = eq_mask i (SB.size_to_limb (size (j + 1))) in
assert (v c == (if v i = j + 1 then ones_v t else 0));
Math.Lemmas.lemma_mult_le_right len (j + 2) table_len;
let res_j = sub table ((j + 1) * len) len in
let res = map2 (SB.mask_select c) res_j acc in
SB.lseq_mask_select_lemma res_j acc c
val table_select_loop_lemma:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len} ->
Pure (lseq (uint_t t SEC) len)
(requires True)
(ensures fun res ->
let res0 = sub table 0 len in
Math.Lemmas.lemma_mult_le_right len (v i + 1) table_len;
res == Loops.repeati (table_len - 1) (table_select_f len table_len table i) res0 /\
res == sub table (v i * len) len)
let table_select_loop_lemma #t len table_len table i =
let f = table_select_f len table_len table i in
let res0 = sub table 0 len in
Math.Lemmas.lemma_mult_le_right len (v i + 1) table_len;
Loops.eq_repeati0 (table_len - 1) f res0;
Loops.repeati_inductive (table_len - 1)
(fun j priv ->
priv == Loops.repeati j f res0 /\
priv == (if j >= v i then sub table (v i * len) len else res0))
(fun j priv ->
Loops.unfold_repeati (j + 1) f res0 j;
let res = f j priv in
table_select_f_lemma len table_len table i j priv;
Math.Lemmas.lemma_mult_le_right len (j + 2) table_len;
let res_j = sub table ((j + 1) * len) len in
assert (res == (if v i = j + 1 then res_j else priv));
res) res0
val table_select_lemma:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len} ->
Lemma (Math.Lemmas.lemma_mult_le_right len (v i + 1) table_len;
table_select len table_len table i == sub table (v i * len) len) | false | false | Hacl.Spec.PrecompTable.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val table_select_lemma:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len} ->
Lemma (Math.Lemmas.lemma_mult_le_right len (v i + 1) table_len;
table_select len table_len table i == sub table (v i * len) len) | [] | Hacl.Spec.PrecompTable.table_select_lemma | {
"file_name": "code/bignum/Hacl.Spec.PrecompTable.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
len: Lib.IntTypes.size_nat{len > 0} ->
table_len: Lib.IntTypes.size_nat{1 < table_len /\ table_len * len <= Lib.IntTypes.max_size_t} ->
table: Lib.Sequence.lseq (Lib.IntTypes.uint_t t Lib.IntTypes.SEC) (table_len * len) ->
i: Lib.IntTypes.uint_t t Lib.IntTypes.SEC {Lib.IntTypes.v i < table_len}
-> FStar.Pervasives.Lemma
(ensures
([@@ FStar.Pervasives.inline_let ]let _ =
FStar.Math.Lemmas.lemma_mult_le_right len (Lib.IntTypes.v i + 1) table_len
in
Hacl.Spec.PrecompTable.table_select len table_len table i ==
Lib.Sequence.sub table (Lib.IntTypes.v i * len) len)) | {
"end_col": 61,
"end_line": 118,
"start_col": 49,
"start_line": 117
} |
Prims.Tot | val table_select:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len} ->
lseq (uint_t t SEC) len | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let table_select #a_t len table_len table i =
let res = sub table 0 len in
Loops.repeati (table_len - 1) (table_select_f #a_t len table_len table i) res | val table_select:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len} ->
lseq (uint_t t SEC) len
let table_select #a_t len table_len table i = | false | null | false | let res = sub table 0 len in
Loops.repeati (table_len - 1) (table_select_f #a_t len table_len table i) res | {
"checked_file": "Hacl.Spec.PrecompTable.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.PrecompTable.fst"
} | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.l_and",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.SEC",
"Lib.IntTypes.v",
"Lib.LoopCombinators.repeati",
"Prims.op_Subtraction",
"Hacl.Spec.PrecompTable.table_select_f",
"Lib.IntTypes.int_t",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.op_Multiply",
"Prims.op_Addition",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Lib.Sequence.sub"
] | [] | module Hacl.Spec.PrecompTable
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module SB = Hacl.Spec.Bignum.Base
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val table_select_f:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len}
-> j:size_nat{j < table_len - 1}
-> acc:lseq (uint_t t SEC) len ->
lseq (uint_t t SEC) len
let table_select_f #t len table_len table i j acc =
let c = eq_mask i (SB.size_to_limb (size j +! 1ul)) in
//assert (v c == (if v i = v j + 1 then ones_v a_t else 0));
Math.Lemmas.lemma_mult_le_right len (j + 2) table_len;
let res_j = sub table ((j + 1) * len) len in
let acc = map2 (SB.mask_select c) res_j acc in
acc
val table_select:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len} ->
lseq (uint_t t SEC) len | false | false | Hacl.Spec.PrecompTable.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val table_select:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len} ->
lseq (uint_t t SEC) len | [] | Hacl.Spec.PrecompTable.table_select | {
"file_name": "code/bignum/Hacl.Spec.PrecompTable.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
len: Lib.IntTypes.size_nat{len > 0} ->
table_len: Lib.IntTypes.size_nat{1 < table_len /\ table_len * len <= Lib.IntTypes.max_size_t} ->
table: Lib.Sequence.lseq (Lib.IntTypes.uint_t t Lib.IntTypes.SEC) (table_len * len) ->
i: Lib.IntTypes.uint_t t Lib.IntTypes.SEC {Lib.IntTypes.v i < table_len}
-> Lib.Sequence.lseq (Lib.IntTypes.uint_t t Lib.IntTypes.SEC) len | {
"end_col": 79,
"end_line": 46,
"start_col": 45,
"start_line": 44
} |
Prims.Tot | val table_select_f:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len}
-> j:size_nat{j < table_len - 1}
-> acc:lseq (uint_t t SEC) len ->
lseq (uint_t t SEC) len | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let table_select_f #t len table_len table i j acc =
let c = eq_mask i (SB.size_to_limb (size j +! 1ul)) in
//assert (v c == (if v i = v j + 1 then ones_v a_t else 0));
Math.Lemmas.lemma_mult_le_right len (j + 2) table_len;
let res_j = sub table ((j + 1) * len) len in
let acc = map2 (SB.mask_select c) res_j acc in
acc | val table_select_f:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len}
-> j:size_nat{j < table_len - 1}
-> acc:lseq (uint_t t SEC) len ->
lseq (uint_t t SEC) len
let table_select_f #t len table_len table i j acc = | false | null | false | let c = eq_mask i (SB.size_to_limb (size j +! 1ul)) in
Math.Lemmas.lemma_mult_le_right len (j + 2) table_len;
let res_j = sub table ((j + 1) * len) len in
let acc = map2 (SB.mask_select c) res_j acc in
acc | {
"checked_file": "Hacl.Spec.PrecompTable.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.PrecompTable.fst"
} | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.l_and",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.SEC",
"Lib.IntTypes.v",
"Prims.op_Subtraction",
"Lib.IntTypes.int_t",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.eq2",
"Lib.Sequence.index",
"Hacl.Spec.Bignum.Base.mask_select",
"Lib.Sequence.map2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.op_Multiply",
"Prims.op_Addition",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.sub",
"Prims.unit",
"FStar.Math.Lemmas.lemma_mult_le_right",
"Lib.IntTypes.eq_mask",
"Hacl.Spec.Bignum.Base.size_to_limb",
"Lib.IntTypes.op_Plus_Bang",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.IntTypes.size",
"FStar.UInt32.__uint_to_t"
] | [] | module Hacl.Spec.PrecompTable
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module SB = Hacl.Spec.Bignum.Base
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val table_select_f:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len}
-> j:size_nat{j < table_len - 1}
-> acc:lseq (uint_t t SEC) len ->
lseq (uint_t t SEC) len | false | false | Hacl.Spec.PrecompTable.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val table_select_f:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len}
-> j:size_nat{j < table_len - 1}
-> acc:lseq (uint_t t SEC) len ->
lseq (uint_t t SEC) len | [] | Hacl.Spec.PrecompTable.table_select_f | {
"file_name": "code/bignum/Hacl.Spec.PrecompTable.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
len: Lib.IntTypes.size_nat{len > 0} ->
table_len: Lib.IntTypes.size_nat{1 < table_len /\ table_len * len <= Lib.IntTypes.max_size_t} ->
table: Lib.Sequence.lseq (Lib.IntTypes.uint_t t Lib.IntTypes.SEC) (table_len * len) ->
i: Lib.IntTypes.uint_t t Lib.IntTypes.SEC {Lib.IntTypes.v i < table_len} ->
j: Lib.IntTypes.size_nat{j < table_len - 1} ->
acc: Lib.Sequence.lseq (Lib.IntTypes.uint_t t Lib.IntTypes.SEC) len
-> Lib.Sequence.lseq (Lib.IntTypes.uint_t t Lib.IntTypes.SEC) len | {
"end_col": 5,
"end_line": 33,
"start_col": 51,
"start_line": 26
} |
FStar.Pervasives.Lemma | val table_select_f_lemma:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len}
-> j:size_nat{j < table_len - 1}
-> acc:lseq (uint_t t SEC) len ->
Lemma (
let res = table_select_f len table_len table i j acc in
Math.Lemmas.lemma_mult_le_right len (j + 2) table_len;
let res_j = sub table ((j + 1) * len) len in
res == (if v i = j + 1 then res_j else acc)) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let table_select_f_lemma #t len table_len table i j acc =
let c = eq_mask i (SB.size_to_limb (size (j + 1))) in
assert (v c == (if v i = j + 1 then ones_v t else 0));
Math.Lemmas.lemma_mult_le_right len (j + 2) table_len;
let res_j = sub table ((j + 1) * len) len in
let res = map2 (SB.mask_select c) res_j acc in
SB.lseq_mask_select_lemma res_j acc c | val table_select_f_lemma:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len}
-> j:size_nat{j < table_len - 1}
-> acc:lseq (uint_t t SEC) len ->
Lemma (
let res = table_select_f len table_len table i j acc in
Math.Lemmas.lemma_mult_le_right len (j + 2) table_len;
let res_j = sub table ((j + 1) * len) len in
res == (if v i = j + 1 then res_j else acc))
let table_select_f_lemma #t len table_len table i j acc = | false | null | true | let c = eq_mask i (SB.size_to_limb (size (j + 1))) in
assert (v c == (if v i = j + 1 then ones_v t else 0));
Math.Lemmas.lemma_mult_le_right len (j + 2) table_len;
let res_j = sub table ((j + 1) * len) len in
let res = map2 (SB.mask_select c) res_j acc in
SB.lseq_mask_select_lemma res_j acc c | {
"checked_file": "Hacl.Spec.PrecompTable.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.PrecompTable.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.l_and",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.SEC",
"Lib.IntTypes.v",
"Prims.op_Subtraction",
"Hacl.Spec.Bignum.Base.lseq_mask_select_lemma",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.eq2",
"Lib.Sequence.index",
"Hacl.Spec.Bignum.Base.mask_select",
"Lib.IntTypes.int_t",
"Lib.Sequence.map2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.op_Multiply",
"Prims.op_Addition",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.sub",
"Prims.unit",
"FStar.Math.Lemmas.lemma_mult_le_right",
"Prims._assert",
"Prims.int",
"Prims.op_Equality",
"Lib.IntTypes.ones_v",
"Prims.bool",
"Lib.IntTypes.eq_mask",
"Hacl.Spec.Bignum.Base.size_to_limb",
"Lib.IntTypes.size"
] | [] | module Hacl.Spec.PrecompTable
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module SB = Hacl.Spec.Bignum.Base
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val table_select_f:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len}
-> j:size_nat{j < table_len - 1}
-> acc:lseq (uint_t t SEC) len ->
lseq (uint_t t SEC) len
let table_select_f #t len table_len table i j acc =
let c = eq_mask i (SB.size_to_limb (size j +! 1ul)) in
//assert (v c == (if v i = v j + 1 then ones_v a_t else 0));
Math.Lemmas.lemma_mult_le_right len (j + 2) table_len;
let res_j = sub table ((j + 1) * len) len in
let acc = map2 (SB.mask_select c) res_j acc in
acc
val table_select:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len} ->
lseq (uint_t t SEC) len
let table_select #a_t len table_len table i =
let res = sub table 0 len in
Loops.repeati (table_len - 1) (table_select_f #a_t len table_len table i) res
val table_select_f_lemma:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len}
-> j:size_nat{j < table_len - 1}
-> acc:lseq (uint_t t SEC) len ->
Lemma (
let res = table_select_f len table_len table i j acc in
Math.Lemmas.lemma_mult_le_right len (j + 2) table_len;
let res_j = sub table ((j + 1) * len) len in
res == (if v i = j + 1 then res_j else acc)) | false | false | Hacl.Spec.PrecompTable.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val table_select_f_lemma:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len}
-> j:size_nat{j < table_len - 1}
-> acc:lseq (uint_t t SEC) len ->
Lemma (
let res = table_select_f len table_len table i j acc in
Math.Lemmas.lemma_mult_le_right len (j + 2) table_len;
let res_j = sub table ((j + 1) * len) len in
res == (if v i = j + 1 then res_j else acc)) | [] | Hacl.Spec.PrecompTable.table_select_f_lemma | {
"file_name": "code/bignum/Hacl.Spec.PrecompTable.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
len: Lib.IntTypes.size_nat{len > 0} ->
table_len: Lib.IntTypes.size_nat{1 < table_len /\ table_len * len <= Lib.IntTypes.max_size_t} ->
table: Lib.Sequence.lseq (Lib.IntTypes.uint_t t Lib.IntTypes.SEC) (table_len * len) ->
i: Lib.IntTypes.uint_t t Lib.IntTypes.SEC {Lib.IntTypes.v i < table_len} ->
j: Lib.IntTypes.size_nat{j < table_len - 1} ->
acc: Lib.Sequence.lseq (Lib.IntTypes.uint_t t Lib.IntTypes.SEC) len
-> FStar.Pervasives.Lemma
(ensures
(let res = Hacl.Spec.PrecompTable.table_select_f len table_len table i j acc in
[@@ FStar.Pervasives.inline_let ]let _ =
FStar.Math.Lemmas.lemma_mult_le_right len (j + 2) table_len
in
let res_j = Lib.Sequence.sub table ((j + 1) * len) len in
res ==
(match Lib.IntTypes.v i = j + 1 with
| true -> res_j
| _ -> acc))) | {
"end_col": 39,
"end_line": 71,
"start_col": 57,
"start_line": 64
} |
Prims.Pure | val table_select_loop_lemma:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len} ->
Pure (lseq (uint_t t SEC) len)
(requires True)
(ensures fun res ->
let res0 = sub table 0 len in
Math.Lemmas.lemma_mult_le_right len (v i + 1) table_len;
res == Loops.repeati (table_len - 1) (table_select_f len table_len table i) res0 /\
res == sub table (v i * len) len) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let table_select_loop_lemma #t len table_len table i =
let f = table_select_f len table_len table i in
let res0 = sub table 0 len in
Math.Lemmas.lemma_mult_le_right len (v i + 1) table_len;
Loops.eq_repeati0 (table_len - 1) f res0;
Loops.repeati_inductive (table_len - 1)
(fun j priv ->
priv == Loops.repeati j f res0 /\
priv == (if j >= v i then sub table (v i * len) len else res0))
(fun j priv ->
Loops.unfold_repeati (j + 1) f res0 j;
let res = f j priv in
table_select_f_lemma len table_len table i j priv;
Math.Lemmas.lemma_mult_le_right len (j + 2) table_len;
let res_j = sub table ((j + 1) * len) len in
assert (res == (if v i = j + 1 then res_j else priv));
res) res0 | val table_select_loop_lemma:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len} ->
Pure (lseq (uint_t t SEC) len)
(requires True)
(ensures fun res ->
let res0 = sub table 0 len in
Math.Lemmas.lemma_mult_le_right len (v i + 1) table_len;
res == Loops.repeati (table_len - 1) (table_select_f len table_len table i) res0 /\
res == sub table (v i * len) len)
let table_select_loop_lemma #t len table_len table i = | false | null | false | let f = table_select_f len table_len table i in
let res0 = sub table 0 len in
Math.Lemmas.lemma_mult_le_right len (v i + 1) table_len;
Loops.eq_repeati0 (table_len - 1) f res0;
Loops.repeati_inductive (table_len - 1)
(fun j priv ->
priv == Loops.repeati j f res0 /\
priv == (if j >= v i then sub table (v i * len) len else res0))
(fun j priv ->
Loops.unfold_repeati (j + 1) f res0 j;
let res = f j priv in
table_select_f_lemma len table_len table i j priv;
Math.Lemmas.lemma_mult_le_right len (j + 2) table_len;
let res_j = sub table ((j + 1) * len) len in
assert (res == (if v i = j + 1 then res_j else priv));
res)
res0 | {
"checked_file": "Hacl.Spec.PrecompTable.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.PrecompTable.fst"
} | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.l_and",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.SEC",
"Lib.IntTypes.v",
"Lib.LoopCombinators.repeati_inductive",
"Prims.l_or",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"Prims.l_Forall",
"Prims.nat",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Prims.op_Subtraction",
"Lib.LoopCombinators.repeati",
"Prims.op_GreaterThanOrEqual",
"Lib.Sequence.sub",
"Prims.bool",
"Prims.unit",
"Prims._assert",
"Prims.op_Equality",
"Prims.int",
"Lib.IntTypes.int_t",
"Prims.op_Multiply",
"FStar.Math.Lemmas.lemma_mult_le_right",
"Hacl.Spec.PrecompTable.table_select_f_lemma",
"Lib.LoopCombinators.unfold_repeati",
"Lib.LoopCombinators.eq_repeati0",
"Prims.pow2",
"Hacl.Spec.PrecompTable.table_select_f"
] | [] | module Hacl.Spec.PrecompTable
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
module SB = Hacl.Spec.Bignum.Base
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val table_select_f:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len}
-> j:size_nat{j < table_len - 1}
-> acc:lseq (uint_t t SEC) len ->
lseq (uint_t t SEC) len
let table_select_f #t len table_len table i j acc =
let c = eq_mask i (SB.size_to_limb (size j +! 1ul)) in
//assert (v c == (if v i = v j + 1 then ones_v a_t else 0));
Math.Lemmas.lemma_mult_le_right len (j + 2) table_len;
let res_j = sub table ((j + 1) * len) len in
let acc = map2 (SB.mask_select c) res_j acc in
acc
val table_select:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len} ->
lseq (uint_t t SEC) len
let table_select #a_t len table_len table i =
let res = sub table 0 len in
Loops.repeati (table_len - 1) (table_select_f #a_t len table_len table i) res
val table_select_f_lemma:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len}
-> j:size_nat{j < table_len - 1}
-> acc:lseq (uint_t t SEC) len ->
Lemma (
let res = table_select_f len table_len table i j acc in
Math.Lemmas.lemma_mult_le_right len (j + 2) table_len;
let res_j = sub table ((j + 1) * len) len in
res == (if v i = j + 1 then res_j else acc))
let table_select_f_lemma #t len table_len table i j acc =
let c = eq_mask i (SB.size_to_limb (size (j + 1))) in
assert (v c == (if v i = j + 1 then ones_v t else 0));
Math.Lemmas.lemma_mult_le_right len (j + 2) table_len;
let res_j = sub table ((j + 1) * len) len in
let res = map2 (SB.mask_select c) res_j acc in
SB.lseq_mask_select_lemma res_j acc c
val table_select_loop_lemma:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len} ->
Pure (lseq (uint_t t SEC) len)
(requires True)
(ensures fun res ->
let res0 = sub table 0 len in
Math.Lemmas.lemma_mult_le_right len (v i + 1) table_len;
res == Loops.repeati (table_len - 1) (table_select_f len table_len table i) res0 /\
res == sub table (v i * len) len) | false | false | Hacl.Spec.PrecompTable.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val table_select_loop_lemma:
#t:limb_t
-> len:size_nat{len > 0}
-> table_len:size_nat{1 < table_len /\ table_len * len <= max_size_t}
-> table:lseq (uint_t t SEC) (table_len * len)
-> i:uint_t t SEC{v i < table_len} ->
Pure (lseq (uint_t t SEC) len)
(requires True)
(ensures fun res ->
let res0 = sub table 0 len in
Math.Lemmas.lemma_mult_le_right len (v i + 1) table_len;
res == Loops.repeati (table_len - 1) (table_select_f len table_len table i) res0 /\
res == sub table (v i * len) len) | [] | Hacl.Spec.PrecompTable.table_select_loop_lemma | {
"file_name": "code/bignum/Hacl.Spec.PrecompTable.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
len: Lib.IntTypes.size_nat{len > 0} ->
table_len: Lib.IntTypes.size_nat{1 < table_len /\ table_len * len <= Lib.IntTypes.max_size_t} ->
table: Lib.Sequence.lseq (Lib.IntTypes.uint_t t Lib.IntTypes.SEC) (table_len * len) ->
i: Lib.IntTypes.uint_t t Lib.IntTypes.SEC {Lib.IntTypes.v i < table_len}
-> Prims.Pure (Lib.Sequence.lseq (Lib.IntTypes.uint_t t Lib.IntTypes.SEC) len) | {
"end_col": 13,
"end_line": 105,
"start_col": 54,
"start_line": 88
} |
Prims.Tot | val parse_list_bare (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (bare_parser (list t)) | [
{
"abbrev": true,
"full_module": "FStar.Classical",
"short_module": "Classical"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_list_bare
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (bare_parser (list t))
= (fun b -> parse_list_aux #k #t p b) <: bare_parser (list t) | val parse_list_bare (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (bare_parser (list t))
let parse_list_bare (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (bare_parser (list t)) = | false | null | false | (fun b -> parse_list_aux #k #t p b) <: bare_parser (list t) | {
"checked_file": "LowParse.Spec.List.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.List.fsti"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Bytes.bytes",
"LowParse.Spec.List.parse_list_aux",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"Prims.list",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.Base.bare_parser"
] | [] | module LowParse.Spec.List
include LowParse.Spec.Combinators // for seq_slice_append_l
module Seq = FStar.Seq
module L = FStar.List.Tot
module U32 = FStar.UInt32
module Classical = FStar.Classical
(* Parse a list, until there is nothing left to read. This parser will mostly fail EXCEPT if the whole size is known and the slice has been suitably truncated beforehand, or if the elements of the list all have a known constant size. *)
let rec parse_list_aux
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: GTot (option (list t * (consumed_length b)))
(decreases (Seq.length b))
= if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse_list_aux p (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
let parse_list_bare
(#k: parser_kind)
(#t: Type)
(p: parser k t) | false | false | LowParse.Spec.List.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val parse_list_bare (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (bare_parser (list t)) | [] | LowParse.Spec.List.parse_list_bare | {
"file_name": "src/lowparse/LowParse.Spec.List.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p: LowParse.Spec.Base.parser k t -> LowParse.Spec.Base.bare_parser (Prims.list t) | {
"end_col": 61,
"end_line": 37,
"start_col": 2,
"start_line": 37
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.Classical",
"short_module": "Classical"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_list_kind =
{
parser_kind_low = 0;
parser_kind_high = None;
parser_kind_metadata = None;
parser_kind_subkind = Some ParserConsumesAll;
} | let parse_list_kind = | false | null | false | {
parser_kind_low = 0;
parser_kind_high = None;
parser_kind_metadata = None;
parser_kind_subkind = Some ParserConsumesAll
} | {
"checked_file": "LowParse.Spec.List.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.List.fsti"
} | [
"total"
] | [
"LowParse.Spec.Base.Mkparser_kind'",
"FStar.Pervasives.Native.None",
"Prims.nat",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.ParserConsumesAll",
"LowParse.Spec.Base.parser_kind_metadata_some"
] | [] | module LowParse.Spec.List
include LowParse.Spec.Combinators // for seq_slice_append_l
module Seq = FStar.Seq
module L = FStar.List.Tot
module U32 = FStar.UInt32
module Classical = FStar.Classical
(* Parse a list, until there is nothing left to read. This parser will mostly fail EXCEPT if the whole size is known and the slice has been suitably truncated beforehand, or if the elements of the list all have a known constant size. *)
let rec parse_list_aux
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: GTot (option (list t * (consumed_length b)))
(decreases (Seq.length b))
= if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse_list_aux p (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
let parse_list_bare
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (bare_parser (list t))
= (fun b -> parse_list_aux #k #t p b) <: bare_parser (list t)
let rec parse_list_bare_consumed
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (Some? (parse_list_bare p b)))
(ensures (
let pb = parse_list_bare p b in (
Some? pb /\ (
let (Some (_, consumed)) = pb in
consumed == Seq.length b
))))
(decreases (Seq.length b))
= if Seq.length b = 0
then ()
else
let (Some (_, consumed1)) = p b in
let b' = Seq.slice b consumed1 (Seq.length b) in
parse_list_bare_consumed p b'
let parse_list_bare_consumes_all
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(consumes_all (parse_list_bare p))
= Classical.forall_intro (Classical.move_requires (parse_list_bare_consumed p))
val parse_list_bare_injective
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(ensures (injective (parse_list_bare p)))
inline_for_extraction
let parse_list_kind = | false | true | LowParse.Spec.List.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val parse_list_kind : LowParse.Spec.Base.parser_kind' | [] | LowParse.Spec.List.parse_list_kind | {
"file_name": "src/lowparse/LowParse.Spec.List.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | LowParse.Spec.Base.parser_kind' | {
"end_col": 49,
"end_line": 81,
"start_col": 4,
"start_line": 78
} |
|
Prims.Tot | val serialize_list_precond (k: parser_kind) : Tot bool | [
{
"abbrev": true,
"full_module": "FStar.Classical",
"short_module": "Classical"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let serialize_list_precond
(k: parser_kind)
: Tot bool
= k.parser_kind_subkind = Some ParserStrong &&
k.parser_kind_low > 0 | val serialize_list_precond (k: parser_kind) : Tot bool
let serialize_list_precond (k: parser_kind) : Tot bool = | false | null | false | k.parser_kind_subkind = Some ParserStrong && k.parser_kind_low > 0 | {
"checked_file": "LowParse.Spec.List.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.List.fsti"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"Prims.op_AmpAmp",
"Prims.op_Equality",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"Prims.op_GreaterThan",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"Prims.bool"
] | [] | module LowParse.Spec.List
include LowParse.Spec.Combinators // for seq_slice_append_l
module Seq = FStar.Seq
module L = FStar.List.Tot
module U32 = FStar.UInt32
module Classical = FStar.Classical
(* Parse a list, until there is nothing left to read. This parser will mostly fail EXCEPT if the whole size is known and the slice has been suitably truncated beforehand, or if the elements of the list all have a known constant size. *)
let rec parse_list_aux
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: GTot (option (list t * (consumed_length b)))
(decreases (Seq.length b))
= if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse_list_aux p (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
let parse_list_bare
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (bare_parser (list t))
= (fun b -> parse_list_aux #k #t p b) <: bare_parser (list t)
let rec parse_list_bare_consumed
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (Some? (parse_list_bare p b)))
(ensures (
let pb = parse_list_bare p b in (
Some? pb /\ (
let (Some (_, consumed)) = pb in
consumed == Seq.length b
))))
(decreases (Seq.length b))
= if Seq.length b = 0
then ()
else
let (Some (_, consumed1)) = p b in
let b' = Seq.slice b consumed1 (Seq.length b) in
parse_list_bare_consumed p b'
let parse_list_bare_consumes_all
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(consumes_all (parse_list_bare p))
= Classical.forall_intro (Classical.move_requires (parse_list_bare_consumed p))
val parse_list_bare_injective
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(ensures (injective (parse_list_bare p)))
inline_for_extraction
let parse_list_kind =
{
parser_kind_low = 0;
parser_kind_high = None;
parser_kind_metadata = None;
parser_kind_subkind = Some ParserConsumesAll;
}
val parse_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser parse_list_kind (list t))
val parse_list_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(parse (parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse (parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
))
val parse_list_eq'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (k.parser_kind_low > 0))
(ensures (parse (parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
begin match parse (parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
end
)))
val tot_parse_list
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
: Pure (tot_parser parse_list_kind (list t))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_list #k p) x
))
let tot_parse_list_eq
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(b: bytes)
: Lemma
(parse (tot_parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse (tot_parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
))
= parse_list_eq #k p b
let rec bare_serialize_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(x: list t)
: GTot bytes
= match x with
| [] -> Seq.empty
| a :: q -> Seq.append (s a) (bare_serialize_list p s q)
unfold
let serialize_list_precond
(k: parser_kind) | false | true | LowParse.Spec.List.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_list_precond (k: parser_kind) : Tot bool | [] | LowParse.Spec.List.serialize_list_precond | {
"file_name": "src/lowparse/LowParse.Spec.List.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | k: LowParse.Spec.Base.parser_kind -> Prims.bool | {
"end_col": 23,
"end_line": 182,
"start_col": 2,
"start_line": 181
} |
FStar.Pervasives.Lemma | val parse_list_bare_consumes_all (#k: parser_kind) (#t: Type) (p: parser k t)
: Lemma (consumes_all (parse_list_bare p)) | [
{
"abbrev": true,
"full_module": "FStar.Classical",
"short_module": "Classical"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_list_bare_consumes_all
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(consumes_all (parse_list_bare p))
= Classical.forall_intro (Classical.move_requires (parse_list_bare_consumed p)) | val parse_list_bare_consumes_all (#k: parser_kind) (#t: Type) (p: parser k t)
: Lemma (consumes_all (parse_list_bare p))
let parse_list_bare_consumes_all (#k: parser_kind) (#t: Type) (p: parser k t)
: Lemma (consumes_all (parse_list_bare p)) = | false | null | true | Classical.forall_intro (Classical.move_requires (parse_list_bare_consumed p)) | {
"checked_file": "LowParse.Spec.List.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.List.fsti"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Classical.forall_intro",
"LowParse.Bytes.bytes",
"Prims.l_imp",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"FStar.Pervasives.Native.tuple2",
"Prims.list",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.List.parse_list_bare",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"Prims.logical",
"FStar.Classical.move_requires",
"LowParse.Spec.List.parse_list_bare_consumed",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"LowParse.Spec.Base.consumes_all",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.List
include LowParse.Spec.Combinators // for seq_slice_append_l
module Seq = FStar.Seq
module L = FStar.List.Tot
module U32 = FStar.UInt32
module Classical = FStar.Classical
(* Parse a list, until there is nothing left to read. This parser will mostly fail EXCEPT if the whole size is known and the slice has been suitably truncated beforehand, or if the elements of the list all have a known constant size. *)
let rec parse_list_aux
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: GTot (option (list t * (consumed_length b)))
(decreases (Seq.length b))
= if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse_list_aux p (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
let parse_list_bare
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (bare_parser (list t))
= (fun b -> parse_list_aux #k #t p b) <: bare_parser (list t)
let rec parse_list_bare_consumed
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (Some? (parse_list_bare p b)))
(ensures (
let pb = parse_list_bare p b in (
Some? pb /\ (
let (Some (_, consumed)) = pb in
consumed == Seq.length b
))))
(decreases (Seq.length b))
= if Seq.length b = 0
then ()
else
let (Some (_, consumed1)) = p b in
let b' = Seq.slice b consumed1 (Seq.length b) in
parse_list_bare_consumed p b'
let parse_list_bare_consumes_all
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma | false | false | LowParse.Spec.List.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val parse_list_bare_consumes_all (#k: parser_kind) (#t: Type) (p: parser k t)
: Lemma (consumes_all (parse_list_bare p)) | [] | LowParse.Spec.List.parse_list_bare_consumes_all | {
"file_name": "src/lowparse/LowParse.Spec.List.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p: LowParse.Spec.Base.parser k t
-> FStar.Pervasives.Lemma
(ensures LowParse.Spec.Base.consumes_all (LowParse.Spec.List.parse_list_bare p)) | {
"end_col": 79,
"end_line": 66,
"start_col": 2,
"start_line": 66
} |
Prims.GTot | val bare_serialize_list (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x: list t)
: GTot bytes | [
{
"abbrev": true,
"full_module": "FStar.Classical",
"short_module": "Classical"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec bare_serialize_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(x: list t)
: GTot bytes
= match x with
| [] -> Seq.empty
| a :: q -> Seq.append (s a) (bare_serialize_list p s q) | val bare_serialize_list (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x: list t)
: GTot bytes
let rec bare_serialize_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(x: list t)
: GTot bytes = | false | null | false | match x with
| [] -> Seq.empty
| a :: q -> Seq.append (s a) (bare_serialize_list p s q) | {
"checked_file": "LowParse.Spec.List.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.List.fsti"
} | [
"sometrivial"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.list",
"FStar.Seq.Base.empty",
"LowParse.Bytes.byte",
"FStar.Seq.Base.append",
"LowParse.Spec.List.bare_serialize_list",
"LowParse.Bytes.bytes"
] | [] | module LowParse.Spec.List
include LowParse.Spec.Combinators // for seq_slice_append_l
module Seq = FStar.Seq
module L = FStar.List.Tot
module U32 = FStar.UInt32
module Classical = FStar.Classical
(* Parse a list, until there is nothing left to read. This parser will mostly fail EXCEPT if the whole size is known and the slice has been suitably truncated beforehand, or if the elements of the list all have a known constant size. *)
let rec parse_list_aux
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: GTot (option (list t * (consumed_length b)))
(decreases (Seq.length b))
= if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse_list_aux p (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
let parse_list_bare
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (bare_parser (list t))
= (fun b -> parse_list_aux #k #t p b) <: bare_parser (list t)
let rec parse_list_bare_consumed
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (Some? (parse_list_bare p b)))
(ensures (
let pb = parse_list_bare p b in (
Some? pb /\ (
let (Some (_, consumed)) = pb in
consumed == Seq.length b
))))
(decreases (Seq.length b))
= if Seq.length b = 0
then ()
else
let (Some (_, consumed1)) = p b in
let b' = Seq.slice b consumed1 (Seq.length b) in
parse_list_bare_consumed p b'
let parse_list_bare_consumes_all
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(consumes_all (parse_list_bare p))
= Classical.forall_intro (Classical.move_requires (parse_list_bare_consumed p))
val parse_list_bare_injective
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(ensures (injective (parse_list_bare p)))
inline_for_extraction
let parse_list_kind =
{
parser_kind_low = 0;
parser_kind_high = None;
parser_kind_metadata = None;
parser_kind_subkind = Some ParserConsumesAll;
}
val parse_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser parse_list_kind (list t))
val parse_list_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(parse (parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse (parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
))
val parse_list_eq'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (k.parser_kind_low > 0))
(ensures (parse (parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
begin match parse (parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
end
)))
val tot_parse_list
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
: Pure (tot_parser parse_list_kind (list t))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_list #k p) x
))
let tot_parse_list_eq
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(b: bytes)
: Lemma
(parse (tot_parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse (tot_parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
))
= parse_list_eq #k p b
let rec bare_serialize_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(x: list t) | false | false | LowParse.Spec.List.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val bare_serialize_list (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x: list t)
: GTot bytes | [
"recursion"
] | LowParse.Spec.List.bare_serialize_list | {
"file_name": "src/lowparse/LowParse.Spec.List.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p: LowParse.Spec.Base.parser k t -> s: LowParse.Spec.Base.serializer p -> x: Prims.list t
-> Prims.GTot LowParse.Bytes.bytes | {
"end_col": 58,
"end_line": 175,
"start_col": 2,
"start_line": 173
} |
Prims.GTot | val parse_list_aux (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes)
: GTot (option (list t * (consumed_length b))) (decreases (Seq.length b)) | [
{
"abbrev": true,
"full_module": "FStar.Classical",
"short_module": "Classical"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec parse_list_aux
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: GTot (option (list t * (consumed_length b)))
(decreases (Seq.length b))
= if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse_list_aux p (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None | val parse_list_aux (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes)
: GTot (option (list t * (consumed_length b))) (decreases (Seq.length b))
let rec parse_list_aux (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes)
: GTot (option (list t * (consumed_length b))) (decreases (Seq.length b)) = | false | null | false | if Seq.length b = 0
then Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None
else
match parse_list_aux p (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None | {
"checked_file": "LowParse.Spec.List.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.List.fsti"
} | [
"sometrivial",
""
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Bytes.bytes",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"Prims.list",
"LowParse.Spec.Base.consumed_length",
"FStar.Pervasives.Native.Mktuple2",
"Prims.Nil",
"Prims.bool",
"LowParse.Spec.Base.parse",
"FStar.Pervasives.Native.None",
"LowParse.Spec.List.parse_list_aux",
"FStar.Seq.Base.slice",
"Prims.Cons",
"Prims.op_Addition",
"FStar.Pervasives.Native.option"
] | [] | module LowParse.Spec.List
include LowParse.Spec.Combinators // for seq_slice_append_l
module Seq = FStar.Seq
module L = FStar.List.Tot
module U32 = FStar.UInt32
module Classical = FStar.Classical
(* Parse a list, until there is nothing left to read. This parser will mostly fail EXCEPT if the whole size is known and the slice has been suitably truncated beforehand, or if the elements of the list all have a known constant size. *)
let rec parse_list_aux
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: GTot (option (list t * (consumed_length b))) | false | false | LowParse.Spec.List.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val parse_list_aux (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes)
: GTot (option (list t * (consumed_length b))) (decreases (Seq.length b)) | [
"recursion"
] | LowParse.Spec.List.parse_list_aux | {
"file_name": "src/lowparse/LowParse.Spec.List.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p: LowParse.Spec.Base.parser k t -> b: LowParse.Bytes.bytes
-> Prims.GTot
(FStar.Pervasives.Native.option (Prims.list t * LowParse.Spec.Base.consumed_length b)) | {
"end_col": 12,
"end_line": 30,
"start_col": 2,
"start_line": 18
} |
FStar.Pervasives.Lemma | val parse_list_bare_consumed (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes)
: Lemma (requires (Some? (parse_list_bare p b)))
(ensures
(let pb = parse_list_bare p b in
(Some? pb /\
(let Some (_, consumed) = pb in
consumed == Seq.length b))))
(decreases (Seq.length b)) | [
{
"abbrev": true,
"full_module": "FStar.Classical",
"short_module": "Classical"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec parse_list_bare_consumed
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (Some? (parse_list_bare p b)))
(ensures (
let pb = parse_list_bare p b in (
Some? pb /\ (
let (Some (_, consumed)) = pb in
consumed == Seq.length b
))))
(decreases (Seq.length b))
= if Seq.length b = 0
then ()
else
let (Some (_, consumed1)) = p b in
let b' = Seq.slice b consumed1 (Seq.length b) in
parse_list_bare_consumed p b' | val parse_list_bare_consumed (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes)
: Lemma (requires (Some? (parse_list_bare p b)))
(ensures
(let pb = parse_list_bare p b in
(Some? pb /\
(let Some (_, consumed) = pb in
consumed == Seq.length b))))
(decreases (Seq.length b))
let rec parse_list_bare_consumed (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes)
: Lemma (requires (Some? (parse_list_bare p b)))
(ensures
(let pb = parse_list_bare p b in
(Some? pb /\
(let Some (_, consumed) = pb in
consumed == Seq.length b))))
(decreases (Seq.length b)) = | false | null | true | if Seq.length b = 0
then ()
else
let Some (_, consumed1) = p b in
let b' = Seq.slice b consumed1 (Seq.length b) in
parse_list_bare_consumed p b' | {
"checked_file": "LowParse.Spec.List.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.List.fsti"
} | [
"lemma",
""
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Bytes.bytes",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"Prims.bool",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.List.parse_list_bare_consumed",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.slice",
"Prims.unit",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"Prims.list",
"LowParse.Spec.List.parse_list_bare",
"Prims.squash",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"Prims.logical",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.List
include LowParse.Spec.Combinators // for seq_slice_append_l
module Seq = FStar.Seq
module L = FStar.List.Tot
module U32 = FStar.UInt32
module Classical = FStar.Classical
(* Parse a list, until there is nothing left to read. This parser will mostly fail EXCEPT if the whole size is known and the slice has been suitably truncated beforehand, or if the elements of the list all have a known constant size. *)
let rec parse_list_aux
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: GTot (option (list t * (consumed_length b)))
(decreases (Seq.length b))
= if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse_list_aux p (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
let parse_list_bare
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (bare_parser (list t))
= (fun b -> parse_list_aux #k #t p b) <: bare_parser (list t)
let rec parse_list_bare_consumed
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (Some? (parse_list_bare p b)))
(ensures (
let pb = parse_list_bare p b in (
Some? pb /\ (
let (Some (_, consumed)) = pb in
consumed == Seq.length b
)))) | false | false | LowParse.Spec.List.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val parse_list_bare_consumed (#k: parser_kind) (#t: Type) (p: parser k t) (b: bytes)
: Lemma (requires (Some? (parse_list_bare p b)))
(ensures
(let pb = parse_list_bare p b in
(Some? pb /\
(let Some (_, consumed) = pb in
consumed == Seq.length b))))
(decreases (Seq.length b)) | [
"recursion"
] | LowParse.Spec.List.parse_list_bare_consumed | {
"file_name": "src/lowparse/LowParse.Spec.List.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p: LowParse.Spec.Base.parser k t -> b: LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma (requires Some? (LowParse.Spec.List.parse_list_bare p b))
(ensures
(let pb = LowParse.Spec.List.parse_list_bare p b in
Some? pb /\
(let _ = pb in
(let FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ _ consumed)
=
_
in
consumed == FStar.Seq.Base.length b)
<:
Prims.logical)))
(decreases FStar.Seq.Base.length b) | {
"end_col": 33,
"end_line": 58,
"start_col": 2,
"start_line": 53
} |
FStar.Pervasives.Lemma | val parse_list_total_constant_size
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(elem_count: nat)
(x: bytes)
: Lemma
(requires
(serialize_list_precond k /\ k.parser_kind_high == Some k.parser_kind_low /\
k.parser_kind_metadata == Some ParserKindMetadataTotal /\
Seq.length x == elem_count `Prims.op_Multiply` k.parser_kind_low))
(ensures (Some? (parse (parse_list p) x)))
(decreases elem_count) | [
{
"abbrev": true,
"full_module": "FStar.Classical",
"short_module": "Classical"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec parse_list_total_constant_size
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(elem_count: nat)
(x: bytes)
: Lemma
(requires (
serialize_list_precond k /\
k.parser_kind_high == Some k.parser_kind_low /\
k.parser_kind_metadata == Some ParserKindMetadataTotal /\
Seq.length x == elem_count `Prims.op_Multiply` k.parser_kind_low
))
(ensures (
Some? (parse (parse_list p) x)
))
(decreases elem_count)
= parse_list_eq p x;
if elem_count = 0
then ()
else begin
assert (Seq.length x == k.parser_kind_low + ((elem_count - 1) `Prims.op_Multiply` k.parser_kind_low));
parser_kind_prop_equiv k p;
assert (Some? (parse p x));
let Some (_, len) = parse p x in
assert (len == k.parser_kind_low);
parse_list_total_constant_size p (elem_count - 1) (Seq.slice x len (Seq.length x))
end | val parse_list_total_constant_size
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(elem_count: nat)
(x: bytes)
: Lemma
(requires
(serialize_list_precond k /\ k.parser_kind_high == Some k.parser_kind_low /\
k.parser_kind_metadata == Some ParserKindMetadataTotal /\
Seq.length x == elem_count `Prims.op_Multiply` k.parser_kind_low))
(ensures (Some? (parse (parse_list p) x)))
(decreases elem_count)
let rec parse_list_total_constant_size
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(elem_count: nat)
(x: bytes)
: Lemma
(requires
(serialize_list_precond k /\ k.parser_kind_high == Some k.parser_kind_low /\
k.parser_kind_metadata == Some ParserKindMetadataTotal /\
Seq.length x == elem_count `Prims.op_Multiply` k.parser_kind_low))
(ensures (Some? (parse (parse_list p) x)))
(decreases elem_count) = | false | null | true | parse_list_eq p x;
if elem_count = 0
then ()
else
(assert (Seq.length x ==
k.parser_kind_low + ((elem_count - 1) `Prims.op_Multiply` k.parser_kind_low));
parser_kind_prop_equiv k p;
assert (Some? (parse p x));
let Some (_, len) = parse p x in
assert (len == k.parser_kind_low);
parse_list_total_constant_size p (elem_count - 1) (Seq.slice x len (Seq.length x))) | {
"checked_file": "LowParse.Spec.List.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.List.fsti"
} | [
"lemma",
""
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"Prims.nat",
"LowParse.Bytes.bytes",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.List.parse_list_total_constant_size",
"Prims.op_Subtraction",
"FStar.Seq.Base.slice",
"LowParse.Bytes.byte",
"FStar.Seq.Base.length",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.parse",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"Prims.op_Addition",
"Prims.op_Multiply",
"LowParse.Spec.List.parse_list_eq",
"Prims.l_and",
"LowParse.Spec.List.serialize_list_precond",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_high",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.parser_kind_metadata_some",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_metadata",
"LowParse.Spec.Base.ParserKindMetadataTotal",
"Prims.squash",
"Prims.list",
"LowParse.Spec.List.parse_list",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.List
include LowParse.Spec.Combinators // for seq_slice_append_l
module Seq = FStar.Seq
module L = FStar.List.Tot
module U32 = FStar.UInt32
module Classical = FStar.Classical
(* Parse a list, until there is nothing left to read. This parser will mostly fail EXCEPT if the whole size is known and the slice has been suitably truncated beforehand, or if the elements of the list all have a known constant size. *)
let rec parse_list_aux
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: GTot (option (list t * (consumed_length b)))
(decreases (Seq.length b))
= if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse_list_aux p (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
let parse_list_bare
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (bare_parser (list t))
= (fun b -> parse_list_aux #k #t p b) <: bare_parser (list t)
let rec parse_list_bare_consumed
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (Some? (parse_list_bare p b)))
(ensures (
let pb = parse_list_bare p b in (
Some? pb /\ (
let (Some (_, consumed)) = pb in
consumed == Seq.length b
))))
(decreases (Seq.length b))
= if Seq.length b = 0
then ()
else
let (Some (_, consumed1)) = p b in
let b' = Seq.slice b consumed1 (Seq.length b) in
parse_list_bare_consumed p b'
let parse_list_bare_consumes_all
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(consumes_all (parse_list_bare p))
= Classical.forall_intro (Classical.move_requires (parse_list_bare_consumed p))
val parse_list_bare_injective
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(ensures (injective (parse_list_bare p)))
inline_for_extraction
let parse_list_kind =
{
parser_kind_low = 0;
parser_kind_high = None;
parser_kind_metadata = None;
parser_kind_subkind = Some ParserConsumesAll;
}
val parse_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser parse_list_kind (list t))
val parse_list_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(parse (parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse (parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
))
val parse_list_eq'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (k.parser_kind_low > 0))
(ensures (parse (parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
begin match parse (parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
end
)))
val tot_parse_list
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
: Pure (tot_parser parse_list_kind (list t))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_list #k p) x
))
let tot_parse_list_eq
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(b: bytes)
: Lemma
(parse (tot_parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse (tot_parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
))
= parse_list_eq #k p b
let rec bare_serialize_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(x: list t)
: GTot bytes
= match x with
| [] -> Seq.empty
| a :: q -> Seq.append (s a) (bare_serialize_list p s q)
unfold
let serialize_list_precond
(k: parser_kind)
: Tot bool
= k.parser_kind_subkind = Some ParserStrong &&
k.parser_kind_low > 0
val bare_serialize_list_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
: Lemma
(requires (serialize_list_precond k))
(ensures (serializer_correct (parse_list p) (bare_serialize_list p s)))
val serialize_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
: Pure (serializer (parse_list p))
(requires (
serialize_list_precond k
))
(ensures (fun _ -> True))
val serialize_list_nil
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
: Lemma
(requires (
serialize_list_precond k
))
(ensures (serialize (serialize_list p s) [] == Seq.empty))
val serialize_list_cons
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(a: t)
(q: list t)
: Lemma
(requires (
serialize_list_precond k
))
(ensures (
serialize (serialize_list p s) (a :: q) == Seq.append (serialize s a) (serialize (serialize_list p s) q)
))
val serialize_list_singleton
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(a: t)
: Lemma
(requires (serialize_list_precond k))
(ensures (serialize (serialize_list p s) [a] == serialize s a))
val serialize_list_append
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(l1 l2: list t)
: Lemma
(requires (serialize_list_precond k))
(ensures (serialize (serialize_list p s) (L.append l1 l2) == Seq.append (serialize (serialize_list p s) l1) (serialize (serialize_list p s) l2)))
let rec serialize_list_eq_parser_fail
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 })
(l1 l2: list t)
(b1 b2: bytes)
: Lemma
(requires (
serialize (serialize_list _ s) l1 `Seq.append` b1 == serialize (serialize_list _ s) l2 `Seq.append` b2 /\
parse p b1 == None /\
parse p b2 == None
))
(ensures (l1 == l2 /\ b1 == b2))
(decreases (L.length l1))
= serialize_list_nil _ s;
assert (b1 `Seq.equal` (Seq.append Seq.empty b1));
assert (b2 `Seq.equal` (Seq.append Seq.empty b2));
if L.length l2 < L.length l1
then serialize_list_eq_parser_fail s l2 l1 b2 b1
else match l1, l2 with
| [], [] -> ()
| x1 :: l1', x2 :: l2' ->
serialize_list_cons _ s x1 l1' ;
serialize_list_cons _ s x2 l2' ;
Seq.append_assoc (serialize s x1) (serialize (serialize_list _ s) l1') b1;
Seq.append_assoc (serialize s x2) (serialize (serialize_list _ s) l2') b2;
serialize_strong_prefix s x1 x2 (serialize (serialize_list _ s) l1' `Seq.append` b1) (serialize (serialize_list _ s) l2' `Seq.append` b2);
serialize_list_eq_parser_fail s l1' l2' b1 b2
| [], x2 :: l2' ->
serialize_list_cons _ s x2 l2' ;
parse_strong_prefix p (serialize s x2) b1
let serialize_list_cons_upd
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires (
serialize_list_precond k /\
Seq.length (serialize s y) == Seq.length (serialize s x)
))
(ensures (
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (x :: l2) in
Seq.length sl == Seq.length sx + ln2 /\
serialize (serialize_list _ s) (y :: l2) == seq_upd_seq sl 0 (serialize s y)
))
= serialize_list_cons _ s x l2;
serialize_list_cons _ s y l2;
let sl = serialize (serialize_list _ s) (x :: l2) in
seq_upd_seq_left sl (serialize s y);
let ln = Seq.length (serialize s x) in
Seq.lemma_split sl ln;
Seq.lemma_append_inj (Seq.slice sl 0 ln) (Seq.slice sl ln (Seq.length sl)) (serialize s x) (serialize (serialize_list _ s) l2)
#set-options "--z3rlimit 32"
let serialize_list_upd
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires (
serialize_list_precond k /\
Seq.length (serialize s y) == Seq.length (serialize s x)
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_seq sl ln1 (serialize s y)
))
(decreases (L.length l1))
= serialize_list_append _ s l1 (y :: l2);
assert (serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == serialize (serialize_list _ s) l1 `Seq.append` serialize (serialize_list _ s) (y :: l2));
serialize_list_cons_upd s x l2 y;
assert (serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == serialize (serialize_list _ s) l1 `Seq.append` seq_upd_seq (serialize (serialize_list _ s) (x :: l2)) 0 (serialize s y));
seq_append_seq_upd_seq_l (serialize (serialize_list _ s) (x :: l2)) 0 (serialize s y) (serialize (serialize_list _ s) l1);
assert (serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_seq (serialize (serialize_list _ s) l1 `Seq.append` serialize (serialize_list _ s) (x :: l2)) (Seq.length (serialize (serialize_list _ s) l1) + 0) (serialize s y));
serialize_list_append _ s l1 (x :: l2)
let serialize_list_upd_bw
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires (
serialize_list_precond k /\
Seq.length (serialize s y) == Seq.length (serialize s x)
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_bw_seq sl ln2 (serialize s y)
))
(decreases (L.length l1))
= serialize_list_upd s l1 x l2 y
#set-options "--z3rlimit 64"
let serialize_list_upd_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
serialize_list_precond k /\
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_seq sx i' s'
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
ln1 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_seq sl (ln1 + i') s'
))
= serialize_list_upd s l1 x l2 y;
serialize_list_append _ s l1 (x :: l2);
let sl1 = serialize (serialize_list _ s) l1 in
let ln1 = Seq.length sl1 in
let sxl2 = serialize (serialize_list _ s) (x :: l2) in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.lemma_split sl ln1;
Seq.lemma_append_inj (Seq.slice sl 0 ln1) (Seq.slice sl ln1 (Seq.length sl)) sl1 sxl2;
let sx = serialize s x in
let sl2 = serialize (serialize_list _ s) l2 in
let lx = Seq.length sx in
serialize_list_cons _ s x l2;
Seq.lemma_split sxl2 lx;
Seq.lemma_append_inj (Seq.slice sxl2 0 lx) (Seq.slice sxl2 lx (Seq.length sxl2)) sx sl2;
Seq.slice_slice sl ln1 (Seq.length sl) 0 lx;
assert (sx == Seq.slice sl ln1 (ln1 + lx));
seq_upd_seq_seq_upd_seq_slice sl ln1 (ln1 + lx) i' s';
()
let serialize_list_upd_bw_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
serialize_list_precond k /\
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_bw_seq sx i' s'
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
ln2 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_bw_seq sl (ln2 + i') s'
))
= let sx = serialize s x in
let j' = Seq.length sx - i' - Seq.length s' in
serialize_list_upd_chain s l1 x l2 y j' s'
val serialize_list_cons_upd_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
(l2: list t)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
serialize_list_precond k /\
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_seq sx i' s'
))
(ensures (
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (x :: l2) in
Seq.length sl == Seq.length sx + ln2 /\
i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (y :: l2) == seq_upd_seq sl i' s'
))
let serialize_list_cons_upd_bw_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
(l2: list t)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
serialize_list_precond k /\
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_bw_seq sx i' s'
))
(ensures (
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (x :: l2) in
Seq.length sl == Seq.length sx + ln2 /\
ln2 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (y :: l2) == seq_upd_bw_seq sl (ln2 + i') s'
))
= let j' = Seq.length (serialize s x) - i' - Seq.length s' in
serialize_list_cons_upd_chain s x l2 y j' s'
val serialize_list_snoc_upd_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
serialize_list_precond k /\
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_seq sx i' s'
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` [x]) in
Seq.length sl == ln1 + Seq.length sx /\
ln1 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` [y]) == seq_upd_seq sl (ln1 + i') s'
))
let serialize_list_snoc_upd_bw_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
serialize_list_precond k /\
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_bw_seq sx i' s'
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` [x]) in
Seq.length sl == ln1 + Seq.length sx /\
i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` [y]) == seq_upd_bw_seq sl i' s'
))
= let j' = Seq.length (serialize s x) - i' - Seq.length s' in
serialize_list_snoc_upd_chain s l1 x y j' s'
val list_length_constant_size_parser_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (
k.parser_kind_high == Some k.parser_kind_low /\
Some? (parse (parse_list p) b)
))
(ensures (
let pb = parse (parse_list p) b in
Some? pb /\ (
let (Some (l, _)) = pb in
FStar.Mul.op_Star (L.length l) k.parser_kind_low == Seq.length b
)))
(decreases (Seq.length b))
let rec parse_list_total_constant_size
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(elem_count: nat)
(x: bytes)
: Lemma
(requires (
serialize_list_precond k /\
k.parser_kind_high == Some k.parser_kind_low /\
k.parser_kind_metadata == Some ParserKindMetadataTotal /\
Seq.length x == elem_count `Prims.op_Multiply` k.parser_kind_low
))
(ensures (
Some? (parse (parse_list p) x)
)) | false | false | LowParse.Spec.List.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 64,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val parse_list_total_constant_size
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(elem_count: nat)
(x: bytes)
: Lemma
(requires
(serialize_list_precond k /\ k.parser_kind_high == Some k.parser_kind_low /\
k.parser_kind_metadata == Some ParserKindMetadataTotal /\
Seq.length x == elem_count `Prims.op_Multiply` k.parser_kind_low))
(ensures (Some? (parse (parse_list p) x)))
(decreases elem_count) | [
"recursion"
] | LowParse.Spec.List.parse_list_total_constant_size | {
"file_name": "src/lowparse/LowParse.Spec.List.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p: LowParse.Spec.Base.parser k t -> elem_count: Prims.nat -> x: LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
LowParse.Spec.List.serialize_list_precond k /\
Mkparser_kind'?.parser_kind_high k ==
FStar.Pervasives.Native.Some (Mkparser_kind'?.parser_kind_low k) /\
Mkparser_kind'?.parser_kind_metadata k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserKindMetadataTotal /\
FStar.Seq.Base.length x == elem_count * Mkparser_kind'?.parser_kind_low k)
(ensures Some? (LowParse.Spec.Base.parse (LowParse.Spec.List.parse_list p) x))
(decreases elem_count) | {
"end_col": 5,
"end_line": 602,
"start_col": 2,
"start_line": 592
} |
FStar.Pervasives.Lemma | val serialize_list_cons_upd
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires
(serialize_list_precond k /\ Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures
(let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (x :: l2) in
Seq.length sl == Seq.length sx + ln2 /\
serialize (serialize_list _ s) (y :: l2) == seq_upd_seq sl 0 (serialize s y))) | [
{
"abbrev": true,
"full_module": "FStar.Classical",
"short_module": "Classical"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let serialize_list_cons_upd
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires (
serialize_list_precond k /\
Seq.length (serialize s y) == Seq.length (serialize s x)
))
(ensures (
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (x :: l2) in
Seq.length sl == Seq.length sx + ln2 /\
serialize (serialize_list _ s) (y :: l2) == seq_upd_seq sl 0 (serialize s y)
))
= serialize_list_cons _ s x l2;
serialize_list_cons _ s y l2;
let sl = serialize (serialize_list _ s) (x :: l2) in
seq_upd_seq_left sl (serialize s y);
let ln = Seq.length (serialize s x) in
Seq.lemma_split sl ln;
Seq.lemma_append_inj (Seq.slice sl 0 ln) (Seq.slice sl ln (Seq.length sl)) (serialize s x) (serialize (serialize_list _ s) l2) | val serialize_list_cons_upd
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires
(serialize_list_precond k /\ Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures
(let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (x :: l2) in
Seq.length sl == Seq.length sx + ln2 /\
serialize (serialize_list _ s) (y :: l2) == seq_upd_seq sl 0 (serialize s y)))
let serialize_list_cons_upd
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires
(serialize_list_precond k /\ Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures
(let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (x :: l2) in
Seq.length sl == Seq.length sx + ln2 /\
serialize (serialize_list _ s) (y :: l2) == seq_upd_seq sl 0 (serialize s y))) = | false | null | true | serialize_list_cons _ s x l2;
serialize_list_cons _ s y l2;
let sl = serialize (serialize_list _ s) (x :: l2) in
seq_upd_seq_left sl (serialize s y);
let ln = Seq.length (serialize s x) in
Seq.lemma_split sl ln;
Seq.lemma_append_inj (Seq.slice sl 0 ln)
(Seq.slice sl ln (Seq.length sl))
(serialize s x)
(serialize (serialize_list _ s) l2) | {
"checked_file": "LowParse.Spec.List.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.List.fsti"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.list",
"FStar.Seq.Properties.lemma_append_inj",
"LowParse.Bytes.byte",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.length",
"LowParse.Spec.Base.serialize",
"LowParse.Spec.List.parse_list_kind",
"LowParse.Spec.List.parse_list",
"LowParse.Spec.List.serialize_list",
"Prims.unit",
"FStar.Seq.Properties.lemma_split",
"Prims.nat",
"LowParse.Spec.Base.seq_upd_seq_left",
"LowParse.Bytes.bytes",
"Prims.Cons",
"LowParse.Spec.List.serialize_list_cons",
"Prims.l_and",
"Prims.b2t",
"LowParse.Spec.List.serialize_list_precond",
"Prims.eq2",
"Prims.squash",
"Prims.int",
"Prims.op_Addition",
"FStar.Seq.Base.seq",
"LowParse.Spec.Base.seq_upd_seq",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.List
include LowParse.Spec.Combinators // for seq_slice_append_l
module Seq = FStar.Seq
module L = FStar.List.Tot
module U32 = FStar.UInt32
module Classical = FStar.Classical
(* Parse a list, until there is nothing left to read. This parser will mostly fail EXCEPT if the whole size is known and the slice has been suitably truncated beforehand, or if the elements of the list all have a known constant size. *)
let rec parse_list_aux
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: GTot (option (list t * (consumed_length b)))
(decreases (Seq.length b))
= if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse_list_aux p (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
let parse_list_bare
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (bare_parser (list t))
= (fun b -> parse_list_aux #k #t p b) <: bare_parser (list t)
let rec parse_list_bare_consumed
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (Some? (parse_list_bare p b)))
(ensures (
let pb = parse_list_bare p b in (
Some? pb /\ (
let (Some (_, consumed)) = pb in
consumed == Seq.length b
))))
(decreases (Seq.length b))
= if Seq.length b = 0
then ()
else
let (Some (_, consumed1)) = p b in
let b' = Seq.slice b consumed1 (Seq.length b) in
parse_list_bare_consumed p b'
let parse_list_bare_consumes_all
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(consumes_all (parse_list_bare p))
= Classical.forall_intro (Classical.move_requires (parse_list_bare_consumed p))
val parse_list_bare_injective
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(ensures (injective (parse_list_bare p)))
inline_for_extraction
let parse_list_kind =
{
parser_kind_low = 0;
parser_kind_high = None;
parser_kind_metadata = None;
parser_kind_subkind = Some ParserConsumesAll;
}
val parse_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser parse_list_kind (list t))
val parse_list_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(parse (parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse (parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
))
val parse_list_eq'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (k.parser_kind_low > 0))
(ensures (parse (parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
begin match parse (parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
end
)))
val tot_parse_list
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
: Pure (tot_parser parse_list_kind (list t))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_list #k p) x
))
let tot_parse_list_eq
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(b: bytes)
: Lemma
(parse (tot_parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse (tot_parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
))
= parse_list_eq #k p b
let rec bare_serialize_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(x: list t)
: GTot bytes
= match x with
| [] -> Seq.empty
| a :: q -> Seq.append (s a) (bare_serialize_list p s q)
unfold
let serialize_list_precond
(k: parser_kind)
: Tot bool
= k.parser_kind_subkind = Some ParserStrong &&
k.parser_kind_low > 0
val bare_serialize_list_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
: Lemma
(requires (serialize_list_precond k))
(ensures (serializer_correct (parse_list p) (bare_serialize_list p s)))
val serialize_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
: Pure (serializer (parse_list p))
(requires (
serialize_list_precond k
))
(ensures (fun _ -> True))
val serialize_list_nil
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
: Lemma
(requires (
serialize_list_precond k
))
(ensures (serialize (serialize_list p s) [] == Seq.empty))
val serialize_list_cons
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(a: t)
(q: list t)
: Lemma
(requires (
serialize_list_precond k
))
(ensures (
serialize (serialize_list p s) (a :: q) == Seq.append (serialize s a) (serialize (serialize_list p s) q)
))
val serialize_list_singleton
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(a: t)
: Lemma
(requires (serialize_list_precond k))
(ensures (serialize (serialize_list p s) [a] == serialize s a))
val serialize_list_append
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(l1 l2: list t)
: Lemma
(requires (serialize_list_precond k))
(ensures (serialize (serialize_list p s) (L.append l1 l2) == Seq.append (serialize (serialize_list p s) l1) (serialize (serialize_list p s) l2)))
let rec serialize_list_eq_parser_fail
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 })
(l1 l2: list t)
(b1 b2: bytes)
: Lemma
(requires (
serialize (serialize_list _ s) l1 `Seq.append` b1 == serialize (serialize_list _ s) l2 `Seq.append` b2 /\
parse p b1 == None /\
parse p b2 == None
))
(ensures (l1 == l2 /\ b1 == b2))
(decreases (L.length l1))
= serialize_list_nil _ s;
assert (b1 `Seq.equal` (Seq.append Seq.empty b1));
assert (b2 `Seq.equal` (Seq.append Seq.empty b2));
if L.length l2 < L.length l1
then serialize_list_eq_parser_fail s l2 l1 b2 b1
else match l1, l2 with
| [], [] -> ()
| x1 :: l1', x2 :: l2' ->
serialize_list_cons _ s x1 l1' ;
serialize_list_cons _ s x2 l2' ;
Seq.append_assoc (serialize s x1) (serialize (serialize_list _ s) l1') b1;
Seq.append_assoc (serialize s x2) (serialize (serialize_list _ s) l2') b2;
serialize_strong_prefix s x1 x2 (serialize (serialize_list _ s) l1' `Seq.append` b1) (serialize (serialize_list _ s) l2' `Seq.append` b2);
serialize_list_eq_parser_fail s l1' l2' b1 b2
| [], x2 :: l2' ->
serialize_list_cons _ s x2 l2' ;
parse_strong_prefix p (serialize s x2) b1
let serialize_list_cons_upd
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires (
serialize_list_precond k /\
Seq.length (serialize s y) == Seq.length (serialize s x)
))
(ensures (
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (x :: l2) in
Seq.length sl == Seq.length sx + ln2 /\
serialize (serialize_list _ s) (y :: l2) == seq_upd_seq sl 0 (serialize s y) | false | false | LowParse.Spec.List.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_list_cons_upd
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires
(serialize_list_precond k /\ Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures
(let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (x :: l2) in
Seq.length sl == Seq.length sx + ln2 /\
serialize (serialize_list _ s) (y :: l2) == seq_upd_seq sl 0 (serialize s y))) | [] | LowParse.Spec.List.serialize_list_cons_upd | {
"file_name": "src/lowparse/LowParse.Spec.List.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | s: LowParse.Spec.Base.serializer p -> x: t -> l2: Prims.list t -> y: t
-> FStar.Pervasives.Lemma
(requires
LowParse.Spec.List.serialize_list_precond k /\
FStar.Seq.Base.length (LowParse.Spec.Base.serialize s y) ==
FStar.Seq.Base.length (LowParse.Spec.Base.serialize s x))
(ensures
(let ln2 =
FStar.Seq.Base.length (LowParse.Spec.Base.serialize (LowParse.Spec.List.serialize_list p
s)
l2)
in
let sx = LowParse.Spec.Base.serialize s x in
let sl = LowParse.Spec.Base.serialize (LowParse.Spec.List.serialize_list p s) (x :: l2) in
FStar.Seq.Base.length sl == FStar.Seq.Base.length sx + ln2 /\
LowParse.Spec.Base.serialize (LowParse.Spec.List.serialize_list p s) (y :: l2) ==
LowParse.Spec.Base.seq_upd_seq sl 0 (LowParse.Spec.Base.serialize s y))) | {
"end_col": 128,
"end_line": 309,
"start_col": 2,
"start_line": 303
} |
FStar.Pervasives.Lemma | val serialize_list_upd_bw
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires
(serialize_list_precond k /\ Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures
(let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) ==
seq_upd_bw_seq sl ln2 (serialize s y)))
(decreases (L.length l1)) | [
{
"abbrev": true,
"full_module": "FStar.Classical",
"short_module": "Classical"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let serialize_list_upd_bw
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires (
serialize_list_precond k /\
Seq.length (serialize s y) == Seq.length (serialize s x)
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_bw_seq sl ln2 (serialize s y)
))
(decreases (L.length l1))
= serialize_list_upd s l1 x l2 y | val serialize_list_upd_bw
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires
(serialize_list_precond k /\ Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures
(let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) ==
seq_upd_bw_seq sl ln2 (serialize s y)))
(decreases (L.length l1))
let serialize_list_upd_bw
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires
(serialize_list_precond k /\ Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures
(let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) ==
seq_upd_bw_seq sl ln2 (serialize s y)))
(decreases (L.length l1)) = | false | null | true | serialize_list_upd s l1 x l2 y | {
"checked_file": "LowParse.Spec.List.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.List.fsti"
} | [
"lemma",
""
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.list",
"LowParse.Spec.List.serialize_list_upd",
"Prims.unit",
"FStar.List.Tot.Base.length",
"Prims.l_and",
"Prims.b2t",
"LowParse.Spec.List.serialize_list_precond",
"Prims.eq2",
"Prims.nat",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.serialize",
"Prims.squash",
"Prims.int",
"Prims.op_Addition",
"FStar.Seq.Base.seq",
"LowParse.Spec.List.parse_list_kind",
"LowParse.Spec.List.parse_list",
"LowParse.Spec.List.serialize_list",
"FStar.List.Tot.Base.append",
"Prims.Cons",
"LowParse.Spec.Base.seq_upd_bw_seq",
"LowParse.Bytes.bytes",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.List
include LowParse.Spec.Combinators // for seq_slice_append_l
module Seq = FStar.Seq
module L = FStar.List.Tot
module U32 = FStar.UInt32
module Classical = FStar.Classical
(* Parse a list, until there is nothing left to read. This parser will mostly fail EXCEPT if the whole size is known and the slice has been suitably truncated beforehand, or if the elements of the list all have a known constant size. *)
let rec parse_list_aux
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: GTot (option (list t * (consumed_length b)))
(decreases (Seq.length b))
= if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse_list_aux p (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
let parse_list_bare
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (bare_parser (list t))
= (fun b -> parse_list_aux #k #t p b) <: bare_parser (list t)
let rec parse_list_bare_consumed
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (Some? (parse_list_bare p b)))
(ensures (
let pb = parse_list_bare p b in (
Some? pb /\ (
let (Some (_, consumed)) = pb in
consumed == Seq.length b
))))
(decreases (Seq.length b))
= if Seq.length b = 0
then ()
else
let (Some (_, consumed1)) = p b in
let b' = Seq.slice b consumed1 (Seq.length b) in
parse_list_bare_consumed p b'
let parse_list_bare_consumes_all
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(consumes_all (parse_list_bare p))
= Classical.forall_intro (Classical.move_requires (parse_list_bare_consumed p))
val parse_list_bare_injective
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(ensures (injective (parse_list_bare p)))
inline_for_extraction
let parse_list_kind =
{
parser_kind_low = 0;
parser_kind_high = None;
parser_kind_metadata = None;
parser_kind_subkind = Some ParserConsumesAll;
}
val parse_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser parse_list_kind (list t))
val parse_list_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(parse (parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse (parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
))
val parse_list_eq'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (k.parser_kind_low > 0))
(ensures (parse (parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
begin match parse (parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
end
)))
val tot_parse_list
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
: Pure (tot_parser parse_list_kind (list t))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_list #k p) x
))
let tot_parse_list_eq
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(b: bytes)
: Lemma
(parse (tot_parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse (tot_parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
))
= parse_list_eq #k p b
let rec bare_serialize_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(x: list t)
: GTot bytes
= match x with
| [] -> Seq.empty
| a :: q -> Seq.append (s a) (bare_serialize_list p s q)
unfold
let serialize_list_precond
(k: parser_kind)
: Tot bool
= k.parser_kind_subkind = Some ParserStrong &&
k.parser_kind_low > 0
val bare_serialize_list_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
: Lemma
(requires (serialize_list_precond k))
(ensures (serializer_correct (parse_list p) (bare_serialize_list p s)))
val serialize_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
: Pure (serializer (parse_list p))
(requires (
serialize_list_precond k
))
(ensures (fun _ -> True))
val serialize_list_nil
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
: Lemma
(requires (
serialize_list_precond k
))
(ensures (serialize (serialize_list p s) [] == Seq.empty))
val serialize_list_cons
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(a: t)
(q: list t)
: Lemma
(requires (
serialize_list_precond k
))
(ensures (
serialize (serialize_list p s) (a :: q) == Seq.append (serialize s a) (serialize (serialize_list p s) q)
))
val serialize_list_singleton
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(a: t)
: Lemma
(requires (serialize_list_precond k))
(ensures (serialize (serialize_list p s) [a] == serialize s a))
val serialize_list_append
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(l1 l2: list t)
: Lemma
(requires (serialize_list_precond k))
(ensures (serialize (serialize_list p s) (L.append l1 l2) == Seq.append (serialize (serialize_list p s) l1) (serialize (serialize_list p s) l2)))
let rec serialize_list_eq_parser_fail
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 })
(l1 l2: list t)
(b1 b2: bytes)
: Lemma
(requires (
serialize (serialize_list _ s) l1 `Seq.append` b1 == serialize (serialize_list _ s) l2 `Seq.append` b2 /\
parse p b1 == None /\
parse p b2 == None
))
(ensures (l1 == l2 /\ b1 == b2))
(decreases (L.length l1))
= serialize_list_nil _ s;
assert (b1 `Seq.equal` (Seq.append Seq.empty b1));
assert (b2 `Seq.equal` (Seq.append Seq.empty b2));
if L.length l2 < L.length l1
then serialize_list_eq_parser_fail s l2 l1 b2 b1
else match l1, l2 with
| [], [] -> ()
| x1 :: l1', x2 :: l2' ->
serialize_list_cons _ s x1 l1' ;
serialize_list_cons _ s x2 l2' ;
Seq.append_assoc (serialize s x1) (serialize (serialize_list _ s) l1') b1;
Seq.append_assoc (serialize s x2) (serialize (serialize_list _ s) l2') b2;
serialize_strong_prefix s x1 x2 (serialize (serialize_list _ s) l1' `Seq.append` b1) (serialize (serialize_list _ s) l2' `Seq.append` b2);
serialize_list_eq_parser_fail s l1' l2' b1 b2
| [], x2 :: l2' ->
serialize_list_cons _ s x2 l2' ;
parse_strong_prefix p (serialize s x2) b1
let serialize_list_cons_upd
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires (
serialize_list_precond k /\
Seq.length (serialize s y) == Seq.length (serialize s x)
))
(ensures (
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (x :: l2) in
Seq.length sl == Seq.length sx + ln2 /\
serialize (serialize_list _ s) (y :: l2) == seq_upd_seq sl 0 (serialize s y)
))
= serialize_list_cons _ s x l2;
serialize_list_cons _ s y l2;
let sl = serialize (serialize_list _ s) (x :: l2) in
seq_upd_seq_left sl (serialize s y);
let ln = Seq.length (serialize s x) in
Seq.lemma_split sl ln;
Seq.lemma_append_inj (Seq.slice sl 0 ln) (Seq.slice sl ln (Seq.length sl)) (serialize s x) (serialize (serialize_list _ s) l2)
#set-options "--z3rlimit 32"
let serialize_list_upd
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires (
serialize_list_precond k /\
Seq.length (serialize s y) == Seq.length (serialize s x)
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_seq sl ln1 (serialize s y)
))
(decreases (L.length l1))
= serialize_list_append _ s l1 (y :: l2);
assert (serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == serialize (serialize_list _ s) l1 `Seq.append` serialize (serialize_list _ s) (y :: l2));
serialize_list_cons_upd s x l2 y;
assert (serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == serialize (serialize_list _ s) l1 `Seq.append` seq_upd_seq (serialize (serialize_list _ s) (x :: l2)) 0 (serialize s y));
seq_append_seq_upd_seq_l (serialize (serialize_list _ s) (x :: l2)) 0 (serialize s y) (serialize (serialize_list _ s) l1);
assert (serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_seq (serialize (serialize_list _ s) l1 `Seq.append` serialize (serialize_list _ s) (x :: l2)) (Seq.length (serialize (serialize_list _ s) l1) + 0) (serialize s y));
serialize_list_append _ s l1 (x :: l2)
let serialize_list_upd_bw
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires (
serialize_list_precond k /\
Seq.length (serialize s y) == Seq.length (serialize s x)
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_bw_seq sl ln2 (serialize s y)
)) | false | false | LowParse.Spec.List.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_list_upd_bw
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires
(serialize_list_precond k /\ Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures
(let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) ==
seq_upd_bw_seq sl ln2 (serialize s y)))
(decreases (L.length l1)) | [] | LowParse.Spec.List.serialize_list_upd_bw | {
"file_name": "src/lowparse/LowParse.Spec.List.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | s: LowParse.Spec.Base.serializer p -> l1: Prims.list t -> x: t -> l2: Prims.list t -> y: t
-> FStar.Pervasives.Lemma
(requires
LowParse.Spec.List.serialize_list_precond k /\
FStar.Seq.Base.length (LowParse.Spec.Base.serialize s y) ==
FStar.Seq.Base.length (LowParse.Spec.Base.serialize s x))
(ensures
(let ln1 =
FStar.Seq.Base.length (LowParse.Spec.Base.serialize (LowParse.Spec.List.serialize_list p
s)
l1)
in
let ln2 =
FStar.Seq.Base.length (LowParse.Spec.Base.serialize (LowParse.Spec.List.serialize_list p
s)
l2)
in
let sx = LowParse.Spec.Base.serialize s x in
let sl =
LowParse.Spec.Base.serialize (LowParse.Spec.List.serialize_list p s) (l1 @ x :: l2)
in
FStar.Seq.Base.length sl == ln1 + FStar.Seq.Base.length sx + ln2 /\
LowParse.Spec.Base.serialize (LowParse.Spec.List.serialize_list p s) (l1 @ y :: l2) ==
LowParse.Spec.Base.seq_upd_bw_seq sl ln2 (LowParse.Spec.Base.serialize s y)))
(decreases FStar.List.Tot.Base.length l1) | {
"end_col": 32,
"end_line": 367,
"start_col": 2,
"start_line": 367
} |
FStar.Pervasives.Lemma | val serialize_list_cons_upd_bw_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
(l2: list t)
(y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
serialize_list_precond k /\ i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_bw_seq sx i' s'))
(ensures
(let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (x :: l2) in
Seq.length sl == Seq.length sx + ln2 /\ ln2 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (y :: l2) == seq_upd_bw_seq sl (ln2 + i') s')) | [
{
"abbrev": true,
"full_module": "FStar.Classical",
"short_module": "Classical"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let serialize_list_cons_upd_bw_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
(l2: list t)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
serialize_list_precond k /\
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_bw_seq sx i' s'
))
(ensures (
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (x :: l2) in
Seq.length sl == Seq.length sx + ln2 /\
ln2 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (y :: l2) == seq_upd_bw_seq sl (ln2 + i') s'
))
= let j' = Seq.length (serialize s x) - i' - Seq.length s' in
serialize_list_cons_upd_chain s x l2 y j' s' | val serialize_list_cons_upd_bw_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
(l2: list t)
(y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
serialize_list_precond k /\ i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_bw_seq sx i' s'))
(ensures
(let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (x :: l2) in
Seq.length sl == Seq.length sx + ln2 /\ ln2 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (y :: l2) == seq_upd_bw_seq sl (ln2 + i') s'))
let serialize_list_cons_upd_bw_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
(l2: list t)
(y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
serialize_list_precond k /\ i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_bw_seq sx i' s'))
(ensures
(let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (x :: l2) in
Seq.length sl == Seq.length sx + ln2 /\ ln2 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (y :: l2) == seq_upd_bw_seq sl (ln2 + i') s')) = | false | null | true | let j' = Seq.length (serialize s x) - i' - Seq.length s' in
serialize_list_cons_upd_chain s x l2 y j' s' | {
"checked_file": "LowParse.Spec.List.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.List.fsti"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.list",
"Prims.nat",
"LowParse.Bytes.bytes",
"LowParse.Spec.List.serialize_list_cons_upd_chain",
"Prims.int",
"Prims.op_Subtraction",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.serialize",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"LowParse.Spec.List.serialize_list_precond",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Prims.eq2",
"FStar.Seq.Base.seq",
"LowParse.Spec.Base.seq_upd_bw_seq",
"Prims.squash",
"LowParse.Spec.List.parse_list_kind",
"LowParse.Spec.List.parse_list",
"LowParse.Spec.List.serialize_list",
"Prims.Cons",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.List
include LowParse.Spec.Combinators // for seq_slice_append_l
module Seq = FStar.Seq
module L = FStar.List.Tot
module U32 = FStar.UInt32
module Classical = FStar.Classical
(* Parse a list, until there is nothing left to read. This parser will mostly fail EXCEPT if the whole size is known and the slice has been suitably truncated beforehand, or if the elements of the list all have a known constant size. *)
let rec parse_list_aux
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: GTot (option (list t * (consumed_length b)))
(decreases (Seq.length b))
= if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse_list_aux p (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
let parse_list_bare
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (bare_parser (list t))
= (fun b -> parse_list_aux #k #t p b) <: bare_parser (list t)
let rec parse_list_bare_consumed
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (Some? (parse_list_bare p b)))
(ensures (
let pb = parse_list_bare p b in (
Some? pb /\ (
let (Some (_, consumed)) = pb in
consumed == Seq.length b
))))
(decreases (Seq.length b))
= if Seq.length b = 0
then ()
else
let (Some (_, consumed1)) = p b in
let b' = Seq.slice b consumed1 (Seq.length b) in
parse_list_bare_consumed p b'
let parse_list_bare_consumes_all
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(consumes_all (parse_list_bare p))
= Classical.forall_intro (Classical.move_requires (parse_list_bare_consumed p))
val parse_list_bare_injective
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(ensures (injective (parse_list_bare p)))
inline_for_extraction
let parse_list_kind =
{
parser_kind_low = 0;
parser_kind_high = None;
parser_kind_metadata = None;
parser_kind_subkind = Some ParserConsumesAll;
}
val parse_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser parse_list_kind (list t))
val parse_list_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(parse (parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse (parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
))
val parse_list_eq'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (k.parser_kind_low > 0))
(ensures (parse (parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
begin match parse (parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
end
)))
val tot_parse_list
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
: Pure (tot_parser parse_list_kind (list t))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_list #k p) x
))
let tot_parse_list_eq
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(b: bytes)
: Lemma
(parse (tot_parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse (tot_parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
))
= parse_list_eq #k p b
let rec bare_serialize_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(x: list t)
: GTot bytes
= match x with
| [] -> Seq.empty
| a :: q -> Seq.append (s a) (bare_serialize_list p s q)
unfold
let serialize_list_precond
(k: parser_kind)
: Tot bool
= k.parser_kind_subkind = Some ParserStrong &&
k.parser_kind_low > 0
val bare_serialize_list_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
: Lemma
(requires (serialize_list_precond k))
(ensures (serializer_correct (parse_list p) (bare_serialize_list p s)))
val serialize_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
: Pure (serializer (parse_list p))
(requires (
serialize_list_precond k
))
(ensures (fun _ -> True))
val serialize_list_nil
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
: Lemma
(requires (
serialize_list_precond k
))
(ensures (serialize (serialize_list p s) [] == Seq.empty))
val serialize_list_cons
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(a: t)
(q: list t)
: Lemma
(requires (
serialize_list_precond k
))
(ensures (
serialize (serialize_list p s) (a :: q) == Seq.append (serialize s a) (serialize (serialize_list p s) q)
))
val serialize_list_singleton
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(a: t)
: Lemma
(requires (serialize_list_precond k))
(ensures (serialize (serialize_list p s) [a] == serialize s a))
val serialize_list_append
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(l1 l2: list t)
: Lemma
(requires (serialize_list_precond k))
(ensures (serialize (serialize_list p s) (L.append l1 l2) == Seq.append (serialize (serialize_list p s) l1) (serialize (serialize_list p s) l2)))
let rec serialize_list_eq_parser_fail
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 })
(l1 l2: list t)
(b1 b2: bytes)
: Lemma
(requires (
serialize (serialize_list _ s) l1 `Seq.append` b1 == serialize (serialize_list _ s) l2 `Seq.append` b2 /\
parse p b1 == None /\
parse p b2 == None
))
(ensures (l1 == l2 /\ b1 == b2))
(decreases (L.length l1))
= serialize_list_nil _ s;
assert (b1 `Seq.equal` (Seq.append Seq.empty b1));
assert (b2 `Seq.equal` (Seq.append Seq.empty b2));
if L.length l2 < L.length l1
then serialize_list_eq_parser_fail s l2 l1 b2 b1
else match l1, l2 with
| [], [] -> ()
| x1 :: l1', x2 :: l2' ->
serialize_list_cons _ s x1 l1' ;
serialize_list_cons _ s x2 l2' ;
Seq.append_assoc (serialize s x1) (serialize (serialize_list _ s) l1') b1;
Seq.append_assoc (serialize s x2) (serialize (serialize_list _ s) l2') b2;
serialize_strong_prefix s x1 x2 (serialize (serialize_list _ s) l1' `Seq.append` b1) (serialize (serialize_list _ s) l2' `Seq.append` b2);
serialize_list_eq_parser_fail s l1' l2' b1 b2
| [], x2 :: l2' ->
serialize_list_cons _ s x2 l2' ;
parse_strong_prefix p (serialize s x2) b1
let serialize_list_cons_upd
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires (
serialize_list_precond k /\
Seq.length (serialize s y) == Seq.length (serialize s x)
))
(ensures (
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (x :: l2) in
Seq.length sl == Seq.length sx + ln2 /\
serialize (serialize_list _ s) (y :: l2) == seq_upd_seq sl 0 (serialize s y)
))
= serialize_list_cons _ s x l2;
serialize_list_cons _ s y l2;
let sl = serialize (serialize_list _ s) (x :: l2) in
seq_upd_seq_left sl (serialize s y);
let ln = Seq.length (serialize s x) in
Seq.lemma_split sl ln;
Seq.lemma_append_inj (Seq.slice sl 0 ln) (Seq.slice sl ln (Seq.length sl)) (serialize s x) (serialize (serialize_list _ s) l2)
#set-options "--z3rlimit 32"
let serialize_list_upd
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires (
serialize_list_precond k /\
Seq.length (serialize s y) == Seq.length (serialize s x)
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_seq sl ln1 (serialize s y)
))
(decreases (L.length l1))
= serialize_list_append _ s l1 (y :: l2);
assert (serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == serialize (serialize_list _ s) l1 `Seq.append` serialize (serialize_list _ s) (y :: l2));
serialize_list_cons_upd s x l2 y;
assert (serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == serialize (serialize_list _ s) l1 `Seq.append` seq_upd_seq (serialize (serialize_list _ s) (x :: l2)) 0 (serialize s y));
seq_append_seq_upd_seq_l (serialize (serialize_list _ s) (x :: l2)) 0 (serialize s y) (serialize (serialize_list _ s) l1);
assert (serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_seq (serialize (serialize_list _ s) l1 `Seq.append` serialize (serialize_list _ s) (x :: l2)) (Seq.length (serialize (serialize_list _ s) l1) + 0) (serialize s y));
serialize_list_append _ s l1 (x :: l2)
let serialize_list_upd_bw
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires (
serialize_list_precond k /\
Seq.length (serialize s y) == Seq.length (serialize s x)
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_bw_seq sl ln2 (serialize s y)
))
(decreases (L.length l1))
= serialize_list_upd s l1 x l2 y
#set-options "--z3rlimit 64"
let serialize_list_upd_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
serialize_list_precond k /\
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_seq sx i' s'
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
ln1 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_seq sl (ln1 + i') s'
))
= serialize_list_upd s l1 x l2 y;
serialize_list_append _ s l1 (x :: l2);
let sl1 = serialize (serialize_list _ s) l1 in
let ln1 = Seq.length sl1 in
let sxl2 = serialize (serialize_list _ s) (x :: l2) in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.lemma_split sl ln1;
Seq.lemma_append_inj (Seq.slice sl 0 ln1) (Seq.slice sl ln1 (Seq.length sl)) sl1 sxl2;
let sx = serialize s x in
let sl2 = serialize (serialize_list _ s) l2 in
let lx = Seq.length sx in
serialize_list_cons _ s x l2;
Seq.lemma_split sxl2 lx;
Seq.lemma_append_inj (Seq.slice sxl2 0 lx) (Seq.slice sxl2 lx (Seq.length sxl2)) sx sl2;
Seq.slice_slice sl ln1 (Seq.length sl) 0 lx;
assert (sx == Seq.slice sl ln1 (ln1 + lx));
seq_upd_seq_seq_upd_seq_slice sl ln1 (ln1 + lx) i' s';
()
let serialize_list_upd_bw_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
serialize_list_precond k /\
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_bw_seq sx i' s'
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
ln2 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_bw_seq sl (ln2 + i') s'
))
= let sx = serialize s x in
let j' = Seq.length sx - i' - Seq.length s' in
serialize_list_upd_chain s l1 x l2 y j' s'
val serialize_list_cons_upd_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
(l2: list t)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
serialize_list_precond k /\
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_seq sx i' s'
))
(ensures (
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (x :: l2) in
Seq.length sl == Seq.length sx + ln2 /\
i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (y :: l2) == seq_upd_seq sl i' s'
))
let serialize_list_cons_upd_bw_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
(l2: list t)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
serialize_list_precond k /\
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_bw_seq sx i' s'
))
(ensures (
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (x :: l2) in
Seq.length sl == Seq.length sx + ln2 /\
ln2 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (y :: l2) == seq_upd_bw_seq sl (ln2 + i') s' | false | false | LowParse.Spec.List.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 64,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_list_cons_upd_bw_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
(l2: list t)
(y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
serialize_list_precond k /\ i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_bw_seq sx i' s'))
(ensures
(let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (x :: l2) in
Seq.length sl == Seq.length sx + ln2 /\ ln2 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (y :: l2) == seq_upd_bw_seq sl (ln2 + i') s')) | [] | LowParse.Spec.List.serialize_list_cons_upd_bw_chain | {
"file_name": "src/lowparse/LowParse.Spec.List.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
s: LowParse.Spec.Base.serializer p ->
x: t ->
l2: Prims.list t ->
y: t ->
i': Prims.nat ->
s': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
(let sx = LowParse.Spec.Base.serialize s x in
LowParse.Spec.List.serialize_list_precond k /\
i' + FStar.Seq.Base.length s' <= FStar.Seq.Base.length sx /\
LowParse.Spec.Base.serialize s y == LowParse.Spec.Base.seq_upd_bw_seq sx i' s'))
(ensures
(let ln2 =
FStar.Seq.Base.length (LowParse.Spec.Base.serialize (LowParse.Spec.List.serialize_list p
s)
l2)
in
let sx = LowParse.Spec.Base.serialize s x in
let sl = LowParse.Spec.Base.serialize (LowParse.Spec.List.serialize_list p s) (x :: l2) in
FStar.Seq.Base.length sl == FStar.Seq.Base.length sx + ln2 /\
ln2 + i' + FStar.Seq.Base.length s' <= FStar.Seq.Base.length sl /\
LowParse.Spec.Base.serialize (LowParse.Spec.List.serialize_list p s) (y :: l2) ==
LowParse.Spec.Base.seq_upd_bw_seq sl (ln2 + i') s')) | {
"end_col": 46,
"end_line": 500,
"start_col": 1,
"start_line": 499
} |
FStar.Pervasives.Lemma | val serialize_list_snoc_upd_bw_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
serialize_list_precond k /\ i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_bw_seq sx i' s'))
(ensures
(let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` [x]) in
Seq.length sl == ln1 + Seq.length sx /\ i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` [y]) == seq_upd_bw_seq sl i' s')) | [
{
"abbrev": true,
"full_module": "FStar.Classical",
"short_module": "Classical"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let serialize_list_snoc_upd_bw_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
serialize_list_precond k /\
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_bw_seq sx i' s'
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` [x]) in
Seq.length sl == ln1 + Seq.length sx /\
i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` [y]) == seq_upd_bw_seq sl i' s'
))
= let j' = Seq.length (serialize s x) - i' - Seq.length s' in
serialize_list_snoc_upd_chain s l1 x y j' s' | val serialize_list_snoc_upd_bw_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
serialize_list_precond k /\ i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_bw_seq sx i' s'))
(ensures
(let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` [x]) in
Seq.length sl == ln1 + Seq.length sx /\ i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` [y]) == seq_upd_bw_seq sl i' s'))
let serialize_list_snoc_upd_bw_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
serialize_list_precond k /\ i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_bw_seq sx i' s'))
(ensures
(let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` [x]) in
Seq.length sl == ln1 + Seq.length sx /\ i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` [y]) == seq_upd_bw_seq sl i' s')) = | false | null | true | let j' = Seq.length (serialize s x) - i' - Seq.length s' in
serialize_list_snoc_upd_chain s l1 x y j' s' | {
"checked_file": "LowParse.Spec.List.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.List.fsti"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.list",
"Prims.nat",
"LowParse.Bytes.bytes",
"LowParse.Spec.List.serialize_list_snoc_upd_chain",
"Prims.int",
"Prims.op_Subtraction",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.serialize",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"LowParse.Spec.List.serialize_list_precond",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Prims.eq2",
"FStar.Seq.Base.seq",
"LowParse.Spec.Base.seq_upd_bw_seq",
"Prims.squash",
"LowParse.Spec.List.parse_list_kind",
"LowParse.Spec.List.parse_list",
"LowParse.Spec.List.serialize_list",
"FStar.List.Tot.Base.append",
"Prims.Cons",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.List
include LowParse.Spec.Combinators // for seq_slice_append_l
module Seq = FStar.Seq
module L = FStar.List.Tot
module U32 = FStar.UInt32
module Classical = FStar.Classical
(* Parse a list, until there is nothing left to read. This parser will mostly fail EXCEPT if the whole size is known and the slice has been suitably truncated beforehand, or if the elements of the list all have a known constant size. *)
let rec parse_list_aux
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: GTot (option (list t * (consumed_length b)))
(decreases (Seq.length b))
= if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse_list_aux p (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
let parse_list_bare
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (bare_parser (list t))
= (fun b -> parse_list_aux #k #t p b) <: bare_parser (list t)
let rec parse_list_bare_consumed
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (Some? (parse_list_bare p b)))
(ensures (
let pb = parse_list_bare p b in (
Some? pb /\ (
let (Some (_, consumed)) = pb in
consumed == Seq.length b
))))
(decreases (Seq.length b))
= if Seq.length b = 0
then ()
else
let (Some (_, consumed1)) = p b in
let b' = Seq.slice b consumed1 (Seq.length b) in
parse_list_bare_consumed p b'
let parse_list_bare_consumes_all
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(consumes_all (parse_list_bare p))
= Classical.forall_intro (Classical.move_requires (parse_list_bare_consumed p))
val parse_list_bare_injective
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(ensures (injective (parse_list_bare p)))
inline_for_extraction
let parse_list_kind =
{
parser_kind_low = 0;
parser_kind_high = None;
parser_kind_metadata = None;
parser_kind_subkind = Some ParserConsumesAll;
}
val parse_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser parse_list_kind (list t))
val parse_list_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(parse (parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse (parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
))
val parse_list_eq'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (k.parser_kind_low > 0))
(ensures (parse (parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
begin match parse (parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
end
)))
val tot_parse_list
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
: Pure (tot_parser parse_list_kind (list t))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_list #k p) x
))
let tot_parse_list_eq
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(b: bytes)
: Lemma
(parse (tot_parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse (tot_parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
))
= parse_list_eq #k p b
let rec bare_serialize_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(x: list t)
: GTot bytes
= match x with
| [] -> Seq.empty
| a :: q -> Seq.append (s a) (bare_serialize_list p s q)
unfold
let serialize_list_precond
(k: parser_kind)
: Tot bool
= k.parser_kind_subkind = Some ParserStrong &&
k.parser_kind_low > 0
val bare_serialize_list_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
: Lemma
(requires (serialize_list_precond k))
(ensures (serializer_correct (parse_list p) (bare_serialize_list p s)))
val serialize_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
: Pure (serializer (parse_list p))
(requires (
serialize_list_precond k
))
(ensures (fun _ -> True))
val serialize_list_nil
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
: Lemma
(requires (
serialize_list_precond k
))
(ensures (serialize (serialize_list p s) [] == Seq.empty))
val serialize_list_cons
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(a: t)
(q: list t)
: Lemma
(requires (
serialize_list_precond k
))
(ensures (
serialize (serialize_list p s) (a :: q) == Seq.append (serialize s a) (serialize (serialize_list p s) q)
))
val serialize_list_singleton
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(a: t)
: Lemma
(requires (serialize_list_precond k))
(ensures (serialize (serialize_list p s) [a] == serialize s a))
val serialize_list_append
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(l1 l2: list t)
: Lemma
(requires (serialize_list_precond k))
(ensures (serialize (serialize_list p s) (L.append l1 l2) == Seq.append (serialize (serialize_list p s) l1) (serialize (serialize_list p s) l2)))
let rec serialize_list_eq_parser_fail
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 })
(l1 l2: list t)
(b1 b2: bytes)
: Lemma
(requires (
serialize (serialize_list _ s) l1 `Seq.append` b1 == serialize (serialize_list _ s) l2 `Seq.append` b2 /\
parse p b1 == None /\
parse p b2 == None
))
(ensures (l1 == l2 /\ b1 == b2))
(decreases (L.length l1))
= serialize_list_nil _ s;
assert (b1 `Seq.equal` (Seq.append Seq.empty b1));
assert (b2 `Seq.equal` (Seq.append Seq.empty b2));
if L.length l2 < L.length l1
then serialize_list_eq_parser_fail s l2 l1 b2 b1
else match l1, l2 with
| [], [] -> ()
| x1 :: l1', x2 :: l2' ->
serialize_list_cons _ s x1 l1' ;
serialize_list_cons _ s x2 l2' ;
Seq.append_assoc (serialize s x1) (serialize (serialize_list _ s) l1') b1;
Seq.append_assoc (serialize s x2) (serialize (serialize_list _ s) l2') b2;
serialize_strong_prefix s x1 x2 (serialize (serialize_list _ s) l1' `Seq.append` b1) (serialize (serialize_list _ s) l2' `Seq.append` b2);
serialize_list_eq_parser_fail s l1' l2' b1 b2
| [], x2 :: l2' ->
serialize_list_cons _ s x2 l2' ;
parse_strong_prefix p (serialize s x2) b1
let serialize_list_cons_upd
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires (
serialize_list_precond k /\
Seq.length (serialize s y) == Seq.length (serialize s x)
))
(ensures (
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (x :: l2) in
Seq.length sl == Seq.length sx + ln2 /\
serialize (serialize_list _ s) (y :: l2) == seq_upd_seq sl 0 (serialize s y)
))
= serialize_list_cons _ s x l2;
serialize_list_cons _ s y l2;
let sl = serialize (serialize_list _ s) (x :: l2) in
seq_upd_seq_left sl (serialize s y);
let ln = Seq.length (serialize s x) in
Seq.lemma_split sl ln;
Seq.lemma_append_inj (Seq.slice sl 0 ln) (Seq.slice sl ln (Seq.length sl)) (serialize s x) (serialize (serialize_list _ s) l2)
#set-options "--z3rlimit 32"
let serialize_list_upd
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires (
serialize_list_precond k /\
Seq.length (serialize s y) == Seq.length (serialize s x)
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_seq sl ln1 (serialize s y)
))
(decreases (L.length l1))
= serialize_list_append _ s l1 (y :: l2);
assert (serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == serialize (serialize_list _ s) l1 `Seq.append` serialize (serialize_list _ s) (y :: l2));
serialize_list_cons_upd s x l2 y;
assert (serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == serialize (serialize_list _ s) l1 `Seq.append` seq_upd_seq (serialize (serialize_list _ s) (x :: l2)) 0 (serialize s y));
seq_append_seq_upd_seq_l (serialize (serialize_list _ s) (x :: l2)) 0 (serialize s y) (serialize (serialize_list _ s) l1);
assert (serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_seq (serialize (serialize_list _ s) l1 `Seq.append` serialize (serialize_list _ s) (x :: l2)) (Seq.length (serialize (serialize_list _ s) l1) + 0) (serialize s y));
serialize_list_append _ s l1 (x :: l2)
let serialize_list_upd_bw
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires (
serialize_list_precond k /\
Seq.length (serialize s y) == Seq.length (serialize s x)
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_bw_seq sl ln2 (serialize s y)
))
(decreases (L.length l1))
= serialize_list_upd s l1 x l2 y
#set-options "--z3rlimit 64"
let serialize_list_upd_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
serialize_list_precond k /\
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_seq sx i' s'
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
ln1 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_seq sl (ln1 + i') s'
))
= serialize_list_upd s l1 x l2 y;
serialize_list_append _ s l1 (x :: l2);
let sl1 = serialize (serialize_list _ s) l1 in
let ln1 = Seq.length sl1 in
let sxl2 = serialize (serialize_list _ s) (x :: l2) in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.lemma_split sl ln1;
Seq.lemma_append_inj (Seq.slice sl 0 ln1) (Seq.slice sl ln1 (Seq.length sl)) sl1 sxl2;
let sx = serialize s x in
let sl2 = serialize (serialize_list _ s) l2 in
let lx = Seq.length sx in
serialize_list_cons _ s x l2;
Seq.lemma_split sxl2 lx;
Seq.lemma_append_inj (Seq.slice sxl2 0 lx) (Seq.slice sxl2 lx (Seq.length sxl2)) sx sl2;
Seq.slice_slice sl ln1 (Seq.length sl) 0 lx;
assert (sx == Seq.slice sl ln1 (ln1 + lx));
seq_upd_seq_seq_upd_seq_slice sl ln1 (ln1 + lx) i' s';
()
let serialize_list_upd_bw_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
serialize_list_precond k /\
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_bw_seq sx i' s'
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
ln2 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_bw_seq sl (ln2 + i') s'
))
= let sx = serialize s x in
let j' = Seq.length sx - i' - Seq.length s' in
serialize_list_upd_chain s l1 x l2 y j' s'
val serialize_list_cons_upd_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
(l2: list t)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
serialize_list_precond k /\
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_seq sx i' s'
))
(ensures (
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (x :: l2) in
Seq.length sl == Seq.length sx + ln2 /\
i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (y :: l2) == seq_upd_seq sl i' s'
))
let serialize_list_cons_upd_bw_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
(l2: list t)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
serialize_list_precond k /\
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_bw_seq sx i' s'
))
(ensures (
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (x :: l2) in
Seq.length sl == Seq.length sx + ln2 /\
ln2 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (y :: l2) == seq_upd_bw_seq sl (ln2 + i') s'
))
= let j' = Seq.length (serialize s x) - i' - Seq.length s' in
serialize_list_cons_upd_chain s x l2 y j' s'
val serialize_list_snoc_upd_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
serialize_list_precond k /\
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_seq sx i' s'
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` [x]) in
Seq.length sl == ln1 + Seq.length sx /\
ln1 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` [y]) == seq_upd_seq sl (ln1 + i') s'
))
let serialize_list_snoc_upd_bw_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
serialize_list_precond k /\
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_bw_seq sx i' s'
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` [x]) in
Seq.length sl == ln1 + Seq.length sx /\
i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` [y]) == seq_upd_bw_seq sl i' s' | false | false | LowParse.Spec.List.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 64,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_list_snoc_upd_bw_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
serialize_list_precond k /\ i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_bw_seq sx i' s'))
(ensures
(let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` [x]) in
Seq.length sl == ln1 + Seq.length sx /\ i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` [y]) == seq_upd_bw_seq sl i' s')) | [] | LowParse.Spec.List.serialize_list_snoc_upd_bw_chain | {
"file_name": "src/lowparse/LowParse.Spec.List.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
s: LowParse.Spec.Base.serializer p ->
l1: Prims.list t ->
x: t ->
y: t ->
i': Prims.nat ->
s': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
(let sx = LowParse.Spec.Base.serialize s x in
LowParse.Spec.List.serialize_list_precond k /\
i' + FStar.Seq.Base.length s' <= FStar.Seq.Base.length sx /\
LowParse.Spec.Base.serialize s y == LowParse.Spec.Base.seq_upd_bw_seq sx i' s'))
(ensures
(let ln1 =
FStar.Seq.Base.length (LowParse.Spec.Base.serialize (LowParse.Spec.List.serialize_list p
s)
l1)
in
let sx = LowParse.Spec.Base.serialize s x in
let sl =
LowParse.Spec.Base.serialize (LowParse.Spec.List.serialize_list p s) (l1 @ [x])
in
FStar.Seq.Base.length sl == ln1 + FStar.Seq.Base.length sx /\
i' + FStar.Seq.Base.length s' <= FStar.Seq.Base.length sl /\
LowParse.Spec.Base.serialize (LowParse.Spec.List.serialize_list p s) (l1 @ [y]) ==
LowParse.Spec.Base.seq_upd_bw_seq sl i' s')) | {
"end_col": 46,
"end_line": 554,
"start_col": 1,
"start_line": 553
} |
FStar.Pervasives.Lemma | val serialize_list_upd_bw_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
serialize_list_precond k /\ i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_bw_seq sx i' s'))
(ensures
(let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\ ln2 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) ==
seq_upd_bw_seq sl (ln2 + i') s')) | [
{
"abbrev": true,
"full_module": "FStar.Classical",
"short_module": "Classical"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let serialize_list_upd_bw_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
serialize_list_precond k /\
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_bw_seq sx i' s'
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
ln2 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_bw_seq sl (ln2 + i') s'
))
= let sx = serialize s x in
let j' = Seq.length sx - i' - Seq.length s' in
serialize_list_upd_chain s l1 x l2 y j' s' | val serialize_list_upd_bw_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
serialize_list_precond k /\ i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_bw_seq sx i' s'))
(ensures
(let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\ ln2 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) ==
seq_upd_bw_seq sl (ln2 + i') s'))
let serialize_list_upd_bw_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
serialize_list_precond k /\ i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_bw_seq sx i' s'))
(ensures
(let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\ ln2 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) ==
seq_upd_bw_seq sl (ln2 + i') s')) = | false | null | true | let sx = serialize s x in
let j' = Seq.length sx - i' - Seq.length s' in
serialize_list_upd_chain s l1 x l2 y j' s' | {
"checked_file": "LowParse.Spec.List.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.List.fsti"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.list",
"Prims.nat",
"LowParse.Bytes.bytes",
"LowParse.Spec.List.serialize_list_upd_chain",
"Prims.int",
"Prims.op_Subtraction",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.serialize",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"LowParse.Spec.List.serialize_list_precond",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Prims.eq2",
"FStar.Seq.Base.seq",
"LowParse.Spec.Base.seq_upd_bw_seq",
"Prims.squash",
"LowParse.Spec.List.parse_list_kind",
"LowParse.Spec.List.parse_list",
"LowParse.Spec.List.serialize_list",
"FStar.List.Tot.Base.append",
"Prims.Cons",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.List
include LowParse.Spec.Combinators // for seq_slice_append_l
module Seq = FStar.Seq
module L = FStar.List.Tot
module U32 = FStar.UInt32
module Classical = FStar.Classical
(* Parse a list, until there is nothing left to read. This parser will mostly fail EXCEPT if the whole size is known and the slice has been suitably truncated beforehand, or if the elements of the list all have a known constant size. *)
let rec parse_list_aux
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: GTot (option (list t * (consumed_length b)))
(decreases (Seq.length b))
= if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse_list_aux p (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
let parse_list_bare
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (bare_parser (list t))
= (fun b -> parse_list_aux #k #t p b) <: bare_parser (list t)
let rec parse_list_bare_consumed
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (Some? (parse_list_bare p b)))
(ensures (
let pb = parse_list_bare p b in (
Some? pb /\ (
let (Some (_, consumed)) = pb in
consumed == Seq.length b
))))
(decreases (Seq.length b))
= if Seq.length b = 0
then ()
else
let (Some (_, consumed1)) = p b in
let b' = Seq.slice b consumed1 (Seq.length b) in
parse_list_bare_consumed p b'
let parse_list_bare_consumes_all
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(consumes_all (parse_list_bare p))
= Classical.forall_intro (Classical.move_requires (parse_list_bare_consumed p))
val parse_list_bare_injective
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(ensures (injective (parse_list_bare p)))
inline_for_extraction
let parse_list_kind =
{
parser_kind_low = 0;
parser_kind_high = None;
parser_kind_metadata = None;
parser_kind_subkind = Some ParserConsumesAll;
}
val parse_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser parse_list_kind (list t))
val parse_list_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(parse (parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse (parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
))
val parse_list_eq'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (k.parser_kind_low > 0))
(ensures (parse (parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
begin match parse (parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
end
)))
val tot_parse_list
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
: Pure (tot_parser parse_list_kind (list t))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_list #k p) x
))
let tot_parse_list_eq
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(b: bytes)
: Lemma
(parse (tot_parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse (tot_parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
))
= parse_list_eq #k p b
let rec bare_serialize_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(x: list t)
: GTot bytes
= match x with
| [] -> Seq.empty
| a :: q -> Seq.append (s a) (bare_serialize_list p s q)
unfold
let serialize_list_precond
(k: parser_kind)
: Tot bool
= k.parser_kind_subkind = Some ParserStrong &&
k.parser_kind_low > 0
val bare_serialize_list_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
: Lemma
(requires (serialize_list_precond k))
(ensures (serializer_correct (parse_list p) (bare_serialize_list p s)))
val serialize_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
: Pure (serializer (parse_list p))
(requires (
serialize_list_precond k
))
(ensures (fun _ -> True))
val serialize_list_nil
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
: Lemma
(requires (
serialize_list_precond k
))
(ensures (serialize (serialize_list p s) [] == Seq.empty))
val serialize_list_cons
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(a: t)
(q: list t)
: Lemma
(requires (
serialize_list_precond k
))
(ensures (
serialize (serialize_list p s) (a :: q) == Seq.append (serialize s a) (serialize (serialize_list p s) q)
))
val serialize_list_singleton
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(a: t)
: Lemma
(requires (serialize_list_precond k))
(ensures (serialize (serialize_list p s) [a] == serialize s a))
val serialize_list_append
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(l1 l2: list t)
: Lemma
(requires (serialize_list_precond k))
(ensures (serialize (serialize_list p s) (L.append l1 l2) == Seq.append (serialize (serialize_list p s) l1) (serialize (serialize_list p s) l2)))
let rec serialize_list_eq_parser_fail
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 })
(l1 l2: list t)
(b1 b2: bytes)
: Lemma
(requires (
serialize (serialize_list _ s) l1 `Seq.append` b1 == serialize (serialize_list _ s) l2 `Seq.append` b2 /\
parse p b1 == None /\
parse p b2 == None
))
(ensures (l1 == l2 /\ b1 == b2))
(decreases (L.length l1))
= serialize_list_nil _ s;
assert (b1 `Seq.equal` (Seq.append Seq.empty b1));
assert (b2 `Seq.equal` (Seq.append Seq.empty b2));
if L.length l2 < L.length l1
then serialize_list_eq_parser_fail s l2 l1 b2 b1
else match l1, l2 with
| [], [] -> ()
| x1 :: l1', x2 :: l2' ->
serialize_list_cons _ s x1 l1' ;
serialize_list_cons _ s x2 l2' ;
Seq.append_assoc (serialize s x1) (serialize (serialize_list _ s) l1') b1;
Seq.append_assoc (serialize s x2) (serialize (serialize_list _ s) l2') b2;
serialize_strong_prefix s x1 x2 (serialize (serialize_list _ s) l1' `Seq.append` b1) (serialize (serialize_list _ s) l2' `Seq.append` b2);
serialize_list_eq_parser_fail s l1' l2' b1 b2
| [], x2 :: l2' ->
serialize_list_cons _ s x2 l2' ;
parse_strong_prefix p (serialize s x2) b1
let serialize_list_cons_upd
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires (
serialize_list_precond k /\
Seq.length (serialize s y) == Seq.length (serialize s x)
))
(ensures (
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (x :: l2) in
Seq.length sl == Seq.length sx + ln2 /\
serialize (serialize_list _ s) (y :: l2) == seq_upd_seq sl 0 (serialize s y)
))
= serialize_list_cons _ s x l2;
serialize_list_cons _ s y l2;
let sl = serialize (serialize_list _ s) (x :: l2) in
seq_upd_seq_left sl (serialize s y);
let ln = Seq.length (serialize s x) in
Seq.lemma_split sl ln;
Seq.lemma_append_inj (Seq.slice sl 0 ln) (Seq.slice sl ln (Seq.length sl)) (serialize s x) (serialize (serialize_list _ s) l2)
#set-options "--z3rlimit 32"
let serialize_list_upd
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires (
serialize_list_precond k /\
Seq.length (serialize s y) == Seq.length (serialize s x)
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_seq sl ln1 (serialize s y)
))
(decreases (L.length l1))
= serialize_list_append _ s l1 (y :: l2);
assert (serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == serialize (serialize_list _ s) l1 `Seq.append` serialize (serialize_list _ s) (y :: l2));
serialize_list_cons_upd s x l2 y;
assert (serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == serialize (serialize_list _ s) l1 `Seq.append` seq_upd_seq (serialize (serialize_list _ s) (x :: l2)) 0 (serialize s y));
seq_append_seq_upd_seq_l (serialize (serialize_list _ s) (x :: l2)) 0 (serialize s y) (serialize (serialize_list _ s) l1);
assert (serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_seq (serialize (serialize_list _ s) l1 `Seq.append` serialize (serialize_list _ s) (x :: l2)) (Seq.length (serialize (serialize_list _ s) l1) + 0) (serialize s y));
serialize_list_append _ s l1 (x :: l2)
let serialize_list_upd_bw
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires (
serialize_list_precond k /\
Seq.length (serialize s y) == Seq.length (serialize s x)
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_bw_seq sl ln2 (serialize s y)
))
(decreases (L.length l1))
= serialize_list_upd s l1 x l2 y
#set-options "--z3rlimit 64"
let serialize_list_upd_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
serialize_list_precond k /\
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_seq sx i' s'
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
ln1 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_seq sl (ln1 + i') s'
))
= serialize_list_upd s l1 x l2 y;
serialize_list_append _ s l1 (x :: l2);
let sl1 = serialize (serialize_list _ s) l1 in
let ln1 = Seq.length sl1 in
let sxl2 = serialize (serialize_list _ s) (x :: l2) in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.lemma_split sl ln1;
Seq.lemma_append_inj (Seq.slice sl 0 ln1) (Seq.slice sl ln1 (Seq.length sl)) sl1 sxl2;
let sx = serialize s x in
let sl2 = serialize (serialize_list _ s) l2 in
let lx = Seq.length sx in
serialize_list_cons _ s x l2;
Seq.lemma_split sxl2 lx;
Seq.lemma_append_inj (Seq.slice sxl2 0 lx) (Seq.slice sxl2 lx (Seq.length sxl2)) sx sl2;
Seq.slice_slice sl ln1 (Seq.length sl) 0 lx;
assert (sx == Seq.slice sl ln1 (ln1 + lx));
seq_upd_seq_seq_upd_seq_slice sl ln1 (ln1 + lx) i' s';
()
let serialize_list_upd_bw_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
serialize_list_precond k /\
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_bw_seq sx i' s'
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
ln2 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_bw_seq sl (ln2 + i') s' | false | false | LowParse.Spec.List.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 64,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_list_upd_bw_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
serialize_list_precond k /\ i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_bw_seq sx i' s'))
(ensures
(let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\ ln2 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) ==
seq_upd_bw_seq sl (ln2 + i') s')) | [] | LowParse.Spec.List.serialize_list_upd_bw_chain | {
"file_name": "src/lowparse/LowParse.Spec.List.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
s: LowParse.Spec.Base.serializer p ->
l1: Prims.list t ->
x: t ->
l2: Prims.list t ->
y: t ->
i': Prims.nat ->
s': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
(let sx = LowParse.Spec.Base.serialize s x in
LowParse.Spec.List.serialize_list_precond k /\
i' + FStar.Seq.Base.length s' <= FStar.Seq.Base.length sx /\
LowParse.Spec.Base.serialize s y == LowParse.Spec.Base.seq_upd_bw_seq sx i' s'))
(ensures
(let ln1 =
FStar.Seq.Base.length (LowParse.Spec.Base.serialize (LowParse.Spec.List.serialize_list p
s)
l1)
in
let ln2 =
FStar.Seq.Base.length (LowParse.Spec.Base.serialize (LowParse.Spec.List.serialize_list p
s)
l2)
in
let sx = LowParse.Spec.Base.serialize s x in
let sl =
LowParse.Spec.Base.serialize (LowParse.Spec.List.serialize_list p s) (l1 @ x :: l2)
in
FStar.Seq.Base.length sl == ln1 + FStar.Seq.Base.length sx + ln2 /\
ln2 + i' + FStar.Seq.Base.length s' <= FStar.Seq.Base.length sl /\
LowParse.Spec.Base.serialize (LowParse.Spec.List.serialize_list p s) (l1 @ y :: l2) ==
LowParse.Spec.Base.seq_upd_bw_seq sl (ln2 + i') s')) | {
"end_col": 44,
"end_line": 446,
"start_col": 1,
"start_line": 444
} |
FStar.Pervasives.Lemma | val serialize_list_upd
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires
(serialize_list_precond k /\ Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures
(let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) ==
seq_upd_seq sl ln1 (serialize s y)))
(decreases (L.length l1)) | [
{
"abbrev": true,
"full_module": "FStar.Classical",
"short_module": "Classical"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let serialize_list_upd
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires (
serialize_list_precond k /\
Seq.length (serialize s y) == Seq.length (serialize s x)
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_seq sl ln1 (serialize s y)
))
(decreases (L.length l1))
= serialize_list_append _ s l1 (y :: l2);
assert (serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == serialize (serialize_list _ s) l1 `Seq.append` serialize (serialize_list _ s) (y :: l2));
serialize_list_cons_upd s x l2 y;
assert (serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == serialize (serialize_list _ s) l1 `Seq.append` seq_upd_seq (serialize (serialize_list _ s) (x :: l2)) 0 (serialize s y));
seq_append_seq_upd_seq_l (serialize (serialize_list _ s) (x :: l2)) 0 (serialize s y) (serialize (serialize_list _ s) l1);
assert (serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_seq (serialize (serialize_list _ s) l1 `Seq.append` serialize (serialize_list _ s) (x :: l2)) (Seq.length (serialize (serialize_list _ s) l1) + 0) (serialize s y));
serialize_list_append _ s l1 (x :: l2) | val serialize_list_upd
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires
(serialize_list_precond k /\ Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures
(let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) ==
seq_upd_seq sl ln1 (serialize s y)))
(decreases (L.length l1))
let serialize_list_upd
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires
(serialize_list_precond k /\ Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures
(let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) ==
seq_upd_seq sl ln1 (serialize s y)))
(decreases (L.length l1)) = | false | null | true | serialize_list_append _ s l1 (y :: l2);
assert (serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) ==
(serialize (serialize_list _ s) l1)
`Seq.append`
(serialize (serialize_list _ s) (y :: l2)));
serialize_list_cons_upd s x l2 y;
assert (serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) ==
(serialize (serialize_list _ s) l1)
`Seq.append`
(seq_upd_seq (serialize (serialize_list _ s) (x :: l2)) 0 (serialize s y)));
seq_append_seq_upd_seq_l (serialize (serialize_list _ s) (x :: l2))
0
(serialize s y)
(serialize (serialize_list _ s) l1);
assert (serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) ==
seq_upd_seq ((serialize (serialize_list _ s) l1)
`Seq.append`
(serialize (serialize_list _ s) (x :: l2)))
(Seq.length (serialize (serialize_list _ s) l1) + 0)
(serialize s y));
serialize_list_append _ s l1 (x :: l2) | {
"checked_file": "LowParse.Spec.List.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.List.fsti"
} | [
"lemma",
""
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.list",
"LowParse.Spec.List.serialize_list_append",
"Prims.Cons",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"FStar.Seq.Base.seq",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.serialize",
"LowParse.Spec.List.parse_list_kind",
"LowParse.Spec.List.parse_list",
"LowParse.Spec.List.serialize_list",
"FStar.List.Tot.Base.append",
"LowParse.Spec.Base.seq_upd_seq",
"FStar.Seq.Base.append",
"Prims.op_Addition",
"FStar.Seq.Base.length",
"LowParse.Spec.Base.seq_append_seq_upd_seq_l",
"LowParse.Spec.List.serialize_list_cons_upd",
"FStar.List.Tot.Base.length",
"Prims.l_and",
"Prims.b2t",
"LowParse.Spec.List.serialize_list_precond",
"Prims.nat",
"Prims.squash",
"Prims.int",
"LowParse.Bytes.bytes",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.List
include LowParse.Spec.Combinators // for seq_slice_append_l
module Seq = FStar.Seq
module L = FStar.List.Tot
module U32 = FStar.UInt32
module Classical = FStar.Classical
(* Parse a list, until there is nothing left to read. This parser will mostly fail EXCEPT if the whole size is known and the slice has been suitably truncated beforehand, or if the elements of the list all have a known constant size. *)
let rec parse_list_aux
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: GTot (option (list t * (consumed_length b)))
(decreases (Seq.length b))
= if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse_list_aux p (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
let parse_list_bare
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (bare_parser (list t))
= (fun b -> parse_list_aux #k #t p b) <: bare_parser (list t)
let rec parse_list_bare_consumed
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (Some? (parse_list_bare p b)))
(ensures (
let pb = parse_list_bare p b in (
Some? pb /\ (
let (Some (_, consumed)) = pb in
consumed == Seq.length b
))))
(decreases (Seq.length b))
= if Seq.length b = 0
then ()
else
let (Some (_, consumed1)) = p b in
let b' = Seq.slice b consumed1 (Seq.length b) in
parse_list_bare_consumed p b'
let parse_list_bare_consumes_all
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(consumes_all (parse_list_bare p))
= Classical.forall_intro (Classical.move_requires (parse_list_bare_consumed p))
val parse_list_bare_injective
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(ensures (injective (parse_list_bare p)))
inline_for_extraction
let parse_list_kind =
{
parser_kind_low = 0;
parser_kind_high = None;
parser_kind_metadata = None;
parser_kind_subkind = Some ParserConsumesAll;
}
val parse_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser parse_list_kind (list t))
val parse_list_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(parse (parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse (parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
))
val parse_list_eq'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (k.parser_kind_low > 0))
(ensures (parse (parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
begin match parse (parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
end
)))
val tot_parse_list
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
: Pure (tot_parser parse_list_kind (list t))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_list #k p) x
))
let tot_parse_list_eq
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(b: bytes)
: Lemma
(parse (tot_parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse (tot_parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
))
= parse_list_eq #k p b
let rec bare_serialize_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(x: list t)
: GTot bytes
= match x with
| [] -> Seq.empty
| a :: q -> Seq.append (s a) (bare_serialize_list p s q)
unfold
let serialize_list_precond
(k: parser_kind)
: Tot bool
= k.parser_kind_subkind = Some ParserStrong &&
k.parser_kind_low > 0
val bare_serialize_list_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
: Lemma
(requires (serialize_list_precond k))
(ensures (serializer_correct (parse_list p) (bare_serialize_list p s)))
val serialize_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
: Pure (serializer (parse_list p))
(requires (
serialize_list_precond k
))
(ensures (fun _ -> True))
val serialize_list_nil
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
: Lemma
(requires (
serialize_list_precond k
))
(ensures (serialize (serialize_list p s) [] == Seq.empty))
val serialize_list_cons
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(a: t)
(q: list t)
: Lemma
(requires (
serialize_list_precond k
))
(ensures (
serialize (serialize_list p s) (a :: q) == Seq.append (serialize s a) (serialize (serialize_list p s) q)
))
val serialize_list_singleton
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(a: t)
: Lemma
(requires (serialize_list_precond k))
(ensures (serialize (serialize_list p s) [a] == serialize s a))
val serialize_list_append
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(l1 l2: list t)
: Lemma
(requires (serialize_list_precond k))
(ensures (serialize (serialize_list p s) (L.append l1 l2) == Seq.append (serialize (serialize_list p s) l1) (serialize (serialize_list p s) l2)))
let rec serialize_list_eq_parser_fail
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 })
(l1 l2: list t)
(b1 b2: bytes)
: Lemma
(requires (
serialize (serialize_list _ s) l1 `Seq.append` b1 == serialize (serialize_list _ s) l2 `Seq.append` b2 /\
parse p b1 == None /\
parse p b2 == None
))
(ensures (l1 == l2 /\ b1 == b2))
(decreases (L.length l1))
= serialize_list_nil _ s;
assert (b1 `Seq.equal` (Seq.append Seq.empty b1));
assert (b2 `Seq.equal` (Seq.append Seq.empty b2));
if L.length l2 < L.length l1
then serialize_list_eq_parser_fail s l2 l1 b2 b1
else match l1, l2 with
| [], [] -> ()
| x1 :: l1', x2 :: l2' ->
serialize_list_cons _ s x1 l1' ;
serialize_list_cons _ s x2 l2' ;
Seq.append_assoc (serialize s x1) (serialize (serialize_list _ s) l1') b1;
Seq.append_assoc (serialize s x2) (serialize (serialize_list _ s) l2') b2;
serialize_strong_prefix s x1 x2 (serialize (serialize_list _ s) l1' `Seq.append` b1) (serialize (serialize_list _ s) l2' `Seq.append` b2);
serialize_list_eq_parser_fail s l1' l2' b1 b2
| [], x2 :: l2' ->
serialize_list_cons _ s x2 l2' ;
parse_strong_prefix p (serialize s x2) b1
let serialize_list_cons_upd
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires (
serialize_list_precond k /\
Seq.length (serialize s y) == Seq.length (serialize s x)
))
(ensures (
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (x :: l2) in
Seq.length sl == Seq.length sx + ln2 /\
serialize (serialize_list _ s) (y :: l2) == seq_upd_seq sl 0 (serialize s y)
))
= serialize_list_cons _ s x l2;
serialize_list_cons _ s y l2;
let sl = serialize (serialize_list _ s) (x :: l2) in
seq_upd_seq_left sl (serialize s y);
let ln = Seq.length (serialize s x) in
Seq.lemma_split sl ln;
Seq.lemma_append_inj (Seq.slice sl 0 ln) (Seq.slice sl ln (Seq.length sl)) (serialize s x) (serialize (serialize_list _ s) l2)
#set-options "--z3rlimit 32"
let serialize_list_upd
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires (
serialize_list_precond k /\
Seq.length (serialize s y) == Seq.length (serialize s x)
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_seq sl ln1 (serialize s y)
)) | false | false | LowParse.Spec.List.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_list_upd
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires
(serialize_list_precond k /\ Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures
(let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) ==
seq_upd_seq sl ln1 (serialize s y)))
(decreases (L.length l1)) | [] | LowParse.Spec.List.serialize_list_upd | {
"file_name": "src/lowparse/LowParse.Spec.List.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | s: LowParse.Spec.Base.serializer p -> l1: Prims.list t -> x: t -> l2: Prims.list t -> y: t
-> FStar.Pervasives.Lemma
(requires
LowParse.Spec.List.serialize_list_precond k /\
FStar.Seq.Base.length (LowParse.Spec.Base.serialize s y) ==
FStar.Seq.Base.length (LowParse.Spec.Base.serialize s x))
(ensures
(let ln1 =
FStar.Seq.Base.length (LowParse.Spec.Base.serialize (LowParse.Spec.List.serialize_list p
s)
l1)
in
let ln2 =
FStar.Seq.Base.length (LowParse.Spec.Base.serialize (LowParse.Spec.List.serialize_list p
s)
l2)
in
let sx = LowParse.Spec.Base.serialize s x in
let sl =
LowParse.Spec.Base.serialize (LowParse.Spec.List.serialize_list p s) (l1 @ x :: l2)
in
FStar.Seq.Base.length sl == ln1 + FStar.Seq.Base.length sx + ln2 /\
LowParse.Spec.Base.serialize (LowParse.Spec.List.serialize_list p s) (l1 @ y :: l2) ==
LowParse.Spec.Base.seq_upd_seq sl ln1 (LowParse.Spec.Base.serialize s y)))
(decreases FStar.List.Tot.Base.length l1) | {
"end_col": 40,
"end_line": 342,
"start_col": 2,
"start_line": 336
} |
FStar.Pervasives.Lemma | val tot_parse_list_eq (#k: parser_kind) (#t: Type) (p: tot_parser k t) (b: bytes)
: Lemma
(parse (tot_parse_list p) b ==
(if Seq.length b = 0
then Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None
else
match parse (tot_parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None)) | [
{
"abbrev": true,
"full_module": "FStar.Classical",
"short_module": "Classical"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let tot_parse_list_eq
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(b: bytes)
: Lemma
(parse (tot_parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse (tot_parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
))
= parse_list_eq #k p b | val tot_parse_list_eq (#k: parser_kind) (#t: Type) (p: tot_parser k t) (b: bytes)
: Lemma
(parse (tot_parse_list p) b ==
(if Seq.length b = 0
then Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None
else
match parse (tot_parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None))
let tot_parse_list_eq (#k: parser_kind) (#t: Type) (p: tot_parser k t) (b: bytes)
: Lemma
(parse (tot_parse_list p) b ==
(if Seq.length b = 0
then Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None
else
match parse (tot_parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None)) = | false | null | true | parse_list_eq #k p b | {
"checked_file": "LowParse.Spec.List.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.List.fsti"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.tot_parser",
"LowParse.Bytes.bytes",
"LowParse.Spec.List.parse_list_eq",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"Prims.list",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.Base.parse",
"LowParse.Spec.List.tot_parse_list",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.Mktuple2",
"Prims.Nil",
"Prims.bool",
"FStar.Pervasives.Native.None",
"FStar.Seq.Base.slice",
"Prims.Cons",
"Prims.op_Addition",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.List
include LowParse.Spec.Combinators // for seq_slice_append_l
module Seq = FStar.Seq
module L = FStar.List.Tot
module U32 = FStar.UInt32
module Classical = FStar.Classical
(* Parse a list, until there is nothing left to read. This parser will mostly fail EXCEPT if the whole size is known and the slice has been suitably truncated beforehand, or if the elements of the list all have a known constant size. *)
let rec parse_list_aux
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: GTot (option (list t * (consumed_length b)))
(decreases (Seq.length b))
= if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse_list_aux p (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
let parse_list_bare
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (bare_parser (list t))
= (fun b -> parse_list_aux #k #t p b) <: bare_parser (list t)
let rec parse_list_bare_consumed
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (Some? (parse_list_bare p b)))
(ensures (
let pb = parse_list_bare p b in (
Some? pb /\ (
let (Some (_, consumed)) = pb in
consumed == Seq.length b
))))
(decreases (Seq.length b))
= if Seq.length b = 0
then ()
else
let (Some (_, consumed1)) = p b in
let b' = Seq.slice b consumed1 (Seq.length b) in
parse_list_bare_consumed p b'
let parse_list_bare_consumes_all
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(consumes_all (parse_list_bare p))
= Classical.forall_intro (Classical.move_requires (parse_list_bare_consumed p))
val parse_list_bare_injective
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(ensures (injective (parse_list_bare p)))
inline_for_extraction
let parse_list_kind =
{
parser_kind_low = 0;
parser_kind_high = None;
parser_kind_metadata = None;
parser_kind_subkind = Some ParserConsumesAll;
}
val parse_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser parse_list_kind (list t))
val parse_list_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(parse (parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse (parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
))
val parse_list_eq'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (k.parser_kind_low > 0))
(ensures (parse (parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
begin match parse (parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
end
)))
val tot_parse_list
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
: Pure (tot_parser parse_list_kind (list t))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_list #k p) x
))
let tot_parse_list_eq
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(b: bytes)
: Lemma
(parse (tot_parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse (tot_parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None | false | false | LowParse.Spec.List.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tot_parse_list_eq (#k: parser_kind) (#t: Type) (p: tot_parser k t) (b: bytes)
: Lemma
(parse (tot_parse_list p) b ==
(if Seq.length b = 0
then Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None
else
match parse (tot_parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None)) | [] | LowParse.Spec.List.tot_parse_list_eq | {
"file_name": "src/lowparse/LowParse.Spec.List.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p: LowParse.Spec.Base.tot_parser k t -> b: LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Base.parse (LowParse.Spec.List.tot_parse_list p) b ==
(match FStar.Seq.Base.length b = 0 with
| true -> FStar.Pervasives.Native.Some ([], 0)
| _ ->
(match LowParse.Spec.Base.parse p b with
| FStar.Pervasives.Native.None #_ -> FStar.Pervasives.Native.None
| FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ v n) ->
(match n = 0 with
| true -> FStar.Pervasives.Native.None
| _ ->
(match
LowParse.Spec.Base.parse (LowParse.Spec.List.tot_parse_list p)
(FStar.Seq.Base.slice b n (FStar.Seq.Base.length b))
with
| FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ l n') ->
FStar.Pervasives.Native.Some (v :: l, n + n')
| _ -> FStar.Pervasives.Native.None)
<:
FStar.Pervasives.Native.option (Prims.list t *
LowParse.Spec.Base.consumed_length b))
<:
FStar.Pervasives.Native.option (Prims.list t * LowParse.Spec.Base.consumed_length b))
<:
FStar.Pervasives.Native.option (Prims.list t * LowParse.Spec.Base.consumed_length b))) | {
"end_col": 22,
"end_line": 164,
"start_col": 2,
"start_line": 164
} |
FStar.Pervasives.Lemma | val serialize_list_upd_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
serialize_list_precond k /\ i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_seq sx i' s'))
(ensures
(let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\ ln1 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_seq sl (ln1 + i') s')) | [
{
"abbrev": true,
"full_module": "FStar.Classical",
"short_module": "Classical"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let serialize_list_upd_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
serialize_list_precond k /\
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_seq sx i' s'
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
ln1 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_seq sl (ln1 + i') s'
))
= serialize_list_upd s l1 x l2 y;
serialize_list_append _ s l1 (x :: l2);
let sl1 = serialize (serialize_list _ s) l1 in
let ln1 = Seq.length sl1 in
let sxl2 = serialize (serialize_list _ s) (x :: l2) in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.lemma_split sl ln1;
Seq.lemma_append_inj (Seq.slice sl 0 ln1) (Seq.slice sl ln1 (Seq.length sl)) sl1 sxl2;
let sx = serialize s x in
let sl2 = serialize (serialize_list _ s) l2 in
let lx = Seq.length sx in
serialize_list_cons _ s x l2;
Seq.lemma_split sxl2 lx;
Seq.lemma_append_inj (Seq.slice sxl2 0 lx) (Seq.slice sxl2 lx (Seq.length sxl2)) sx sl2;
Seq.slice_slice sl ln1 (Seq.length sl) 0 lx;
assert (sx == Seq.slice sl ln1 (ln1 + lx));
seq_upd_seq_seq_upd_seq_slice sl ln1 (ln1 + lx) i' s';
() | val serialize_list_upd_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
serialize_list_precond k /\ i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_seq sx i' s'))
(ensures
(let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\ ln1 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_seq sl (ln1 + i') s'))
let serialize_list_upd_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
serialize_list_precond k /\ i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_seq sx i' s'))
(ensures
(let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\ ln1 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_seq sl (ln1 + i') s')) = | false | null | true | serialize_list_upd s l1 x l2 y;
serialize_list_append _ s l1 (x :: l2);
let sl1 = serialize (serialize_list _ s) l1 in
let ln1 = Seq.length sl1 in
let sxl2 = serialize (serialize_list _ s) (x :: l2) in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.lemma_split sl ln1;
Seq.lemma_append_inj (Seq.slice sl 0 ln1) (Seq.slice sl ln1 (Seq.length sl)) sl1 sxl2;
let sx = serialize s x in
let sl2 = serialize (serialize_list _ s) l2 in
let lx = Seq.length sx in
serialize_list_cons _ s x l2;
Seq.lemma_split sxl2 lx;
Seq.lemma_append_inj (Seq.slice sxl2 0 lx) (Seq.slice sxl2 lx (Seq.length sxl2)) sx sl2;
Seq.slice_slice sl ln1 (Seq.length sl) 0 lx;
assert (sx == Seq.slice sl ln1 (ln1 + lx));
seq_upd_seq_seq_upd_seq_slice sl ln1 (ln1 + lx) i' s';
() | {
"checked_file": "LowParse.Spec.List.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.List.fsti"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.list",
"Prims.nat",
"LowParse.Bytes.bytes",
"Prims.unit",
"LowParse.Spec.Base.seq_upd_seq_seq_upd_seq_slice",
"LowParse.Bytes.byte",
"Prims.op_Addition",
"Prims._assert",
"Prims.eq2",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.slice",
"FStar.Seq.Properties.slice_slice",
"FStar.Seq.Base.length",
"FStar.Seq.Properties.lemma_append_inj",
"FStar.Seq.Properties.lemma_split",
"LowParse.Spec.List.serialize_list_cons",
"LowParse.Spec.Base.serialize",
"LowParse.Spec.List.parse_list_kind",
"LowParse.Spec.List.parse_list",
"LowParse.Spec.List.serialize_list",
"FStar.List.Tot.Base.append",
"Prims.Cons",
"LowParse.Spec.List.serialize_list_append",
"LowParse.Spec.List.serialize_list_upd",
"Prims.l_and",
"Prims.b2t",
"LowParse.Spec.List.serialize_list_precond",
"Prims.op_LessThanOrEqual",
"LowParse.Spec.Base.seq_upd_seq",
"Prims.squash",
"Prims.int",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.List
include LowParse.Spec.Combinators // for seq_slice_append_l
module Seq = FStar.Seq
module L = FStar.List.Tot
module U32 = FStar.UInt32
module Classical = FStar.Classical
(* Parse a list, until there is nothing left to read. This parser will mostly fail EXCEPT if the whole size is known and the slice has been suitably truncated beforehand, or if the elements of the list all have a known constant size. *)
let rec parse_list_aux
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: GTot (option (list t * (consumed_length b)))
(decreases (Seq.length b))
= if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse_list_aux p (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
let parse_list_bare
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (bare_parser (list t))
= (fun b -> parse_list_aux #k #t p b) <: bare_parser (list t)
let rec parse_list_bare_consumed
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (Some? (parse_list_bare p b)))
(ensures (
let pb = parse_list_bare p b in (
Some? pb /\ (
let (Some (_, consumed)) = pb in
consumed == Seq.length b
))))
(decreases (Seq.length b))
= if Seq.length b = 0
then ()
else
let (Some (_, consumed1)) = p b in
let b' = Seq.slice b consumed1 (Seq.length b) in
parse_list_bare_consumed p b'
let parse_list_bare_consumes_all
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(consumes_all (parse_list_bare p))
= Classical.forall_intro (Classical.move_requires (parse_list_bare_consumed p))
val parse_list_bare_injective
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(ensures (injective (parse_list_bare p)))
inline_for_extraction
let parse_list_kind =
{
parser_kind_low = 0;
parser_kind_high = None;
parser_kind_metadata = None;
parser_kind_subkind = Some ParserConsumesAll;
}
val parse_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser parse_list_kind (list t))
val parse_list_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(parse (parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse (parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
))
val parse_list_eq'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (k.parser_kind_low > 0))
(ensures (parse (parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
begin match parse (parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
end
)))
val tot_parse_list
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
: Pure (tot_parser parse_list_kind (list t))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_list #k p) x
))
let tot_parse_list_eq
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(b: bytes)
: Lemma
(parse (tot_parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse (tot_parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
))
= parse_list_eq #k p b
let rec bare_serialize_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(x: list t)
: GTot bytes
= match x with
| [] -> Seq.empty
| a :: q -> Seq.append (s a) (bare_serialize_list p s q)
unfold
let serialize_list_precond
(k: parser_kind)
: Tot bool
= k.parser_kind_subkind = Some ParserStrong &&
k.parser_kind_low > 0
val bare_serialize_list_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
: Lemma
(requires (serialize_list_precond k))
(ensures (serializer_correct (parse_list p) (bare_serialize_list p s)))
val serialize_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
: Pure (serializer (parse_list p))
(requires (
serialize_list_precond k
))
(ensures (fun _ -> True))
val serialize_list_nil
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
: Lemma
(requires (
serialize_list_precond k
))
(ensures (serialize (serialize_list p s) [] == Seq.empty))
val serialize_list_cons
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(a: t)
(q: list t)
: Lemma
(requires (
serialize_list_precond k
))
(ensures (
serialize (serialize_list p s) (a :: q) == Seq.append (serialize s a) (serialize (serialize_list p s) q)
))
val serialize_list_singleton
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(a: t)
: Lemma
(requires (serialize_list_precond k))
(ensures (serialize (serialize_list p s) [a] == serialize s a))
val serialize_list_append
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(l1 l2: list t)
: Lemma
(requires (serialize_list_precond k))
(ensures (serialize (serialize_list p s) (L.append l1 l2) == Seq.append (serialize (serialize_list p s) l1) (serialize (serialize_list p s) l2)))
let rec serialize_list_eq_parser_fail
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 })
(l1 l2: list t)
(b1 b2: bytes)
: Lemma
(requires (
serialize (serialize_list _ s) l1 `Seq.append` b1 == serialize (serialize_list _ s) l2 `Seq.append` b2 /\
parse p b1 == None /\
parse p b2 == None
))
(ensures (l1 == l2 /\ b1 == b2))
(decreases (L.length l1))
= serialize_list_nil _ s;
assert (b1 `Seq.equal` (Seq.append Seq.empty b1));
assert (b2 `Seq.equal` (Seq.append Seq.empty b2));
if L.length l2 < L.length l1
then serialize_list_eq_parser_fail s l2 l1 b2 b1
else match l1, l2 with
| [], [] -> ()
| x1 :: l1', x2 :: l2' ->
serialize_list_cons _ s x1 l1' ;
serialize_list_cons _ s x2 l2' ;
Seq.append_assoc (serialize s x1) (serialize (serialize_list _ s) l1') b1;
Seq.append_assoc (serialize s x2) (serialize (serialize_list _ s) l2') b2;
serialize_strong_prefix s x1 x2 (serialize (serialize_list _ s) l1' `Seq.append` b1) (serialize (serialize_list _ s) l2' `Seq.append` b2);
serialize_list_eq_parser_fail s l1' l2' b1 b2
| [], x2 :: l2' ->
serialize_list_cons _ s x2 l2' ;
parse_strong_prefix p (serialize s x2) b1
let serialize_list_cons_upd
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires (
serialize_list_precond k /\
Seq.length (serialize s y) == Seq.length (serialize s x)
))
(ensures (
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (x :: l2) in
Seq.length sl == Seq.length sx + ln2 /\
serialize (serialize_list _ s) (y :: l2) == seq_upd_seq sl 0 (serialize s y)
))
= serialize_list_cons _ s x l2;
serialize_list_cons _ s y l2;
let sl = serialize (serialize_list _ s) (x :: l2) in
seq_upd_seq_left sl (serialize s y);
let ln = Seq.length (serialize s x) in
Seq.lemma_split sl ln;
Seq.lemma_append_inj (Seq.slice sl 0 ln) (Seq.slice sl ln (Seq.length sl)) (serialize s x) (serialize (serialize_list _ s) l2)
#set-options "--z3rlimit 32"
let serialize_list_upd
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires (
serialize_list_precond k /\
Seq.length (serialize s y) == Seq.length (serialize s x)
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_seq sl ln1 (serialize s y)
))
(decreases (L.length l1))
= serialize_list_append _ s l1 (y :: l2);
assert (serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == serialize (serialize_list _ s) l1 `Seq.append` serialize (serialize_list _ s) (y :: l2));
serialize_list_cons_upd s x l2 y;
assert (serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == serialize (serialize_list _ s) l1 `Seq.append` seq_upd_seq (serialize (serialize_list _ s) (x :: l2)) 0 (serialize s y));
seq_append_seq_upd_seq_l (serialize (serialize_list _ s) (x :: l2)) 0 (serialize s y) (serialize (serialize_list _ s) l1);
assert (serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_seq (serialize (serialize_list _ s) l1 `Seq.append` serialize (serialize_list _ s) (x :: l2)) (Seq.length (serialize (serialize_list _ s) l1) + 0) (serialize s y));
serialize_list_append _ s l1 (x :: l2)
let serialize_list_upd_bw
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
: Lemma
(requires (
serialize_list_precond k /\
Seq.length (serialize s y) == Seq.length (serialize s x)
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_bw_seq sl ln2 (serialize s y)
))
(decreases (L.length l1))
= serialize_list_upd s l1 x l2 y
#set-options "--z3rlimit 64"
let serialize_list_upd_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
serialize_list_precond k /\
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_seq sx i' s'
))
(ensures (
let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\
ln1 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_seq sl (ln1 + i') s' | false | false | LowParse.Spec.List.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 64,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_list_upd_chain
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(l1: list t)
(x: t)
(l2: list t)
(y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
serialize_list_precond k /\ i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_seq sx i' s'))
(ensures
(let ln1 = Seq.length (serialize (serialize_list _ s) l1) in
let ln2 = Seq.length (serialize (serialize_list _ s) l2) in
let sx = serialize s x in
let sl = serialize (serialize_list _ s) (l1 `L.append` (x :: l2)) in
Seq.length sl == ln1 + Seq.length sx + ln2 /\ ln1 + i' + Seq.length s' <= Seq.length sl /\
serialize (serialize_list _ s) (l1 `L.append` (y :: l2)) == seq_upd_seq sl (ln1 + i') s')) | [] | LowParse.Spec.List.serialize_list_upd_chain | {
"file_name": "src/lowparse/LowParse.Spec.List.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
s: LowParse.Spec.Base.serializer p ->
l1: Prims.list t ->
x: t ->
l2: Prims.list t ->
y: t ->
i': Prims.nat ->
s': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
(let sx = LowParse.Spec.Base.serialize s x in
LowParse.Spec.List.serialize_list_precond k /\
i' + FStar.Seq.Base.length s' <= FStar.Seq.Base.length sx /\
LowParse.Spec.Base.serialize s y == LowParse.Spec.Base.seq_upd_seq sx i' s'))
(ensures
(let ln1 =
FStar.Seq.Base.length (LowParse.Spec.Base.serialize (LowParse.Spec.List.serialize_list p
s)
l1)
in
let ln2 =
FStar.Seq.Base.length (LowParse.Spec.Base.serialize (LowParse.Spec.List.serialize_list p
s)
l2)
in
let sx = LowParse.Spec.Base.serialize s x in
let sl =
LowParse.Spec.Base.serialize (LowParse.Spec.List.serialize_list p s) (l1 @ x :: l2)
in
FStar.Seq.Base.length sl == ln1 + FStar.Seq.Base.length sx + ln2 /\
ln1 + i' + FStar.Seq.Base.length s' <= FStar.Seq.Base.length sl /\
LowParse.Spec.Base.serialize (LowParse.Spec.List.serialize_list p s) (l1 @ y :: l2) ==
LowParse.Spec.Base.seq_upd_seq sl (ln1 + i') s')) | {
"end_col": 4,
"end_line": 415,
"start_col": 2,
"start_line": 398
} |
FStar.Pervasives.Lemma | val serialize_list_eq_parser_fail
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(l1 l2: list t)
(b1 b2: bytes)
: Lemma
(requires
((serialize (serialize_list _ s) l1)
`Seq.append`
b1 ==
(serialize (serialize_list _ s) l2)
`Seq.append`
b2 /\ parse p b1 == None /\ parse p b2 == None))
(ensures (l1 == l2 /\ b1 == b2))
(decreases (L.length l1)) | [
{
"abbrev": true,
"full_module": "FStar.Classical",
"short_module": "Classical"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec serialize_list_eq_parser_fail
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 })
(l1 l2: list t)
(b1 b2: bytes)
: Lemma
(requires (
serialize (serialize_list _ s) l1 `Seq.append` b1 == serialize (serialize_list _ s) l2 `Seq.append` b2 /\
parse p b1 == None /\
parse p b2 == None
))
(ensures (l1 == l2 /\ b1 == b2))
(decreases (L.length l1))
= serialize_list_nil _ s;
assert (b1 `Seq.equal` (Seq.append Seq.empty b1));
assert (b2 `Seq.equal` (Seq.append Seq.empty b2));
if L.length l2 < L.length l1
then serialize_list_eq_parser_fail s l2 l1 b2 b1
else match l1, l2 with
| [], [] -> ()
| x1 :: l1', x2 :: l2' ->
serialize_list_cons _ s x1 l1' ;
serialize_list_cons _ s x2 l2' ;
Seq.append_assoc (serialize s x1) (serialize (serialize_list _ s) l1') b1;
Seq.append_assoc (serialize s x2) (serialize (serialize_list _ s) l2') b2;
serialize_strong_prefix s x1 x2 (serialize (serialize_list _ s) l1' `Seq.append` b1) (serialize (serialize_list _ s) l2' `Seq.append` b2);
serialize_list_eq_parser_fail s l1' l2' b1 b2
| [], x2 :: l2' ->
serialize_list_cons _ s x2 l2' ;
parse_strong_prefix p (serialize s x2) b1 | val serialize_list_eq_parser_fail
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(l1 l2: list t)
(b1 b2: bytes)
: Lemma
(requires
((serialize (serialize_list _ s) l1)
`Seq.append`
b1 ==
(serialize (serialize_list _ s) l2)
`Seq.append`
b2 /\ parse p b1 == None /\ parse p b2 == None))
(ensures (l1 == l2 /\ b1 == b2))
(decreases (L.length l1))
let rec serialize_list_eq_parser_fail
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(l1 l2: list t)
(b1 b2: bytes)
: Lemma
(requires
((serialize (serialize_list _ s) l1)
`Seq.append`
b1 ==
(serialize (serialize_list _ s) l2)
`Seq.append`
b2 /\ parse p b1 == None /\ parse p b2 == None))
(ensures (l1 == l2 /\ b1 == b2))
(decreases (L.length l1)) = | false | null | true | serialize_list_nil _ s;
assert (b1 `Seq.equal` (Seq.append Seq.empty b1));
assert (b2 `Seq.equal` (Seq.append Seq.empty b2));
if L.length l2 < L.length l1
then serialize_list_eq_parser_fail s l2 l1 b2 b1
else
match l1, l2 with
| [], [] -> ()
| x1 :: l1', x2 :: l2' ->
serialize_list_cons _ s x1 l1';
serialize_list_cons _ s x2 l2';
Seq.append_assoc (serialize s x1) (serialize (serialize_list _ s) l1') b1;
Seq.append_assoc (serialize s x2) (serialize (serialize_list _ s) l2') b2;
serialize_strong_prefix s
x1
x2
((serialize (serialize_list _ s) l1') `Seq.append` b1)
((serialize (serialize_list _ s) l2') `Seq.append` b2);
serialize_list_eq_parser_fail s l1' l2' b1 b2
| [], x2 :: l2' ->
serialize_list_cons _ s x2 l2';
parse_strong_prefix p (serialize s x2) b1 | {
"checked_file": "LowParse.Spec.List.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.List.fsti"
} | [
"lemma",
""
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.l_and",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"Prims.b2t",
"Prims.op_GreaterThan",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"Prims.list",
"LowParse.Bytes.bytes",
"Prims.op_LessThan",
"FStar.List.Tot.Base.length",
"LowParse.Spec.List.serialize_list_eq_parser_fail",
"Prims.bool",
"FStar.Pervasives.Native.Mktuple2",
"Prims.unit",
"LowParse.Spec.Base.serialize_strong_prefix",
"FStar.Seq.Base.append",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.serialize",
"LowParse.Spec.List.parse_list_kind",
"LowParse.Spec.List.parse_list",
"LowParse.Spec.List.serialize_list",
"FStar.Seq.Base.append_assoc",
"LowParse.Spec.List.serialize_list_cons",
"LowParse.Spec.Base.parse_strong_prefix",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.empty",
"LowParse.Spec.List.serialize_list_nil",
"FStar.Seq.Base.seq",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.Base.parse",
"FStar.Pervasives.Native.None",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.List
include LowParse.Spec.Combinators // for seq_slice_append_l
module Seq = FStar.Seq
module L = FStar.List.Tot
module U32 = FStar.UInt32
module Classical = FStar.Classical
(* Parse a list, until there is nothing left to read. This parser will mostly fail EXCEPT if the whole size is known and the slice has been suitably truncated beforehand, or if the elements of the list all have a known constant size. *)
let rec parse_list_aux
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: GTot (option (list t * (consumed_length b)))
(decreases (Seq.length b))
= if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse_list_aux p (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
let parse_list_bare
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (bare_parser (list t))
= (fun b -> parse_list_aux #k #t p b) <: bare_parser (list t)
let rec parse_list_bare_consumed
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (Some? (parse_list_bare p b)))
(ensures (
let pb = parse_list_bare p b in (
Some? pb /\ (
let (Some (_, consumed)) = pb in
consumed == Seq.length b
))))
(decreases (Seq.length b))
= if Seq.length b = 0
then ()
else
let (Some (_, consumed1)) = p b in
let b' = Seq.slice b consumed1 (Seq.length b) in
parse_list_bare_consumed p b'
let parse_list_bare_consumes_all
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(consumes_all (parse_list_bare p))
= Classical.forall_intro (Classical.move_requires (parse_list_bare_consumed p))
val parse_list_bare_injective
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(ensures (injective (parse_list_bare p)))
inline_for_extraction
let parse_list_kind =
{
parser_kind_low = 0;
parser_kind_high = None;
parser_kind_metadata = None;
parser_kind_subkind = Some ParserConsumesAll;
}
val parse_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser parse_list_kind (list t))
val parse_list_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(parse (parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse (parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
))
val parse_list_eq'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b: bytes)
: Lemma
(requires (k.parser_kind_low > 0))
(ensures (parse (parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
begin match parse (parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
end
)))
val tot_parse_list
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
: Pure (tot_parser parse_list_kind (list t))
(requires True)
(ensures (fun y ->
forall x . parse y x == parse (parse_list #k p) x
))
let tot_parse_list_eq
(#k: parser_kind)
(#t: Type)
(p: tot_parser k t)
(b: bytes)
: Lemma
(parse (tot_parse_list p) b == (
if Seq.length b = 0
then
Some ([], (0 <: consumed_length b))
else
match parse p b with
| None -> None
| Some (v, n) ->
if n = 0
then None (* elements cannot be empty *)
else
match parse (tot_parse_list p) (Seq.slice b n (Seq.length b)) with
| Some (l, n') -> Some (v :: l, (n + n' <: consumed_length b))
| _ -> None
))
= parse_list_eq #k p b
let rec bare_serialize_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(x: list t)
: GTot bytes
= match x with
| [] -> Seq.empty
| a :: q -> Seq.append (s a) (bare_serialize_list p s q)
unfold
let serialize_list_precond
(k: parser_kind)
: Tot bool
= k.parser_kind_subkind = Some ParserStrong &&
k.parser_kind_low > 0
val bare_serialize_list_correct
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
: Lemma
(requires (serialize_list_precond k))
(ensures (serializer_correct (parse_list p) (bare_serialize_list p s)))
val serialize_list
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
: Pure (serializer (parse_list p))
(requires (
serialize_list_precond k
))
(ensures (fun _ -> True))
val serialize_list_nil
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
: Lemma
(requires (
serialize_list_precond k
))
(ensures (serialize (serialize_list p s) [] == Seq.empty))
val serialize_list_cons
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(a: t)
(q: list t)
: Lemma
(requires (
serialize_list_precond k
))
(ensures (
serialize (serialize_list p s) (a :: q) == Seq.append (serialize s a) (serialize (serialize_list p s) q)
))
val serialize_list_singleton
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(a: t)
: Lemma
(requires (serialize_list_precond k))
(ensures (serialize (serialize_list p s) [a] == serialize s a))
val serialize_list_append
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(s: serializer p)
(l1 l2: list t)
: Lemma
(requires (serialize_list_precond k))
(ensures (serialize (serialize_list p s) (L.append l1 l2) == Seq.append (serialize (serialize_list p s) l1) (serialize (serialize_list p s) l2)))
let rec serialize_list_eq_parser_fail
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 })
(l1 l2: list t)
(b1 b2: bytes)
: Lemma
(requires (
serialize (serialize_list _ s) l1 `Seq.append` b1 == serialize (serialize_list _ s) l2 `Seq.append` b2 /\
parse p b1 == None /\
parse p b2 == None
))
(ensures (l1 == l2 /\ b1 == b2)) | false | false | LowParse.Spec.List.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_list_eq_parser_fail
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(l1 l2: list t)
(b1 b2: bytes)
: Lemma
(requires
((serialize (serialize_list _ s) l1)
`Seq.append`
b1 ==
(serialize (serialize_list _ s) l2)
`Seq.append`
b2 /\ parse p b1 == None /\ parse p b2 == None))
(ensures (l1 == l2 /\ b1 == b2))
(decreases (L.length l1)) | [
"recursion"
] | LowParse.Spec.List.serialize_list_eq_parser_fail | {
"file_name": "src/lowparse/LowParse.Spec.List.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
s:
LowParse.Spec.Base.serializer p
{ Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
Mkparser_kind'?.parser_kind_low k > 0 } ->
l1: Prims.list t ->
l2: Prims.list t ->
b1: LowParse.Bytes.bytes ->
b2: LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
FStar.Seq.Base.append (LowParse.Spec.Base.serialize (LowParse.Spec.List.serialize_list p s)
l1)
b1 ==
FStar.Seq.Base.append (LowParse.Spec.Base.serialize (LowParse.Spec.List.serialize_list p s)
l2)
b2 /\ LowParse.Spec.Base.parse p b1 == FStar.Pervasives.Native.None /\
LowParse.Spec.Base.parse p b2 == FStar.Pervasives.Native.None)
(ensures l1 == l2 /\ b1 == b2)
(decreases FStar.List.Tot.Base.length l1) | {
"end_col": 45,
"end_line": 281,
"start_col": 2,
"start_line": 265
} |
FStar.Pervasives.Lemma | val elab_comp_open_commute (c:comp) (x:term)
: Lemma (elab_comp (open_comp_with c x) == RT.open_with (elab_comp c) (elab_term x)) | [
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Naming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Core",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let elab_comp_open_commute (c:comp) (x:term)
: Lemma (elab_comp (open_comp_with c x) == RT.open_with (elab_comp c) (elab_term x))
= RT.open_with_spec (elab_comp c) (elab_term x);
elab_comp_open_commute' c x 0 | val elab_comp_open_commute (c:comp) (x:term)
: Lemma (elab_comp (open_comp_with c x) == RT.open_with (elab_comp c) (elab_term x))
let elab_comp_open_commute (c: comp) (x: term)
: Lemma (elab_comp (open_comp_with c x) == RT.open_with (elab_comp c) (elab_term x)) = | false | null | true | RT.open_with_spec (elab_comp c) (elab_term x);
elab_comp_open_commute' c x 0 | {
"checked_file": "Pulse.Elaborate.fst.checked",
"dependencies": [
"Pulse.Typing.fst.checked",
"Pulse.Syntax.fst.checked",
"Pulse.Elaborate.Core.fst.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": true,
"source_file": "Pulse.Elaborate.fst"
} | [
"lemma"
] | [
"Pulse.Syntax.Base.comp",
"Pulse.Syntax.Base.term",
"Pulse.Elaborate.elab_comp_open_commute'",
"Prims.unit",
"FStar.Reflection.Typing.open_with_spec",
"Pulse.Elaborate.Pure.elab_comp",
"Pulse.Elaborate.Pure.elab_term",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Reflection.Types.term",
"Pulse.Syntax.Naming.open_comp_with",
"FStar.Reflection.Typing.open_with",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Pulse.Elaborate
module RT = FStar.Reflection.Typing
module R = FStar.Reflection.V2
module L = FStar.List.Tot
module T = FStar.Tactics.V2
open FStar.List.Tot
open Pulse.Syntax
open Pulse.Typing
open Pulse.Elaborate.Core
// let rec elab_term_bv_sort (t:term)
// : Lemma
// (ensures
// (R.Tv_Var? (R.inspect_ln (elab_term t)) \/
// R.Tv_BVar? (R.inspect_ln (elab_term t))) ==>
// (match R.inspect_ln (elab_term t) with
// | R.Tv_Var bv
// | R.Tv_BVar bv ->
// let vv = R.inspect_bv bv in
// vv.bv_sort == RT.tun))
// = admit()
#push-options "--fuel 10 --ifuel 10 --z3rlimit_factor 30 --query_stats --z3cliopt 'smt.qi.eager_threshold=100'"
let rec elab_open_commute' (e:term)
(v:term)
(n:index)
: Lemma (ensures
RT.subst_term (elab_term e) [ RT.DT n (elab_term v) ] ==
elab_term (open_term' e v n))
(decreases e)
= match e.t with
| Tm_Emp
| Tm_Inames
| Tm_EmpInames
| Tm_VProp
| Tm_Unknown -> ()
// | Tm_PureApp e1 _ e2 ->
// elab_open_commute' e1 v n;
// elab_open_commute' e2 v n
| Tm_Pure p ->
elab_open_commute' p v n
| Tm_Star e1 e2 ->
elab_open_commute' e1 v n;
elab_open_commute' e2 v n
| Tm_ExistsSL u t body
| Tm_ForallSL u t body ->
elab_open_commute' t.binder_ty v n;
elab_open_commute' body v (n + 1)
| Tm_FStar t -> ()
let elab_comp_open_commute' (c:comp) (v:term) (n:index)
: Lemma (ensures
RT.subst_term (elab_comp c) [ RT.DT n (elab_term v) ] ==
elab_comp (open_comp' c v n))
= match c with
| C_Tot t -> elab_open_commute' t v n
| C_ST s ->
elab_open_commute' s.res v n;
elab_open_commute' s.pre v n;
elab_open_commute' s.post v (n + 1)
| C_STAtomic inames s
| C_STGhost inames s ->
elab_open_commute' inames v n;
elab_open_commute' s.res v n;
elab_open_commute' s.pre v n;
elab_open_commute' s.post v (n + 1)
let rec elab_close_commute' (e:term)
(v:var)
(n:index)
: Lemma (ensures (
RT.subst_term (elab_term e) [ RT.ND v n ] ==
elab_term (close_term' e v n)))
(decreases e)
= match e.t with
| Tm_Emp
| Tm_Inames
| Tm_EmpInames
| Tm_VProp
| Tm_Unknown -> ()
| Tm_Pure p ->
elab_close_commute' p v n
| Tm_Star e1 e2 ->
elab_close_commute' e1 v n;
elab_close_commute' e2 v n
| Tm_ExistsSL _ t body
| Tm_ForallSL _ t body ->
elab_close_commute' t.binder_ty v n;
elab_close_commute' body v (n + 1)
| Tm_FStar _ -> ()
let elab_comp_close_commute' (c:comp) (v:var) (n:index)
: Lemma (ensures
RT.subst_term (elab_comp c) [ RT.ND v n ] ==
elab_comp (close_comp' c v n))
(decreases c)
= match c with
| C_Tot t -> elab_close_commute' t v n
| C_ST s ->
elab_close_commute' s.res v n;
elab_close_commute' s.pre v n;
elab_close_commute' s.post v (n + 1)
| C_STAtomic inames s
| C_STGhost inames s ->
elab_close_commute' inames v n;
elab_close_commute' s.res v n;
elab_close_commute' s.pre v n;
elab_close_commute' s.post v (n + 1)
let elab_open_commute (t:term) (x:var)
: Lemma (elab_term (open_term t x) == RT.open_term (elab_term t) x)
= RT.open_term_spec (elab_term t) x;
elab_open_commute' t (null_var x) 0
let elab_comp_close_commute (c:comp) (x:var)
: Lemma (elab_comp (close_comp c x) == RT.close_term (elab_comp c) x)
= RT.close_term_spec (elab_comp c) x;
elab_comp_close_commute' c x 0
let elab_comp_open_commute (c:comp) (x:term) | false | false | Pulse.Elaborate.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 10,
"initial_ifuel": 10,
"max_fuel": 10,
"max_ifuel": 10,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 30,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val elab_comp_open_commute (c:comp) (x:term)
: Lemma (elab_comp (open_comp_with c x) == RT.open_with (elab_comp c) (elab_term x)) | [] | Pulse.Elaborate.elab_comp_open_commute | {
"file_name": "lib/steel/pulse/Pulse.Elaborate.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | c: Pulse.Syntax.Base.comp -> x: Pulse.Syntax.Base.term
-> FStar.Pervasives.Lemma
(ensures
Pulse.Elaborate.Pure.elab_comp (Pulse.Syntax.Naming.open_comp_with c x) ==
FStar.Reflection.Typing.open_with (Pulse.Elaborate.Pure.elab_comp c)
(Pulse.Elaborate.Pure.elab_term x)) | {
"end_col": 33,
"end_line": 124,
"start_col": 4,
"start_line": 123
} |
FStar.Pervasives.Lemma | val elab_comp_close_commute (c:comp) (x:var)
: Lemma (elab_comp (close_comp c x) == RT.close_term (elab_comp c) x) | [
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Naming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Core",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let elab_comp_close_commute (c:comp) (x:var)
: Lemma (elab_comp (close_comp c x) == RT.close_term (elab_comp c) x)
= RT.close_term_spec (elab_comp c) x;
elab_comp_close_commute' c x 0 | val elab_comp_close_commute (c:comp) (x:var)
: Lemma (elab_comp (close_comp c x) == RT.close_term (elab_comp c) x)
let elab_comp_close_commute (c: comp) (x: var)
: Lemma (elab_comp (close_comp c x) == RT.close_term (elab_comp c) x) = | false | null | true | RT.close_term_spec (elab_comp c) x;
elab_comp_close_commute' c x 0 | {
"checked_file": "Pulse.Elaborate.fst.checked",
"dependencies": [
"Pulse.Typing.fst.checked",
"Pulse.Syntax.fst.checked",
"Pulse.Elaborate.Core.fst.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": true,
"source_file": "Pulse.Elaborate.fst"
} | [
"lemma"
] | [
"Pulse.Syntax.Base.comp",
"Pulse.Syntax.Base.var",
"Pulse.Elaborate.elab_comp_close_commute'",
"Prims.unit",
"FStar.Reflection.Typing.close_term_spec",
"Pulse.Elaborate.Pure.elab_comp",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Reflection.Types.term",
"Pulse.Syntax.Naming.close_comp",
"FStar.Reflection.Typing.close_term",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Pulse.Elaborate
module RT = FStar.Reflection.Typing
module R = FStar.Reflection.V2
module L = FStar.List.Tot
module T = FStar.Tactics.V2
open FStar.List.Tot
open Pulse.Syntax
open Pulse.Typing
open Pulse.Elaborate.Core
// let rec elab_term_bv_sort (t:term)
// : Lemma
// (ensures
// (R.Tv_Var? (R.inspect_ln (elab_term t)) \/
// R.Tv_BVar? (R.inspect_ln (elab_term t))) ==>
// (match R.inspect_ln (elab_term t) with
// | R.Tv_Var bv
// | R.Tv_BVar bv ->
// let vv = R.inspect_bv bv in
// vv.bv_sort == RT.tun))
// = admit()
#push-options "--fuel 10 --ifuel 10 --z3rlimit_factor 30 --query_stats --z3cliopt 'smt.qi.eager_threshold=100'"
let rec elab_open_commute' (e:term)
(v:term)
(n:index)
: Lemma (ensures
RT.subst_term (elab_term e) [ RT.DT n (elab_term v) ] ==
elab_term (open_term' e v n))
(decreases e)
= match e.t with
| Tm_Emp
| Tm_Inames
| Tm_EmpInames
| Tm_VProp
| Tm_Unknown -> ()
// | Tm_PureApp e1 _ e2 ->
// elab_open_commute' e1 v n;
// elab_open_commute' e2 v n
| Tm_Pure p ->
elab_open_commute' p v n
| Tm_Star e1 e2 ->
elab_open_commute' e1 v n;
elab_open_commute' e2 v n
| Tm_ExistsSL u t body
| Tm_ForallSL u t body ->
elab_open_commute' t.binder_ty v n;
elab_open_commute' body v (n + 1)
| Tm_FStar t -> ()
let elab_comp_open_commute' (c:comp) (v:term) (n:index)
: Lemma (ensures
RT.subst_term (elab_comp c) [ RT.DT n (elab_term v) ] ==
elab_comp (open_comp' c v n))
= match c with
| C_Tot t -> elab_open_commute' t v n
| C_ST s ->
elab_open_commute' s.res v n;
elab_open_commute' s.pre v n;
elab_open_commute' s.post v (n + 1)
| C_STAtomic inames s
| C_STGhost inames s ->
elab_open_commute' inames v n;
elab_open_commute' s.res v n;
elab_open_commute' s.pre v n;
elab_open_commute' s.post v (n + 1)
let rec elab_close_commute' (e:term)
(v:var)
(n:index)
: Lemma (ensures (
RT.subst_term (elab_term e) [ RT.ND v n ] ==
elab_term (close_term' e v n)))
(decreases e)
= match e.t with
| Tm_Emp
| Tm_Inames
| Tm_EmpInames
| Tm_VProp
| Tm_Unknown -> ()
| Tm_Pure p ->
elab_close_commute' p v n
| Tm_Star e1 e2 ->
elab_close_commute' e1 v n;
elab_close_commute' e2 v n
| Tm_ExistsSL _ t body
| Tm_ForallSL _ t body ->
elab_close_commute' t.binder_ty v n;
elab_close_commute' body v (n + 1)
| Tm_FStar _ -> ()
let elab_comp_close_commute' (c:comp) (v:var) (n:index)
: Lemma (ensures
RT.subst_term (elab_comp c) [ RT.ND v n ] ==
elab_comp (close_comp' c v n))
(decreases c)
= match c with
| C_Tot t -> elab_close_commute' t v n
| C_ST s ->
elab_close_commute' s.res v n;
elab_close_commute' s.pre v n;
elab_close_commute' s.post v (n + 1)
| C_STAtomic inames s
| C_STGhost inames s ->
elab_close_commute' inames v n;
elab_close_commute' s.res v n;
elab_close_commute' s.pre v n;
elab_close_commute' s.post v (n + 1)
let elab_open_commute (t:term) (x:var)
: Lemma (elab_term (open_term t x) == RT.open_term (elab_term t) x)
= RT.open_term_spec (elab_term t) x;
elab_open_commute' t (null_var x) 0
let elab_comp_close_commute (c:comp) (x:var) | false | false | Pulse.Elaborate.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 10,
"initial_ifuel": 10,
"max_fuel": 10,
"max_ifuel": 10,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 30,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val elab_comp_close_commute (c:comp) (x:var)
: Lemma (elab_comp (close_comp c x) == RT.close_term (elab_comp c) x) | [] | Pulse.Elaborate.elab_comp_close_commute | {
"file_name": "lib/steel/pulse/Pulse.Elaborate.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | c: Pulse.Syntax.Base.comp -> x: Pulse.Syntax.Base.var
-> FStar.Pervasives.Lemma
(ensures
Pulse.Elaborate.Pure.elab_comp (Pulse.Syntax.Naming.close_comp c x) ==
FStar.Reflection.Typing.close_term (Pulse.Elaborate.Pure.elab_comp c) x) | {
"end_col": 34,
"end_line": 119,
"start_col": 4,
"start_line": 118
} |
FStar.Pervasives.Lemma | val elab_open_commute (t:term) (x:var)
: Lemma (elab_term (open_term t x) == RT.open_term (elab_term t) x) | [
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Naming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Core",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let elab_open_commute (t:term) (x:var)
: Lemma (elab_term (open_term t x) == RT.open_term (elab_term t) x)
= RT.open_term_spec (elab_term t) x;
elab_open_commute' t (null_var x) 0 | val elab_open_commute (t:term) (x:var)
: Lemma (elab_term (open_term t x) == RT.open_term (elab_term t) x)
let elab_open_commute (t: term) (x: var)
: Lemma (elab_term (open_term t x) == RT.open_term (elab_term t) x) = | false | null | true | RT.open_term_spec (elab_term t) x;
elab_open_commute' t (null_var x) 0 | {
"checked_file": "Pulse.Elaborate.fst.checked",
"dependencies": [
"Pulse.Typing.fst.checked",
"Pulse.Syntax.fst.checked",
"Pulse.Elaborate.Core.fst.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": true,
"source_file": "Pulse.Elaborate.fst"
} | [
"lemma"
] | [
"Pulse.Syntax.Base.term",
"Pulse.Syntax.Base.var",
"Pulse.Elaborate.elab_open_commute'",
"Pulse.Syntax.Pure.null_var",
"Prims.unit",
"FStar.Reflection.Typing.open_term_spec",
"Pulse.Elaborate.Pure.elab_term",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Reflection.Types.term",
"Pulse.Syntax.Naming.open_term",
"FStar.Reflection.Typing.open_term",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Pulse.Elaborate
module RT = FStar.Reflection.Typing
module R = FStar.Reflection.V2
module L = FStar.List.Tot
module T = FStar.Tactics.V2
open FStar.List.Tot
open Pulse.Syntax
open Pulse.Typing
open Pulse.Elaborate.Core
// let rec elab_term_bv_sort (t:term)
// : Lemma
// (ensures
// (R.Tv_Var? (R.inspect_ln (elab_term t)) \/
// R.Tv_BVar? (R.inspect_ln (elab_term t))) ==>
// (match R.inspect_ln (elab_term t) with
// | R.Tv_Var bv
// | R.Tv_BVar bv ->
// let vv = R.inspect_bv bv in
// vv.bv_sort == RT.tun))
// = admit()
#push-options "--fuel 10 --ifuel 10 --z3rlimit_factor 30 --query_stats --z3cliopt 'smt.qi.eager_threshold=100'"
let rec elab_open_commute' (e:term)
(v:term)
(n:index)
: Lemma (ensures
RT.subst_term (elab_term e) [ RT.DT n (elab_term v) ] ==
elab_term (open_term' e v n))
(decreases e)
= match e.t with
| Tm_Emp
| Tm_Inames
| Tm_EmpInames
| Tm_VProp
| Tm_Unknown -> ()
// | Tm_PureApp e1 _ e2 ->
// elab_open_commute' e1 v n;
// elab_open_commute' e2 v n
| Tm_Pure p ->
elab_open_commute' p v n
| Tm_Star e1 e2 ->
elab_open_commute' e1 v n;
elab_open_commute' e2 v n
| Tm_ExistsSL u t body
| Tm_ForallSL u t body ->
elab_open_commute' t.binder_ty v n;
elab_open_commute' body v (n + 1)
| Tm_FStar t -> ()
let elab_comp_open_commute' (c:comp) (v:term) (n:index)
: Lemma (ensures
RT.subst_term (elab_comp c) [ RT.DT n (elab_term v) ] ==
elab_comp (open_comp' c v n))
= match c with
| C_Tot t -> elab_open_commute' t v n
| C_ST s ->
elab_open_commute' s.res v n;
elab_open_commute' s.pre v n;
elab_open_commute' s.post v (n + 1)
| C_STAtomic inames s
| C_STGhost inames s ->
elab_open_commute' inames v n;
elab_open_commute' s.res v n;
elab_open_commute' s.pre v n;
elab_open_commute' s.post v (n + 1)
let rec elab_close_commute' (e:term)
(v:var)
(n:index)
: Lemma (ensures (
RT.subst_term (elab_term e) [ RT.ND v n ] ==
elab_term (close_term' e v n)))
(decreases e)
= match e.t with
| Tm_Emp
| Tm_Inames
| Tm_EmpInames
| Tm_VProp
| Tm_Unknown -> ()
| Tm_Pure p ->
elab_close_commute' p v n
| Tm_Star e1 e2 ->
elab_close_commute' e1 v n;
elab_close_commute' e2 v n
| Tm_ExistsSL _ t body
| Tm_ForallSL _ t body ->
elab_close_commute' t.binder_ty v n;
elab_close_commute' body v (n + 1)
| Tm_FStar _ -> ()
let elab_comp_close_commute' (c:comp) (v:var) (n:index)
: Lemma (ensures
RT.subst_term (elab_comp c) [ RT.ND v n ] ==
elab_comp (close_comp' c v n))
(decreases c)
= match c with
| C_Tot t -> elab_close_commute' t v n
| C_ST s ->
elab_close_commute' s.res v n;
elab_close_commute' s.pre v n;
elab_close_commute' s.post v (n + 1)
| C_STAtomic inames s
| C_STGhost inames s ->
elab_close_commute' inames v n;
elab_close_commute' s.res v n;
elab_close_commute' s.pre v n;
elab_close_commute' s.post v (n + 1)
let elab_open_commute (t:term) (x:var) | false | false | Pulse.Elaborate.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 10,
"initial_ifuel": 10,
"max_fuel": 10,
"max_ifuel": 10,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 30,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val elab_open_commute (t:term) (x:var)
: Lemma (elab_term (open_term t x) == RT.open_term (elab_term t) x) | [] | Pulse.Elaborate.elab_open_commute | {
"file_name": "lib/steel/pulse/Pulse.Elaborate.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | t: Pulse.Syntax.Base.term -> x: Pulse.Syntax.Base.var
-> FStar.Pervasives.Lemma
(ensures
Pulse.Elaborate.Pure.elab_term (Pulse.Syntax.Naming.open_term t x) ==
FStar.Reflection.Typing.open_term (Pulse.Elaborate.Pure.elab_term t) x) | {
"end_col": 39,
"end_line": 114,
"start_col": 4,
"start_line": 113
} |
FStar.Pervasives.Lemma | val elab_freevars (e:term)
: Lemma (freevars e == RT.freevars (elab_term e)) | [
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Naming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Core",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let elab_freevars e = elab_freevars_eq e | val elab_freevars (e:term)
: Lemma (freevars e == RT.freevars (elab_term e))
let elab_freevars e = | false | null | true | elab_freevars_eq e | {
"checked_file": "Pulse.Elaborate.fst.checked",
"dependencies": [
"Pulse.Typing.fst.checked",
"Pulse.Syntax.fst.checked",
"Pulse.Elaborate.Core.fst.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": true,
"source_file": "Pulse.Elaborate.fst"
} | [
"lemma"
] | [
"Pulse.Syntax.Base.term",
"Pulse.Elaborate.elab_freevars_eq",
"Prims.unit"
] | [] | module Pulse.Elaborate
module RT = FStar.Reflection.Typing
module R = FStar.Reflection.V2
module L = FStar.List.Tot
module T = FStar.Tactics.V2
open FStar.List.Tot
open Pulse.Syntax
open Pulse.Typing
open Pulse.Elaborate.Core
// let rec elab_term_bv_sort (t:term)
// : Lemma
// (ensures
// (R.Tv_Var? (R.inspect_ln (elab_term t)) \/
// R.Tv_BVar? (R.inspect_ln (elab_term t))) ==>
// (match R.inspect_ln (elab_term t) with
// | R.Tv_Var bv
// | R.Tv_BVar bv ->
// let vv = R.inspect_bv bv in
// vv.bv_sort == RT.tun))
// = admit()
#push-options "--fuel 10 --ifuel 10 --z3rlimit_factor 30 --query_stats --z3cliopt 'smt.qi.eager_threshold=100'"
let rec elab_open_commute' (e:term)
(v:term)
(n:index)
: Lemma (ensures
RT.subst_term (elab_term e) [ RT.DT n (elab_term v) ] ==
elab_term (open_term' e v n))
(decreases e)
= match e.t with
| Tm_Emp
| Tm_Inames
| Tm_EmpInames
| Tm_VProp
| Tm_Unknown -> ()
// | Tm_PureApp e1 _ e2 ->
// elab_open_commute' e1 v n;
// elab_open_commute' e2 v n
| Tm_Pure p ->
elab_open_commute' p v n
| Tm_Star e1 e2 ->
elab_open_commute' e1 v n;
elab_open_commute' e2 v n
| Tm_ExistsSL u t body
| Tm_ForallSL u t body ->
elab_open_commute' t.binder_ty v n;
elab_open_commute' body v (n + 1)
| Tm_FStar t -> ()
let elab_comp_open_commute' (c:comp) (v:term) (n:index)
: Lemma (ensures
RT.subst_term (elab_comp c) [ RT.DT n (elab_term v) ] ==
elab_comp (open_comp' c v n))
= match c with
| C_Tot t -> elab_open_commute' t v n
| C_ST s ->
elab_open_commute' s.res v n;
elab_open_commute' s.pre v n;
elab_open_commute' s.post v (n + 1)
| C_STAtomic inames s
| C_STGhost inames s ->
elab_open_commute' inames v n;
elab_open_commute' s.res v n;
elab_open_commute' s.pre v n;
elab_open_commute' s.post v (n + 1)
let rec elab_close_commute' (e:term)
(v:var)
(n:index)
: Lemma (ensures (
RT.subst_term (elab_term e) [ RT.ND v n ] ==
elab_term (close_term' e v n)))
(decreases e)
= match e.t with
| Tm_Emp
| Tm_Inames
| Tm_EmpInames
| Tm_VProp
| Tm_Unknown -> ()
| Tm_Pure p ->
elab_close_commute' p v n
| Tm_Star e1 e2 ->
elab_close_commute' e1 v n;
elab_close_commute' e2 v n
| Tm_ExistsSL _ t body
| Tm_ForallSL _ t body ->
elab_close_commute' t.binder_ty v n;
elab_close_commute' body v (n + 1)
| Tm_FStar _ -> ()
let elab_comp_close_commute' (c:comp) (v:var) (n:index)
: Lemma (ensures
RT.subst_term (elab_comp c) [ RT.ND v n ] ==
elab_comp (close_comp' c v n))
(decreases c)
= match c with
| C_Tot t -> elab_close_commute' t v n
| C_ST s ->
elab_close_commute' s.res v n;
elab_close_commute' s.pre v n;
elab_close_commute' s.post v (n + 1)
| C_STAtomic inames s
| C_STGhost inames s ->
elab_close_commute' inames v n;
elab_close_commute' s.res v n;
elab_close_commute' s.pre v n;
elab_close_commute' s.post v (n + 1)
let elab_open_commute (t:term) (x:var)
: Lemma (elab_term (open_term t x) == RT.open_term (elab_term t) x)
= RT.open_term_spec (elab_term t) x;
elab_open_commute' t (null_var x) 0
let elab_comp_close_commute (c:comp) (x:var)
: Lemma (elab_comp (close_comp c x) == RT.close_term (elab_comp c) x)
= RT.close_term_spec (elab_comp c) x;
elab_comp_close_commute' c x 0
let elab_comp_open_commute (c:comp) (x:term)
: Lemma (elab_comp (open_comp_with c x) == RT.open_with (elab_comp c) (elab_term x))
= RT.open_with_spec (elab_comp c) (elab_term x);
elab_comp_open_commute' c x 0
let rec elab_ln t i =
match t.t with
| Tm_Emp -> ()
| Tm_Pure t -> elab_ln t i
| Tm_Star l r ->
elab_ln l i;
elab_ln r i
| Tm_ExistsSL _ t body
| Tm_ForallSL _ t body ->
elab_ln t.binder_ty i;
elab_ln body (i + 1)
| Tm_VProp
| Tm_Inames
| Tm_EmpInames
| Tm_Unknown
| Tm_FStar _ -> ()
let elab_ln_comp (c:comp) (i:int)
: Lemma (requires ln_c' c i)
(ensures RT.ln' (elab_comp c) i) =
match c with
| C_Tot t -> elab_ln t i
| C_ST st ->
elab_ln st.res i;
elab_ln st.pre i;
elab_ln st.post (i + 1)
| C_STAtomic inames st
| C_STGhost inames st ->
elab_ln inames i;
elab_ln st.res i;
elab_ln st.pre i;
elab_ln st.post (i + 1)
let rec elab_freevars_eq (e:term)
: Lemma (Set.equal (freevars e) (RT.freevars (elab_term e))) =
match e.t with
| Tm_Emp -> ()
| Tm_Pure t -> elab_freevars_eq t
| Tm_Star l r ->
elab_freevars_eq l;
elab_freevars_eq r
| Tm_ExistsSL _ t body
| Tm_ForallSL _ t body ->
elab_freevars_eq t.binder_ty;
elab_freevars_eq body
| Tm_VProp
| Tm_Inames
| Tm_EmpInames
| Tm_Unknown
| Tm_FStar _ -> ()
let elab_freevars_comp_eq (c:comp)
: Lemma (Set.equal (freevars_comp c) (RT.freevars (elab_comp c))) =
match c with
| C_Tot t -> elab_freevars_eq t
| C_ST st ->
elab_freevars_eq st.res;
elab_freevars_eq st.pre;
elab_freevars_eq st.post
| C_STAtomic inames st
| C_STGhost inames st ->
elab_freevars_eq inames;
elab_freevars_eq st.res;
elab_freevars_eq st.pre;
elab_freevars_eq st.post
#pop-options | false | false | Pulse.Elaborate.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val elab_freevars (e:term)
: Lemma (freevars e == RT.freevars (elab_term e)) | [] | Pulse.Elaborate.elab_freevars | {
"file_name": "lib/steel/pulse/Pulse.Elaborate.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | e: Pulse.Syntax.Base.term
-> FStar.Pervasives.Lemma
(ensures
Pulse.Syntax.Naming.freevars e ==
FStar.Reflection.Typing.freevars (Pulse.Elaborate.Pure.elab_term e)) | {
"end_col": 40,
"end_line": 195,
"start_col": 22,
"start_line": 195
} |
FStar.Pervasives.Lemma | val elab_ln (t:term) (i:int)
: Lemma (requires ln' t i)
(ensures RT.ln' (elab_term t) i) | [
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Naming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Core",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec elab_ln t i =
match t.t with
| Tm_Emp -> ()
| Tm_Pure t -> elab_ln t i
| Tm_Star l r ->
elab_ln l i;
elab_ln r i
| Tm_ExistsSL _ t body
| Tm_ForallSL _ t body ->
elab_ln t.binder_ty i;
elab_ln body (i + 1)
| Tm_VProp
| Tm_Inames
| Tm_EmpInames
| Tm_Unknown
| Tm_FStar _ -> () | val elab_ln (t:term) (i:int)
: Lemma (requires ln' t i)
(ensures RT.ln' (elab_term t) i)
let rec elab_ln t i = | false | null | true | match t.t with
| Tm_Emp -> ()
| Tm_Pure t -> elab_ln t i
| Tm_Star l r ->
elab_ln l i;
elab_ln r i
| Tm_ExistsSL _ t body
| Tm_ForallSL _ t body ->
elab_ln t.binder_ty i;
elab_ln body (i + 1)
| Tm_VProp | Tm_Inames | Tm_EmpInames | Tm_Unknown | Tm_FStar _ -> () | {
"checked_file": "Pulse.Elaborate.fst.checked",
"dependencies": [
"Pulse.Typing.fst.checked",
"Pulse.Syntax.fst.checked",
"Pulse.Elaborate.Core.fst.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": true,
"source_file": "Pulse.Elaborate.fst"
} | [
"lemma"
] | [
"Pulse.Syntax.Base.term",
"Prims.int",
"Pulse.Syntax.Base.__proj__Mkterm__item__t",
"Pulse.Elaborate.elab_ln",
"Prims.unit",
"Pulse.Syntax.Base.universe",
"Pulse.Syntax.Base.binder",
"Prims.op_Addition",
"Pulse.Syntax.Base.__proj__Mkbinder__item__binder_ty",
"Pulse.Syntax.Base.host_term"
] | [] | module Pulse.Elaborate
module RT = FStar.Reflection.Typing
module R = FStar.Reflection.V2
module L = FStar.List.Tot
module T = FStar.Tactics.V2
open FStar.List.Tot
open Pulse.Syntax
open Pulse.Typing
open Pulse.Elaborate.Core
// let rec elab_term_bv_sort (t:term)
// : Lemma
// (ensures
// (R.Tv_Var? (R.inspect_ln (elab_term t)) \/
// R.Tv_BVar? (R.inspect_ln (elab_term t))) ==>
// (match R.inspect_ln (elab_term t) with
// | R.Tv_Var bv
// | R.Tv_BVar bv ->
// let vv = R.inspect_bv bv in
// vv.bv_sort == RT.tun))
// = admit()
#push-options "--fuel 10 --ifuel 10 --z3rlimit_factor 30 --query_stats --z3cliopt 'smt.qi.eager_threshold=100'"
let rec elab_open_commute' (e:term)
(v:term)
(n:index)
: Lemma (ensures
RT.subst_term (elab_term e) [ RT.DT n (elab_term v) ] ==
elab_term (open_term' e v n))
(decreases e)
= match e.t with
| Tm_Emp
| Tm_Inames
| Tm_EmpInames
| Tm_VProp
| Tm_Unknown -> ()
// | Tm_PureApp e1 _ e2 ->
// elab_open_commute' e1 v n;
// elab_open_commute' e2 v n
| Tm_Pure p ->
elab_open_commute' p v n
| Tm_Star e1 e2 ->
elab_open_commute' e1 v n;
elab_open_commute' e2 v n
| Tm_ExistsSL u t body
| Tm_ForallSL u t body ->
elab_open_commute' t.binder_ty v n;
elab_open_commute' body v (n + 1)
| Tm_FStar t -> ()
let elab_comp_open_commute' (c:comp) (v:term) (n:index)
: Lemma (ensures
RT.subst_term (elab_comp c) [ RT.DT n (elab_term v) ] ==
elab_comp (open_comp' c v n))
= match c with
| C_Tot t -> elab_open_commute' t v n
| C_ST s ->
elab_open_commute' s.res v n;
elab_open_commute' s.pre v n;
elab_open_commute' s.post v (n + 1)
| C_STAtomic inames s
| C_STGhost inames s ->
elab_open_commute' inames v n;
elab_open_commute' s.res v n;
elab_open_commute' s.pre v n;
elab_open_commute' s.post v (n + 1)
let rec elab_close_commute' (e:term)
(v:var)
(n:index)
: Lemma (ensures (
RT.subst_term (elab_term e) [ RT.ND v n ] ==
elab_term (close_term' e v n)))
(decreases e)
= match e.t with
| Tm_Emp
| Tm_Inames
| Tm_EmpInames
| Tm_VProp
| Tm_Unknown -> ()
| Tm_Pure p ->
elab_close_commute' p v n
| Tm_Star e1 e2 ->
elab_close_commute' e1 v n;
elab_close_commute' e2 v n
| Tm_ExistsSL _ t body
| Tm_ForallSL _ t body ->
elab_close_commute' t.binder_ty v n;
elab_close_commute' body v (n + 1)
| Tm_FStar _ -> ()
let elab_comp_close_commute' (c:comp) (v:var) (n:index)
: Lemma (ensures
RT.subst_term (elab_comp c) [ RT.ND v n ] ==
elab_comp (close_comp' c v n))
(decreases c)
= match c with
| C_Tot t -> elab_close_commute' t v n
| C_ST s ->
elab_close_commute' s.res v n;
elab_close_commute' s.pre v n;
elab_close_commute' s.post v (n + 1)
| C_STAtomic inames s
| C_STGhost inames s ->
elab_close_commute' inames v n;
elab_close_commute' s.res v n;
elab_close_commute' s.pre v n;
elab_close_commute' s.post v (n + 1)
let elab_open_commute (t:term) (x:var)
: Lemma (elab_term (open_term t x) == RT.open_term (elab_term t) x)
= RT.open_term_spec (elab_term t) x;
elab_open_commute' t (null_var x) 0
let elab_comp_close_commute (c:comp) (x:var)
: Lemma (elab_comp (close_comp c x) == RT.close_term (elab_comp c) x)
= RT.close_term_spec (elab_comp c) x;
elab_comp_close_commute' c x 0
let elab_comp_open_commute (c:comp) (x:term)
: Lemma (elab_comp (open_comp_with c x) == RT.open_with (elab_comp c) (elab_term x))
= RT.open_with_spec (elab_comp c) (elab_term x);
elab_comp_open_commute' c x 0 | false | false | Pulse.Elaborate.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 10,
"initial_ifuel": 10,
"max_fuel": 10,
"max_ifuel": 10,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 30,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val elab_ln (t:term) (i:int)
: Lemma (requires ln' t i)
(ensures RT.ln' (elab_term t) i) | [
"recursion"
] | Pulse.Elaborate.elab_ln | {
"file_name": "lib/steel/pulse/Pulse.Elaborate.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | t: Pulse.Syntax.Base.term -> i: Prims.int
-> FStar.Pervasives.Lemma (requires Pulse.Syntax.Naming.ln' t i)
(ensures FStar.Reflection.Typing.ln' (Pulse.Elaborate.Pure.elab_term t) i) | {
"end_col": 20,
"end_line": 141,
"start_col": 2,
"start_line": 127
} |
FStar.Pervasives.Lemma | val elab_ln_comp (c:comp) (i:int)
: Lemma (requires ln_c' c i) (ensures RT.ln' (elab_comp c) i) | [
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Naming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Core",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let elab_ln_comp (c:comp) (i:int)
: Lemma (requires ln_c' c i)
(ensures RT.ln' (elab_comp c) i) =
match c with
| C_Tot t -> elab_ln t i
| C_ST st ->
elab_ln st.res i;
elab_ln st.pre i;
elab_ln st.post (i + 1)
| C_STAtomic inames st
| C_STGhost inames st ->
elab_ln inames i;
elab_ln st.res i;
elab_ln st.pre i;
elab_ln st.post (i + 1) | val elab_ln_comp (c:comp) (i:int)
: Lemma (requires ln_c' c i) (ensures RT.ln' (elab_comp c) i)
let elab_ln_comp (c: comp) (i: int) : Lemma (requires ln_c' c i) (ensures RT.ln' (elab_comp c) i) = | false | null | true | match c with
| C_Tot t -> elab_ln t i
| C_ST st ->
elab_ln st.res i;
elab_ln st.pre i;
elab_ln st.post (i + 1)
| C_STAtomic inames st
| C_STGhost inames st ->
elab_ln inames i;
elab_ln st.res i;
elab_ln st.pre i;
elab_ln st.post (i + 1) | {
"checked_file": "Pulse.Elaborate.fst.checked",
"dependencies": [
"Pulse.Typing.fst.checked",
"Pulse.Syntax.fst.checked",
"Pulse.Elaborate.Core.fst.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": true,
"source_file": "Pulse.Elaborate.fst"
} | [
"lemma"
] | [
"Pulse.Syntax.Base.comp",
"Prims.int",
"Pulse.Syntax.Base.term",
"Pulse.Elaborate.elab_ln",
"Pulse.Syntax.Base.st_comp",
"Pulse.Syntax.Base.__proj__Mkst_comp__item__post",
"Prims.op_Addition",
"Prims.unit",
"Pulse.Syntax.Base.__proj__Mkst_comp__item__pre",
"Pulse.Syntax.Base.__proj__Mkst_comp__item__res",
"Prims.b2t",
"Pulse.Syntax.Naming.ln_c'",
"Prims.squash",
"FStar.Reflection.Typing.ln'",
"Pulse.Elaborate.Pure.elab_comp",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Pulse.Elaborate
module RT = FStar.Reflection.Typing
module R = FStar.Reflection.V2
module L = FStar.List.Tot
module T = FStar.Tactics.V2
open FStar.List.Tot
open Pulse.Syntax
open Pulse.Typing
open Pulse.Elaborate.Core
// let rec elab_term_bv_sort (t:term)
// : Lemma
// (ensures
// (R.Tv_Var? (R.inspect_ln (elab_term t)) \/
// R.Tv_BVar? (R.inspect_ln (elab_term t))) ==>
// (match R.inspect_ln (elab_term t) with
// | R.Tv_Var bv
// | R.Tv_BVar bv ->
// let vv = R.inspect_bv bv in
// vv.bv_sort == RT.tun))
// = admit()
#push-options "--fuel 10 --ifuel 10 --z3rlimit_factor 30 --query_stats --z3cliopt 'smt.qi.eager_threshold=100'"
let rec elab_open_commute' (e:term)
(v:term)
(n:index)
: Lemma (ensures
RT.subst_term (elab_term e) [ RT.DT n (elab_term v) ] ==
elab_term (open_term' e v n))
(decreases e)
= match e.t with
| Tm_Emp
| Tm_Inames
| Tm_EmpInames
| Tm_VProp
| Tm_Unknown -> ()
// | Tm_PureApp e1 _ e2 ->
// elab_open_commute' e1 v n;
// elab_open_commute' e2 v n
| Tm_Pure p ->
elab_open_commute' p v n
| Tm_Star e1 e2 ->
elab_open_commute' e1 v n;
elab_open_commute' e2 v n
| Tm_ExistsSL u t body
| Tm_ForallSL u t body ->
elab_open_commute' t.binder_ty v n;
elab_open_commute' body v (n + 1)
| Tm_FStar t -> ()
let elab_comp_open_commute' (c:comp) (v:term) (n:index)
: Lemma (ensures
RT.subst_term (elab_comp c) [ RT.DT n (elab_term v) ] ==
elab_comp (open_comp' c v n))
= match c with
| C_Tot t -> elab_open_commute' t v n
| C_ST s ->
elab_open_commute' s.res v n;
elab_open_commute' s.pre v n;
elab_open_commute' s.post v (n + 1)
| C_STAtomic inames s
| C_STGhost inames s ->
elab_open_commute' inames v n;
elab_open_commute' s.res v n;
elab_open_commute' s.pre v n;
elab_open_commute' s.post v (n + 1)
let rec elab_close_commute' (e:term)
(v:var)
(n:index)
: Lemma (ensures (
RT.subst_term (elab_term e) [ RT.ND v n ] ==
elab_term (close_term' e v n)))
(decreases e)
= match e.t with
| Tm_Emp
| Tm_Inames
| Tm_EmpInames
| Tm_VProp
| Tm_Unknown -> ()
| Tm_Pure p ->
elab_close_commute' p v n
| Tm_Star e1 e2 ->
elab_close_commute' e1 v n;
elab_close_commute' e2 v n
| Tm_ExistsSL _ t body
| Tm_ForallSL _ t body ->
elab_close_commute' t.binder_ty v n;
elab_close_commute' body v (n + 1)
| Tm_FStar _ -> ()
let elab_comp_close_commute' (c:comp) (v:var) (n:index)
: Lemma (ensures
RT.subst_term (elab_comp c) [ RT.ND v n ] ==
elab_comp (close_comp' c v n))
(decreases c)
= match c with
| C_Tot t -> elab_close_commute' t v n
| C_ST s ->
elab_close_commute' s.res v n;
elab_close_commute' s.pre v n;
elab_close_commute' s.post v (n + 1)
| C_STAtomic inames s
| C_STGhost inames s ->
elab_close_commute' inames v n;
elab_close_commute' s.res v n;
elab_close_commute' s.pre v n;
elab_close_commute' s.post v (n + 1)
let elab_open_commute (t:term) (x:var)
: Lemma (elab_term (open_term t x) == RT.open_term (elab_term t) x)
= RT.open_term_spec (elab_term t) x;
elab_open_commute' t (null_var x) 0
let elab_comp_close_commute (c:comp) (x:var)
: Lemma (elab_comp (close_comp c x) == RT.close_term (elab_comp c) x)
= RT.close_term_spec (elab_comp c) x;
elab_comp_close_commute' c x 0
let elab_comp_open_commute (c:comp) (x:term)
: Lemma (elab_comp (open_comp_with c x) == RT.open_with (elab_comp c) (elab_term x))
= RT.open_with_spec (elab_comp c) (elab_term x);
elab_comp_open_commute' c x 0
let rec elab_ln t i =
match t.t with
| Tm_Emp -> ()
| Tm_Pure t -> elab_ln t i
| Tm_Star l r ->
elab_ln l i;
elab_ln r i
| Tm_ExistsSL _ t body
| Tm_ForallSL _ t body ->
elab_ln t.binder_ty i;
elab_ln body (i + 1)
| Tm_VProp
| Tm_Inames
| Tm_EmpInames
| Tm_Unknown
| Tm_FStar _ -> ()
let elab_ln_comp (c:comp) (i:int)
: Lemma (requires ln_c' c i)
(ensures RT.ln' (elab_comp c) i) = | false | false | Pulse.Elaborate.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 10,
"initial_ifuel": 10,
"max_fuel": 10,
"max_ifuel": 10,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 30,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val elab_ln_comp (c:comp) (i:int)
: Lemma (requires ln_c' c i) (ensures RT.ln' (elab_comp c) i) | [] | Pulse.Elaborate.elab_ln_comp | {
"file_name": "lib/steel/pulse/Pulse.Elaborate.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | c: Pulse.Syntax.Base.comp -> i: Prims.int
-> FStar.Pervasives.Lemma (requires Pulse.Syntax.Naming.ln_c' c i)
(ensures FStar.Reflection.Typing.ln' (Pulse.Elaborate.Pure.elab_comp c) i) | {
"end_col": 27,
"end_line": 158,
"start_col": 2,
"start_line": 147
} |
FStar.Pervasives.Lemma | val elab_open_commute' (e:term)
(v:term)
(n:index)
: Lemma (ensures
RT.subst_term (elab_term e) [ RT.DT n (elab_term v) ] ==
elab_term (open_term' e v n)) | [
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Naming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Core",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec elab_open_commute' (e:term)
(v:term)
(n:index)
: Lemma (ensures
RT.subst_term (elab_term e) [ RT.DT n (elab_term v) ] ==
elab_term (open_term' e v n))
(decreases e)
= match e.t with
| Tm_Emp
| Tm_Inames
| Tm_EmpInames
| Tm_VProp
| Tm_Unknown -> ()
// | Tm_PureApp e1 _ e2 ->
// elab_open_commute' e1 v n;
// elab_open_commute' e2 v n
| Tm_Pure p ->
elab_open_commute' p v n
| Tm_Star e1 e2 ->
elab_open_commute' e1 v n;
elab_open_commute' e2 v n
| Tm_ExistsSL u t body
| Tm_ForallSL u t body ->
elab_open_commute' t.binder_ty v n;
elab_open_commute' body v (n + 1)
| Tm_FStar t -> () | val elab_open_commute' (e:term)
(v:term)
(n:index)
: Lemma (ensures
RT.subst_term (elab_term e) [ RT.DT n (elab_term v) ] ==
elab_term (open_term' e v n))
let rec elab_open_commute' (e v: term) (n: index)
: Lemma
(ensures RT.subst_term (elab_term e) [RT.DT n (elab_term v)] == elab_term (open_term' e v n))
(decreases e) = | false | null | true | match e.t with
| Tm_Emp | Tm_Inames | Tm_EmpInames | Tm_VProp | Tm_Unknown -> ()
| Tm_Pure p -> elab_open_commute' p v n
| Tm_Star e1 e2 ->
elab_open_commute' e1 v n;
elab_open_commute' e2 v n
| Tm_ExistsSL u t body
| Tm_ForallSL u t body ->
elab_open_commute' t.binder_ty v n;
elab_open_commute' body v (n + 1)
| Tm_FStar t -> () | {
"checked_file": "Pulse.Elaborate.fst.checked",
"dependencies": [
"Pulse.Typing.fst.checked",
"Pulse.Syntax.fst.checked",
"Pulse.Elaborate.Core.fst.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": true,
"source_file": "Pulse.Elaborate.fst"
} | [
"",
"lemma"
] | [
"Pulse.Syntax.Base.term",
"Pulse.Syntax.Base.index",
"Pulse.Syntax.Base.__proj__Mkterm__item__t",
"Pulse.Elaborate.elab_open_commute'",
"Prims.unit",
"Pulse.Syntax.Base.universe",
"Pulse.Syntax.Base.binder",
"Prims.op_Addition",
"Pulse.Syntax.Base.__proj__Mkbinder__item__binder_ty",
"Pulse.Syntax.Base.host_term",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Reflection.Types.term",
"FStar.Reflection.Typing.subst_term",
"Pulse.Elaborate.Pure.elab_term",
"Prims.Cons",
"FStar.Reflection.Typing.subst_elt",
"FStar.Reflection.Typing.DT",
"Prims.Nil",
"Pulse.Syntax.Naming.open_term'",
"FStar.Pervasives.pattern"
] | [] | module Pulse.Elaborate
module RT = FStar.Reflection.Typing
module R = FStar.Reflection.V2
module L = FStar.List.Tot
module T = FStar.Tactics.V2
open FStar.List.Tot
open Pulse.Syntax
open Pulse.Typing
open Pulse.Elaborate.Core
// let rec elab_term_bv_sort (t:term)
// : Lemma
// (ensures
// (R.Tv_Var? (R.inspect_ln (elab_term t)) \/
// R.Tv_BVar? (R.inspect_ln (elab_term t))) ==>
// (match R.inspect_ln (elab_term t) with
// | R.Tv_Var bv
// | R.Tv_BVar bv ->
// let vv = R.inspect_bv bv in
// vv.bv_sort == RT.tun))
// = admit()
#push-options "--fuel 10 --ifuel 10 --z3rlimit_factor 30 --query_stats --z3cliopt 'smt.qi.eager_threshold=100'"
let rec elab_open_commute' (e:term)
(v:term)
(n:index)
: Lemma (ensures
RT.subst_term (elab_term e) [ RT.DT n (elab_term v) ] ==
elab_term (open_term' e v n)) | false | false | Pulse.Elaborate.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 10,
"initial_ifuel": 10,
"max_fuel": 10,
"max_ifuel": 10,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 30,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val elab_open_commute' (e:term)
(v:term)
(n:index)
: Lemma (ensures
RT.subst_term (elab_term e) [ RT.DT n (elab_term v) ] ==
elab_term (open_term' e v n)) | [
"recursion"
] | Pulse.Elaborate.elab_open_commute' | {
"file_name": "lib/steel/pulse/Pulse.Elaborate.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | e: Pulse.Syntax.Base.term -> v: Pulse.Syntax.Base.term -> n: Pulse.Syntax.Base.index
-> FStar.Pervasives.Lemma
(ensures
FStar.Reflection.Typing.subst_term (Pulse.Elaborate.Pure.elab_term e)
[FStar.Reflection.Typing.DT n (Pulse.Elaborate.Pure.elab_term v)] ==
Pulse.Elaborate.Pure.elab_term (Pulse.Syntax.Naming.open_term' e v n)) (decreases e) | {
"end_col": 22,
"end_line": 50,
"start_col": 4,
"start_line": 32
} |
FStar.Pervasives.Lemma | val elab_close_commute' (e:term)
(v:var)
(n:index)
: Lemma (RT.subst_term (elab_term e) [ RT.ND v n ] ==
elab_term (close_term' e v n)) | [
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Naming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Core",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec elab_close_commute' (e:term)
(v:var)
(n:index)
: Lemma (ensures (
RT.subst_term (elab_term e) [ RT.ND v n ] ==
elab_term (close_term' e v n)))
(decreases e)
= match e.t with
| Tm_Emp
| Tm_Inames
| Tm_EmpInames
| Tm_VProp
| Tm_Unknown -> ()
| Tm_Pure p ->
elab_close_commute' p v n
| Tm_Star e1 e2 ->
elab_close_commute' e1 v n;
elab_close_commute' e2 v n
| Tm_ExistsSL _ t body
| Tm_ForallSL _ t body ->
elab_close_commute' t.binder_ty v n;
elab_close_commute' body v (n + 1)
| Tm_FStar _ -> () | val elab_close_commute' (e:term)
(v:var)
(n:index)
: Lemma (RT.subst_term (elab_term e) [ RT.ND v n ] ==
elab_term (close_term' e v n))
let rec elab_close_commute' (e: term) (v: var) (n: index)
: Lemma (ensures (RT.subst_term (elab_term e) [RT.ND v n] == elab_term (close_term' e v n)))
(decreases e) = | false | null | true | match e.t with
| Tm_Emp | Tm_Inames | Tm_EmpInames | Tm_VProp | Tm_Unknown -> ()
| Tm_Pure p -> elab_close_commute' p v n
| Tm_Star e1 e2 ->
elab_close_commute' e1 v n;
elab_close_commute' e2 v n
| Tm_ExistsSL _ t body
| Tm_ForallSL _ t body ->
elab_close_commute' t.binder_ty v n;
elab_close_commute' body v (n + 1)
| Tm_FStar _ -> () | {
"checked_file": "Pulse.Elaborate.fst.checked",
"dependencies": [
"Pulse.Typing.fst.checked",
"Pulse.Syntax.fst.checked",
"Pulse.Elaborate.Core.fst.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": true,
"source_file": "Pulse.Elaborate.fst"
} | [
"",
"lemma"
] | [
"Pulse.Syntax.Base.term",
"Pulse.Syntax.Base.var",
"Pulse.Syntax.Base.index",
"Pulse.Syntax.Base.__proj__Mkterm__item__t",
"Pulse.Elaborate.elab_close_commute'",
"Prims.unit",
"Pulse.Syntax.Base.universe",
"Pulse.Syntax.Base.binder",
"Prims.op_Addition",
"Pulse.Syntax.Base.__proj__Mkbinder__item__binder_ty",
"Pulse.Syntax.Base.host_term",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Reflection.Types.term",
"FStar.Reflection.Typing.subst_term",
"Pulse.Elaborate.Pure.elab_term",
"Prims.Cons",
"FStar.Reflection.Typing.subst_elt",
"FStar.Reflection.Typing.ND",
"Prims.Nil",
"Pulse.Syntax.Naming.close_term'",
"FStar.Pervasives.pattern"
] | [] | module Pulse.Elaborate
module RT = FStar.Reflection.Typing
module R = FStar.Reflection.V2
module L = FStar.List.Tot
module T = FStar.Tactics.V2
open FStar.List.Tot
open Pulse.Syntax
open Pulse.Typing
open Pulse.Elaborate.Core
// let rec elab_term_bv_sort (t:term)
// : Lemma
// (ensures
// (R.Tv_Var? (R.inspect_ln (elab_term t)) \/
// R.Tv_BVar? (R.inspect_ln (elab_term t))) ==>
// (match R.inspect_ln (elab_term t) with
// | R.Tv_Var bv
// | R.Tv_BVar bv ->
// let vv = R.inspect_bv bv in
// vv.bv_sort == RT.tun))
// = admit()
#push-options "--fuel 10 --ifuel 10 --z3rlimit_factor 30 --query_stats --z3cliopt 'smt.qi.eager_threshold=100'"
let rec elab_open_commute' (e:term)
(v:term)
(n:index)
: Lemma (ensures
RT.subst_term (elab_term e) [ RT.DT n (elab_term v) ] ==
elab_term (open_term' e v n))
(decreases e)
= match e.t with
| Tm_Emp
| Tm_Inames
| Tm_EmpInames
| Tm_VProp
| Tm_Unknown -> ()
// | Tm_PureApp e1 _ e2 ->
// elab_open_commute' e1 v n;
// elab_open_commute' e2 v n
| Tm_Pure p ->
elab_open_commute' p v n
| Tm_Star e1 e2 ->
elab_open_commute' e1 v n;
elab_open_commute' e2 v n
| Tm_ExistsSL u t body
| Tm_ForallSL u t body ->
elab_open_commute' t.binder_ty v n;
elab_open_commute' body v (n + 1)
| Tm_FStar t -> ()
let elab_comp_open_commute' (c:comp) (v:term) (n:index)
: Lemma (ensures
RT.subst_term (elab_comp c) [ RT.DT n (elab_term v) ] ==
elab_comp (open_comp' c v n))
= match c with
| C_Tot t -> elab_open_commute' t v n
| C_ST s ->
elab_open_commute' s.res v n;
elab_open_commute' s.pre v n;
elab_open_commute' s.post v (n + 1)
| C_STAtomic inames s
| C_STGhost inames s ->
elab_open_commute' inames v n;
elab_open_commute' s.res v n;
elab_open_commute' s.pre v n;
elab_open_commute' s.post v (n + 1)
let rec elab_close_commute' (e:term)
(v:var)
(n:index)
: Lemma (ensures (
RT.subst_term (elab_term e) [ RT.ND v n ] ==
elab_term (close_term' e v n))) | false | false | Pulse.Elaborate.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 10,
"initial_ifuel": 10,
"max_fuel": 10,
"max_ifuel": 10,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 30,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val elab_close_commute' (e:term)
(v:var)
(n:index)
: Lemma (RT.subst_term (elab_term e) [ RT.ND v n ] ==
elab_term (close_term' e v n)) | [
"recursion"
] | Pulse.Elaborate.elab_close_commute' | {
"file_name": "lib/steel/pulse/Pulse.Elaborate.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | e: Pulse.Syntax.Base.term -> v: Pulse.Syntax.Base.var -> n: Pulse.Syntax.Base.index
-> FStar.Pervasives.Lemma
(ensures
FStar.Reflection.Typing.subst_term (Pulse.Elaborate.Pure.elab_term e)
[FStar.Reflection.Typing.ND v n] ==
Pulse.Elaborate.Pure.elab_term (Pulse.Syntax.Naming.close_term' e v n)) (decreases e) | {
"end_col": 22,
"end_line": 91,
"start_col": 4,
"start_line": 76
} |
FStar.Pervasives.Lemma | val elab_freevars_comp_eq (c: comp)
: Lemma (Set.equal (freevars_comp c) (RT.freevars (elab_comp c))) | [
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Core",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Naming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Core",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let elab_freevars_comp_eq (c:comp)
: Lemma (Set.equal (freevars_comp c) (RT.freevars (elab_comp c))) =
match c with
| C_Tot t -> elab_freevars_eq t
| C_ST st ->
elab_freevars_eq st.res;
elab_freevars_eq st.pre;
elab_freevars_eq st.post
| C_STAtomic inames st
| C_STGhost inames st ->
elab_freevars_eq inames;
elab_freevars_eq st.res;
elab_freevars_eq st.pre;
elab_freevars_eq st.post | val elab_freevars_comp_eq (c: comp)
: Lemma (Set.equal (freevars_comp c) (RT.freevars (elab_comp c)))
let elab_freevars_comp_eq (c: comp)
: Lemma (Set.equal (freevars_comp c) (RT.freevars (elab_comp c))) = | false | null | true | match c with
| C_Tot t -> elab_freevars_eq t
| C_ST st ->
elab_freevars_eq st.res;
elab_freevars_eq st.pre;
elab_freevars_eq st.post
| C_STAtomic inames st
| C_STGhost inames st ->
elab_freevars_eq inames;
elab_freevars_eq st.res;
elab_freevars_eq st.pre;
elab_freevars_eq st.post | {
"checked_file": "Pulse.Elaborate.fst.checked",
"dependencies": [
"Pulse.Typing.fst.checked",
"Pulse.Syntax.fst.checked",
"Pulse.Elaborate.Core.fst.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": true,
"source_file": "Pulse.Elaborate.fst"
} | [
"lemma"
] | [
"Pulse.Syntax.Base.comp",
"Pulse.Syntax.Base.term",
"Pulse.Elaborate.elab_freevars_eq",
"Pulse.Syntax.Base.st_comp",
"Pulse.Syntax.Base.__proj__Mkst_comp__item__post",
"Prims.unit",
"Pulse.Syntax.Base.__proj__Mkst_comp__item__pre",
"Pulse.Syntax.Base.__proj__Mkst_comp__item__res",
"Prims.l_True",
"Prims.squash",
"FStar.Set.equal",
"Pulse.Syntax.Base.var",
"Pulse.Syntax.Naming.freevars_comp",
"FStar.Reflection.Typing.freevars",
"Pulse.Elaborate.Pure.elab_comp",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Pulse.Elaborate
module RT = FStar.Reflection.Typing
module R = FStar.Reflection.V2
module L = FStar.List.Tot
module T = FStar.Tactics.V2
open FStar.List.Tot
open Pulse.Syntax
open Pulse.Typing
open Pulse.Elaborate.Core
// let rec elab_term_bv_sort (t:term)
// : Lemma
// (ensures
// (R.Tv_Var? (R.inspect_ln (elab_term t)) \/
// R.Tv_BVar? (R.inspect_ln (elab_term t))) ==>
// (match R.inspect_ln (elab_term t) with
// | R.Tv_Var bv
// | R.Tv_BVar bv ->
// let vv = R.inspect_bv bv in
// vv.bv_sort == RT.tun))
// = admit()
#push-options "--fuel 10 --ifuel 10 --z3rlimit_factor 30 --query_stats --z3cliopt 'smt.qi.eager_threshold=100'"
let rec elab_open_commute' (e:term)
(v:term)
(n:index)
: Lemma (ensures
RT.subst_term (elab_term e) [ RT.DT n (elab_term v) ] ==
elab_term (open_term' e v n))
(decreases e)
= match e.t with
| Tm_Emp
| Tm_Inames
| Tm_EmpInames
| Tm_VProp
| Tm_Unknown -> ()
// | Tm_PureApp e1 _ e2 ->
// elab_open_commute' e1 v n;
// elab_open_commute' e2 v n
| Tm_Pure p ->
elab_open_commute' p v n
| Tm_Star e1 e2 ->
elab_open_commute' e1 v n;
elab_open_commute' e2 v n
| Tm_ExistsSL u t body
| Tm_ForallSL u t body ->
elab_open_commute' t.binder_ty v n;
elab_open_commute' body v (n + 1)
| Tm_FStar t -> ()
let elab_comp_open_commute' (c:comp) (v:term) (n:index)
: Lemma (ensures
RT.subst_term (elab_comp c) [ RT.DT n (elab_term v) ] ==
elab_comp (open_comp' c v n))
= match c with
| C_Tot t -> elab_open_commute' t v n
| C_ST s ->
elab_open_commute' s.res v n;
elab_open_commute' s.pre v n;
elab_open_commute' s.post v (n + 1)
| C_STAtomic inames s
| C_STGhost inames s ->
elab_open_commute' inames v n;
elab_open_commute' s.res v n;
elab_open_commute' s.pre v n;
elab_open_commute' s.post v (n + 1)
let rec elab_close_commute' (e:term)
(v:var)
(n:index)
: Lemma (ensures (
RT.subst_term (elab_term e) [ RT.ND v n ] ==
elab_term (close_term' e v n)))
(decreases e)
= match e.t with
| Tm_Emp
| Tm_Inames
| Tm_EmpInames
| Tm_VProp
| Tm_Unknown -> ()
| Tm_Pure p ->
elab_close_commute' p v n
| Tm_Star e1 e2 ->
elab_close_commute' e1 v n;
elab_close_commute' e2 v n
| Tm_ExistsSL _ t body
| Tm_ForallSL _ t body ->
elab_close_commute' t.binder_ty v n;
elab_close_commute' body v (n + 1)
| Tm_FStar _ -> ()
let elab_comp_close_commute' (c:comp) (v:var) (n:index)
: Lemma (ensures
RT.subst_term (elab_comp c) [ RT.ND v n ] ==
elab_comp (close_comp' c v n))
(decreases c)
= match c with
| C_Tot t -> elab_close_commute' t v n
| C_ST s ->
elab_close_commute' s.res v n;
elab_close_commute' s.pre v n;
elab_close_commute' s.post v (n + 1)
| C_STAtomic inames s
| C_STGhost inames s ->
elab_close_commute' inames v n;
elab_close_commute' s.res v n;
elab_close_commute' s.pre v n;
elab_close_commute' s.post v (n + 1)
let elab_open_commute (t:term) (x:var)
: Lemma (elab_term (open_term t x) == RT.open_term (elab_term t) x)
= RT.open_term_spec (elab_term t) x;
elab_open_commute' t (null_var x) 0
let elab_comp_close_commute (c:comp) (x:var)
: Lemma (elab_comp (close_comp c x) == RT.close_term (elab_comp c) x)
= RT.close_term_spec (elab_comp c) x;
elab_comp_close_commute' c x 0
let elab_comp_open_commute (c:comp) (x:term)
: Lemma (elab_comp (open_comp_with c x) == RT.open_with (elab_comp c) (elab_term x))
= RT.open_with_spec (elab_comp c) (elab_term x);
elab_comp_open_commute' c x 0
let rec elab_ln t i =
match t.t with
| Tm_Emp -> ()
| Tm_Pure t -> elab_ln t i
| Tm_Star l r ->
elab_ln l i;
elab_ln r i
| Tm_ExistsSL _ t body
| Tm_ForallSL _ t body ->
elab_ln t.binder_ty i;
elab_ln body (i + 1)
| Tm_VProp
| Tm_Inames
| Tm_EmpInames
| Tm_Unknown
| Tm_FStar _ -> ()
let elab_ln_comp (c:comp) (i:int)
: Lemma (requires ln_c' c i)
(ensures RT.ln' (elab_comp c) i) =
match c with
| C_Tot t -> elab_ln t i
| C_ST st ->
elab_ln st.res i;
elab_ln st.pre i;
elab_ln st.post (i + 1)
| C_STAtomic inames st
| C_STGhost inames st ->
elab_ln inames i;
elab_ln st.res i;
elab_ln st.pre i;
elab_ln st.post (i + 1)
let rec elab_freevars_eq (e:term)
: Lemma (Set.equal (freevars e) (RT.freevars (elab_term e))) =
match e.t with
| Tm_Emp -> ()
| Tm_Pure t -> elab_freevars_eq t
| Tm_Star l r ->
elab_freevars_eq l;
elab_freevars_eq r
| Tm_ExistsSL _ t body
| Tm_ForallSL _ t body ->
elab_freevars_eq t.binder_ty;
elab_freevars_eq body
| Tm_VProp
| Tm_Inames
| Tm_EmpInames
| Tm_Unknown
| Tm_FStar _ -> ()
let elab_freevars_comp_eq (c:comp)
: Lemma (Set.equal (freevars_comp c) (RT.freevars (elab_comp c))) = | false | false | Pulse.Elaborate.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 10,
"initial_ifuel": 10,
"max_fuel": 10,
"max_ifuel": 10,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 30,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val elab_freevars_comp_eq (c: comp)
: Lemma (Set.equal (freevars_comp c) (RT.freevars (elab_comp c))) | [] | Pulse.Elaborate.elab_freevars_comp_eq | {
"file_name": "lib/steel/pulse/Pulse.Elaborate.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | c: Pulse.Syntax.Base.comp
-> FStar.Pervasives.Lemma
(ensures
FStar.Set.equal (Pulse.Syntax.Naming.freevars_comp c)
(FStar.Reflection.Typing.freevars (Pulse.Elaborate.Pure.elab_comp c))) | {
"end_col": 28,
"end_line": 192,
"start_col": 2,
"start_line": 181
} |
FStar.Pervasives.Lemma | val elab_freevars_eq (e: term) : Lemma (Set.equal (freevars e) (RT.freevars (elab_term e))) | [
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Core",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Naming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Core",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec elab_freevars_eq (e:term)
: Lemma (Set.equal (freevars e) (RT.freevars (elab_term e))) =
match e.t with
| Tm_Emp -> ()
| Tm_Pure t -> elab_freevars_eq t
| Tm_Star l r ->
elab_freevars_eq l;
elab_freevars_eq r
| Tm_ExistsSL _ t body
| Tm_ForallSL _ t body ->
elab_freevars_eq t.binder_ty;
elab_freevars_eq body
| Tm_VProp
| Tm_Inames
| Tm_EmpInames
| Tm_Unknown
| Tm_FStar _ -> () | val elab_freevars_eq (e: term) : Lemma (Set.equal (freevars e) (RT.freevars (elab_term e)))
let rec elab_freevars_eq (e: term) : Lemma (Set.equal (freevars e) (RT.freevars (elab_term e))) = | false | null | true | match e.t with
| Tm_Emp -> ()
| Tm_Pure t -> elab_freevars_eq t
| Tm_Star l r ->
elab_freevars_eq l;
elab_freevars_eq r
| Tm_ExistsSL _ t body
| Tm_ForallSL _ t body ->
elab_freevars_eq t.binder_ty;
elab_freevars_eq body
| Tm_VProp | Tm_Inames | Tm_EmpInames | Tm_Unknown | Tm_FStar _ -> () | {
"checked_file": "Pulse.Elaborate.fst.checked",
"dependencies": [
"Pulse.Typing.fst.checked",
"Pulse.Syntax.fst.checked",
"Pulse.Elaborate.Core.fst.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": true,
"source_file": "Pulse.Elaborate.fst"
} | [
"lemma"
] | [
"Pulse.Syntax.Base.term",
"Pulse.Syntax.Base.__proj__Mkterm__item__t",
"Pulse.Elaborate.elab_freevars_eq",
"Prims.unit",
"Pulse.Syntax.Base.universe",
"Pulse.Syntax.Base.binder",
"Pulse.Syntax.Base.__proj__Mkbinder__item__binder_ty",
"Pulse.Syntax.Base.host_term",
"Prims.l_True",
"Prims.squash",
"FStar.Set.equal",
"Pulse.Syntax.Base.var",
"Pulse.Syntax.Naming.freevars",
"FStar.Reflection.Typing.freevars",
"Pulse.Elaborate.Pure.elab_term",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Pulse.Elaborate
module RT = FStar.Reflection.Typing
module R = FStar.Reflection.V2
module L = FStar.List.Tot
module T = FStar.Tactics.V2
open FStar.List.Tot
open Pulse.Syntax
open Pulse.Typing
open Pulse.Elaborate.Core
// let rec elab_term_bv_sort (t:term)
// : Lemma
// (ensures
// (R.Tv_Var? (R.inspect_ln (elab_term t)) \/
// R.Tv_BVar? (R.inspect_ln (elab_term t))) ==>
// (match R.inspect_ln (elab_term t) with
// | R.Tv_Var bv
// | R.Tv_BVar bv ->
// let vv = R.inspect_bv bv in
// vv.bv_sort == RT.tun))
// = admit()
#push-options "--fuel 10 --ifuel 10 --z3rlimit_factor 30 --query_stats --z3cliopt 'smt.qi.eager_threshold=100'"
let rec elab_open_commute' (e:term)
(v:term)
(n:index)
: Lemma (ensures
RT.subst_term (elab_term e) [ RT.DT n (elab_term v) ] ==
elab_term (open_term' e v n))
(decreases e)
= match e.t with
| Tm_Emp
| Tm_Inames
| Tm_EmpInames
| Tm_VProp
| Tm_Unknown -> ()
// | Tm_PureApp e1 _ e2 ->
// elab_open_commute' e1 v n;
// elab_open_commute' e2 v n
| Tm_Pure p ->
elab_open_commute' p v n
| Tm_Star e1 e2 ->
elab_open_commute' e1 v n;
elab_open_commute' e2 v n
| Tm_ExistsSL u t body
| Tm_ForallSL u t body ->
elab_open_commute' t.binder_ty v n;
elab_open_commute' body v (n + 1)
| Tm_FStar t -> ()
let elab_comp_open_commute' (c:comp) (v:term) (n:index)
: Lemma (ensures
RT.subst_term (elab_comp c) [ RT.DT n (elab_term v) ] ==
elab_comp (open_comp' c v n))
= match c with
| C_Tot t -> elab_open_commute' t v n
| C_ST s ->
elab_open_commute' s.res v n;
elab_open_commute' s.pre v n;
elab_open_commute' s.post v (n + 1)
| C_STAtomic inames s
| C_STGhost inames s ->
elab_open_commute' inames v n;
elab_open_commute' s.res v n;
elab_open_commute' s.pre v n;
elab_open_commute' s.post v (n + 1)
let rec elab_close_commute' (e:term)
(v:var)
(n:index)
: Lemma (ensures (
RT.subst_term (elab_term e) [ RT.ND v n ] ==
elab_term (close_term' e v n)))
(decreases e)
= match e.t with
| Tm_Emp
| Tm_Inames
| Tm_EmpInames
| Tm_VProp
| Tm_Unknown -> ()
| Tm_Pure p ->
elab_close_commute' p v n
| Tm_Star e1 e2 ->
elab_close_commute' e1 v n;
elab_close_commute' e2 v n
| Tm_ExistsSL _ t body
| Tm_ForallSL _ t body ->
elab_close_commute' t.binder_ty v n;
elab_close_commute' body v (n + 1)
| Tm_FStar _ -> ()
let elab_comp_close_commute' (c:comp) (v:var) (n:index)
: Lemma (ensures
RT.subst_term (elab_comp c) [ RT.ND v n ] ==
elab_comp (close_comp' c v n))
(decreases c)
= match c with
| C_Tot t -> elab_close_commute' t v n
| C_ST s ->
elab_close_commute' s.res v n;
elab_close_commute' s.pre v n;
elab_close_commute' s.post v (n + 1)
| C_STAtomic inames s
| C_STGhost inames s ->
elab_close_commute' inames v n;
elab_close_commute' s.res v n;
elab_close_commute' s.pre v n;
elab_close_commute' s.post v (n + 1)
let elab_open_commute (t:term) (x:var)
: Lemma (elab_term (open_term t x) == RT.open_term (elab_term t) x)
= RT.open_term_spec (elab_term t) x;
elab_open_commute' t (null_var x) 0
let elab_comp_close_commute (c:comp) (x:var)
: Lemma (elab_comp (close_comp c x) == RT.close_term (elab_comp c) x)
= RT.close_term_spec (elab_comp c) x;
elab_comp_close_commute' c x 0
let elab_comp_open_commute (c:comp) (x:term)
: Lemma (elab_comp (open_comp_with c x) == RT.open_with (elab_comp c) (elab_term x))
= RT.open_with_spec (elab_comp c) (elab_term x);
elab_comp_open_commute' c x 0
let rec elab_ln t i =
match t.t with
| Tm_Emp -> ()
| Tm_Pure t -> elab_ln t i
| Tm_Star l r ->
elab_ln l i;
elab_ln r i
| Tm_ExistsSL _ t body
| Tm_ForallSL _ t body ->
elab_ln t.binder_ty i;
elab_ln body (i + 1)
| Tm_VProp
| Tm_Inames
| Tm_EmpInames
| Tm_Unknown
| Tm_FStar _ -> ()
let elab_ln_comp (c:comp) (i:int)
: Lemma (requires ln_c' c i)
(ensures RT.ln' (elab_comp c) i) =
match c with
| C_Tot t -> elab_ln t i
| C_ST st ->
elab_ln st.res i;
elab_ln st.pre i;
elab_ln st.post (i + 1)
| C_STAtomic inames st
| C_STGhost inames st ->
elab_ln inames i;
elab_ln st.res i;
elab_ln st.pre i;
elab_ln st.post (i + 1)
let rec elab_freevars_eq (e:term) | false | false | Pulse.Elaborate.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 10,
"initial_ifuel": 10,
"max_fuel": 10,
"max_ifuel": 10,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 30,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val elab_freevars_eq (e: term) : Lemma (Set.equal (freevars e) (RT.freevars (elab_term e))) | [
"recursion"
] | Pulse.Elaborate.elab_freevars_eq | {
"file_name": "lib/steel/pulse/Pulse.Elaborate.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | e: Pulse.Syntax.Base.term
-> FStar.Pervasives.Lemma
(ensures
FStar.Set.equal (Pulse.Syntax.Naming.freevars e)
(FStar.Reflection.Typing.freevars (Pulse.Elaborate.Pure.elab_term e))) | {
"end_col": 20,
"end_line": 176,
"start_col": 2,
"start_line": 162
} |
FStar.Pervasives.Lemma | val elab_comp_open_commute' (c: comp) (v: term) (n: index)
: Lemma
(ensures RT.subst_term (elab_comp c) [RT.DT n (elab_term v)] == elab_comp (open_comp' c v n)) | [
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Core",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Naming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Core",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let elab_comp_open_commute' (c:comp) (v:term) (n:index)
: Lemma (ensures
RT.subst_term (elab_comp c) [ RT.DT n (elab_term v) ] ==
elab_comp (open_comp' c v n))
= match c with
| C_Tot t -> elab_open_commute' t v n
| C_ST s ->
elab_open_commute' s.res v n;
elab_open_commute' s.pre v n;
elab_open_commute' s.post v (n + 1)
| C_STAtomic inames s
| C_STGhost inames s ->
elab_open_commute' inames v n;
elab_open_commute' s.res v n;
elab_open_commute' s.pre v n;
elab_open_commute' s.post v (n + 1) | val elab_comp_open_commute' (c: comp) (v: term) (n: index)
: Lemma
(ensures RT.subst_term (elab_comp c) [RT.DT n (elab_term v)] == elab_comp (open_comp' c v n))
let elab_comp_open_commute' (c: comp) (v: term) (n: index)
: Lemma
(ensures RT.subst_term (elab_comp c) [RT.DT n (elab_term v)] == elab_comp (open_comp' c v n)) = | false | null | true | match c with
| C_Tot t -> elab_open_commute' t v n
| C_ST s ->
elab_open_commute' s.res v n;
elab_open_commute' s.pre v n;
elab_open_commute' s.post v (n + 1)
| C_STAtomic inames s
| C_STGhost inames s ->
elab_open_commute' inames v n;
elab_open_commute' s.res v n;
elab_open_commute' s.pre v n;
elab_open_commute' s.post v (n + 1) | {
"checked_file": "Pulse.Elaborate.fst.checked",
"dependencies": [
"Pulse.Typing.fst.checked",
"Pulse.Syntax.fst.checked",
"Pulse.Elaborate.Core.fst.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": true,
"source_file": "Pulse.Elaborate.fst"
} | [
"lemma"
] | [
"Pulse.Syntax.Base.comp",
"Pulse.Syntax.Base.term",
"Pulse.Syntax.Base.index",
"Pulse.Elaborate.elab_open_commute'",
"Pulse.Syntax.Base.st_comp",
"Pulse.Syntax.Base.__proj__Mkst_comp__item__post",
"Prims.op_Addition",
"Prims.unit",
"Pulse.Syntax.Base.__proj__Mkst_comp__item__pre",
"Pulse.Syntax.Base.__proj__Mkst_comp__item__res",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Reflection.Types.term",
"FStar.Reflection.Typing.subst_term",
"Pulse.Elaborate.Pure.elab_comp",
"Prims.Cons",
"FStar.Reflection.Typing.subst_elt",
"FStar.Reflection.Typing.DT",
"Pulse.Elaborate.Pure.elab_term",
"Prims.Nil",
"Pulse.Syntax.Naming.open_comp'",
"FStar.Pervasives.pattern"
] | [] | module Pulse.Elaborate
module RT = FStar.Reflection.Typing
module R = FStar.Reflection.V2
module L = FStar.List.Tot
module T = FStar.Tactics.V2
open FStar.List.Tot
open Pulse.Syntax
open Pulse.Typing
open Pulse.Elaborate.Core
// let rec elab_term_bv_sort (t:term)
// : Lemma
// (ensures
// (R.Tv_Var? (R.inspect_ln (elab_term t)) \/
// R.Tv_BVar? (R.inspect_ln (elab_term t))) ==>
// (match R.inspect_ln (elab_term t) with
// | R.Tv_Var bv
// | R.Tv_BVar bv ->
// let vv = R.inspect_bv bv in
// vv.bv_sort == RT.tun))
// = admit()
#push-options "--fuel 10 --ifuel 10 --z3rlimit_factor 30 --query_stats --z3cliopt 'smt.qi.eager_threshold=100'"
let rec elab_open_commute' (e:term)
(v:term)
(n:index)
: Lemma (ensures
RT.subst_term (elab_term e) [ RT.DT n (elab_term v) ] ==
elab_term (open_term' e v n))
(decreases e)
= match e.t with
| Tm_Emp
| Tm_Inames
| Tm_EmpInames
| Tm_VProp
| Tm_Unknown -> ()
// | Tm_PureApp e1 _ e2 ->
// elab_open_commute' e1 v n;
// elab_open_commute' e2 v n
| Tm_Pure p ->
elab_open_commute' p v n
| Tm_Star e1 e2 ->
elab_open_commute' e1 v n;
elab_open_commute' e2 v n
| Tm_ExistsSL u t body
| Tm_ForallSL u t body ->
elab_open_commute' t.binder_ty v n;
elab_open_commute' body v (n + 1)
| Tm_FStar t -> ()
let elab_comp_open_commute' (c:comp) (v:term) (n:index)
: Lemma (ensures
RT.subst_term (elab_comp c) [ RT.DT n (elab_term v) ] == | false | false | Pulse.Elaborate.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 10,
"initial_ifuel": 10,
"max_fuel": 10,
"max_ifuel": 10,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 30,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val elab_comp_open_commute' (c: comp) (v: term) (n: index)
: Lemma
(ensures RT.subst_term (elab_comp c) [RT.DT n (elab_term v)] == elab_comp (open_comp' c v n)) | [] | Pulse.Elaborate.elab_comp_open_commute' | {
"file_name": "lib/steel/pulse/Pulse.Elaborate.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | c: Pulse.Syntax.Base.comp -> v: Pulse.Syntax.Base.term -> n: Pulse.Syntax.Base.index
-> FStar.Pervasives.Lemma
(ensures
FStar.Reflection.Typing.subst_term (Pulse.Elaborate.Pure.elab_comp c)
[FStar.Reflection.Typing.DT n (Pulse.Elaborate.Pure.elab_term v)] ==
Pulse.Elaborate.Pure.elab_comp (Pulse.Syntax.Naming.open_comp' c v n)) | {
"end_col": 41,
"end_line": 67,
"start_col": 4,
"start_line": 56
} |
FStar.Pervasives.Lemma | val elab_comp_close_commute' (c: comp) (v: var) (n: index)
: Lemma (ensures RT.subst_term (elab_comp c) [RT.ND v n] == elab_comp (close_comp' c v n))
(decreases c) | [
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Core",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax.Naming",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Core",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let elab_comp_close_commute' (c:comp) (v:var) (n:index)
: Lemma (ensures
RT.subst_term (elab_comp c) [ RT.ND v n ] ==
elab_comp (close_comp' c v n))
(decreases c)
= match c with
| C_Tot t -> elab_close_commute' t v n
| C_ST s ->
elab_close_commute' s.res v n;
elab_close_commute' s.pre v n;
elab_close_commute' s.post v (n + 1)
| C_STAtomic inames s
| C_STGhost inames s ->
elab_close_commute' inames v n;
elab_close_commute' s.res v n;
elab_close_commute' s.pre v n;
elab_close_commute' s.post v (n + 1) | val elab_comp_close_commute' (c: comp) (v: var) (n: index)
: Lemma (ensures RT.subst_term (elab_comp c) [RT.ND v n] == elab_comp (close_comp' c v n))
(decreases c)
let elab_comp_close_commute' (c: comp) (v: var) (n: index)
: Lemma (ensures RT.subst_term (elab_comp c) [RT.ND v n] == elab_comp (close_comp' c v n))
(decreases c) = | false | null | true | match c with
| C_Tot t -> elab_close_commute' t v n
| C_ST s ->
elab_close_commute' s.res v n;
elab_close_commute' s.pre v n;
elab_close_commute' s.post v (n + 1)
| C_STAtomic inames s
| C_STGhost inames s ->
elab_close_commute' inames v n;
elab_close_commute' s.res v n;
elab_close_commute' s.pre v n;
elab_close_commute' s.post v (n + 1) | {
"checked_file": "Pulse.Elaborate.fst.checked",
"dependencies": [
"Pulse.Typing.fst.checked",
"Pulse.Syntax.fst.checked",
"Pulse.Elaborate.Core.fst.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": true,
"source_file": "Pulse.Elaborate.fst"
} | [
"lemma",
""
] | [
"Pulse.Syntax.Base.comp",
"Pulse.Syntax.Base.var",
"Pulse.Syntax.Base.index",
"Pulse.Syntax.Base.term",
"Pulse.Elaborate.elab_close_commute'",
"Pulse.Syntax.Base.st_comp",
"Pulse.Syntax.Base.__proj__Mkst_comp__item__post",
"Prims.op_Addition",
"Prims.unit",
"Pulse.Syntax.Base.__proj__Mkst_comp__item__pre",
"Pulse.Syntax.Base.__proj__Mkst_comp__item__res",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Reflection.Types.term",
"FStar.Reflection.Typing.subst_term",
"Pulse.Elaborate.Pure.elab_comp",
"Prims.Cons",
"FStar.Reflection.Typing.subst_elt",
"FStar.Reflection.Typing.ND",
"Prims.Nil",
"Pulse.Syntax.Naming.close_comp'",
"FStar.Pervasives.pattern"
] | [] | module Pulse.Elaborate
module RT = FStar.Reflection.Typing
module R = FStar.Reflection.V2
module L = FStar.List.Tot
module T = FStar.Tactics.V2
open FStar.List.Tot
open Pulse.Syntax
open Pulse.Typing
open Pulse.Elaborate.Core
// let rec elab_term_bv_sort (t:term)
// : Lemma
// (ensures
// (R.Tv_Var? (R.inspect_ln (elab_term t)) \/
// R.Tv_BVar? (R.inspect_ln (elab_term t))) ==>
// (match R.inspect_ln (elab_term t) with
// | R.Tv_Var bv
// | R.Tv_BVar bv ->
// let vv = R.inspect_bv bv in
// vv.bv_sort == RT.tun))
// = admit()
#push-options "--fuel 10 --ifuel 10 --z3rlimit_factor 30 --query_stats --z3cliopt 'smt.qi.eager_threshold=100'"
let rec elab_open_commute' (e:term)
(v:term)
(n:index)
: Lemma (ensures
RT.subst_term (elab_term e) [ RT.DT n (elab_term v) ] ==
elab_term (open_term' e v n))
(decreases e)
= match e.t with
| Tm_Emp
| Tm_Inames
| Tm_EmpInames
| Tm_VProp
| Tm_Unknown -> ()
// | Tm_PureApp e1 _ e2 ->
// elab_open_commute' e1 v n;
// elab_open_commute' e2 v n
| Tm_Pure p ->
elab_open_commute' p v n
| Tm_Star e1 e2 ->
elab_open_commute' e1 v n;
elab_open_commute' e2 v n
| Tm_ExistsSL u t body
| Tm_ForallSL u t body ->
elab_open_commute' t.binder_ty v n;
elab_open_commute' body v (n + 1)
| Tm_FStar t -> ()
let elab_comp_open_commute' (c:comp) (v:term) (n:index)
: Lemma (ensures
RT.subst_term (elab_comp c) [ RT.DT n (elab_term v) ] ==
elab_comp (open_comp' c v n))
= match c with
| C_Tot t -> elab_open_commute' t v n
| C_ST s ->
elab_open_commute' s.res v n;
elab_open_commute' s.pre v n;
elab_open_commute' s.post v (n + 1)
| C_STAtomic inames s
| C_STGhost inames s ->
elab_open_commute' inames v n;
elab_open_commute' s.res v n;
elab_open_commute' s.pre v n;
elab_open_commute' s.post v (n + 1)
let rec elab_close_commute' (e:term)
(v:var)
(n:index)
: Lemma (ensures (
RT.subst_term (elab_term e) [ RT.ND v n ] ==
elab_term (close_term' e v n)))
(decreases e)
= match e.t with
| Tm_Emp
| Tm_Inames
| Tm_EmpInames
| Tm_VProp
| Tm_Unknown -> ()
| Tm_Pure p ->
elab_close_commute' p v n
| Tm_Star e1 e2 ->
elab_close_commute' e1 v n;
elab_close_commute' e2 v n
| Tm_ExistsSL _ t body
| Tm_ForallSL _ t body ->
elab_close_commute' t.binder_ty v n;
elab_close_commute' body v (n + 1)
| Tm_FStar _ -> ()
let elab_comp_close_commute' (c:comp) (v:var) (n:index)
: Lemma (ensures
RT.subst_term (elab_comp c) [ RT.ND v n ] ==
elab_comp (close_comp' c v n)) | false | false | Pulse.Elaborate.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 10,
"initial_ifuel": 10,
"max_fuel": 10,
"max_ifuel": 10,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 30,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val elab_comp_close_commute' (c: comp) (v: var) (n: index)
: Lemma (ensures RT.subst_term (elab_comp c) [RT.ND v n] == elab_comp (close_comp' c v n))
(decreases c) | [] | Pulse.Elaborate.elab_comp_close_commute' | {
"file_name": "lib/steel/pulse/Pulse.Elaborate.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | c: Pulse.Syntax.Base.comp -> v: Pulse.Syntax.Base.var -> n: Pulse.Syntax.Base.index
-> FStar.Pervasives.Lemma
(ensures
FStar.Reflection.Typing.subst_term (Pulse.Elaborate.Pure.elab_comp c)
[FStar.Reflection.Typing.ND v n] ==
Pulse.Elaborate.Pure.elab_comp (Pulse.Syntax.Naming.close_comp' c v n)) (decreases c) | {
"end_col": 42,
"end_line": 109,
"start_col": 4,
"start_line": 98
} |
Prims.Tot | val ins_Cmovc64 : instr_dep [inOut op64] [op64; opFlagsCf] PreserveFlags eval_Cmovc64 | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src]) | val ins_Cmovc64 : instr_dep [inOut op64] [op64; opFlagsCf] PreserveFlags eval_Cmovc64
let ins_Cmovc64 = | false | null | false | make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.op64",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.opFlagsCf",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Cmovc64",
"Vale.X64.Machine_s.operand64",
"Vale.X64.Instruction_s.print_s",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.P64",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Cmovc64 : instr_dep [inOut op64] [op64; opFlagsCf] PreserveFlags eval_Cmovc64 | [] | Vale.X64.Instructions_s.ins_Cmovc64 | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.op64]
[Vale.X64.Instruction_s.op64; Vale.X64.Instruction_s.opFlagsCf]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_Cmovc64 | {
"end_col": 78,
"end_line": 11,
"start_col": 18,
"start_line": 11
} |
Prims.Tot | val ins_MovBe64 : instr_dep [out op64] [op64] PreserveFlags eval_MovBe64 | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src]) | val ins_MovBe64 : instr_dep [out op64] [op64] PreserveFlags eval_MovBe64
let ins_MovBe64 = | false | null | false | make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.op64",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_MovBe64",
"Vale.X64.Machine_s.operand64",
"Vale.X64.Instruction_s.print_s",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.P64",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_MovBe64 : instr_dep [out op64] [op64] PreserveFlags eval_MovBe64 | [] | Vale.X64.Instructions_s.ins_MovBe64 | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.out Vale.X64.Instruction_s.op64]
[Vale.X64.Instruction_s.op64]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_MovBe64 | {
"end_col": 78,
"end_line": 7,
"start_col": 18,
"start_line": 7
} |
Prims.Tot | val ins_Adcx64 : instr_dep [inOut opFlagsCf; inOut op64] [op64] PreserveFlags eval_Adcx64_Adox64 | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src]) | val ins_Adcx64 : instr_dep [inOut opFlagsCf; inOut op64] [op64] PreserveFlags eval_Adcx64_Adox64
let ins_Adcx64 = | false | null | false | make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opFlagsCf",
"Vale.X64.Instruction_s.op64",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Adcx64_Adox64",
"Vale.X64.Machine_s.operand64",
"Vale.X64.Instruction_s.print_s",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.P64",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Adcx64 : instr_dep [inOut opFlagsCf; inOut op64] [op64] PreserveFlags eval_Adcx64_Adox64 | [] | Vale.X64.Instructions_s.ins_Adcx64 | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [
Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.opFlagsCf;
Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.op64
]
[Vale.X64.Instruction_s.op64]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_Adcx64_Adox64 | {
"end_col": 76,
"end_line": 30,
"start_col": 17,
"start_line": 30
} |
Prims.Tot | val ins_AddCarry64 : instr_dep [inOut opFlagsCf; inOut op64] [op64] HavocFlags eval_AddCarry64 | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src]) | val ins_AddCarry64 : instr_dep [inOut opFlagsCf; inOut op64] [op64] HavocFlags eval_AddCarry64
let ins_AddCarry64 = | false | null | false | make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opFlagsCf",
"Vale.X64.Instruction_s.op64",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.HavocFlags",
"Vale.X64.Instructions_s.eval_AddCarry64",
"Vale.X64.Machine_s.operand64",
"Vale.X64.Instruction_s.print_s",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.P64",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_AddCarry64 : instr_dep [inOut opFlagsCf; inOut op64] [op64] HavocFlags eval_AddCarry64 | [] | Vale.X64.Instructions_s.ins_AddCarry64 | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [
Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.opFlagsCf;
Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.op64
]
[Vale.X64.Instruction_s.op64]
Vale.X64.Instruction_s.HavocFlags
Vale.X64.Instructions_s.eval_AddCarry64 | {
"end_col": 79,
"end_line": 28,
"start_col": 21,
"start_line": 28
} |
Prims.Tot | val ins_Mul64 : instr_dep [out (one64Reg rRdx); inOut (one64Reg rRax)] [op64] HavocFlags eval_Mul64 | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src]) | val ins_Mul64 : instr_dep [out (one64Reg rRdx); inOut (one64Reg rRax)] [op64] HavocFlags eval_Mul64
let ins_Mul64 = | false | null | false | make_ins (fun src -> print_s "mul" [P64 src]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.one64Reg",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Machine_s.rRax",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.op64",
"Vale.X64.Instruction_s.HavocFlags",
"Vale.X64.Instructions_s.eval_Mul64",
"Vale.X64.Machine_s.operand64",
"Vale.X64.Instruction_s.print_s",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.P64",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Mul64 : instr_dep [out (one64Reg rRdx); inOut (one64Reg rRax)] [op64] HavocFlags eval_Mul64 | [] | Vale.X64.Instructions_s.ins_Mul64 | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [
Vale.X64.Instruction_s.out (Vale.X64.Instruction_s.one64Reg Vale.X64.Machine_s.rRdx);
Vale.X64.Instruction_s.inOut (Vale.X64.Instruction_s.one64Reg Vale.X64.Machine_s.rRax)
]
[Vale.X64.Instruction_s.op64]
Vale.X64.Instruction_s.HavocFlags
Vale.X64.Instructions_s.eval_Mul64 | {
"end_col": 61,
"end_line": 38,
"start_col": 16,
"start_line": 38
} |
Prims.Tot | val ins_Adox64 : instr_dep [inOut opFlagsOf; inOut op64] [op64] PreserveFlags eval_Adcx64_Adox64 | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src]) | val ins_Adox64 : instr_dep [inOut opFlagsOf; inOut op64] [op64] PreserveFlags eval_Adcx64_Adox64
let ins_Adox64 = | false | null | false | make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opFlagsOf",
"Vale.X64.Instruction_s.op64",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Adcx64_Adox64",
"Vale.X64.Machine_s.operand64",
"Vale.X64.Instruction_s.print_s",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.P64",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Adox64 : instr_dep [inOut opFlagsOf; inOut op64] [op64] PreserveFlags eval_Adcx64_Adox64 | [] | Vale.X64.Instructions_s.ins_Adox64 | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [
Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.opFlagsOf;
Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.op64
]
[Vale.X64.Instruction_s.op64]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_Adcx64_Adox64 | {
"end_col": 76,
"end_line": 32,
"start_col": 17,
"start_line": 32
} |
Prims.Tot | val ins_Shr64 : instr_dep [inOut op64] [op64] HavocFlags eval_Shr64 | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Shr64 = make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt]) | val ins_Shr64 : instr_dep [inOut op64] [op64] HavocFlags eval_Shr64
let ins_Shr64 = | false | null | false | make_ins (fun dst amt -> print_s "shr" [P64 dst; PShift amt]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.op64",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.HavocFlags",
"Vale.X64.Instructions_s.eval_Shr64",
"Vale.X64.Machine_s.operand64",
"Vale.X64.Instruction_s.print_s",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.P64",
"Vale.X64.Instruction_s.PShift",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src])
let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src])
let ins_And64 = make_ins (fun dst src -> print_s "and" [P64 dst; P64 src])
let ins_Xor64 = make_ins (fun dst src -> print_s "xor"
// special idiom for zeroing r: xor64 r, r --> xor32 r, r
(if OReg? dst && dst = src then [P32 dst; P32 src] else [P64 dst; P64 src])) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Shr64 : instr_dep [inOut op64] [op64] HavocFlags eval_Shr64 | [] | Vale.X64.Instructions_s.ins_Shr64 | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.op64]
[Vale.X64.Instruction_s.op64]
Vale.X64.Instruction_s.HavocFlags
Vale.X64.Instructions_s.eval_Shr64 | {
"end_col": 77,
"end_line": 51,
"start_col": 16,
"start_line": 51
} |
Prims.Tot | val ins_IMul64 : instr_dep [inOut op64] [op64] HavocFlags eval_IMul64 | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_IMul64 = make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src]) | val ins_IMul64 : instr_dep [inOut op64] [op64] HavocFlags eval_IMul64
let ins_IMul64 = | false | null | false | make_ins (fun dst src -> print_s "imul" [P64 dst; P64 src]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.op64",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.HavocFlags",
"Vale.X64.Instructions_s.eval_IMul64",
"Vale.X64.Machine_s.operand64",
"Vale.X64.Instruction_s.print_s",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.P64",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src])
let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src])
let ins_Mul64 = make_ins (fun src -> print_s "mul" [P64 src])
let ins_Mulx64 =
make_ins (fun dst_hi dst_lo src -> print_s "mulx" [P64 dst_hi; P64 dst_lo; P64 src]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_IMul64 : instr_dep [inOut op64] [op64] HavocFlags eval_IMul64 | [] | Vale.X64.Instructions_s.ins_IMul64 | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.op64]
[Vale.X64.Instruction_s.op64]
Vale.X64.Instruction_s.HavocFlags
Vale.X64.Instructions_s.eval_IMul64 | {
"end_col": 76,
"end_line": 43,
"start_col": 17,
"start_line": 43
} |
Prims.Tot | val ins_Mov64 : instr_dep [out op64] [op64] PreserveFlags eval_Mov64 | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src]) | val ins_Mov64 : instr_dep [out op64] [op64] PreserveFlags eval_Mov64
let ins_Mov64 = | false | null | false | make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.op64",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.eval_Mov64",
"Vale.X64.Machine_s.operand64",
"Vale.X64.Instruction_s.print_s",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.P64",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Mov64 : instr_dep [out op64] [op64] PreserveFlags eval_Mov64 | [] | Vale.X64.Instructions_s.ins_Mov64 | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [Vale.X64.Instruction_s.out Vale.X64.Instruction_s.op64]
[Vale.X64.Instruction_s.op64]
Vale.X64.Instruction_s.PreserveFlags
Vale.X64.Instructions_s.eval_Mov64 | {
"end_col": 74,
"end_line": 5,
"start_col": 16,
"start_line": 5
} |
Prims.Tot | val ins_Sbb64 : instr_dep [inOut opFlagsCf; inOut op64] [op64] HavocFlags eval_Sbb64 | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ins_Sbb64 = make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src]) | val ins_Sbb64 : instr_dep [inOut opFlagsCf; inOut op64] [op64] HavocFlags eval_Sbb64
let ins_Sbb64 = | false | null | false | make_ins (fun dst src -> print_s "sbb" [P64 dst; P64 src]) | {
"checked_file": "Vale.X64.Instructions_s.fst.checked",
"dependencies": [
"Vale.X64.Instruction_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Instructions_s.fst"
} | [
"total"
] | [
"Vale.X64.Instruction_s.make_ins",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opFlagsCf",
"Vale.X64.Instruction_s.op64",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.HavocFlags",
"Vale.X64.Instructions_s.eval_Sbb64",
"Vale.X64.Machine_s.operand64",
"Vale.X64.Instruction_s.print_s",
"Vale.X64.Instruction_s.instr_print_operand",
"Vale.X64.Instruction_s.P64",
"Vale.X64.Instruction_s.instr_print"
] | [] | module Vale.X64.Instructions_s
open FStar.Mul
friend Vale.X64.Instruction_s // We're part of the trusted specification, so we can friend Instruction_s
let ins_Mov64 = make_ins (fun dst src -> print_s "mov" [P64 dst; P64 src])
let ins_MovBe64 = make_ins (fun dst src -> print_s "movbe" [P64 dst; P64 src])
let ins_Bswap64 = make_ins (fun dst -> print_s "bswap" [P64 dst])
let ins_Cmovc64 = make_ins (fun dst src -> print_s "cmovc" [P64 dst; P64 src])
let ins_Add64 = make_ins (fun dst src -> print_s "add" [P64 dst; P64 src])
let ins_AddLea64 =
make_ins (fun (dst src1 src2:operand64) ->
let m =
match (src1, src2) with
| (OReg r1, OConst i2) -> MReg (Reg 0 r1) i2
| (OReg r1, OReg r2) -> MIndex (Reg 0 r1) 1 (Reg 0 r2) 0
| _ -> MConst pow2_128 // Shouldn't hit this, but if we do, assembler will complain
in
let m = (m, Public) in // taint is not actually printed; we're just using OMem for its printer
// TODO: what's the right suffix here?
// print_s "lea" [P64 dst; P64 (OMem m)])
print "lea" [P64 dst; P64 (OMem m)])
let ins_AddCarry64 = make_ins (fun dst src -> print_s "adc" [P64 dst; P64 src])
let ins_Adcx64 = make_ins (fun dst src -> print_s "adcx" [P64 dst; P64 src])
let ins_Adox64 = make_ins (fun dst src -> print_s "adox" [P64 dst; P64 src])
let ins_Sub64 = make_ins (fun dst src -> print_s "sub" [P64 dst; P64 src]) | false | true | Vale.X64.Instructions_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ins_Sbb64 : instr_dep [inOut opFlagsCf; inOut op64] [op64] HavocFlags eval_Sbb64 | [] | Vale.X64.Instructions_s.ins_Sbb64 | {
"file_name": "vale/specs/hardware/Vale.X64.Instructions_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.X64.Instruction_s.instr_dep [
Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.opFlagsCf;
Vale.X64.Instruction_s.inOut Vale.X64.Instruction_s.op64
]
[Vale.X64.Instruction_s.op64]
Vale.X64.Instruction_s.HavocFlags
Vale.X64.Instructions_s.eval_Sbb64 | {
"end_col": 74,
"end_line": 36,
"start_col": 16,
"start_line": 36
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.