file_name
stringlengths 5
52
| name
stringlengths 4
95
| original_source_type
stringlengths 0
23k
| source_type
stringlengths 9
23k
| source_definition
stringlengths 9
57.9k
| source
dict | source_range
dict | file_context
stringlengths 0
721k
| dependencies
dict | opens_and_abbrevs
listlengths 2
94
| vconfig
dict | interleaved
bool 1
class | verbose_type
stringlengths 1
7.42k
| effect
stringclasses 118
values | effect_flags
sequencelengths 0
2
| mutual_with
sequencelengths 0
11
| ideal_premises
sequencelengths 0
236
| proof_features
sequencelengths 0
1
| is_simple_lemma
bool 2
classes | is_div
bool 2
classes | is_proof
bool 2
classes | is_simply_typed
bool 2
classes | is_type
bool 2
classes | partial_definition
stringlengths 5
3.99k
| completed_definiton
stringlengths 1
1.63M
| isa_cross_project_example
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Lib.ByteSequence.fsti | Lib.ByteSequence.bytes_empty | val bytes_empty:bytes | val bytes_empty:bytes | let bytes_empty: bytes = Seq.Base.empty | {
"file_name": "lib/Lib.ByteSequence.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 39,
"end_line": 59,
"start_col": 0,
"start_line": 59
} | module Lib.ByteSequence
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 30 --max_fuel 0 --max_ifuel 0"
/// Definition of byte-based sequences
unfold inline_for_extraction
type bytes_l (l:secrecy_level) = seq (uint_t U8 l)
unfold inline_for_extraction
type lbytes_l (l:secrecy_level) (len:size_nat) = lseq (uint_t U8 l) len
unfold inline_for_extraction let bytes = bytes_l SEC
unfold inline_for_extraction let lbytes (len:size_nat) = lbytes_l SEC len
unfold inline_for_extraction let pub_bytes = bytes_l PUB
unfold inline_for_extraction let pub_lbytes (len:size_nat) = lbytes_l PUB len
(* Alias *)
unfold inline_for_extraction let bytes_t = bytes
unfold inline_for_extraction let pub_bytes_t = pub_bytes
(** Construct the equality mask for a pair of secret integer sequences *)
val seq_eq_mask: #t:inttype{~(S128? t)} -> #len1:size_nat -> #len2:size_nat
-> b1:lseq (int_t t SEC) len1
-> b2:lseq (int_t t SEC) len2
-> len:size_nat{len <= len1 /\ len <= len2}
-> res:int_t t SEC{
(sub b1 0 len == sub b2 0 len ==> v res == v (ones t SEC)) /\
(sub b1 0 len =!= sub b2 0 len ==> v res == v (zeros t SEC))}
(** Compares two byte sequences and declassifies the result *)
inline_for_extraction
val lbytes_eq: #len:size_nat -> b1:lbytes len -> b2:lbytes len -> b:bool{b <==> b1 == b2}
inline_for_extraction
val mask_select: #t:inttype{~(S128? t)} -> mask:int_t t SEC -> a:int_t t SEC -> b:int_t t SEC -> int_t t SEC
val mask_select_lemma: #t:inttype{~(S128? t)} -> mask:int_t t SEC -> a:int_t t SEC -> b:int_t t SEC -> Lemma
(requires v mask = 0 \/ v mask = v (ones t SEC))
(ensures mask_select mask a b == (if v mask = 0 then b else a))
val seq_mask_select: #t:inttype{~(S128? t)} -> #len:size_nat
-> a:lseq (int_t t SEC) len
-> b:lseq (int_t t SEC) len
-> mask:int_t t SEC
-> Pure (lseq (int_t t SEC) len)
(requires v mask = 0 \/ v mask = v (ones t SEC))
(ensures fun res -> res == (if v mask = 0 then b else a))
/// Constant for empty lbytes | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Lib.ByteSequence.fsti"
} | [
{
"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": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Lib.Sequence.seq (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.SEC) | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.empty",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC"
] | [] | false | false | false | true | false | let bytes_empty:bytes =
| Seq.Base.empty | false |
Hacl.Impl.Lib.fst | Hacl.Impl.Lib.fill_blocks4 | val fill_blocks4:
#t:Type0
-> #a:Type0
-> h0:mem
-> n4:size_t{4 * v n4 <= max_size_t}
-> output:lbuffer t (4ul *! n4)
-> refl:(mem -> i:size_nat{i <= 4 * v n4} -> GTot a)
-> footprint:(i:size_nat{i <= 4 * v n4} -> GTot
(l:B.loc{B.loc_disjoint l (loc output) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}))
-> spec:(mem -> GTot (i:size_nat{i < 4 * v n4} -> a -> a & t))
-> impl:(i:size_t{v i < 4 * v n4} -> Stack unit
(requires fun h ->
modifies (footprint (v i) |+| loc (gsub output 0ul i)) h0 h)
(ensures fun h1 _ h2 ->
(let block1 = gsub output i 1ul in
let c, e = spec h0 (v i) (refl h1 (v i)) in
refl h2 (v i + 1) == c /\ LSeq.index (as_seq h2 block1) 0 == e /\
footprint (v i + 1) `B.loc_includes` footprint (v i) /\
modifies (footprint (v i + 1) |+| (loc block1)) h1 h2))) ->
Stack unit
(requires fun h -> h0 == h /\ live h output)
(ensures fun _ _ h1 -> modifies (footprint (4 * v n4) |+| loc output) h0 h1 /\
(let s, o = LSeq.generate_blocks 4 (v n4) (v n4) (Loops.fixed_a a)
(S.generate_blocks4_f #t #a (v n4) (spec h0)) (refl h0 0) in
refl h1 (4 * v n4) == s /\ as_seq #_ #t h1 output == o)) | val fill_blocks4:
#t:Type0
-> #a:Type0
-> h0:mem
-> n4:size_t{4 * v n4 <= max_size_t}
-> output:lbuffer t (4ul *! n4)
-> refl:(mem -> i:size_nat{i <= 4 * v n4} -> GTot a)
-> footprint:(i:size_nat{i <= 4 * v n4} -> GTot
(l:B.loc{B.loc_disjoint l (loc output) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}))
-> spec:(mem -> GTot (i:size_nat{i < 4 * v n4} -> a -> a & t))
-> impl:(i:size_t{v i < 4 * v n4} -> Stack unit
(requires fun h ->
modifies (footprint (v i) |+| loc (gsub output 0ul i)) h0 h)
(ensures fun h1 _ h2 ->
(let block1 = gsub output i 1ul in
let c, e = spec h0 (v i) (refl h1 (v i)) in
refl h2 (v i + 1) == c /\ LSeq.index (as_seq h2 block1) 0 == e /\
footprint (v i + 1) `B.loc_includes` footprint (v i) /\
modifies (footprint (v i + 1) |+| (loc block1)) h1 h2))) ->
Stack unit
(requires fun h -> h0 == h /\ live h output)
(ensures fun _ _ h1 -> modifies (footprint (4 * v n4) |+| loc output) h0 h1 /\
(let s, o = LSeq.generate_blocks 4 (v n4) (v n4) (Loops.fixed_a a)
(S.generate_blocks4_f #t #a (v n4) (spec h0)) (refl h0 0) in
refl h1 (4 * v n4) == s /\ as_seq #_ #t h1 output == o)) | let fill_blocks4 #t #a h0 n4 output refl footprint spec impl =
fill_blocks h0 4ul n4 output (Loops.fixed_a a)
(fun h i -> refl h (4 * i))
(fun i -> footprint (4 * i))
(fun h0 -> S.generate_blocks4_f #t #a (v n4) (spec h0))
(fun i ->
let h1 = ST.get () in
impl (4ul *! i);
impl (4ul *! i +! 1ul);
impl (4ul *! i +! 2ul);
impl (4ul *! i +! 3ul);
let h2 = ST.get () in
assert (
let c0, e0 = spec h0 (4 * v i) (refl h1 (4 * v i)) in
let c1, e1 = spec h0 (4 * v i + 1) c0 in
let c2, e2 = spec h0 (4 * v i + 2) c1 in
let c3, e3 = spec h0 (4 * v i + 3) c2 in
let res = LSeq.create4 e0 e1 e2 e3 in
LSeq.create4_lemma e0 e1 e2 e3;
let res1 = LSeq.sub (as_seq h2 output) (4 * v i) 4 in
refl h2 (4 * v i + 4) == c3 /\
(LSeq.eq_intro res res1; res1 `LSeq.equal` res))
) | {
"file_name": "code/bignum/Hacl.Impl.Lib.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 120,
"start_col": 0,
"start_line": 98
} | module Hacl.Impl.Lib
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module LSeq = Lib.Sequence
module Loops = Lib.LoopCombinators
module S = Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let fill_elems_st =
#t:Type0
-> #a:Type0
-> h0:mem
-> n:size_t
-> output:lbuffer t n
-> refl:(mem -> i:size_nat{i <= v n} -> GTot a)
-> footprint:(i:size_nat{i <= v n} -> GTot
(l:B.loc{B.loc_disjoint l (loc output) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}))
-> spec:(mem -> GTot (i:size_nat{i < v n} -> a -> a & t))
-> impl:(i:size_t{v i < v n} -> Stack unit
(requires fun h ->
modifies (footprint (v i) |+| loc (gsub output 0ul i)) h0 h)
(ensures fun h1 _ h2 ->
(let block1 = gsub output i 1ul in
let c, e = spec h0 (v i) (refl h1 (v i)) in
refl h2 (v i + 1) == c /\
LSeq.index (as_seq h2 block1) 0 == e /\
footprint (v i + 1) `B.loc_includes` footprint (v i) /\
modifies (footprint (v i + 1) |+| (loc block1)) h1 h2))) ->
Stack unit
(requires fun h -> h0 == h /\ live h output)
(ensures fun _ _ h1 -> modifies (footprint (v n) |+| loc output) h0 h1 /\
(let s, o = S.generate_elems (v n) (v n) (spec h0) (refl h0 0) in
refl h1 (v n) == s /\ as_seq #_ #t h1 output == o))
inline_for_extraction noextract
val fill_elems : fill_elems_st
let fill_elems #t #a h0 n output refl footprint spec impl =
[@inline_let]
let refl' h (i:nat{i <= v n}) : GTot (S.generate_elem_a t a (v n) i) =
refl h i, as_seq h (gsub output 0ul (size i)) in
[@inline_let]
let footprint' i = footprint i |+| loc (gsub output 0ul (size i)) in
[@inline_let]
let spec' h0 = S.generate_elem_f (v n) (spec h0) in
let h0 = ST.get () in
loop h0 n (S.generate_elem_a t a (v n)) refl' footprint' spec'
(fun i ->
Loops.unfold_repeat_gen (v n) (S.generate_elem_a t a (v n)) (spec' h0) (refl' h0 0) (v i);
impl i;
let h = ST.get() in
FStar.Seq.lemma_split (as_seq h (gsub output 0ul (i +! 1ul))) (v i)
);
let h1 = ST.get () in
assert (refl' h1 (v n) ==
Loops.repeat_gen (v n) (S.generate_elem_a t a (v n)) (S.generate_elem_f (v n) (spec h0)) (refl' h0 0))
inline_for_extraction noextract
val fill_blocks4:
#t:Type0
-> #a:Type0
-> h0:mem
-> n4:size_t{4 * v n4 <= max_size_t}
-> output:lbuffer t (4ul *! n4)
-> refl:(mem -> i:size_nat{i <= 4 * v n4} -> GTot a)
-> footprint:(i:size_nat{i <= 4 * v n4} -> GTot
(l:B.loc{B.loc_disjoint l (loc output) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}))
-> spec:(mem -> GTot (i:size_nat{i < 4 * v n4} -> a -> a & t))
-> impl:(i:size_t{v i < 4 * v n4} -> Stack unit
(requires fun h ->
modifies (footprint (v i) |+| loc (gsub output 0ul i)) h0 h)
(ensures fun h1 _ h2 ->
(let block1 = gsub output i 1ul in
let c, e = spec h0 (v i) (refl h1 (v i)) in
refl h2 (v i + 1) == c /\ LSeq.index (as_seq h2 block1) 0 == e /\
footprint (v i + 1) `B.loc_includes` footprint (v i) /\
modifies (footprint (v i + 1) |+| (loc block1)) h1 h2))) ->
Stack unit
(requires fun h -> h0 == h /\ live h output)
(ensures fun _ _ h1 -> modifies (footprint (4 * v n4) |+| loc output) h0 h1 /\
(let s, o = LSeq.generate_blocks 4 (v n4) (v n4) (Loops.fixed_a a)
(S.generate_blocks4_f #t #a (v n4) (spec h0)) (refl h0 0) in
refl h1 (4 * v n4) == s /\ as_seq #_ #t h1 output == o)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.Loops.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Lib.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Lib",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"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": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl",
"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
}
] | {
"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"
} | false |
h0: FStar.Monotonic.HyperStack.mem ->
n4: Lib.IntTypes.size_t{4 * Lib.IntTypes.v n4 <= Lib.IntTypes.max_size_t} ->
output: Lib.Buffer.lbuffer t (4ul *! n4) ->
refl:
(_: FStar.Monotonic.HyperStack.mem -> i: Lib.IntTypes.size_nat{i <= 4 * Lib.IntTypes.v n4}
-> Prims.GTot a) ->
footprint:
(i: Lib.IntTypes.size_nat{i <= 4 * Lib.IntTypes.v n4}
-> Prims.GTot
(l:
LowStar.Monotonic.Buffer.loc
{ LowStar.Monotonic.Buffer.loc_disjoint l (Lib.Buffer.loc output) /\
LowStar.Monotonic.Buffer.loc_includes LowStar.Monotonic.Buffer.address_liveness_insensitive_locs
l })) ->
spec:
(_: FStar.Monotonic.HyperStack.mem
-> Prims.GTot (i: Lib.IntTypes.size_nat{i < 4 * Lib.IntTypes.v n4} -> _: a -> a * t)) ->
impl:
(i: Lib.IntTypes.size_t{Lib.IntTypes.v i < 4 * Lib.IntTypes.v n4}
-> FStar.HyperStack.ST.Stack Prims.unit)
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"FStar.Monotonic.HyperStack.mem",
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.IntTypes.max_size_t",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.op_Star_Bang",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.size_nat",
"LowStar.Monotonic.Buffer.loc",
"Prims.l_and",
"LowStar.Monotonic.Buffer.loc_disjoint",
"Lib.Buffer.loc",
"Lib.Buffer.MUT",
"LowStar.Monotonic.Buffer.loc_includes",
"LowStar.Monotonic.Buffer.address_liveness_insensitive_locs",
"Prims.op_LessThan",
"FStar.Pervasives.Native.tuple2",
"Prims.unit",
"Lib.Buffer.modifies",
"Lib.Buffer.op_Bar_Plus_Bar",
"Lib.Buffer.gsub",
"Prims.eq2",
"Prims.op_Addition",
"Lib.Sequence.index",
"Lib.Buffer.as_seq",
"Lib.Buffer.lbuffer_t",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.fill_blocks",
"Lib.LoopCombinators.fixed_a",
"Hacl.Spec.Lib.generate_blocks4_f",
"Lib.Sequence.lseq",
"Prims._assert",
"Lib.Sequence.equal",
"Lib.Sequence.eq_intro",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Lib.IntTypes.mul",
"Prims.op_Multiply",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.sub",
"Lib.Sequence.create4_lemma",
"Lib.Sequence.create4",
"FStar.HyperStack.ST.get",
"Lib.IntTypes.op_Plus_Bang"
] | [] | false | true | false | false | false | let fill_blocks4 #t #a h0 n4 output refl footprint spec impl =
| fill_blocks h0
4ul
n4
output
(Loops.fixed_a a)
(fun h i -> refl h (4 * i))
(fun i -> footprint (4 * i))
(fun h0 -> S.generate_blocks4_f #t #a (v n4) (spec h0))
(fun i ->
let h1 = ST.get () in
impl (4ul *! i);
impl (4ul *! i +! 1ul);
impl (4ul *! i +! 2ul);
impl (4ul *! i +! 3ul);
let h2 = ST.get () in
assert (let c0, e0 = spec h0 (4 * v i) (refl h1 (4 * v i)) in
let c1, e1 = spec h0 (4 * v i + 1) c0 in
let c2, e2 = spec h0 (4 * v i + 2) c1 in
let c3, e3 = spec h0 (4 * v i + 3) c2 in
let res = LSeq.create4 e0 e1 e2 e3 in
LSeq.create4_lemma e0 e1 e2 e3;
let res1 = LSeq.sub (as_seq h2 output) (4 * v i) 4 in
refl h2 (4 * v i + 4) == c3 /\
(LSeq.eq_intro res res1;
res1 `LSeq.equal` res))) | false |
Vale.AES.AES256_helpers_BE.fsti | Vale.AES.AES256_helpers_BE.quad32_shr32 | val quad32_shr32 (q: quad32) : quad32 | val quad32_shr32 (q: quad32) : quad32 | let quad32_shr32 (q:quad32) : quad32 =
let Mkfour v0 v1 v2 v3 = q in
Mkfour v1 v2 v3 0 | {
"file_name": "vale/code/crypto/aes/Vale.AES.AES256_helpers_BE.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 19,
"end_line": 23,
"start_col": 0,
"start_line": 21
} | module Vale.AES.AES256_helpers_BE
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Arch.Types
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_BE_s
open Vale.Def.Words.Seq_s
// syntax for seq accesses, s.[index] and s.[index] <- value
unfold let (.[]) (#a:Type) (s:seq a) (i:nat{ i < length s}) : Tot a = index s i
unfold let (.[]<-) = Seq.upd
unfold let ( *^ ) = nat32_xor
unfold let ( *^^ ) = quad32_xor
unfold let be_quad32_to_seq (q:quad32) : seq nat32 = four_to_seq_BE q | {
"checked_file": "/",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_BE_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.AES256_helpers_BE.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"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
}
] | {
"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"
} | false | q: Vale.Def.Types_s.quad32 -> Vale.Def.Types_s.quad32 | Prims.Tot | [
"total"
] | [] | [
"Vale.Def.Types_s.quad32",
"Vale.Def.Types_s.nat32",
"Vale.Def.Words_s.Mkfour"
] | [] | false | false | false | true | false | let quad32_shr32 (q: quad32) : quad32 =
| let Mkfour v0 v1 v2 v3 = q in
Mkfour v1 v2 v3 0 | false |
Vale.AES.AES256_helpers_BE.fsti | Vale.AES.AES256_helpers_BE.round_key_256 | val round_key_256 (prev0 prev1: quad32) (round: nat) : quad32 | val round_key_256 (prev0 prev1: quad32) (round: nat) : quad32 | let round_key_256 (prev0 prev1:quad32) (round:nat) : quad32 =
round_key_256_rcon prev0 prev1 (aes_rcon (round / 2 - 1)) round | {
"file_name": "vale/code/crypto/aes/Vale.AES.AES256_helpers_BE.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 65,
"end_line": 45,
"start_col": 0,
"start_line": 44
} | module Vale.AES.AES256_helpers_BE
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Arch.Types
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_BE_s
open Vale.Def.Words.Seq_s
// syntax for seq accesses, s.[index] and s.[index] <- value
unfold let (.[]) (#a:Type) (s:seq a) (i:nat{ i < length s}) : Tot a = index s i
unfold let (.[]<-) = Seq.upd
unfold let ( *^ ) = nat32_xor
unfold let ( *^^ ) = quad32_xor
unfold let be_quad32_to_seq (q:quad32) : seq nat32 = four_to_seq_BE q
let quad32_shr32 (q:quad32) : quad32 =
let Mkfour v0 v1 v2 v3 = q in
Mkfour v1 v2 v3 0
let make_AES256_key (k0 k1:quad32) : Pure (seq nat32)
(requires True)
(ensures fun key -> is_aes_key_word AES_256 key)
=
append (be_quad32_to_seq k0) (be_quad32_to_seq k1)
// Redefine key expansion in terms of quad32 values rather than nat32 values,
// then prove both definitions are equivalent.
let round_key_256_rcon (prev0 prev1:quad32) (rcon:nat32) (round:int) : quad32 =
let Mkfour v0 v1 v2 v3 = prev0 in
let Mkfour v7 _ _ _ = prev1 in
let c1 = if round % 2 = 0 then sub_word (rot_word v7) *^ rcon else sub_word v7 in
let w3 = v3 *^ c1 in
let w2 = v2 *^ w3 in
let w1 = v1 *^ w2 in
let w0 = v0 *^ w1 in
Mkfour w0 w1 w2 w3 | {
"checked_file": "/",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_BE_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.AES256_helpers_BE.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"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
}
] | {
"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"
} | false | prev0: Vale.Def.Types_s.quad32 -> prev1: Vale.Def.Types_s.quad32 -> round: Prims.nat
-> Vale.Def.Types_s.quad32 | Prims.Tot | [
"total"
] | [] | [
"Vale.Def.Types_s.quad32",
"Prims.nat",
"Vale.AES.AES256_helpers_BE.round_key_256_rcon",
"Vale.AES.AES_common_s.aes_rcon",
"Prims.op_Subtraction",
"Prims.op_Division"
] | [] | false | false | false | true | false | let round_key_256 (prev0 prev1: quad32) (round: nat) : quad32 =
| round_key_256_rcon prev0 prev1 (aes_rcon (round / 2 - 1)) round | false |
Vale.AES.AES256_helpers_BE.fsti | Vale.AES.AES256_helpers_BE.be_quad32_to_seq | val be_quad32_to_seq (q: quad32) : seq nat32 | val be_quad32_to_seq (q: quad32) : seq nat32 | let be_quad32_to_seq (q:quad32) : seq nat32 = four_to_seq_BE q | {
"file_name": "vale/code/crypto/aes/Vale.AES.AES256_helpers_BE.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 69,
"end_line": 19,
"start_col": 7,
"start_line": 19
} | module Vale.AES.AES256_helpers_BE
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Arch.Types
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_BE_s
open Vale.Def.Words.Seq_s
// syntax for seq accesses, s.[index] and s.[index] <- value
unfold let (.[]) (#a:Type) (s:seq a) (i:nat{ i < length s}) : Tot a = index s i
unfold let (.[]<-) = Seq.upd
unfold let ( *^ ) = nat32_xor
unfold let ( *^^ ) = quad32_xor | {
"checked_file": "/",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_BE_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.AES256_helpers_BE.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"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
}
] | {
"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"
} | false | q: Vale.Def.Types_s.quad32 -> FStar.Seq.Base.seq Vale.Def.Types_s.nat32 | Prims.Tot | [
"total"
] | [] | [
"Vale.Def.Types_s.quad32",
"Vale.Def.Words.Seq_s.four_to_seq_BE",
"Vale.Def.Types_s.nat32",
"FStar.Seq.Base.seq"
] | [] | false | false | false | true | false | let be_quad32_to_seq (q: quad32) : seq nat32 =
| four_to_seq_BE q | false |
Vale.AES.AES256_helpers_BE.fsti | Vale.AES.AES256_helpers_BE.round_key_256_rcon | val round_key_256_rcon (prev0 prev1: quad32) (rcon: nat32) (round: int) : quad32 | val round_key_256_rcon (prev0 prev1: quad32) (rcon: nat32) (round: int) : quad32 | let round_key_256_rcon (prev0 prev1:quad32) (rcon:nat32) (round:int) : quad32 =
let Mkfour v0 v1 v2 v3 = prev0 in
let Mkfour v7 _ _ _ = prev1 in
let c1 = if round % 2 = 0 then sub_word (rot_word v7) *^ rcon else sub_word v7 in
let w3 = v3 *^ c1 in
let w2 = v2 *^ w3 in
let w1 = v1 *^ w2 in
let w0 = v0 *^ w1 in
Mkfour w0 w1 w2 w3 | {
"file_name": "vale/code/crypto/aes/Vale.AES.AES256_helpers_BE.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 20,
"end_line": 42,
"start_col": 0,
"start_line": 34
} | module Vale.AES.AES256_helpers_BE
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Arch.Types
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_BE_s
open Vale.Def.Words.Seq_s
// syntax for seq accesses, s.[index] and s.[index] <- value
unfold let (.[]) (#a:Type) (s:seq a) (i:nat{ i < length s}) : Tot a = index s i
unfold let (.[]<-) = Seq.upd
unfold let ( *^ ) = nat32_xor
unfold let ( *^^ ) = quad32_xor
unfold let be_quad32_to_seq (q:quad32) : seq nat32 = four_to_seq_BE q
let quad32_shr32 (q:quad32) : quad32 =
let Mkfour v0 v1 v2 v3 = q in
Mkfour v1 v2 v3 0
let make_AES256_key (k0 k1:quad32) : Pure (seq nat32)
(requires True)
(ensures fun key -> is_aes_key_word AES_256 key)
=
append (be_quad32_to_seq k0) (be_quad32_to_seq k1)
// Redefine key expansion in terms of quad32 values rather than nat32 values,
// then prove both definitions are equivalent. | {
"checked_file": "/",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_BE_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.AES256_helpers_BE.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"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
}
] | {
"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"
} | false |
prev0: Vale.Def.Types_s.quad32 ->
prev1: Vale.Def.Types_s.quad32 ->
rcon: Vale.Def.Types_s.nat32 ->
round: Prims.int
-> Vale.Def.Types_s.quad32 | Prims.Tot | [
"total"
] | [] | [
"Vale.Def.Types_s.quad32",
"Vale.Def.Types_s.nat32",
"Prims.int",
"Vale.Def.Words_s.Mkfour",
"Vale.Def.Words_s.nat32",
"Vale.AES.AES256_helpers_BE.op_Star_Hat",
"Prims.op_Equality",
"Prims.op_Modulus",
"Vale.AES.AES_common_s.sub_word",
"Vale.AES.AES_BE_s.rot_word",
"Prims.bool"
] | [] | false | false | false | true | false | let round_key_256_rcon (prev0 prev1: quad32) (rcon: nat32) (round: int) : quad32 =
| let Mkfour v0 v1 v2 v3 = prev0 in
let Mkfour v7 _ _ _ = prev1 in
let c1 = if round % 2 = 0 then sub_word (rot_word v7) *^ rcon else sub_word v7 in
let w3 = v3 *^ c1 in
let w2 = v2 *^ w3 in
let w1 = v1 *^ w2 in
let w0 = v0 *^ w1 in
Mkfour w0 w1 w2 w3 | false |
Vale.AES.AES256_helpers_BE.fsti | Vale.AES.AES256_helpers_BE.expand_key_256 | val expand_key_256 : key: FStar.Seq.Base.seq Vale.Def.Types_s.nat32 -> round: Prims.nat
-> Prims.Pure Vale.Def.Types_s.quad32 | let expand_key_256 = opaque_make expand_key_256_def | {
"file_name": "vale/code/crypto/aes/Vale.AES.AES256_helpers_BE.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 70,
"end_line": 54,
"start_col": 19,
"start_line": 54
} | module Vale.AES.AES256_helpers_BE
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Arch.Types
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_BE_s
open Vale.Def.Words.Seq_s
// syntax for seq accesses, s.[index] and s.[index] <- value
unfold let (.[]) (#a:Type) (s:seq a) (i:nat{ i < length s}) : Tot a = index s i
unfold let (.[]<-) = Seq.upd
unfold let ( *^ ) = nat32_xor
unfold let ( *^^ ) = quad32_xor
unfold let be_quad32_to_seq (q:quad32) : seq nat32 = four_to_seq_BE q
let quad32_shr32 (q:quad32) : quad32 =
let Mkfour v0 v1 v2 v3 = q in
Mkfour v1 v2 v3 0
let make_AES256_key (k0 k1:quad32) : Pure (seq nat32)
(requires True)
(ensures fun key -> is_aes_key_word AES_256 key)
=
append (be_quad32_to_seq k0) (be_quad32_to_seq k1)
// Redefine key expansion in terms of quad32 values rather than nat32 values,
// then prove both definitions are equivalent.
let round_key_256_rcon (prev0 prev1:quad32) (rcon:nat32) (round:int) : quad32 =
let Mkfour v0 v1 v2 v3 = prev0 in
let Mkfour v7 _ _ _ = prev1 in
let c1 = if round % 2 = 0 then sub_word (rot_word v7) *^ rcon else sub_word v7 in
let w3 = v3 *^ c1 in
let w2 = v2 *^ w3 in
let w1 = v1 *^ w2 in
let w0 = v0 *^ w1 in
Mkfour w0 w1 w2 w3
let round_key_256 (prev0 prev1:quad32) (round:nat) : quad32 =
round_key_256_rcon prev0 prev1 (aes_rcon (round / 2 - 1)) round
let rec expand_key_256_def (key:seq nat32) (round:nat) : Pure quad32
(requires is_aes_key_word AES_256 key)
(ensures fun _ -> True)
=
if round = 0 then Mkfour key.[3] key.[2] key.[1] key.[0]
else if round = 1 then Mkfour key.[7] key.[6] key.[5] key.[4] | {
"checked_file": "/",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_BE_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.AES256_helpers_BE.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"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
}
] | {
"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"
} | false | key: FStar.Seq.Base.seq Vale.Def.Types_s.nat32 -> round: Prims.nat
-> Prims.Pure Vale.Def.Types_s.quad32 | Prims.Pure | [] | [] | [
"Vale.Def.Opaque_s.opaque_make",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat32",
"Prims.nat",
"Vale.Def.Types_s.quad32",
"Vale.AES.AES_BE_s.is_aes_key_word",
"Vale.AES.AES_common_s.AES_256",
"Prims.l_True",
"Vale.AES.AES256_helpers_BE.expand_key_256_def"
] | [] | false | false | false | false | false | let expand_key_256 =
| opaque_make expand_key_256_def | false |
|
Vale.AES.AES256_helpers_BE.fsti | Vale.AES.AES256_helpers_BE.expand_key_256_reveal | val expand_key_256_reveal : _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
Vale.AES.AES256_helpers_BE.expand_key_256 == Vale.AES.AES256_helpers_BE.expand_key_256_def) | let expand_key_256_reveal = opaque_revealer (`%expand_key_256) expand_key_256 expand_key_256_def | {
"file_name": "vale/code/crypto/aes/Vale.AES.AES256_helpers_BE.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 108,
"end_line": 55,
"start_col": 12,
"start_line": 55
} | module Vale.AES.AES256_helpers_BE
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Arch.Types
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_BE_s
open Vale.Def.Words.Seq_s
// syntax for seq accesses, s.[index] and s.[index] <- value
unfold let (.[]) (#a:Type) (s:seq a) (i:nat{ i < length s}) : Tot a = index s i
unfold let (.[]<-) = Seq.upd
unfold let ( *^ ) = nat32_xor
unfold let ( *^^ ) = quad32_xor
unfold let be_quad32_to_seq (q:quad32) : seq nat32 = four_to_seq_BE q
let quad32_shr32 (q:quad32) : quad32 =
let Mkfour v0 v1 v2 v3 = q in
Mkfour v1 v2 v3 0
let make_AES256_key (k0 k1:quad32) : Pure (seq nat32)
(requires True)
(ensures fun key -> is_aes_key_word AES_256 key)
=
append (be_quad32_to_seq k0) (be_quad32_to_seq k1)
// Redefine key expansion in terms of quad32 values rather than nat32 values,
// then prove both definitions are equivalent.
let round_key_256_rcon (prev0 prev1:quad32) (rcon:nat32) (round:int) : quad32 =
let Mkfour v0 v1 v2 v3 = prev0 in
let Mkfour v7 _ _ _ = prev1 in
let c1 = if round % 2 = 0 then sub_word (rot_word v7) *^ rcon else sub_word v7 in
let w3 = v3 *^ c1 in
let w2 = v2 *^ w3 in
let w1 = v1 *^ w2 in
let w0 = v0 *^ w1 in
Mkfour w0 w1 w2 w3
let round_key_256 (prev0 prev1:quad32) (round:nat) : quad32 =
round_key_256_rcon prev0 prev1 (aes_rcon (round / 2 - 1)) round
let rec expand_key_256_def (key:seq nat32) (round:nat) : Pure quad32
(requires is_aes_key_word AES_256 key)
(ensures fun _ -> True)
=
if round = 0 then Mkfour key.[3] key.[2] key.[1] key.[0]
else if round = 1 then Mkfour key.[7] key.[6] key.[5] key.[4]
else round_key_256 (expand_key_256_def key (round - 2)) (expand_key_256_def key (round - 1)) round | {
"checked_file": "/",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_BE_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.AES256_helpers_BE.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"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
}
] | {
"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"
} | false | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
Vale.AES.AES256_helpers_BE.expand_key_256 == Vale.AES.AES256_helpers_BE.expand_key_256_def) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Opaque_s.opaque_revealer",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat32",
"Prims.nat",
"Vale.Def.Types_s.quad32",
"Vale.AES.AES_BE_s.is_aes_key_word",
"Vale.AES.AES_common_s.AES_256",
"Prims.l_True",
"Vale.AES.AES256_helpers_BE.expand_key_256",
"Vale.AES.AES256_helpers_BE.expand_key_256_def"
] | [] | true | false | true | false | false | let expand_key_256_reveal =
| opaque_revealer (`%expand_key_256) expand_key_256 expand_key_256_def | false |
|
Vale.AES.AES256_helpers_BE.fsti | Vale.AES.AES256_helpers_BE.simd_round_key_256 | val simd_round_key_256 (prev0 prev1: quad32) (rcon: nat32) (round: int) : quad32 | val simd_round_key_256 (prev0 prev1: quad32) (rcon: nat32) (round: int) : quad32 | let simd_round_key_256 (prev0 prev1:quad32) (rcon:nat32) (round:int) : quad32 =
let r = if round % 2 = 0 then rot_word (sub_word prev1.lo0 *^ ishl32 rcon 16) else sub_word prev1.lo0 in
let q = prev0 in
let q = q *^^ quad32_shr32 q in
let q = q *^^ quad32_shr32 q in
let q = q *^^ quad32_shr32 q in
q *^^ Mkfour r r r r | {
"file_name": "vale/code/crypto/aes/Vale.AES.AES256_helpers_BE.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 72,
"start_col": 0,
"start_line": 66
} | module Vale.AES.AES256_helpers_BE
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Arch.Types
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_BE_s
open Vale.Def.Words.Seq_s
// syntax for seq accesses, s.[index] and s.[index] <- value
unfold let (.[]) (#a:Type) (s:seq a) (i:nat{ i < length s}) : Tot a = index s i
unfold let (.[]<-) = Seq.upd
unfold let ( *^ ) = nat32_xor
unfold let ( *^^ ) = quad32_xor
unfold let be_quad32_to_seq (q:quad32) : seq nat32 = four_to_seq_BE q
let quad32_shr32 (q:quad32) : quad32 =
let Mkfour v0 v1 v2 v3 = q in
Mkfour v1 v2 v3 0
let make_AES256_key (k0 k1:quad32) : Pure (seq nat32)
(requires True)
(ensures fun key -> is_aes_key_word AES_256 key)
=
append (be_quad32_to_seq k0) (be_quad32_to_seq k1)
// Redefine key expansion in terms of quad32 values rather than nat32 values,
// then prove both definitions are equivalent.
let round_key_256_rcon (prev0 prev1:quad32) (rcon:nat32) (round:int) : quad32 =
let Mkfour v0 v1 v2 v3 = prev0 in
let Mkfour v7 _ _ _ = prev1 in
let c1 = if round % 2 = 0 then sub_word (rot_word v7) *^ rcon else sub_word v7 in
let w3 = v3 *^ c1 in
let w2 = v2 *^ w3 in
let w1 = v1 *^ w2 in
let w0 = v0 *^ w1 in
Mkfour w0 w1 w2 w3
let round_key_256 (prev0 prev1:quad32) (round:nat) : quad32 =
round_key_256_rcon prev0 prev1 (aes_rcon (round / 2 - 1)) round
let rec expand_key_256_def (key:seq nat32) (round:nat) : Pure quad32
(requires is_aes_key_word AES_256 key)
(ensures fun _ -> True)
=
if round = 0 then Mkfour key.[3] key.[2] key.[1] key.[0]
else if round = 1 then Mkfour key.[7] key.[6] key.[5] key.[4]
else round_key_256 (expand_key_256_def key (round - 2)) (expand_key_256_def key (round - 1)) round
[@"opaque_to_smt"] let expand_key_256 = opaque_make expand_key_256_def
irreducible let expand_key_256_reveal = opaque_revealer (`%expand_key_256) expand_key_256 expand_key_256_def
// quad32 key expansion is equivalent to nat32 key expansion
val lemma_expand_key_256 (key:seq nat32) (size:nat) : Lemma
(requires size <= 15 /\ is_aes_key_word AES_256 key)
(ensures (
let s = key_schedule_to_round_keys size (expand_key AES_256 key 60) in
(forall (i:nat).{:pattern (expand_key_256 key i)} i < size ==> expand_key_256 key i == s.[i])
)) | {
"checked_file": "/",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_BE_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.AES256_helpers_BE.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"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
}
] | {
"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"
} | false |
prev0: Vale.Def.Types_s.quad32 ->
prev1: Vale.Def.Types_s.quad32 ->
rcon: Vale.Def.Types_s.nat32 ->
round: Prims.int
-> Vale.Def.Types_s.quad32 | Prims.Tot | [
"total"
] | [] | [
"Vale.Def.Types_s.quad32",
"Vale.Def.Types_s.nat32",
"Prims.int",
"Vale.AES.AES256_helpers_BE.op_Star_Hat_Hat",
"Vale.Def.Words_s.Mkfour",
"Vale.AES.AES256_helpers_BE.quad32_shr32",
"Vale.Def.Words_s.nat32",
"Prims.op_Equality",
"Prims.op_Modulus",
"Vale.AES.AES_BE_s.rot_word",
"Vale.AES.AES256_helpers_BE.op_Star_Hat",
"Vale.AES.AES_common_s.sub_word",
"Vale.Def.Words_s.__proj__Mkfour__item__lo0",
"Vale.Arch.Types.ishl32",
"Prims.bool"
] | [] | false | false | false | true | false | let simd_round_key_256 (prev0 prev1: quad32) (rcon: nat32) (round: int) : quad32 =
| let r =
if round % 2 = 0 then rot_word (sub_word prev1.lo0 *^ ishl32 rcon 16) else sub_word prev1.lo0
in
let q = prev0 in
let q = q *^^ quad32_shr32 q in
let q = q *^^ quad32_shr32 q in
let q = q *^^ quad32_shr32 q in
q *^^ Mkfour r r r r | false |
Vale.X64.State.fsti | Vale.X64.State.eval_reg | val eval_reg (r: reg) (s: vale_state) : t_reg r | val eval_reg (r: reg) (s: vale_state) : t_reg r | let eval_reg (r:reg) (s:vale_state) : t_reg r = Regs.sel r s.vs_regs | {
"file_name": "vale/code/arch/x64/Vale.X64.State.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 75,
"end_line": 26,
"start_col": 7,
"start_line": 26
} | module Vale.X64.State
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
module Flags = Vale.X64.Flags
module Regs = Vale.X64.Regs
module Map16 = Vale.Lib.Map16
noeq type vale_state = {
vs_ok: bool;
vs_regs: Regs.t;
vs_flags: Flags.t;
vs_heap: vale_full_heap;
vs_stack: vale_stack;
vs_stackTaint: memtaint;
}
unfold let vs_get_vale_heap (s:vale_state) : vale_heap = get_vale_heap s.vs_heap | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.State.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Regs",
"short_module": "Regs"
},
{
"abbrev": true,
"full_module": "Vale.X64.Flags",
"short_module": "Flags"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | r: Vale.X64.Machine_s.reg -> s: Vale.X64.State.vale_state -> Vale.X64.Machine_s.t_reg r | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.reg",
"Vale.X64.State.vale_state",
"Vale.X64.Regs.sel",
"Vale.X64.State.__proj__Mkvale_state__item__vs_regs",
"Vale.X64.Machine_s.t_reg"
] | [] | false | false | false | false | false | let eval_reg (r: reg) (s: vale_state) : t_reg r =
| Regs.sel r s.vs_regs | false |
Vale.X64.State.fsti | Vale.X64.State.eval_mem128 | val eval_mem128 (ptr: int) (s: vale_state) : GTot Vale.Def.Types_s.quad32 | val eval_mem128 (ptr: int) (s: vale_state) : GTot Vale.Def.Types_s.quad32 | let eval_mem128 (ptr:int) (s:vale_state) : GTot Vale.Def.Types_s.quad32 = load_mem128 ptr (get_vale_heap s.vs_heap) | {
"file_name": "vale/code/arch/x64/Vale.X64.State.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 122,
"end_line": 34,
"start_col": 7,
"start_line": 34
} | module Vale.X64.State
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
module Flags = Vale.X64.Flags
module Regs = Vale.X64.Regs
module Map16 = Vale.Lib.Map16
noeq type vale_state = {
vs_ok: bool;
vs_regs: Regs.t;
vs_flags: Flags.t;
vs_heap: vale_full_heap;
vs_stack: vale_stack;
vs_stackTaint: memtaint;
}
unfold let vs_get_vale_heap (s:vale_state) : vale_heap = get_vale_heap s.vs_heap
[@va_qattr]
unfold let eval_reg (r:reg) (s:vale_state) : t_reg r = Regs.sel r s.vs_regs
[@va_qattr]
unfold let eval_reg_int (r:reg) (s:vale_state) : int = t_reg_to_int r.rf (eval_reg r s)
[@va_qattr]
unfold let eval_flag (f:flag) (s:vale_state) : Flags.flag_val_t = Flags.sel f s.vs_flags
[@va_qattr]
unfold let eval_mem (ptr:int) (s:vale_state) : GTot nat64 = load_mem64 ptr (get_vale_heap s.vs_heap) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.State.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Regs",
"short_module": "Regs"
},
{
"abbrev": true,
"full_module": "Vale.X64.Flags",
"short_module": "Flags"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | ptr: Prims.int -> s: Vale.X64.State.vale_state -> Prims.GTot Vale.Def.Types_s.quad32 | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.int",
"Vale.X64.State.vale_state",
"Vale.X64.Memory.load_mem128",
"Vale.X64.Memory.get_vale_heap",
"Vale.X64.State.__proj__Mkvale_state__item__vs_heap",
"Vale.Def.Types_s.quad32"
] | [] | false | false | false | false | false | let eval_mem128 (ptr: int) (s: vale_state) : GTot Vale.Def.Types_s.quad32 =
| load_mem128 ptr (get_vale_heap s.vs_heap) | false |
Vale.X64.State.fsti | Vale.X64.State.eval_flag | val eval_flag (f: flag) (s: vale_state) : Flags.flag_val_t | val eval_flag (f: flag) (s: vale_state) : Flags.flag_val_t | let eval_flag (f:flag) (s:vale_state) : Flags.flag_val_t = Flags.sel f s.vs_flags | {
"file_name": "vale/code/arch/x64/Vale.X64.State.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 88,
"end_line": 30,
"start_col": 7,
"start_line": 30
} | module Vale.X64.State
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
module Flags = Vale.X64.Flags
module Regs = Vale.X64.Regs
module Map16 = Vale.Lib.Map16
noeq type vale_state = {
vs_ok: bool;
vs_regs: Regs.t;
vs_flags: Flags.t;
vs_heap: vale_full_heap;
vs_stack: vale_stack;
vs_stackTaint: memtaint;
}
unfold let vs_get_vale_heap (s:vale_state) : vale_heap = get_vale_heap s.vs_heap
[@va_qattr]
unfold let eval_reg (r:reg) (s:vale_state) : t_reg r = Regs.sel r s.vs_regs
[@va_qattr]
unfold let eval_reg_int (r:reg) (s:vale_state) : int = t_reg_to_int r.rf (eval_reg r s) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.State.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Regs",
"short_module": "Regs"
},
{
"abbrev": true,
"full_module": "Vale.X64.Flags",
"short_module": "Flags"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | f: Vale.X64.Machine_s.flag -> s: Vale.X64.State.vale_state -> Vale.X64.Flags.flag_val_t | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.flag",
"Vale.X64.State.vale_state",
"Vale.X64.Flags.sel",
"Vale.X64.State.__proj__Mkvale_state__item__vs_flags",
"Vale.X64.Flags.flag_val_t"
] | [] | false | false | false | true | false | let eval_flag (f: flag) (s: vale_state) : Flags.flag_val_t =
| Flags.sel f s.vs_flags | false |
Vale.X64.State.fsti | Vale.X64.State.eval_mem | val eval_mem (ptr: int) (s: vale_state) : GTot nat64 | val eval_mem (ptr: int) (s: vale_state) : GTot nat64 | let eval_mem (ptr:int) (s:vale_state) : GTot nat64 = load_mem64 ptr (get_vale_heap s.vs_heap) | {
"file_name": "vale/code/arch/x64/Vale.X64.State.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 100,
"end_line": 32,
"start_col": 7,
"start_line": 32
} | module Vale.X64.State
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
module Flags = Vale.X64.Flags
module Regs = Vale.X64.Regs
module Map16 = Vale.Lib.Map16
noeq type vale_state = {
vs_ok: bool;
vs_regs: Regs.t;
vs_flags: Flags.t;
vs_heap: vale_full_heap;
vs_stack: vale_stack;
vs_stackTaint: memtaint;
}
unfold let vs_get_vale_heap (s:vale_state) : vale_heap = get_vale_heap s.vs_heap
[@va_qattr]
unfold let eval_reg (r:reg) (s:vale_state) : t_reg r = Regs.sel r s.vs_regs
[@va_qattr]
unfold let eval_reg_int (r:reg) (s:vale_state) : int = t_reg_to_int r.rf (eval_reg r s)
[@va_qattr]
unfold let eval_flag (f:flag) (s:vale_state) : Flags.flag_val_t = Flags.sel f s.vs_flags | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.State.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Regs",
"short_module": "Regs"
},
{
"abbrev": true,
"full_module": "Vale.X64.Flags",
"short_module": "Flags"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | ptr: Prims.int -> s: Vale.X64.State.vale_state -> Prims.GTot Vale.X64.Memory.nat64 | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.int",
"Vale.X64.State.vale_state",
"Vale.X64.Memory.load_mem64",
"Vale.X64.Memory.get_vale_heap",
"Vale.X64.State.__proj__Mkvale_state__item__vs_heap",
"Vale.X64.Memory.nat64"
] | [] | false | false | false | false | false | let eval_mem (ptr: int) (s: vale_state) : GTot nat64 =
| load_mem64 ptr (get_vale_heap s.vs_heap) | false |
Vale.X64.State.fsti | Vale.X64.State.eval_stack128 | val eval_stack128 (ptr: int) (s: vale_state) : GTot quad32 | val eval_stack128 (ptr: int) (s: vale_state) : GTot quad32 | let eval_stack128 (ptr:int) (s:vale_state) : GTot quad32 = load_stack128 ptr s.vs_stack | {
"file_name": "vale/code/arch/x64/Vale.X64.State.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 94,
"end_line": 38,
"start_col": 7,
"start_line": 38
} | module Vale.X64.State
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
module Flags = Vale.X64.Flags
module Regs = Vale.X64.Regs
module Map16 = Vale.Lib.Map16
noeq type vale_state = {
vs_ok: bool;
vs_regs: Regs.t;
vs_flags: Flags.t;
vs_heap: vale_full_heap;
vs_stack: vale_stack;
vs_stackTaint: memtaint;
}
unfold let vs_get_vale_heap (s:vale_state) : vale_heap = get_vale_heap s.vs_heap
[@va_qattr]
unfold let eval_reg (r:reg) (s:vale_state) : t_reg r = Regs.sel r s.vs_regs
[@va_qattr]
unfold let eval_reg_int (r:reg) (s:vale_state) : int = t_reg_to_int r.rf (eval_reg r s)
[@va_qattr]
unfold let eval_flag (f:flag) (s:vale_state) : Flags.flag_val_t = Flags.sel f s.vs_flags
[@va_qattr]
unfold let eval_mem (ptr:int) (s:vale_state) : GTot nat64 = load_mem64 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_mem128 (ptr:int) (s:vale_state) : GTot Vale.Def.Types_s.quad32 = load_mem128 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_stack (ptr:int) (s:vale_state) : GTot nat64 = load_stack64 ptr s.vs_stack | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.State.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Regs",
"short_module": "Regs"
},
{
"abbrev": true,
"full_module": "Vale.X64.Flags",
"short_module": "Flags"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | ptr: Prims.int -> s: Vale.X64.State.vale_state -> Prims.GTot Vale.X64.Memory.quad32 | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.int",
"Vale.X64.State.vale_state",
"Vale.X64.Stack_i.load_stack128",
"Vale.X64.State.__proj__Mkvale_state__item__vs_stack",
"Vale.X64.Memory.quad32"
] | [] | false | false | false | false | false | let eval_stack128 (ptr: int) (s: vale_state) : GTot quad32 =
| load_stack128 ptr s.vs_stack | false |
Vale.X64.State.fsti | Vale.X64.State.eval_reg_int | val eval_reg_int (r: reg) (s: vale_state) : int | val eval_reg_int (r: reg) (s: vale_state) : int | let eval_reg_int (r:reg) (s:vale_state) : int = t_reg_to_int r.rf (eval_reg r s) | {
"file_name": "vale/code/arch/x64/Vale.X64.State.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 87,
"end_line": 28,
"start_col": 7,
"start_line": 28
} | module Vale.X64.State
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
module Flags = Vale.X64.Flags
module Regs = Vale.X64.Regs
module Map16 = Vale.Lib.Map16
noeq type vale_state = {
vs_ok: bool;
vs_regs: Regs.t;
vs_flags: Flags.t;
vs_heap: vale_full_heap;
vs_stack: vale_stack;
vs_stackTaint: memtaint;
}
unfold let vs_get_vale_heap (s:vale_state) : vale_heap = get_vale_heap s.vs_heap
[@va_qattr]
unfold let eval_reg (r:reg) (s:vale_state) : t_reg r = Regs.sel r s.vs_regs | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.State.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Regs",
"short_module": "Regs"
},
{
"abbrev": true,
"full_module": "Vale.X64.Flags",
"short_module": "Flags"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | r: Vale.X64.Machine_s.reg -> s: Vale.X64.State.vale_state -> Prims.int | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.reg",
"Vale.X64.State.vale_state",
"Vale.X64.Machine_s.t_reg_to_int",
"Vale.X64.Machine_s.__proj__Reg__item__rf",
"Vale.X64.State.eval_reg",
"Prims.int"
] | [] | false | false | false | true | false | let eval_reg_int (r: reg) (s: vale_state) : int =
| t_reg_to_int r.rf (eval_reg r s) | false |
Vale.X64.State.fsti | Vale.X64.State.eval_stack | val eval_stack (ptr: int) (s: vale_state) : GTot nat64 | val eval_stack (ptr: int) (s: vale_state) : GTot nat64 | let eval_stack (ptr:int) (s:vale_state) : GTot nat64 = load_stack64 ptr s.vs_stack | {
"file_name": "vale/code/arch/x64/Vale.X64.State.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 89,
"end_line": 36,
"start_col": 7,
"start_line": 36
} | module Vale.X64.State
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
module Flags = Vale.X64.Flags
module Regs = Vale.X64.Regs
module Map16 = Vale.Lib.Map16
noeq type vale_state = {
vs_ok: bool;
vs_regs: Regs.t;
vs_flags: Flags.t;
vs_heap: vale_full_heap;
vs_stack: vale_stack;
vs_stackTaint: memtaint;
}
unfold let vs_get_vale_heap (s:vale_state) : vale_heap = get_vale_heap s.vs_heap
[@va_qattr]
unfold let eval_reg (r:reg) (s:vale_state) : t_reg r = Regs.sel r s.vs_regs
[@va_qattr]
unfold let eval_reg_int (r:reg) (s:vale_state) : int = t_reg_to_int r.rf (eval_reg r s)
[@va_qattr]
unfold let eval_flag (f:flag) (s:vale_state) : Flags.flag_val_t = Flags.sel f s.vs_flags
[@va_qattr]
unfold let eval_mem (ptr:int) (s:vale_state) : GTot nat64 = load_mem64 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_mem128 (ptr:int) (s:vale_state) : GTot Vale.Def.Types_s.quad32 = load_mem128 ptr (get_vale_heap s.vs_heap) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.State.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Regs",
"short_module": "Regs"
},
{
"abbrev": true,
"full_module": "Vale.X64.Flags",
"short_module": "Flags"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | ptr: Prims.int -> s: Vale.X64.State.vale_state -> Prims.GTot Vale.X64.Memory.nat64 | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.int",
"Vale.X64.State.vale_state",
"Vale.X64.Stack_i.load_stack64",
"Vale.X64.State.__proj__Mkvale_state__item__vs_stack",
"Vale.X64.Memory.nat64"
] | [] | false | false | false | false | false | let eval_stack (ptr: int) (s: vale_state) : GTot nat64 =
| load_stack64 ptr s.vs_stack | false |
Lib.ByteSequence.fsti | Lib.ByteSequence.nat_from_bytes_le | val nat_from_bytes_le (#l: secrecy_level) (b: bytes_l l) : n: nat{n < pow2 (length b * 8)} | val nat_from_bytes_le (#l: secrecy_level) (b: bytes_l l) : n: nat{n < pow2 (length b * 8)} | let nat_from_bytes_le (#l:secrecy_level) (b:bytes_l l) : n:nat{n < pow2 (length b * 8)} =
nat_from_intseq_le #U8 #l b | {
"file_name": "lib/Lib.ByteSequence.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 29,
"end_line": 81,
"start_col": 0,
"start_line": 80
} | module Lib.ByteSequence
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 30 --max_fuel 0 --max_ifuel 0"
/// Definition of byte-based sequences
unfold inline_for_extraction
type bytes_l (l:secrecy_level) = seq (uint_t U8 l)
unfold inline_for_extraction
type lbytes_l (l:secrecy_level) (len:size_nat) = lseq (uint_t U8 l) len
unfold inline_for_extraction let bytes = bytes_l SEC
unfold inline_for_extraction let lbytes (len:size_nat) = lbytes_l SEC len
unfold inline_for_extraction let pub_bytes = bytes_l PUB
unfold inline_for_extraction let pub_lbytes (len:size_nat) = lbytes_l PUB len
(* Alias *)
unfold inline_for_extraction let bytes_t = bytes
unfold inline_for_extraction let pub_bytes_t = pub_bytes
(** Construct the equality mask for a pair of secret integer sequences *)
val seq_eq_mask: #t:inttype{~(S128? t)} -> #len1:size_nat -> #len2:size_nat
-> b1:lseq (int_t t SEC) len1
-> b2:lseq (int_t t SEC) len2
-> len:size_nat{len <= len1 /\ len <= len2}
-> res:int_t t SEC{
(sub b1 0 len == sub b2 0 len ==> v res == v (ones t SEC)) /\
(sub b1 0 len =!= sub b2 0 len ==> v res == v (zeros t SEC))}
(** Compares two byte sequences and declassifies the result *)
inline_for_extraction
val lbytes_eq: #len:size_nat -> b1:lbytes len -> b2:lbytes len -> b:bool{b <==> b1 == b2}
inline_for_extraction
val mask_select: #t:inttype{~(S128? t)} -> mask:int_t t SEC -> a:int_t t SEC -> b:int_t t SEC -> int_t t SEC
val mask_select_lemma: #t:inttype{~(S128? t)} -> mask:int_t t SEC -> a:int_t t SEC -> b:int_t t SEC -> Lemma
(requires v mask = 0 \/ v mask = v (ones t SEC))
(ensures mask_select mask a b == (if v mask = 0 then b else a))
val seq_mask_select: #t:inttype{~(S128? t)} -> #len:size_nat
-> a:lseq (int_t t SEC) len
-> b:lseq (int_t t SEC) len
-> mask:int_t t SEC
-> Pure (lseq (int_t t SEC) len)
(requires v mask = 0 \/ v mask = v (ones t SEC))
(ensures fun res -> res == (if v mask = 0 then b else a))
/// Constant for empty lbytes
let bytes_empty: bytes = Seq.Base.empty
let pub_bytes_empty: pub_bytes = Seq.Base.empty
let lbytes_empty: lbytes 0 = create 0 (u8 0)
/// Conversions between natural numbers and sequences
inline_for_extraction
val nat_from_intseq_be: #t:inttype{unsigned t} -> #l:secrecy_level -> b:seq (uint_t t l)
-> n:nat{n < pow2 (length b * bits t)}
inline_for_extraction
val nat_from_intseq_le: #t:inttype{unsigned t} -> #l:secrecy_level
-> b:seq (uint_t t l) -> n:nat{n < pow2 (length b * bits t)}
inline_for_extraction
let nat_from_bytes_be (#l:secrecy_level) (b:bytes_l l) : n:nat{n < pow2 (length b * 8)} =
nat_from_intseq_be #U8 #l b | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Lib.ByteSequence.fsti"
} | [
{
"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": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b: Lib.ByteSequence.bytes_l l -> n: Prims.nat{n < Prims.pow2 (Lib.Sequence.length b * 8)} | Prims.Tot | [
"total"
] | [] | [
"Lib.IntTypes.secrecy_level",
"Lib.ByteSequence.bytes_l",
"Lib.ByteSequence.nat_from_intseq_le",
"Lib.IntTypes.U8",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"FStar.Mul.op_Star",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t"
] | [] | false | false | false | false | false | let nat_from_bytes_le (#l: secrecy_level) (b: bytes_l l) : n: nat{n < pow2 (length b * 8)} =
| nat_from_intseq_le #U8 #l b | false |
Vale.X64.State.fsti | Vale.X64.State.vs_get_vale_heap | val vs_get_vale_heap (s: vale_state) : vale_heap | val vs_get_vale_heap (s: vale_state) : vale_heap | let vs_get_vale_heap (s:vale_state) : vale_heap = get_vale_heap s.vs_heap | {
"file_name": "vale/code/arch/x64/Vale.X64.State.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 80,
"end_line": 23,
"start_col": 7,
"start_line": 23
} | module Vale.X64.State
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
module Flags = Vale.X64.Flags
module Regs = Vale.X64.Regs
module Map16 = Vale.Lib.Map16
noeq type vale_state = {
vs_ok: bool;
vs_regs: Regs.t;
vs_flags: Flags.t;
vs_heap: vale_full_heap;
vs_stack: vale_stack;
vs_stackTaint: memtaint;
} | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.State.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Regs",
"short_module": "Regs"
},
{
"abbrev": true,
"full_module": "Vale.X64.Flags",
"short_module": "Flags"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | s: Vale.X64.State.vale_state -> Vale.X64.Memory.vale_heap | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.State.vale_state",
"Vale.X64.Memory.get_vale_heap",
"Vale.X64.State.__proj__Mkvale_state__item__vs_heap",
"Vale.X64.Memory.vale_heap"
] | [] | false | false | false | true | false | let vs_get_vale_heap (s: vale_state) : vale_heap =
| get_vale_heap s.vs_heap | false |
Vale.AES.AES256_helpers_BE.fsti | Vale.AES.AES256_helpers_BE.make_AES256_key | val make_AES256_key (k0 k1: quad32)
: Pure (seq nat32) (requires True) (ensures fun key -> is_aes_key_word AES_256 key) | val make_AES256_key (k0 k1: quad32)
: Pure (seq nat32) (requires True) (ensures fun key -> is_aes_key_word AES_256 key) | let make_AES256_key (k0 k1:quad32) : Pure (seq nat32)
(requires True)
(ensures fun key -> is_aes_key_word AES_256 key)
=
append (be_quad32_to_seq k0) (be_quad32_to_seq k1) | {
"file_name": "vale/code/crypto/aes/Vale.AES.AES256_helpers_BE.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 52,
"end_line": 29,
"start_col": 0,
"start_line": 25
} | module Vale.AES.AES256_helpers_BE
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Arch.Types
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_BE_s
open Vale.Def.Words.Seq_s
// syntax for seq accesses, s.[index] and s.[index] <- value
unfold let (.[]) (#a:Type) (s:seq a) (i:nat{ i < length s}) : Tot a = index s i
unfold let (.[]<-) = Seq.upd
unfold let ( *^ ) = nat32_xor
unfold let ( *^^ ) = quad32_xor
unfold let be_quad32_to_seq (q:quad32) : seq nat32 = four_to_seq_BE q
let quad32_shr32 (q:quad32) : quad32 =
let Mkfour v0 v1 v2 v3 = q in
Mkfour v1 v2 v3 0 | {
"checked_file": "/",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_BE_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.AES256_helpers_BE.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"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
}
] | {
"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"
} | false | k0: Vale.Def.Types_s.quad32 -> k1: Vale.Def.Types_s.quad32
-> Prims.Pure (FStar.Seq.Base.seq Vale.Def.Types_s.nat32) | Prims.Pure | [] | [] | [
"Vale.Def.Types_s.quad32",
"FStar.Seq.Base.append",
"Vale.Def.Types_s.nat32",
"Vale.AES.AES256_helpers_BE.be_quad32_to_seq",
"FStar.Seq.Base.seq",
"Prims.l_True",
"Vale.AES.AES_BE_s.is_aes_key_word",
"Vale.AES.AES_common_s.AES_256"
] | [] | false | false | false | false | false | let make_AES256_key (k0 k1: quad32)
: Pure (seq nat32) (requires True) (ensures fun key -> is_aes_key_word AES_256 key) =
| append (be_quad32_to_seq k0) (be_quad32_to_seq k1) | false |
Lib.ByteSequence.fsti | Lib.ByteSequence.nat_from_bytes_be | val nat_from_bytes_be (#l: secrecy_level) (b: bytes_l l) : n: nat{n < pow2 (length b * 8)} | val nat_from_bytes_be (#l: secrecy_level) (b: bytes_l l) : n: nat{n < pow2 (length b * 8)} | let nat_from_bytes_be (#l:secrecy_level) (b:bytes_l l) : n:nat{n < pow2 (length b * 8)} =
nat_from_intseq_be #U8 #l b | {
"file_name": "lib/Lib.ByteSequence.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 29,
"end_line": 77,
"start_col": 0,
"start_line": 76
} | module Lib.ByteSequence
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 30 --max_fuel 0 --max_ifuel 0"
/// Definition of byte-based sequences
unfold inline_for_extraction
type bytes_l (l:secrecy_level) = seq (uint_t U8 l)
unfold inline_for_extraction
type lbytes_l (l:secrecy_level) (len:size_nat) = lseq (uint_t U8 l) len
unfold inline_for_extraction let bytes = bytes_l SEC
unfold inline_for_extraction let lbytes (len:size_nat) = lbytes_l SEC len
unfold inline_for_extraction let pub_bytes = bytes_l PUB
unfold inline_for_extraction let pub_lbytes (len:size_nat) = lbytes_l PUB len
(* Alias *)
unfold inline_for_extraction let bytes_t = bytes
unfold inline_for_extraction let pub_bytes_t = pub_bytes
(** Construct the equality mask for a pair of secret integer sequences *)
val seq_eq_mask: #t:inttype{~(S128? t)} -> #len1:size_nat -> #len2:size_nat
-> b1:lseq (int_t t SEC) len1
-> b2:lseq (int_t t SEC) len2
-> len:size_nat{len <= len1 /\ len <= len2}
-> res:int_t t SEC{
(sub b1 0 len == sub b2 0 len ==> v res == v (ones t SEC)) /\
(sub b1 0 len =!= sub b2 0 len ==> v res == v (zeros t SEC))}
(** Compares two byte sequences and declassifies the result *)
inline_for_extraction
val lbytes_eq: #len:size_nat -> b1:lbytes len -> b2:lbytes len -> b:bool{b <==> b1 == b2}
inline_for_extraction
val mask_select: #t:inttype{~(S128? t)} -> mask:int_t t SEC -> a:int_t t SEC -> b:int_t t SEC -> int_t t SEC
val mask_select_lemma: #t:inttype{~(S128? t)} -> mask:int_t t SEC -> a:int_t t SEC -> b:int_t t SEC -> Lemma
(requires v mask = 0 \/ v mask = v (ones t SEC))
(ensures mask_select mask a b == (if v mask = 0 then b else a))
val seq_mask_select: #t:inttype{~(S128? t)} -> #len:size_nat
-> a:lseq (int_t t SEC) len
-> b:lseq (int_t t SEC) len
-> mask:int_t t SEC
-> Pure (lseq (int_t t SEC) len)
(requires v mask = 0 \/ v mask = v (ones t SEC))
(ensures fun res -> res == (if v mask = 0 then b else a))
/// Constant for empty lbytes
let bytes_empty: bytes = Seq.Base.empty
let pub_bytes_empty: pub_bytes = Seq.Base.empty
let lbytes_empty: lbytes 0 = create 0 (u8 0)
/// Conversions between natural numbers and sequences
inline_for_extraction
val nat_from_intseq_be: #t:inttype{unsigned t} -> #l:secrecy_level -> b:seq (uint_t t l)
-> n:nat{n < pow2 (length b * bits t)}
inline_for_extraction
val nat_from_intseq_le: #t:inttype{unsigned t} -> #l:secrecy_level
-> b:seq (uint_t t l) -> n:nat{n < pow2 (length b * bits t)} | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Lib.ByteSequence.fsti"
} | [
{
"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": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b: Lib.ByteSequence.bytes_l l -> n: Prims.nat{n < Prims.pow2 (Lib.Sequence.length b * 8)} | Prims.Tot | [
"total"
] | [] | [
"Lib.IntTypes.secrecy_level",
"Lib.ByteSequence.bytes_l",
"Lib.ByteSequence.nat_from_intseq_be",
"Lib.IntTypes.U8",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"FStar.Mul.op_Star",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t"
] | [] | false | false | false | false | false | let nat_from_bytes_be (#l: secrecy_level) (b: bytes_l l) : n: nat{n < pow2 (length b * 8)} =
| nat_from_intseq_be #U8 #l b | false |
Vale.X64.State.fsti | Vale.X64.State.update_reg | val update_reg (r: reg) (v: t_reg r) (s: vale_state) : vale_state | val update_reg (r: reg) (v: t_reg r) (s: vale_state) : vale_state | let update_reg (r:reg) (v:t_reg r) (s:vale_state) : vale_state =
{s with vs_regs = Regs.upd r v s.vs_regs} | {
"file_name": "vale/code/arch/x64/Vale.X64.State.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 43,
"end_line": 71,
"start_col": 0,
"start_line": 70
} | module Vale.X64.State
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
module Flags = Vale.X64.Flags
module Regs = Vale.X64.Regs
module Map16 = Vale.Lib.Map16
noeq type vale_state = {
vs_ok: bool;
vs_regs: Regs.t;
vs_flags: Flags.t;
vs_heap: vale_full_heap;
vs_stack: vale_stack;
vs_stackTaint: memtaint;
}
unfold let vs_get_vale_heap (s:vale_state) : vale_heap = get_vale_heap s.vs_heap
[@va_qattr]
unfold let eval_reg (r:reg) (s:vale_state) : t_reg r = Regs.sel r s.vs_regs
[@va_qattr]
unfold let eval_reg_int (r:reg) (s:vale_state) : int = t_reg_to_int r.rf (eval_reg r s)
[@va_qattr]
unfold let eval_flag (f:flag) (s:vale_state) : Flags.flag_val_t = Flags.sel f s.vs_flags
[@va_qattr]
unfold let eval_mem (ptr:int) (s:vale_state) : GTot nat64 = load_mem64 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_mem128 (ptr:int) (s:vale_state) : GTot Vale.Def.Types_s.quad32 = load_mem128 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_stack (ptr:int) (s:vale_state) : GTot nat64 = load_stack64 ptr s.vs_stack
[@va_qattr]
unfold let eval_stack128 (ptr:int) (s:vale_state) : GTot quad32 = load_stack128 ptr s.vs_stack
[@va_qattr]
unfold let eval_reg_64 (r:reg_64) (s:vale_state) : nat64 = eval_reg (Reg 0 r) s
[@va_qattr]
unfold let eval_reg_xmm (r:reg_xmm) (s:vale_state) : quad32 = eval_reg (Reg 1 r) s
[@va_qattr]
let eval_maddr (m:maddr) (s:vale_state) : int =
match m with
| MConst n -> n
| MReg r offset -> eval_reg_int r s + offset
| MIndex base scale index offset -> eval_reg_int base s + scale * (eval_reg_int index s) + offset
[@va_qattr]
let eval_operand (o:operand64) (s:vale_state) : GTot nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s
[@va_qattr]
let eval_operand128 (o:operand128) (s:vale_state) : GTot Vale.Def.Types_s.quad32 =
match o with
| OConst c -> c
| OReg r -> eval_reg_xmm r s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.State.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Regs",
"short_module": "Regs"
},
{
"abbrev": true,
"full_module": "Vale.X64.Flags",
"short_module": "Flags"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | r: Vale.X64.Machine_s.reg -> v: Vale.X64.Machine_s.t_reg r -> s: Vale.X64.State.vale_state
-> Vale.X64.State.vale_state | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.reg",
"Vale.X64.Machine_s.t_reg",
"Vale.X64.State.vale_state",
"Vale.X64.State.Mkvale_state",
"Vale.X64.State.__proj__Mkvale_state__item__vs_ok",
"Vale.X64.Regs.upd",
"Vale.X64.State.__proj__Mkvale_state__item__vs_regs",
"Vale.X64.State.__proj__Mkvale_state__item__vs_flags",
"Vale.X64.State.__proj__Mkvale_state__item__vs_heap",
"Vale.X64.State.__proj__Mkvale_state__item__vs_stack",
"Vale.X64.State.__proj__Mkvale_state__item__vs_stackTaint"
] | [] | false | false | false | false | false | let update_reg (r: reg) (v: t_reg r) (s: vale_state) : vale_state =
| { s with vs_regs = Regs.upd r v s.vs_regs } | false |
Vale.X64.State.fsti | Vale.X64.State.update_flag | val update_flag (f: flag) (v: Flags.flag_val_t) (s: vale_state) : vale_state | val update_flag (f: flag) (v: Flags.flag_val_t) (s: vale_state) : vale_state | let update_flag (f:flag) (v:Flags.flag_val_t) (s:vale_state) : vale_state =
{s with vs_flags = Flags.upd f v s.vs_flags} | {
"file_name": "vale/code/arch/x64/Vale.X64.State.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 46,
"end_line": 79,
"start_col": 0,
"start_line": 78
} | module Vale.X64.State
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
module Flags = Vale.X64.Flags
module Regs = Vale.X64.Regs
module Map16 = Vale.Lib.Map16
noeq type vale_state = {
vs_ok: bool;
vs_regs: Regs.t;
vs_flags: Flags.t;
vs_heap: vale_full_heap;
vs_stack: vale_stack;
vs_stackTaint: memtaint;
}
unfold let vs_get_vale_heap (s:vale_state) : vale_heap = get_vale_heap s.vs_heap
[@va_qattr]
unfold let eval_reg (r:reg) (s:vale_state) : t_reg r = Regs.sel r s.vs_regs
[@va_qattr]
unfold let eval_reg_int (r:reg) (s:vale_state) : int = t_reg_to_int r.rf (eval_reg r s)
[@va_qattr]
unfold let eval_flag (f:flag) (s:vale_state) : Flags.flag_val_t = Flags.sel f s.vs_flags
[@va_qattr]
unfold let eval_mem (ptr:int) (s:vale_state) : GTot nat64 = load_mem64 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_mem128 (ptr:int) (s:vale_state) : GTot Vale.Def.Types_s.quad32 = load_mem128 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_stack (ptr:int) (s:vale_state) : GTot nat64 = load_stack64 ptr s.vs_stack
[@va_qattr]
unfold let eval_stack128 (ptr:int) (s:vale_state) : GTot quad32 = load_stack128 ptr s.vs_stack
[@va_qattr]
unfold let eval_reg_64 (r:reg_64) (s:vale_state) : nat64 = eval_reg (Reg 0 r) s
[@va_qattr]
unfold let eval_reg_xmm (r:reg_xmm) (s:vale_state) : quad32 = eval_reg (Reg 1 r) s
[@va_qattr]
let eval_maddr (m:maddr) (s:vale_state) : int =
match m with
| MConst n -> n
| MReg r offset -> eval_reg_int r s + offset
| MIndex base scale index offset -> eval_reg_int base s + scale * (eval_reg_int index s) + offset
[@va_qattr]
let eval_operand (o:operand64) (s:vale_state) : GTot nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s
[@va_qattr]
let eval_operand128 (o:operand128) (s:vale_state) : GTot Vale.Def.Types_s.quad32 =
match o with
| OConst c -> c
| OReg r -> eval_reg_xmm r s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s
[@va_qattr]
let update_reg (r:reg) (v:t_reg r) (s:vale_state) : vale_state =
{s with vs_regs = Regs.upd r v s.vs_regs}
[@va_qattr]
let update_reg_64 (r:reg_64) (v:nat64) (s:vale_state) : vale_state =
update_reg (Reg 0 r) v s | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.State.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Regs",
"short_module": "Regs"
},
{
"abbrev": true,
"full_module": "Vale.X64.Flags",
"short_module": "Flags"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | f: Vale.X64.Machine_s.flag -> v: Vale.X64.Flags.flag_val_t -> s: Vale.X64.State.vale_state
-> Vale.X64.State.vale_state | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.flag",
"Vale.X64.Flags.flag_val_t",
"Vale.X64.State.vale_state",
"Vale.X64.State.Mkvale_state",
"Vale.X64.State.__proj__Mkvale_state__item__vs_ok",
"Vale.X64.State.__proj__Mkvale_state__item__vs_regs",
"Vale.X64.Flags.upd",
"Vale.X64.State.__proj__Mkvale_state__item__vs_flags",
"Vale.X64.State.__proj__Mkvale_state__item__vs_heap",
"Vale.X64.State.__proj__Mkvale_state__item__vs_stack",
"Vale.X64.State.__proj__Mkvale_state__item__vs_stackTaint"
] | [] | false | false | false | true | false | let update_flag (f: flag) (v: Flags.flag_val_t) (s: vale_state) : vale_state =
| { s with vs_flags = Flags.upd f v s.vs_flags } | false |
Lib.ByteSequence.fsti | Lib.ByteSequence.lbytes_empty | val lbytes_empty:lbytes 0 | val lbytes_empty:lbytes 0 | let lbytes_empty: lbytes 0 = create 0 (u8 0) | {
"file_name": "lib/Lib.ByteSequence.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 44,
"end_line": 63,
"start_col": 0,
"start_line": 63
} | module Lib.ByteSequence
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 30 --max_fuel 0 --max_ifuel 0"
/// Definition of byte-based sequences
unfold inline_for_extraction
type bytes_l (l:secrecy_level) = seq (uint_t U8 l)
unfold inline_for_extraction
type lbytes_l (l:secrecy_level) (len:size_nat) = lseq (uint_t U8 l) len
unfold inline_for_extraction let bytes = bytes_l SEC
unfold inline_for_extraction let lbytes (len:size_nat) = lbytes_l SEC len
unfold inline_for_extraction let pub_bytes = bytes_l PUB
unfold inline_for_extraction let pub_lbytes (len:size_nat) = lbytes_l PUB len
(* Alias *)
unfold inline_for_extraction let bytes_t = bytes
unfold inline_for_extraction let pub_bytes_t = pub_bytes
(** Construct the equality mask for a pair of secret integer sequences *)
val seq_eq_mask: #t:inttype{~(S128? t)} -> #len1:size_nat -> #len2:size_nat
-> b1:lseq (int_t t SEC) len1
-> b2:lseq (int_t t SEC) len2
-> len:size_nat{len <= len1 /\ len <= len2}
-> res:int_t t SEC{
(sub b1 0 len == sub b2 0 len ==> v res == v (ones t SEC)) /\
(sub b1 0 len =!= sub b2 0 len ==> v res == v (zeros t SEC))}
(** Compares two byte sequences and declassifies the result *)
inline_for_extraction
val lbytes_eq: #len:size_nat -> b1:lbytes len -> b2:lbytes len -> b:bool{b <==> b1 == b2}
inline_for_extraction
val mask_select: #t:inttype{~(S128? t)} -> mask:int_t t SEC -> a:int_t t SEC -> b:int_t t SEC -> int_t t SEC
val mask_select_lemma: #t:inttype{~(S128? t)} -> mask:int_t t SEC -> a:int_t t SEC -> b:int_t t SEC -> Lemma
(requires v mask = 0 \/ v mask = v (ones t SEC))
(ensures mask_select mask a b == (if v mask = 0 then b else a))
val seq_mask_select: #t:inttype{~(S128? t)} -> #len:size_nat
-> a:lseq (int_t t SEC) len
-> b:lseq (int_t t SEC) len
-> mask:int_t t SEC
-> Pure (lseq (int_t t SEC) len)
(requires v mask = 0 \/ v mask = v (ones t SEC))
(ensures fun res -> res == (if v mask = 0 then b else a))
/// Constant for empty lbytes
let bytes_empty: bytes = Seq.Base.empty
let pub_bytes_empty: pub_bytes = Seq.Base.empty | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Lib.ByteSequence.fsti"
} | [
{
"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": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Lib.Sequence.lseq (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.SEC) 0 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.create",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.IntTypes.u8"
] | [] | false | false | false | false | false | let lbytes_empty:lbytes 0 =
| create 0 (u8 0) | false |
Vale.AES.AES256_helpers_BE.fsti | Vale.AES.AES256_helpers_BE.expand_key_256_def | val expand_key_256_def (key: seq nat32) (round: nat)
: Pure quad32 (requires is_aes_key_word AES_256 key) (ensures fun _ -> True) | val expand_key_256_def (key: seq nat32) (round: nat)
: Pure quad32 (requires is_aes_key_word AES_256 key) (ensures fun _ -> True) | let rec expand_key_256_def (key:seq nat32) (round:nat) : Pure quad32
(requires is_aes_key_word AES_256 key)
(ensures fun _ -> True)
=
if round = 0 then Mkfour key.[3] key.[2] key.[1] key.[0]
else if round = 1 then Mkfour key.[7] key.[6] key.[5] key.[4]
else round_key_256 (expand_key_256_def key (round - 2)) (expand_key_256_def key (round - 1)) round | {
"file_name": "vale/code/crypto/aes/Vale.AES.AES256_helpers_BE.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 100,
"end_line": 53,
"start_col": 0,
"start_line": 47
} | module Vale.AES.AES256_helpers_BE
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Arch.Types
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_BE_s
open Vale.Def.Words.Seq_s
// syntax for seq accesses, s.[index] and s.[index] <- value
unfold let (.[]) (#a:Type) (s:seq a) (i:nat{ i < length s}) : Tot a = index s i
unfold let (.[]<-) = Seq.upd
unfold let ( *^ ) = nat32_xor
unfold let ( *^^ ) = quad32_xor
unfold let be_quad32_to_seq (q:quad32) : seq nat32 = four_to_seq_BE q
let quad32_shr32 (q:quad32) : quad32 =
let Mkfour v0 v1 v2 v3 = q in
Mkfour v1 v2 v3 0
let make_AES256_key (k0 k1:quad32) : Pure (seq nat32)
(requires True)
(ensures fun key -> is_aes_key_word AES_256 key)
=
append (be_quad32_to_seq k0) (be_quad32_to_seq k1)
// Redefine key expansion in terms of quad32 values rather than nat32 values,
// then prove both definitions are equivalent.
let round_key_256_rcon (prev0 prev1:quad32) (rcon:nat32) (round:int) : quad32 =
let Mkfour v0 v1 v2 v3 = prev0 in
let Mkfour v7 _ _ _ = prev1 in
let c1 = if round % 2 = 0 then sub_word (rot_word v7) *^ rcon else sub_word v7 in
let w3 = v3 *^ c1 in
let w2 = v2 *^ w3 in
let w1 = v1 *^ w2 in
let w0 = v0 *^ w1 in
Mkfour w0 w1 w2 w3
let round_key_256 (prev0 prev1:quad32) (round:nat) : quad32 =
round_key_256_rcon prev0 prev1 (aes_rcon (round / 2 - 1)) round | {
"checked_file": "/",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_BE_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.AES256_helpers_BE.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"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
}
] | {
"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"
} | false | key: FStar.Seq.Base.seq Vale.Def.Types_s.nat32 -> round: Prims.nat
-> Prims.Pure Vale.Def.Types_s.quad32 | Prims.Pure | [] | [] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat32",
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"Vale.Def.Words_s.Mkfour",
"Vale.AES.AES256_helpers_BE.op_String_Access",
"Prims.bool",
"Vale.AES.AES256_helpers_BE.round_key_256",
"Vale.AES.AES256_helpers_BE.expand_key_256_def",
"Prims.op_Subtraction",
"Vale.Def.Types_s.quad32",
"Vale.AES.AES_BE_s.is_aes_key_word",
"Vale.AES.AES_common_s.AES_256",
"Prims.l_True"
] | [
"recursion"
] | false | false | false | false | false | let rec expand_key_256_def (key: seq nat32) (round: nat)
: Pure quad32 (requires is_aes_key_word AES_256 key) (ensures fun _ -> True) =
| if round = 0
then Mkfour key.[ 3 ] key.[ 2 ] key.[ 1 ] key.[ 0 ]
else
if round = 1
then Mkfour key.[ 7 ] key.[ 6 ] key.[ 5 ] key.[ 4 ]
else round_key_256 (expand_key_256_def key (round - 2)) (expand_key_256_def key (round - 1)) round | false |
Vale.X64.State.fsti | Vale.X64.State.update_stack64 | val update_stack64 (ptr: int) (v: nat64) (s: vale_state) : GTot vale_state | val update_stack64 (ptr: int) (v: nat64) (s: vale_state) : GTot vale_state | let update_stack64 (ptr:int) (v:nat64) (s:vale_state) : GTot vale_state =
{s with vs_stack = store_stack64 ptr v s.vs_stack} | {
"file_name": "vale/code/arch/x64/Vale.X64.State.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 52,
"end_line": 91,
"start_col": 0,
"start_line": 90
} | module Vale.X64.State
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
module Flags = Vale.X64.Flags
module Regs = Vale.X64.Regs
module Map16 = Vale.Lib.Map16
noeq type vale_state = {
vs_ok: bool;
vs_regs: Regs.t;
vs_flags: Flags.t;
vs_heap: vale_full_heap;
vs_stack: vale_stack;
vs_stackTaint: memtaint;
}
unfold let vs_get_vale_heap (s:vale_state) : vale_heap = get_vale_heap s.vs_heap
[@va_qattr]
unfold let eval_reg (r:reg) (s:vale_state) : t_reg r = Regs.sel r s.vs_regs
[@va_qattr]
unfold let eval_reg_int (r:reg) (s:vale_state) : int = t_reg_to_int r.rf (eval_reg r s)
[@va_qattr]
unfold let eval_flag (f:flag) (s:vale_state) : Flags.flag_val_t = Flags.sel f s.vs_flags
[@va_qattr]
unfold let eval_mem (ptr:int) (s:vale_state) : GTot nat64 = load_mem64 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_mem128 (ptr:int) (s:vale_state) : GTot Vale.Def.Types_s.quad32 = load_mem128 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_stack (ptr:int) (s:vale_state) : GTot nat64 = load_stack64 ptr s.vs_stack
[@va_qattr]
unfold let eval_stack128 (ptr:int) (s:vale_state) : GTot quad32 = load_stack128 ptr s.vs_stack
[@va_qattr]
unfold let eval_reg_64 (r:reg_64) (s:vale_state) : nat64 = eval_reg (Reg 0 r) s
[@va_qattr]
unfold let eval_reg_xmm (r:reg_xmm) (s:vale_state) : quad32 = eval_reg (Reg 1 r) s
[@va_qattr]
let eval_maddr (m:maddr) (s:vale_state) : int =
match m with
| MConst n -> n
| MReg r offset -> eval_reg_int r s + offset
| MIndex base scale index offset -> eval_reg_int base s + scale * (eval_reg_int index s) + offset
[@va_qattr]
let eval_operand (o:operand64) (s:vale_state) : GTot nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s
[@va_qattr]
let eval_operand128 (o:operand128) (s:vale_state) : GTot Vale.Def.Types_s.quad32 =
match o with
| OConst c -> c
| OReg r -> eval_reg_xmm r s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s
[@va_qattr]
let update_reg (r:reg) (v:t_reg r) (s:vale_state) : vale_state =
{s with vs_regs = Regs.upd r v s.vs_regs}
[@va_qattr]
let update_reg_64 (r:reg_64) (v:nat64) (s:vale_state) : vale_state =
update_reg (Reg 0 r) v s
[@va_qattr]
let update_flag (f:flag) (v:Flags.flag_val_t) (s:vale_state) : vale_state =
{s with vs_flags = Flags.upd f v s.vs_flags}
[@va_qattr]
let update_reg_xmm (r:reg_xmm) (v:quad32) (s:vale_state) : vale_state =
update_reg (Reg 1 r) v s
//[@va_qattr]
//let update_mem (ptr:int) (v:nat64) (s:vale_state) : GTot vale_state =
// {s with vs_heap = set_vale_heap s.vs_heap (store_mem64 ptr v (get_vale_heap s.vs_heap))} | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.State.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Regs",
"short_module": "Regs"
},
{
"abbrev": true,
"full_module": "Vale.X64.Flags",
"short_module": "Flags"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | ptr: Prims.int -> v: Vale.X64.Memory.nat64 -> s: Vale.X64.State.vale_state
-> Prims.GTot Vale.X64.State.vale_state | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.int",
"Vale.X64.Memory.nat64",
"Vale.X64.State.vale_state",
"Vale.X64.State.Mkvale_state",
"Vale.X64.State.__proj__Mkvale_state__item__vs_ok",
"Vale.X64.State.__proj__Mkvale_state__item__vs_regs",
"Vale.X64.State.__proj__Mkvale_state__item__vs_flags",
"Vale.X64.State.__proj__Mkvale_state__item__vs_heap",
"Vale.X64.Stack_i.store_stack64",
"Vale.X64.State.__proj__Mkvale_state__item__vs_stack",
"Vale.X64.State.__proj__Mkvale_state__item__vs_stackTaint"
] | [] | false | false | false | false | false | let update_stack64 (ptr: int) (v: nat64) (s: vale_state) : GTot vale_state =
| { s with vs_stack = store_stack64 ptr v s.vs_stack } | false |
Vale.X64.State.fsti | Vale.X64.State.valid_maddr | val valid_maddr (m: maddr) (s: vale_state) : prop0 | val valid_maddr (m: maddr) (s: vale_state) : prop0 | let valid_maddr (m:maddr) (s:vale_state) : prop0 =
valid_mem64 (eval_maddr m s) (get_vale_heap s.vs_heap) | {
"file_name": "vale/code/arch/x64/Vale.X64.State.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 56,
"end_line": 103,
"start_col": 0,
"start_line": 102
} | module Vale.X64.State
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
module Flags = Vale.X64.Flags
module Regs = Vale.X64.Regs
module Map16 = Vale.Lib.Map16
noeq type vale_state = {
vs_ok: bool;
vs_regs: Regs.t;
vs_flags: Flags.t;
vs_heap: vale_full_heap;
vs_stack: vale_stack;
vs_stackTaint: memtaint;
}
unfold let vs_get_vale_heap (s:vale_state) : vale_heap = get_vale_heap s.vs_heap
[@va_qattr]
unfold let eval_reg (r:reg) (s:vale_state) : t_reg r = Regs.sel r s.vs_regs
[@va_qattr]
unfold let eval_reg_int (r:reg) (s:vale_state) : int = t_reg_to_int r.rf (eval_reg r s)
[@va_qattr]
unfold let eval_flag (f:flag) (s:vale_state) : Flags.flag_val_t = Flags.sel f s.vs_flags
[@va_qattr]
unfold let eval_mem (ptr:int) (s:vale_state) : GTot nat64 = load_mem64 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_mem128 (ptr:int) (s:vale_state) : GTot Vale.Def.Types_s.quad32 = load_mem128 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_stack (ptr:int) (s:vale_state) : GTot nat64 = load_stack64 ptr s.vs_stack
[@va_qattr]
unfold let eval_stack128 (ptr:int) (s:vale_state) : GTot quad32 = load_stack128 ptr s.vs_stack
[@va_qattr]
unfold let eval_reg_64 (r:reg_64) (s:vale_state) : nat64 = eval_reg (Reg 0 r) s
[@va_qattr]
unfold let eval_reg_xmm (r:reg_xmm) (s:vale_state) : quad32 = eval_reg (Reg 1 r) s
[@va_qattr]
let eval_maddr (m:maddr) (s:vale_state) : int =
match m with
| MConst n -> n
| MReg r offset -> eval_reg_int r s + offset
| MIndex base scale index offset -> eval_reg_int base s + scale * (eval_reg_int index s) + offset
[@va_qattr]
let eval_operand (o:operand64) (s:vale_state) : GTot nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s
[@va_qattr]
let eval_operand128 (o:operand128) (s:vale_state) : GTot Vale.Def.Types_s.quad32 =
match o with
| OConst c -> c
| OReg r -> eval_reg_xmm r s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s
[@va_qattr]
let update_reg (r:reg) (v:t_reg r) (s:vale_state) : vale_state =
{s with vs_regs = Regs.upd r v s.vs_regs}
[@va_qattr]
let update_reg_64 (r:reg_64) (v:nat64) (s:vale_state) : vale_state =
update_reg (Reg 0 r) v s
[@va_qattr]
let update_flag (f:flag) (v:Flags.flag_val_t) (s:vale_state) : vale_state =
{s with vs_flags = Flags.upd f v s.vs_flags}
[@va_qattr]
let update_reg_xmm (r:reg_xmm) (v:quad32) (s:vale_state) : vale_state =
update_reg (Reg 1 r) v s
//[@va_qattr]
//let update_mem (ptr:int) (v:nat64) (s:vale_state) : GTot vale_state =
// {s with vs_heap = set_vale_heap s.vs_heap (store_mem64 ptr v (get_vale_heap s.vs_heap))}
[@va_qattr]
let update_stack64 (ptr:int) (v:nat64) (s:vale_state) : GTot vale_state =
{s with vs_stack = store_stack64 ptr v s.vs_stack}
//[@va_qattr]
//let update_operand64 (o:operand64) (v:nat64) (sM:vale_state) : GTot vale_state =
// match o with
// | OConst n -> sM
// | OReg r -> update_reg (Reg 0 r) v sM
// | OMem (m, _) -> update_mem (eval_maddr m sM) v sM
// | OStack (m, _) -> update_stack64 (eval_maddr m sM) v sM | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.State.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Regs",
"short_module": "Regs"
},
{
"abbrev": true,
"full_module": "Vale.X64.Flags",
"short_module": "Flags"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | m: Vale.X64.Machine_s.maddr -> s: Vale.X64.State.vale_state -> Vale.Def.Prop_s.prop0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.maddr",
"Vale.X64.State.vale_state",
"Prims.b2t",
"Vale.X64.Memory.valid_mem64",
"Vale.X64.State.eval_maddr",
"Vale.X64.Memory.get_vale_heap",
"Vale.X64.State.__proj__Mkvale_state__item__vs_heap",
"Vale.Def.Prop_s.prop0"
] | [] | false | false | false | true | false | let valid_maddr (m: maddr) (s: vale_state) : prop0 =
| valid_mem64 (eval_maddr m s) (get_vale_heap s.vs_heap) | false |
Vale.X64.State.fsti | Vale.X64.State.valid_maddr128 | val valid_maddr128 (m: maddr) (s: vale_state) : prop0 | val valid_maddr128 (m: maddr) (s: vale_state) : prop0 | let valid_maddr128 (m:maddr) (s:vale_state) : prop0 =
valid_mem128 (eval_maddr m s) (get_vale_heap s.vs_heap) | {
"file_name": "vale/code/arch/x64/Vale.X64.State.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 57,
"end_line": 107,
"start_col": 0,
"start_line": 106
} | module Vale.X64.State
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
module Flags = Vale.X64.Flags
module Regs = Vale.X64.Regs
module Map16 = Vale.Lib.Map16
noeq type vale_state = {
vs_ok: bool;
vs_regs: Regs.t;
vs_flags: Flags.t;
vs_heap: vale_full_heap;
vs_stack: vale_stack;
vs_stackTaint: memtaint;
}
unfold let vs_get_vale_heap (s:vale_state) : vale_heap = get_vale_heap s.vs_heap
[@va_qattr]
unfold let eval_reg (r:reg) (s:vale_state) : t_reg r = Regs.sel r s.vs_regs
[@va_qattr]
unfold let eval_reg_int (r:reg) (s:vale_state) : int = t_reg_to_int r.rf (eval_reg r s)
[@va_qattr]
unfold let eval_flag (f:flag) (s:vale_state) : Flags.flag_val_t = Flags.sel f s.vs_flags
[@va_qattr]
unfold let eval_mem (ptr:int) (s:vale_state) : GTot nat64 = load_mem64 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_mem128 (ptr:int) (s:vale_state) : GTot Vale.Def.Types_s.quad32 = load_mem128 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_stack (ptr:int) (s:vale_state) : GTot nat64 = load_stack64 ptr s.vs_stack
[@va_qattr]
unfold let eval_stack128 (ptr:int) (s:vale_state) : GTot quad32 = load_stack128 ptr s.vs_stack
[@va_qattr]
unfold let eval_reg_64 (r:reg_64) (s:vale_state) : nat64 = eval_reg (Reg 0 r) s
[@va_qattr]
unfold let eval_reg_xmm (r:reg_xmm) (s:vale_state) : quad32 = eval_reg (Reg 1 r) s
[@va_qattr]
let eval_maddr (m:maddr) (s:vale_state) : int =
match m with
| MConst n -> n
| MReg r offset -> eval_reg_int r s + offset
| MIndex base scale index offset -> eval_reg_int base s + scale * (eval_reg_int index s) + offset
[@va_qattr]
let eval_operand (o:operand64) (s:vale_state) : GTot nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s
[@va_qattr]
let eval_operand128 (o:operand128) (s:vale_state) : GTot Vale.Def.Types_s.quad32 =
match o with
| OConst c -> c
| OReg r -> eval_reg_xmm r s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s
[@va_qattr]
let update_reg (r:reg) (v:t_reg r) (s:vale_state) : vale_state =
{s with vs_regs = Regs.upd r v s.vs_regs}
[@va_qattr]
let update_reg_64 (r:reg_64) (v:nat64) (s:vale_state) : vale_state =
update_reg (Reg 0 r) v s
[@va_qattr]
let update_flag (f:flag) (v:Flags.flag_val_t) (s:vale_state) : vale_state =
{s with vs_flags = Flags.upd f v s.vs_flags}
[@va_qattr]
let update_reg_xmm (r:reg_xmm) (v:quad32) (s:vale_state) : vale_state =
update_reg (Reg 1 r) v s
//[@va_qattr]
//let update_mem (ptr:int) (v:nat64) (s:vale_state) : GTot vale_state =
// {s with vs_heap = set_vale_heap s.vs_heap (store_mem64 ptr v (get_vale_heap s.vs_heap))}
[@va_qattr]
let update_stack64 (ptr:int) (v:nat64) (s:vale_state) : GTot vale_state =
{s with vs_stack = store_stack64 ptr v s.vs_stack}
//[@va_qattr]
//let update_operand64 (o:operand64) (v:nat64) (sM:vale_state) : GTot vale_state =
// match o with
// | OConst n -> sM
// | OReg r -> update_reg (Reg 0 r) v sM
// | OMem (m, _) -> update_mem (eval_maddr m sM) v sM
// | OStack (m, _) -> update_stack64 (eval_maddr m sM) v sM
[@va_qattr]
let valid_maddr (m:maddr) (s:vale_state) : prop0 =
valid_mem64 (eval_maddr m s) (get_vale_heap s.vs_heap) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.State.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Regs",
"short_module": "Regs"
},
{
"abbrev": true,
"full_module": "Vale.X64.Flags",
"short_module": "Flags"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | m: Vale.X64.Machine_s.maddr -> s: Vale.X64.State.vale_state -> Vale.Def.Prop_s.prop0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.maddr",
"Vale.X64.State.vale_state",
"Prims.b2t",
"Vale.X64.Memory.valid_mem128",
"Vale.X64.State.eval_maddr",
"Vale.X64.Memory.get_vale_heap",
"Vale.X64.State.__proj__Mkvale_state__item__vs_heap",
"Vale.Def.Prop_s.prop0"
] | [] | false | false | false | true | false | let valid_maddr128 (m: maddr) (s: vale_state) : prop0 =
| valid_mem128 (eval_maddr m s) (get_vale_heap s.vs_heap) | false |
Vale.X64.State.fsti | Vale.X64.State.state_eta | val state_eta (s: vale_state) : vale_state | val state_eta (s: vale_state) : vale_state | let state_eta (s:vale_state) : vale_state =
{s with
vs_regs = Regs.eta s.vs_regs;
vs_heap = {s.vs_heap with vf_heaplets = Map16.eta s.vs_heap.vf_heaplets};
} | {
"file_name": "vale/code/arch/x64/Vale.X64.State.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 130,
"start_col": 0,
"start_line": 126
} | module Vale.X64.State
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
module Flags = Vale.X64.Flags
module Regs = Vale.X64.Regs
module Map16 = Vale.Lib.Map16
noeq type vale_state = {
vs_ok: bool;
vs_regs: Regs.t;
vs_flags: Flags.t;
vs_heap: vale_full_heap;
vs_stack: vale_stack;
vs_stackTaint: memtaint;
}
unfold let vs_get_vale_heap (s:vale_state) : vale_heap = get_vale_heap s.vs_heap
[@va_qattr]
unfold let eval_reg (r:reg) (s:vale_state) : t_reg r = Regs.sel r s.vs_regs
[@va_qattr]
unfold let eval_reg_int (r:reg) (s:vale_state) : int = t_reg_to_int r.rf (eval_reg r s)
[@va_qattr]
unfold let eval_flag (f:flag) (s:vale_state) : Flags.flag_val_t = Flags.sel f s.vs_flags
[@va_qattr]
unfold let eval_mem (ptr:int) (s:vale_state) : GTot nat64 = load_mem64 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_mem128 (ptr:int) (s:vale_state) : GTot Vale.Def.Types_s.quad32 = load_mem128 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_stack (ptr:int) (s:vale_state) : GTot nat64 = load_stack64 ptr s.vs_stack
[@va_qattr]
unfold let eval_stack128 (ptr:int) (s:vale_state) : GTot quad32 = load_stack128 ptr s.vs_stack
[@va_qattr]
unfold let eval_reg_64 (r:reg_64) (s:vale_state) : nat64 = eval_reg (Reg 0 r) s
[@va_qattr]
unfold let eval_reg_xmm (r:reg_xmm) (s:vale_state) : quad32 = eval_reg (Reg 1 r) s
[@va_qattr]
let eval_maddr (m:maddr) (s:vale_state) : int =
match m with
| MConst n -> n
| MReg r offset -> eval_reg_int r s + offset
| MIndex base scale index offset -> eval_reg_int base s + scale * (eval_reg_int index s) + offset
[@va_qattr]
let eval_operand (o:operand64) (s:vale_state) : GTot nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s
[@va_qattr]
let eval_operand128 (o:operand128) (s:vale_state) : GTot Vale.Def.Types_s.quad32 =
match o with
| OConst c -> c
| OReg r -> eval_reg_xmm r s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s
[@va_qattr]
let update_reg (r:reg) (v:t_reg r) (s:vale_state) : vale_state =
{s with vs_regs = Regs.upd r v s.vs_regs}
[@va_qattr]
let update_reg_64 (r:reg_64) (v:nat64) (s:vale_state) : vale_state =
update_reg (Reg 0 r) v s
[@va_qattr]
let update_flag (f:flag) (v:Flags.flag_val_t) (s:vale_state) : vale_state =
{s with vs_flags = Flags.upd f v s.vs_flags}
[@va_qattr]
let update_reg_xmm (r:reg_xmm) (v:quad32) (s:vale_state) : vale_state =
update_reg (Reg 1 r) v s
//[@va_qattr]
//let update_mem (ptr:int) (v:nat64) (s:vale_state) : GTot vale_state =
// {s with vs_heap = set_vale_heap s.vs_heap (store_mem64 ptr v (get_vale_heap s.vs_heap))}
[@va_qattr]
let update_stack64 (ptr:int) (v:nat64) (s:vale_state) : GTot vale_state =
{s with vs_stack = store_stack64 ptr v s.vs_stack}
//[@va_qattr]
//let update_operand64 (o:operand64) (v:nat64) (sM:vale_state) : GTot vale_state =
// match o with
// | OConst n -> sM
// | OReg r -> update_reg (Reg 0 r) v sM
// | OMem (m, _) -> update_mem (eval_maddr m sM) v sM
// | OStack (m, _) -> update_stack64 (eval_maddr m sM) v sM
[@va_qattr]
let valid_maddr (m:maddr) (s:vale_state) : prop0 =
valid_mem64 (eval_maddr m s) (get_vale_heap s.vs_heap)
[@va_qattr]
let valid_maddr128 (m:maddr) (s:vale_state) : prop0 =
valid_mem128 (eval_maddr m s) (get_vale_heap s.vs_heap)
[@va_qattr]
let valid_src_operand (o:operand64) (s:vale_state) : prop0 =
match o with
| OConst c -> True
| OReg r -> True
| OMem (m, _) -> valid_maddr m s
| OStack (m, _) -> valid_src_stack64 (eval_maddr m s) s.vs_stack
[@va_qattr]
let valid_src_operand128 (o:operand128) (s:vale_state) : prop0 =
match o with
| OConst _ -> False
| OReg _ -> True
| OMem (m, _) -> valid_maddr128 m s
| OStack (m, _) -> valid_src_stack128 (eval_maddr m s) s.vs_stack | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.State.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Regs",
"short_module": "Regs"
},
{
"abbrev": true,
"full_module": "Vale.X64.Flags",
"short_module": "Flags"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | s: Vale.X64.State.vale_state -> Vale.X64.State.vale_state | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.State.vale_state",
"Vale.X64.State.Mkvale_state",
"Vale.X64.State.__proj__Mkvale_state__item__vs_ok",
"Vale.X64.Regs.eta",
"Vale.X64.State.__proj__Mkvale_state__item__vs_regs",
"Vale.X64.State.__proj__Mkvale_state__item__vs_flags",
"Vale.Arch.HeapImpl.Mkvale_full_heap",
"Vale.Arch.HeapImpl.__proj__Mkvale_full_heap__item__vf_layout",
"Vale.Arch.HeapImpl.__proj__Mkvale_full_heap__item__vf_heap",
"Vale.Lib.Map16.eta",
"Vale.Arch.HeapImpl.vale_heap",
"Vale.Arch.HeapImpl.__proj__Mkvale_full_heap__item__vf_heaplets",
"Vale.X64.State.__proj__Mkvale_state__item__vs_heap",
"Vale.Arch.HeapImpl.vale_full_heap",
"Vale.X64.State.__proj__Mkvale_state__item__vs_stack",
"Vale.X64.State.__proj__Mkvale_state__item__vs_stackTaint"
] | [] | false | false | false | true | false | let state_eta (s: vale_state) : vale_state =
| {
s with
vs_regs = Regs.eta s.vs_regs;
vs_heap = { s.vs_heap with vf_heaplets = Map16.eta s.vs_heap.vf_heaplets }
} | false |
Lib.ByteSequence.fsti | Lib.ByteSequence.nat_to_bytes_be | val nat_to_bytes_be (#l: secrecy_level) (len: nat) (n: nat{n < pow2 (8 * len)})
: b: bytes_l l {length b == len /\ n == nat_from_intseq_be #U8 b} | val nat_to_bytes_be (#l: secrecy_level) (len: nat) (n: nat{n < pow2 (8 * len)})
: b: bytes_l l {length b == len /\ n == nat_from_intseq_be #U8 b} | let nat_to_bytes_be (#l:secrecy_level) (len:nat) (n:nat{n < pow2 (8 * len)}) : b:bytes_l l{length b == len /\ n == nat_from_intseq_be #U8 b} =
nat_to_intseq_be #U8 #l len n | {
"file_name": "lib/Lib.ByteSequence.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 31,
"end_line": 111,
"start_col": 0,
"start_line": 110
} | module Lib.ByteSequence
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 30 --max_fuel 0 --max_ifuel 0"
/// Definition of byte-based sequences
unfold inline_for_extraction
type bytes_l (l:secrecy_level) = seq (uint_t U8 l)
unfold inline_for_extraction
type lbytes_l (l:secrecy_level) (len:size_nat) = lseq (uint_t U8 l) len
unfold inline_for_extraction let bytes = bytes_l SEC
unfold inline_for_extraction let lbytes (len:size_nat) = lbytes_l SEC len
unfold inline_for_extraction let pub_bytes = bytes_l PUB
unfold inline_for_extraction let pub_lbytes (len:size_nat) = lbytes_l PUB len
(* Alias *)
unfold inline_for_extraction let bytes_t = bytes
unfold inline_for_extraction let pub_bytes_t = pub_bytes
(** Construct the equality mask for a pair of secret integer sequences *)
val seq_eq_mask: #t:inttype{~(S128? t)} -> #len1:size_nat -> #len2:size_nat
-> b1:lseq (int_t t SEC) len1
-> b2:lseq (int_t t SEC) len2
-> len:size_nat{len <= len1 /\ len <= len2}
-> res:int_t t SEC{
(sub b1 0 len == sub b2 0 len ==> v res == v (ones t SEC)) /\
(sub b1 0 len =!= sub b2 0 len ==> v res == v (zeros t SEC))}
(** Compares two byte sequences and declassifies the result *)
inline_for_extraction
val lbytes_eq: #len:size_nat -> b1:lbytes len -> b2:lbytes len -> b:bool{b <==> b1 == b2}
inline_for_extraction
val mask_select: #t:inttype{~(S128? t)} -> mask:int_t t SEC -> a:int_t t SEC -> b:int_t t SEC -> int_t t SEC
val mask_select_lemma: #t:inttype{~(S128? t)} -> mask:int_t t SEC -> a:int_t t SEC -> b:int_t t SEC -> Lemma
(requires v mask = 0 \/ v mask = v (ones t SEC))
(ensures mask_select mask a b == (if v mask = 0 then b else a))
val seq_mask_select: #t:inttype{~(S128? t)} -> #len:size_nat
-> a:lseq (int_t t SEC) len
-> b:lseq (int_t t SEC) len
-> mask:int_t t SEC
-> Pure (lseq (int_t t SEC) len)
(requires v mask = 0 \/ v mask = v (ones t SEC))
(ensures fun res -> res == (if v mask = 0 then b else a))
/// Constant for empty lbytes
let bytes_empty: bytes = Seq.Base.empty
let pub_bytes_empty: pub_bytes = Seq.Base.empty
let lbytes_empty: lbytes 0 = create 0 (u8 0)
/// Conversions between natural numbers and sequences
inline_for_extraction
val nat_from_intseq_be: #t:inttype{unsigned t} -> #l:secrecy_level -> b:seq (uint_t t l)
-> n:nat{n < pow2 (length b * bits t)}
inline_for_extraction
val nat_from_intseq_le: #t:inttype{unsigned t} -> #l:secrecy_level
-> b:seq (uint_t t l) -> n:nat{n < pow2 (length b * bits t)}
inline_for_extraction
let nat_from_bytes_be (#l:secrecy_level) (b:bytes_l l) : n:nat{n < pow2 (length b * 8)} =
nat_from_intseq_be #U8 #l b
inline_for_extraction
let nat_from_bytes_le (#l:secrecy_level) (b:bytes_l l) : n:nat{n < pow2 (length b * 8)} =
nat_from_intseq_le #U8 #l b
inline_for_extraction
val nat_to_intseq_be: #t:inttype{unsigned t} -> #l:secrecy_level -> len:nat -> n:nat{n < pow2 (bits t * len)} ->
b:seq (uint_t t l){length b == len /\ n == nat_from_intseq_be b}
inline_for_extraction
val nat_to_intseq_le: #t:inttype{unsigned t} -> #l:secrecy_level -> len:nat -> n:nat{n < pow2 (bits t * len)} ->
b:seq (uint_t t l){length b == len /\ n == nat_from_intseq_le b}
val index_nat_to_intseq_le:
#t:inttype{unsigned t}
-> #l:secrecy_level
-> len:size_nat
-> n:nat{n < pow2 (bits t * len)}
-> i:nat{i < len}
-> Lemma (Seq.index (nat_to_intseq_le #t #l len n) i ==
uint #t #l (n / pow2 (bits t * i) % pow2 (bits t)))
val index_nat_to_intseq_be:
#t:inttype{unsigned t}
-> #l:secrecy_level
-> len:size_nat
-> n:nat{n < pow2 (bits t * len)}
-> i:nat{i < len}
-> Lemma (Seq.index (nat_to_intseq_be #t #l len n) (len - i - 1) ==
uint #t #l (n / pow2 (bits t * i) % pow2 (bits t))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Lib.ByteSequence.fsti"
} | [
{
"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": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | len: Prims.nat -> n: Prims.nat{n < Prims.pow2 (8 * len)}
-> b:
Lib.ByteSequence.bytes_l l
{Lib.Sequence.length b == len /\ n == Lib.ByteSequence.nat_from_intseq_be b} | Prims.Tot | [
"total"
] | [] | [
"Lib.IntTypes.secrecy_level",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"FStar.Mul.op_Star",
"Lib.ByteSequence.nat_to_intseq_be",
"Lib.IntTypes.U8",
"Lib.ByteSequence.bytes_l",
"Prims.l_and",
"Prims.eq2",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Prims.l_or",
"Lib.IntTypes.bits",
"Lib.ByteSequence.nat_from_intseq_be"
] | [] | false | false | false | false | false | let nat_to_bytes_be (#l: secrecy_level) (len: nat) (n: nat{n < pow2 (8 * len)})
: b: bytes_l l {length b == len /\ n == nat_from_intseq_be #U8 b} =
| nat_to_intseq_be #U8 #l len n | false |
Vale.X64.State.fsti | Vale.X64.State.state_eq | val state_eq (s0 s1: vale_state) : prop0 | val state_eq (s0 s1: vale_state) : prop0 | let state_eq (s0:vale_state) (s1:vale_state) : prop0 =
s0.vs_ok == s1.vs_ok /\
Regs.equal s0.vs_regs s1.vs_regs /\
Flags.equal s0.vs_flags s1.vs_flags /\
vale_full_heap_equal s0.vs_heap s1.vs_heap /\
s0.vs_stack == s1.vs_stack /\
s0.vs_stackTaint == s1.vs_stackTaint | {
"file_name": "vale/code/arch/x64/Vale.X64.State.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 139,
"start_col": 0,
"start_line": 133
} | module Vale.X64.State
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
module Flags = Vale.X64.Flags
module Regs = Vale.X64.Regs
module Map16 = Vale.Lib.Map16
noeq type vale_state = {
vs_ok: bool;
vs_regs: Regs.t;
vs_flags: Flags.t;
vs_heap: vale_full_heap;
vs_stack: vale_stack;
vs_stackTaint: memtaint;
}
unfold let vs_get_vale_heap (s:vale_state) : vale_heap = get_vale_heap s.vs_heap
[@va_qattr]
unfold let eval_reg (r:reg) (s:vale_state) : t_reg r = Regs.sel r s.vs_regs
[@va_qattr]
unfold let eval_reg_int (r:reg) (s:vale_state) : int = t_reg_to_int r.rf (eval_reg r s)
[@va_qattr]
unfold let eval_flag (f:flag) (s:vale_state) : Flags.flag_val_t = Flags.sel f s.vs_flags
[@va_qattr]
unfold let eval_mem (ptr:int) (s:vale_state) : GTot nat64 = load_mem64 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_mem128 (ptr:int) (s:vale_state) : GTot Vale.Def.Types_s.quad32 = load_mem128 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_stack (ptr:int) (s:vale_state) : GTot nat64 = load_stack64 ptr s.vs_stack
[@va_qattr]
unfold let eval_stack128 (ptr:int) (s:vale_state) : GTot quad32 = load_stack128 ptr s.vs_stack
[@va_qattr]
unfold let eval_reg_64 (r:reg_64) (s:vale_state) : nat64 = eval_reg (Reg 0 r) s
[@va_qattr]
unfold let eval_reg_xmm (r:reg_xmm) (s:vale_state) : quad32 = eval_reg (Reg 1 r) s
[@va_qattr]
let eval_maddr (m:maddr) (s:vale_state) : int =
match m with
| MConst n -> n
| MReg r offset -> eval_reg_int r s + offset
| MIndex base scale index offset -> eval_reg_int base s + scale * (eval_reg_int index s) + offset
[@va_qattr]
let eval_operand (o:operand64) (s:vale_state) : GTot nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s
[@va_qattr]
let eval_operand128 (o:operand128) (s:vale_state) : GTot Vale.Def.Types_s.quad32 =
match o with
| OConst c -> c
| OReg r -> eval_reg_xmm r s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s
[@va_qattr]
let update_reg (r:reg) (v:t_reg r) (s:vale_state) : vale_state =
{s with vs_regs = Regs.upd r v s.vs_regs}
[@va_qattr]
let update_reg_64 (r:reg_64) (v:nat64) (s:vale_state) : vale_state =
update_reg (Reg 0 r) v s
[@va_qattr]
let update_flag (f:flag) (v:Flags.flag_val_t) (s:vale_state) : vale_state =
{s with vs_flags = Flags.upd f v s.vs_flags}
[@va_qattr]
let update_reg_xmm (r:reg_xmm) (v:quad32) (s:vale_state) : vale_state =
update_reg (Reg 1 r) v s
//[@va_qattr]
//let update_mem (ptr:int) (v:nat64) (s:vale_state) : GTot vale_state =
// {s with vs_heap = set_vale_heap s.vs_heap (store_mem64 ptr v (get_vale_heap s.vs_heap))}
[@va_qattr]
let update_stack64 (ptr:int) (v:nat64) (s:vale_state) : GTot vale_state =
{s with vs_stack = store_stack64 ptr v s.vs_stack}
//[@va_qattr]
//let update_operand64 (o:operand64) (v:nat64) (sM:vale_state) : GTot vale_state =
// match o with
// | OConst n -> sM
// | OReg r -> update_reg (Reg 0 r) v sM
// | OMem (m, _) -> update_mem (eval_maddr m sM) v sM
// | OStack (m, _) -> update_stack64 (eval_maddr m sM) v sM
[@va_qattr]
let valid_maddr (m:maddr) (s:vale_state) : prop0 =
valid_mem64 (eval_maddr m s) (get_vale_heap s.vs_heap)
[@va_qattr]
let valid_maddr128 (m:maddr) (s:vale_state) : prop0 =
valid_mem128 (eval_maddr m s) (get_vale_heap s.vs_heap)
[@va_qattr]
let valid_src_operand (o:operand64) (s:vale_state) : prop0 =
match o with
| OConst c -> True
| OReg r -> True
| OMem (m, _) -> valid_maddr m s
| OStack (m, _) -> valid_src_stack64 (eval_maddr m s) s.vs_stack
[@va_qattr]
let valid_src_operand128 (o:operand128) (s:vale_state) : prop0 =
match o with
| OConst _ -> False
| OReg _ -> True
| OMem (m, _) -> valid_maddr128 m s
| OStack (m, _) -> valid_src_stack128 (eval_maddr m s) s.vs_stack
[@va_qattr]
let state_eta (s:vale_state) : vale_state =
{s with
vs_regs = Regs.eta s.vs_regs;
vs_heap = {s.vs_heap with vf_heaplets = Map16.eta s.vs_heap.vf_heaplets};
} | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.State.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Regs",
"short_module": "Regs"
},
{
"abbrev": true,
"full_module": "Vale.X64.Flags",
"short_module": "Flags"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | s0: Vale.X64.State.vale_state -> s1: Vale.X64.State.vale_state -> Vale.Def.Prop_s.prop0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.State.vale_state",
"Prims.l_and",
"Prims.eq2",
"Prims.bool",
"Vale.X64.State.__proj__Mkvale_state__item__vs_ok",
"Vale.X64.Regs.equal",
"Vale.X64.State.__proj__Mkvale_state__item__vs_regs",
"Vale.X64.Flags.equal",
"Vale.X64.State.__proj__Mkvale_state__item__vs_flags",
"Vale.X64.Memory.vale_full_heap_equal",
"Vale.X64.State.__proj__Mkvale_state__item__vs_heap",
"Vale.X64.Stack_i.vale_stack",
"Vale.X64.State.__proj__Mkvale_state__item__vs_stack",
"Vale.X64.Memory.memtaint",
"Vale.X64.State.__proj__Mkvale_state__item__vs_stackTaint",
"Vale.Def.Prop_s.prop0"
] | [] | false | false | false | true | false | let state_eq (s0 s1: vale_state) : prop0 =
| s0.vs_ok == s1.vs_ok /\ Regs.equal s0.vs_regs s1.vs_regs /\ Flags.equal s0.vs_flags s1.vs_flags /\
vale_full_heap_equal s0.vs_heap s1.vs_heap /\ s0.vs_stack == s1.vs_stack /\
s0.vs_stackTaint == s1.vs_stackTaint | false |
Spec.Frodo.Gen.fst | Spec.Frodo.Gen.frodo_gen_matrix_shake_4x_ind | val frodo_gen_matrix_shake_4x_ind:
n:size_nat{n * n <= max_size_t /\ n <= maxint U16 /\ n % 4 = 0}
-> seed:lbytes 16
-> Pure (matrix n n)
(requires True)
(ensures fun res ->
res == Loops.repeati (n / 4) (frodo_gen_matrix_shake_4x1_ind n seed) (Matrix.create n n) /\
res == frodo_gen_matrix_shake_ind n seed) | val frodo_gen_matrix_shake_4x_ind:
n:size_nat{n * n <= max_size_t /\ n <= maxint U16 /\ n % 4 = 0}
-> seed:lbytes 16
-> Pure (matrix n n)
(requires True)
(ensures fun res ->
res == Loops.repeati (n / 4) (frodo_gen_matrix_shake_4x1_ind n seed) (Matrix.create n n) /\
res == frodo_gen_matrix_shake_ind n seed) | let frodo_gen_matrix_shake_4x_ind n seed =
let res = Matrix.create n n in
let n4 = n / 4 in
//Loops.repeati n4 (frodo_gen_matrix_shake_4x1 n seed) res
let res =
Loops.repeati_inductive' n4
(fun i res ->
forall (i0:size_nat{i0 < i}) (j:size_nat{j < n}) (k:size_nat{k < 4}).
res.(4 * i0 + k, j) == frodo_gen_matrix_shake_fc n seed (4 * i0 + k) j)
(frodo_gen_matrix_shake_4x1_ind n seed) res in
//assert (forall (i0:size_nat{i0 < n / 4}) (j:size_nat{j < n}) (k:size_nat{k < 4}).
//res.(4 * i0 + k, j) == frodo_gen_matrix_shake_fc n seed (4 * i0 + k) j);
lemma_gen_matrix_4x n seed res;
Spec.Matrix.extensionality res (frodo_gen_matrix_shake_ind n seed);
res | {
"file_name": "specs/frodo/Spec.Frodo.Gen.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 278,
"start_col": 0,
"start_line": 263
} | module Spec.Frodo.Gen
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
open Spec.SHA3
open Spec.AES
module Matrix = Spec.Matrix
module LSeq = Lib.Sequence
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val frodo_gen_matrix_shake_get_r:
n:size_nat{n * n <= max_size_t /\ n <= maxint U16}
-> seed:lbytes 16
-> i:size_nat{i < n}
-> lbytes (2 * n)
let frodo_gen_matrix_shake_get_r n seed i =
let tmp = uint_to_bytes_le (u16 i) in
let b = concat tmp seed in
shake128 18 b (2 * n)
val frodo_gen_matrix_shake0:
n:size_nat{n * n <= max_size_t}
-> i:size_nat{i < n}
-> res_i:lbytes (2 * n)
-> j:size_nat{j < n}
-> res0:matrix n n
-> matrix n n
let frodo_gen_matrix_shake0 n i res_i j res0 =
res0.(i, j) <- uint_from_bytes_le (LSeq.sub res_i (j * 2) 2)
val frodo_gen_matrix_shake1:
n:size_nat{n * n <= max_size_t /\ n <= maxint U16}
-> seed:lbytes 16
-> i:size_nat{i < n}
-> res:matrix n n
-> matrix n n
let frodo_gen_matrix_shake1 n seed i res =
let res_i = frodo_gen_matrix_shake_get_r n seed i in
Loops.repeati n (frodo_gen_matrix_shake0 n i res_i) res
val frodo_gen_matrix_shake:
n:size_nat{n * n <= max_size_t /\ n <= maxint U16}
-> seed:lbytes 16
-> matrix n n
let frodo_gen_matrix_shake n seed =
let res = Matrix.create n n in
Loops.repeati n (frodo_gen_matrix_shake1 n seed) res
val frodo_gen_matrix_shake_4x0:
n:size_nat{n * n <= max_size_t /\ n <= maxint U16}
-> i:size_nat{i < n / 4}
-> r0:lbytes (2 * n)
-> r1:lbytes (2 * n)
-> r2:lbytes (2 * n)
-> r3:lbytes (2 * n)
-> j:size_nat{j < n}
-> res0:matrix n n
-> matrix n n
let frodo_gen_matrix_shake_4x0 n i r0 r1 r2 r3 j res0 =
let res0 = res0.(4 * i + 0, j) <- uint_from_bytes_le (LSeq.sub r0 (j * 2) 2) in
let res0 = res0.(4 * i + 1, j) <- uint_from_bytes_le (LSeq.sub r1 (j * 2) 2) in
let res0 = res0.(4 * i + 2, j) <- uint_from_bytes_le (LSeq.sub r2 (j * 2) 2) in
let res0 = res0.(4 * i + 3, j) <- uint_from_bytes_le (LSeq.sub r3 (j * 2) 2) in
res0
val frodo_gen_matrix_shake_4x1_get_r:
n:size_nat{n * n <= max_size_t /\ n <= maxint U16}
-> seed:lbytes 16
-> i:size_nat{i < n / 4}
-> lbytes (2 * n) & lbytes (2 * n) & lbytes (2 * n) & lbytes (2 * n)
let frodo_gen_matrix_shake_4x1_get_r n seed i =
let t0 = uint_to_bytes_le (u16 (4 * i + 0)) in
let t1 = uint_to_bytes_le (u16 (4 * i + 1)) in
let t2 = uint_to_bytes_le (u16 (4 * i + 2)) in
let t3 = uint_to_bytes_le (u16 (4 * i + 3)) in
let b0 = concat t0 seed in
let b1 = concat t1 seed in
let b2 = concat t2 seed in
let b3 = concat t3 seed in
let r0 = shake128 18 b0 (2 * n) in
let r1 = shake128 18 b1 (2 * n) in
let r2 = shake128 18 b2 (2 * n) in
let r3 = shake128 18 b3 (2 * n) in
r0, r1, r2, r3
val frodo_gen_matrix_shake_4x1:
n:size_nat{n * n <= max_size_t /\ n <= maxint U16}
-> seed:lbytes 16
-> i:size_nat{i < n / 4}
-> res:matrix n n
-> matrix n n
let frodo_gen_matrix_shake_4x1 n seed i res =
let r0, r1, r2, r3 = frodo_gen_matrix_shake_4x1_get_r n seed i in
Loops.repeati n (frodo_gen_matrix_shake_4x0 n i r0 r1 r2 r3) res
val frodo_gen_matrix_shake_4x:
n:size_nat{n * n <= max_size_t /\ n <= maxint U16 /\ n % 4 = 0}
-> seed:lbytes 16
-> matrix n n
let frodo_gen_matrix_shake_4x n seed =
let res = Matrix.create n n in
let n4 = n / 4 in
Loops.repeati n4 (frodo_gen_matrix_shake_4x1 n seed) res
val frodo_gen_matrix_aes:
n:size_nat{n * n <= max_size_t /\ n <= maxint U16}
-> seed:lbytes 16
-> matrix n n
let frodo_gen_matrix_aes n seed =
let res = Matrix.create n n in
let key = aes128_key_expansion seed in
let tmp = LSeq.create 8 (u16 0) in
let n1 = n / 8 in
Loops.repeati n
(fun i res ->
Loops.repeati n1
(fun j res ->
let j = j * 8 in
let tmp = tmp.[0] <- u16 i in
let tmp = tmp.[1] <- u16 j in
let res_i = aes_encrypt_block AES128 key (uints_to_bytes_le tmp) in
Loops.repeati 8
(fun k res ->
res.(i, j + k) <- uint_from_bytes_le (LSeq.sub res_i (k * 2) 2)
) res
) res
) res
(** Lemma (frodo_gen_matrix_shake == frodo_gen_matrix_shake_4x) *)
val frodo_gen_matrix_shake_fc:
n:size_nat{n * n <= max_size_t /\ n <= maxint U16}
-> seed:lbytes 16
-> i:size_nat{i < n}
-> j:size_nat{j < n}
-> GTot uint16
let frodo_gen_matrix_shake_fc n seed i j =
let res_i = frodo_gen_matrix_shake_get_r n seed i in
uint_from_bytes_le (LSeq.sub res_i (j * 2) 2)
val frodo_gen_matrix_shake1_ind:
n:size_nat{n * n <= max_size_t /\ n <= maxint U16}
-> seed:lbytes 16
-> i:size_nat{i < n}
-> res:matrix n n
-> Pure (matrix n n)
(requires True)
(ensures fun res1 ->
let res_i = frodo_gen_matrix_shake_get_r n seed i in
res1 == Loops.repeati n (frodo_gen_matrix_shake0 n i res_i) res)
let frodo_gen_matrix_shake1_ind n seed i res =
let res_i = frodo_gen_matrix_shake_get_r n seed i in
//Loops.repeati n (frodo_gen_matrix_shake0 n i res_i) res
Loops.repeati_inductive' #(matrix n n) n
(fun j res0 ->
(forall (i0:size_nat{i0 < i}) (j:size_nat{j < n}). res0.(i0, j) == res.(i0, j)) /\
(forall (j0:size_nat{j0 < j}). res0.(i, j0) == frodo_gen_matrix_shake_fc n seed i j0))
(frodo_gen_matrix_shake0 n i res_i) res
val frodo_gen_matrix_shake_ind:
n:size_nat{n * n <= max_size_t /\ n <= maxint U16}
-> seed:lbytes 16
-> Pure (matrix n n)
(requires True)
(ensures fun res ->
res == Loops.repeati n (frodo_gen_matrix_shake1_ind n seed) (Matrix.create n n) /\
(forall (i:size_nat{i < n}) (j:size_nat{j < n}).
res.(i, j) == frodo_gen_matrix_shake_fc n seed i j))
let frodo_gen_matrix_shake_ind n seed =
let res = Matrix.create n n in
//Loops.repeati n (frodo_gen_matrix_shake1 n seed) res
Loops.repeati_inductive' #(matrix n n) n
(fun i res ->
forall (i0:size_nat{i0 < i}) (j:size_nat{j < n}).
res.(i0, j) == frodo_gen_matrix_shake_fc n seed i0 j)
(frodo_gen_matrix_shake1_ind n seed) res
val frodo_gen_matrix_shake_4x1_ind:
n:size_nat{n * n <= max_size_t /\ n <= maxint U16}
-> seed:lbytes 16
-> i:size_nat{i < n / 4}
-> res:matrix n n
-> Pure (matrix n n)
(requires True)
(ensures fun res1 ->
let r0, r1, r2, r3 = frodo_gen_matrix_shake_4x1_get_r n seed i in
res1 == Loops.repeati n (frodo_gen_matrix_shake_4x0 n i r0 r1 r2 r3) res)
let frodo_gen_matrix_shake_4x1_ind n seed i res =
let r0, r1, r2, r3 = frodo_gen_matrix_shake_4x1_get_r n seed i in
//Loops.repeati n (frodo_gen_matrix_shake_4x0 n i r0 r1 r2 r3) res
Loops.repeati_inductive' #(matrix n n) n
(fun j res0 ->
(forall (i0:size_nat{i0 < i}) (j:size_nat{j < n}) (k:size_nat{k < 4}).
res0.(4 * i0 + k, j) == res.(4 * i0 + k, j)) /\
(forall (j0:size_nat{j0 < j}) (k:size_nat{k < 4}).
res0.(4 * i + k, j0) == frodo_gen_matrix_shake_fc n seed (4 * i + k) j0))
(frodo_gen_matrix_shake_4x0 n i r0 r1 r2 r3) res
val lemma_gen_matrix_4x:
n:size_nat{n * n <= max_size_t /\ n <= maxint U16 /\ n % 4 = 0}
-> seed:lbytes 16
-> res:matrix n n
-> Lemma
(requires (forall (i0:size_nat{i0 < n / 4}) (j:size_nat{j < n}) (k:size_nat{k < 4}).
res.(4 * i0 + k, j) == frodo_gen_matrix_shake_fc n seed (4 * i0 + k) j))
(ensures (forall (i:size_nat{i < n}) (j:size_nat{j < n}).
res.(i, j) == frodo_gen_matrix_shake_fc n seed i j))
let lemma_gen_matrix_4x n seed res =
assert (forall (i0:size_nat{i0 < n / 4}) (j:size_nat{j < n}) (k:size_nat{k < 4}).
frodo_gen_matrix_shake_fc n seed (4 * i0 + k) j == frodo_gen_matrix_shake_fc n seed (i0 * 4 + k) j);
assert (forall (i:size_nat{i < n}) (j:size_nat{j < n}). i == i / 4 * 4 + i % 4 /\ i / 4 < n / 4 /\ i % 4 < 4);
assert (forall (i:size_nat{i < n}) (j:size_nat{j < n}). res.(i, j) == frodo_gen_matrix_shake_fc n seed (i / 4 * 4 + i % 4) j)
val frodo_gen_matrix_shake_4x_ind:
n:size_nat{n * n <= max_size_t /\ n <= maxint U16 /\ n % 4 = 0}
-> seed:lbytes 16
-> Pure (matrix n n)
(requires True)
(ensures fun res ->
res == Loops.repeati (n / 4) (frodo_gen_matrix_shake_4x1_ind n seed) (Matrix.create n n) /\
res == frodo_gen_matrix_shake_ind n seed) | {
"checked_file": "/",
"dependencies": [
"Spec.SHA3.fst.checked",
"Spec.Matrix.fst.checked",
"Spec.AES.fst.checked",
"prims.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Gen.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Spec.Matrix",
"short_module": "Matrix"
},
{
"abbrev": false,
"full_module": "Spec.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA3",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"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": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"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
}
] | {
"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"
} | false |
n:
Lib.IntTypes.size_nat
{n * n <= Lib.IntTypes.max_size_t /\ n <= Lib.IntTypes.maxint Lib.IntTypes.U16 /\ n % 4 = 0} ->
seed: Lib.ByteSequence.lbytes 16
-> Prims.Pure (Spec.Matrix.matrix n n) | Prims.Pure | [] | [] | [
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Lib.IntTypes.maxint",
"Lib.IntTypes.U16",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Lib.ByteSequence.lbytes",
"Prims.unit",
"Spec.Matrix.extensionality",
"Spec.Frodo.Gen.frodo_gen_matrix_shake_ind",
"Spec.Frodo.Gen.lemma_gen_matrix_4x",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.SEC",
"Prims.op_Multiply",
"Lib.LoopCombinators.repeati_inductive'",
"Spec.Matrix.matrix",
"Prims.nat",
"Prims.l_Forall",
"Prims.op_LessThan",
"Prims.eq2",
"Lib.IntTypes.uint16",
"Spec.Matrix.op_Array_Access",
"FStar.Pervasives.Native.Mktuple2",
"Prims.op_Addition",
"Spec.Frodo.Gen.frodo_gen_matrix_shake_fc",
"Spec.Frodo.Gen.frodo_gen_matrix_shake_4x1_ind",
"Prims.op_Division",
"Spec.Matrix.create"
] | [] | false | false | false | false | false | let frodo_gen_matrix_shake_4x_ind n seed =
| let res = Matrix.create n n in
let n4 = n / 4 in
let res =
Loops.repeati_inductive' n4
(fun i res ->
forall (i0: size_nat{i0 < i}) (j: size_nat{j < n}) (k: size_nat{k < 4}).
res.(4 * i0 + k, j) == frodo_gen_matrix_shake_fc n seed (4 * i0 + k) j)
(frodo_gen_matrix_shake_4x1_ind n seed)
res
in
lemma_gen_matrix_4x n seed res;
Spec.Matrix.extensionality res (frodo_gen_matrix_shake_ind n seed);
res | false |
Vale.X64.State.fsti | Vale.X64.State.eval_reg_64 | val eval_reg_64 (r: reg_64) (s: vale_state) : nat64 | val eval_reg_64 (r: reg_64) (s: vale_state) : nat64 | let eval_reg_64 (r:reg_64) (s:vale_state) : nat64 = eval_reg (Reg 0 r) s | {
"file_name": "vale/code/arch/x64/Vale.X64.State.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 79,
"end_line": 41,
"start_col": 7,
"start_line": 41
} | module Vale.X64.State
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
module Flags = Vale.X64.Flags
module Regs = Vale.X64.Regs
module Map16 = Vale.Lib.Map16
noeq type vale_state = {
vs_ok: bool;
vs_regs: Regs.t;
vs_flags: Flags.t;
vs_heap: vale_full_heap;
vs_stack: vale_stack;
vs_stackTaint: memtaint;
}
unfold let vs_get_vale_heap (s:vale_state) : vale_heap = get_vale_heap s.vs_heap
[@va_qattr]
unfold let eval_reg (r:reg) (s:vale_state) : t_reg r = Regs.sel r s.vs_regs
[@va_qattr]
unfold let eval_reg_int (r:reg) (s:vale_state) : int = t_reg_to_int r.rf (eval_reg r s)
[@va_qattr]
unfold let eval_flag (f:flag) (s:vale_state) : Flags.flag_val_t = Flags.sel f s.vs_flags
[@va_qattr]
unfold let eval_mem (ptr:int) (s:vale_state) : GTot nat64 = load_mem64 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_mem128 (ptr:int) (s:vale_state) : GTot Vale.Def.Types_s.quad32 = load_mem128 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_stack (ptr:int) (s:vale_state) : GTot nat64 = load_stack64 ptr s.vs_stack
[@va_qattr]
unfold let eval_stack128 (ptr:int) (s:vale_state) : GTot quad32 = load_stack128 ptr s.vs_stack | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.State.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Regs",
"short_module": "Regs"
},
{
"abbrev": true,
"full_module": "Vale.X64.Flags",
"short_module": "Flags"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | r: Vale.X64.Machine_s.reg_64 -> s: Vale.X64.State.vale_state -> Vale.X64.Memory.nat64 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.reg_64",
"Vale.X64.State.vale_state",
"Vale.X64.State.eval_reg",
"Vale.X64.Machine_s.Reg",
"Vale.X64.Memory.nat64"
] | [] | false | false | false | true | false | let eval_reg_64 (r: reg_64) (s: vale_state) : nat64 =
| eval_reg (Reg 0 r) s | false |
Vale.X64.State.fsti | Vale.X64.State.eval_reg_xmm | val eval_reg_xmm (r: reg_xmm) (s: vale_state) : quad32 | val eval_reg_xmm (r: reg_xmm) (s: vale_state) : quad32 | let eval_reg_xmm (r:reg_xmm) (s:vale_state) : quad32 = eval_reg (Reg 1 r) s | {
"file_name": "vale/code/arch/x64/Vale.X64.State.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 82,
"end_line": 44,
"start_col": 7,
"start_line": 44
} | module Vale.X64.State
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
module Flags = Vale.X64.Flags
module Regs = Vale.X64.Regs
module Map16 = Vale.Lib.Map16
noeq type vale_state = {
vs_ok: bool;
vs_regs: Regs.t;
vs_flags: Flags.t;
vs_heap: vale_full_heap;
vs_stack: vale_stack;
vs_stackTaint: memtaint;
}
unfold let vs_get_vale_heap (s:vale_state) : vale_heap = get_vale_heap s.vs_heap
[@va_qattr]
unfold let eval_reg (r:reg) (s:vale_state) : t_reg r = Regs.sel r s.vs_regs
[@va_qattr]
unfold let eval_reg_int (r:reg) (s:vale_state) : int = t_reg_to_int r.rf (eval_reg r s)
[@va_qattr]
unfold let eval_flag (f:flag) (s:vale_state) : Flags.flag_val_t = Flags.sel f s.vs_flags
[@va_qattr]
unfold let eval_mem (ptr:int) (s:vale_state) : GTot nat64 = load_mem64 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_mem128 (ptr:int) (s:vale_state) : GTot Vale.Def.Types_s.quad32 = load_mem128 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_stack (ptr:int) (s:vale_state) : GTot nat64 = load_stack64 ptr s.vs_stack
[@va_qattr]
unfold let eval_stack128 (ptr:int) (s:vale_state) : GTot quad32 = load_stack128 ptr s.vs_stack
[@va_qattr]
unfold let eval_reg_64 (r:reg_64) (s:vale_state) : nat64 = eval_reg (Reg 0 r) s | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.State.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Regs",
"short_module": "Regs"
},
{
"abbrev": true,
"full_module": "Vale.X64.Flags",
"short_module": "Flags"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | r: Vale.X64.Machine_s.reg_xmm -> s: Vale.X64.State.vale_state -> Vale.X64.Memory.quad32 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.State.vale_state",
"Vale.X64.State.eval_reg",
"Vale.X64.Machine_s.Reg",
"Vale.X64.Memory.quad32"
] | [] | false | false | false | true | false | let eval_reg_xmm (r: reg_xmm) (s: vale_state) : quad32 =
| eval_reg (Reg 1 r) s | false |
Vale.X64.State.fsti | Vale.X64.State.eval_operand | val eval_operand (o: operand64) (s: vale_state) : GTot nat64 | val eval_operand (o: operand64) (s: vale_state) : GTot nat64 | let eval_operand (o:operand64) (s:vale_state) : GTot nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s | {
"file_name": "vale/code/arch/x64/Vale.X64.State.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 50,
"end_line": 59,
"start_col": 0,
"start_line": 54
} | module Vale.X64.State
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
module Flags = Vale.X64.Flags
module Regs = Vale.X64.Regs
module Map16 = Vale.Lib.Map16
noeq type vale_state = {
vs_ok: bool;
vs_regs: Regs.t;
vs_flags: Flags.t;
vs_heap: vale_full_heap;
vs_stack: vale_stack;
vs_stackTaint: memtaint;
}
unfold let vs_get_vale_heap (s:vale_state) : vale_heap = get_vale_heap s.vs_heap
[@va_qattr]
unfold let eval_reg (r:reg) (s:vale_state) : t_reg r = Regs.sel r s.vs_regs
[@va_qattr]
unfold let eval_reg_int (r:reg) (s:vale_state) : int = t_reg_to_int r.rf (eval_reg r s)
[@va_qattr]
unfold let eval_flag (f:flag) (s:vale_state) : Flags.flag_val_t = Flags.sel f s.vs_flags
[@va_qattr]
unfold let eval_mem (ptr:int) (s:vale_state) : GTot nat64 = load_mem64 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_mem128 (ptr:int) (s:vale_state) : GTot Vale.Def.Types_s.quad32 = load_mem128 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_stack (ptr:int) (s:vale_state) : GTot nat64 = load_stack64 ptr s.vs_stack
[@va_qattr]
unfold let eval_stack128 (ptr:int) (s:vale_state) : GTot quad32 = load_stack128 ptr s.vs_stack
[@va_qattr]
unfold let eval_reg_64 (r:reg_64) (s:vale_state) : nat64 = eval_reg (Reg 0 r) s
[@va_qattr]
unfold let eval_reg_xmm (r:reg_xmm) (s:vale_state) : quad32 = eval_reg (Reg 1 r) s
[@va_qattr]
let eval_maddr (m:maddr) (s:vale_state) : int =
match m with
| MConst n -> n
| MReg r offset -> eval_reg_int r s + offset
| MIndex base scale index offset -> eval_reg_int base s + scale * (eval_reg_int index s) + offset | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.State.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Regs",
"short_module": "Regs"
},
{
"abbrev": true,
"full_module": "Vale.X64.Flags",
"short_module": "Flags"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | o: Vale.X64.Machine_s.operand64 -> s: Vale.X64.State.vale_state -> Prims.GTot Vale.X64.Memory.nat64 | Prims.GTot | [
"sometrivial"
] | [] | [
"Vale.X64.Machine_s.operand64",
"Vale.X64.State.vale_state",
"Vale.X64.Machine_s.nat64",
"Vale.X64.Machine_s.reg_64",
"Vale.X64.State.eval_reg_64",
"Vale.X64.Machine_s.maddr",
"Vale.Arch.HeapTypes_s.taint",
"Vale.X64.State.eval_mem",
"Vale.X64.State.eval_maddr",
"Vale.X64.State.eval_stack",
"Vale.X64.Memory.nat64"
] | [] | false | false | false | false | false | let eval_operand (o: operand64) (s: vale_state) : GTot nat64 =
| match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s | false |
Vale.X64.State.fsti | Vale.X64.State.update_reg_64 | val update_reg_64 (r: reg_64) (v: nat64) (s: vale_state) : vale_state | val update_reg_64 (r: reg_64) (v: nat64) (s: vale_state) : vale_state | let update_reg_64 (r:reg_64) (v:nat64) (s:vale_state) : vale_state =
update_reg (Reg 0 r) v s | {
"file_name": "vale/code/arch/x64/Vale.X64.State.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 26,
"end_line": 75,
"start_col": 0,
"start_line": 74
} | module Vale.X64.State
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
module Flags = Vale.X64.Flags
module Regs = Vale.X64.Regs
module Map16 = Vale.Lib.Map16
noeq type vale_state = {
vs_ok: bool;
vs_regs: Regs.t;
vs_flags: Flags.t;
vs_heap: vale_full_heap;
vs_stack: vale_stack;
vs_stackTaint: memtaint;
}
unfold let vs_get_vale_heap (s:vale_state) : vale_heap = get_vale_heap s.vs_heap
[@va_qattr]
unfold let eval_reg (r:reg) (s:vale_state) : t_reg r = Regs.sel r s.vs_regs
[@va_qattr]
unfold let eval_reg_int (r:reg) (s:vale_state) : int = t_reg_to_int r.rf (eval_reg r s)
[@va_qattr]
unfold let eval_flag (f:flag) (s:vale_state) : Flags.flag_val_t = Flags.sel f s.vs_flags
[@va_qattr]
unfold let eval_mem (ptr:int) (s:vale_state) : GTot nat64 = load_mem64 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_mem128 (ptr:int) (s:vale_state) : GTot Vale.Def.Types_s.quad32 = load_mem128 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_stack (ptr:int) (s:vale_state) : GTot nat64 = load_stack64 ptr s.vs_stack
[@va_qattr]
unfold let eval_stack128 (ptr:int) (s:vale_state) : GTot quad32 = load_stack128 ptr s.vs_stack
[@va_qattr]
unfold let eval_reg_64 (r:reg_64) (s:vale_state) : nat64 = eval_reg (Reg 0 r) s
[@va_qattr]
unfold let eval_reg_xmm (r:reg_xmm) (s:vale_state) : quad32 = eval_reg (Reg 1 r) s
[@va_qattr]
let eval_maddr (m:maddr) (s:vale_state) : int =
match m with
| MConst n -> n
| MReg r offset -> eval_reg_int r s + offset
| MIndex base scale index offset -> eval_reg_int base s + scale * (eval_reg_int index s) + offset
[@va_qattr]
let eval_operand (o:operand64) (s:vale_state) : GTot nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s
[@va_qattr]
let eval_operand128 (o:operand128) (s:vale_state) : GTot Vale.Def.Types_s.quad32 =
match o with
| OConst c -> c
| OReg r -> eval_reg_xmm r s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s
[@va_qattr]
let update_reg (r:reg) (v:t_reg r) (s:vale_state) : vale_state =
{s with vs_regs = Regs.upd r v s.vs_regs} | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.State.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Regs",
"short_module": "Regs"
},
{
"abbrev": true,
"full_module": "Vale.X64.Flags",
"short_module": "Flags"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | r: Vale.X64.Machine_s.reg_64 -> v: Vale.X64.Memory.nat64 -> s: Vale.X64.State.vale_state
-> Vale.X64.State.vale_state | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.reg_64",
"Vale.X64.Memory.nat64",
"Vale.X64.State.vale_state",
"Vale.X64.State.update_reg",
"Vale.X64.Machine_s.Reg"
] | [] | false | false | false | true | false | let update_reg_64 (r: reg_64) (v: nat64) (s: vale_state) : vale_state =
| update_reg (Reg 0 r) v s | false |
Lib.ByteSequence.fsti | Lib.ByteSequence.nat_to_bytes_le | val nat_to_bytes_le (#l: secrecy_level) (len: nat) (n: nat{n < pow2 (8 * len)})
: b: bytes_l l {length b == len /\ n == nat_from_intseq_le #U8 b} | val nat_to_bytes_le (#l: secrecy_level) (len: nat) (n: nat{n < pow2 (8 * len)})
: b: bytes_l l {length b == len /\ n == nat_from_intseq_le #U8 b} | let nat_to_bytes_le (#l:secrecy_level) (len:nat) (n:nat{n < pow2 (8 * len)}) : b:bytes_l l{length b == len /\ n == nat_from_intseq_le #U8 b} =
nat_to_intseq_le #U8 #l len n | {
"file_name": "lib/Lib.ByteSequence.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 31,
"end_line": 115,
"start_col": 0,
"start_line": 114
} | module Lib.ByteSequence
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 30 --max_fuel 0 --max_ifuel 0"
/// Definition of byte-based sequences
unfold inline_for_extraction
type bytes_l (l:secrecy_level) = seq (uint_t U8 l)
unfold inline_for_extraction
type lbytes_l (l:secrecy_level) (len:size_nat) = lseq (uint_t U8 l) len
unfold inline_for_extraction let bytes = bytes_l SEC
unfold inline_for_extraction let lbytes (len:size_nat) = lbytes_l SEC len
unfold inline_for_extraction let pub_bytes = bytes_l PUB
unfold inline_for_extraction let pub_lbytes (len:size_nat) = lbytes_l PUB len
(* Alias *)
unfold inline_for_extraction let bytes_t = bytes
unfold inline_for_extraction let pub_bytes_t = pub_bytes
(** Construct the equality mask for a pair of secret integer sequences *)
val seq_eq_mask: #t:inttype{~(S128? t)} -> #len1:size_nat -> #len2:size_nat
-> b1:lseq (int_t t SEC) len1
-> b2:lseq (int_t t SEC) len2
-> len:size_nat{len <= len1 /\ len <= len2}
-> res:int_t t SEC{
(sub b1 0 len == sub b2 0 len ==> v res == v (ones t SEC)) /\
(sub b1 0 len =!= sub b2 0 len ==> v res == v (zeros t SEC))}
(** Compares two byte sequences and declassifies the result *)
inline_for_extraction
val lbytes_eq: #len:size_nat -> b1:lbytes len -> b2:lbytes len -> b:bool{b <==> b1 == b2}
inline_for_extraction
val mask_select: #t:inttype{~(S128? t)} -> mask:int_t t SEC -> a:int_t t SEC -> b:int_t t SEC -> int_t t SEC
val mask_select_lemma: #t:inttype{~(S128? t)} -> mask:int_t t SEC -> a:int_t t SEC -> b:int_t t SEC -> Lemma
(requires v mask = 0 \/ v mask = v (ones t SEC))
(ensures mask_select mask a b == (if v mask = 0 then b else a))
val seq_mask_select: #t:inttype{~(S128? t)} -> #len:size_nat
-> a:lseq (int_t t SEC) len
-> b:lseq (int_t t SEC) len
-> mask:int_t t SEC
-> Pure (lseq (int_t t SEC) len)
(requires v mask = 0 \/ v mask = v (ones t SEC))
(ensures fun res -> res == (if v mask = 0 then b else a))
/// Constant for empty lbytes
let bytes_empty: bytes = Seq.Base.empty
let pub_bytes_empty: pub_bytes = Seq.Base.empty
let lbytes_empty: lbytes 0 = create 0 (u8 0)
/// Conversions between natural numbers and sequences
inline_for_extraction
val nat_from_intseq_be: #t:inttype{unsigned t} -> #l:secrecy_level -> b:seq (uint_t t l)
-> n:nat{n < pow2 (length b * bits t)}
inline_for_extraction
val nat_from_intseq_le: #t:inttype{unsigned t} -> #l:secrecy_level
-> b:seq (uint_t t l) -> n:nat{n < pow2 (length b * bits t)}
inline_for_extraction
let nat_from_bytes_be (#l:secrecy_level) (b:bytes_l l) : n:nat{n < pow2 (length b * 8)} =
nat_from_intseq_be #U8 #l b
inline_for_extraction
let nat_from_bytes_le (#l:secrecy_level) (b:bytes_l l) : n:nat{n < pow2 (length b * 8)} =
nat_from_intseq_le #U8 #l b
inline_for_extraction
val nat_to_intseq_be: #t:inttype{unsigned t} -> #l:secrecy_level -> len:nat -> n:nat{n < pow2 (bits t * len)} ->
b:seq (uint_t t l){length b == len /\ n == nat_from_intseq_be b}
inline_for_extraction
val nat_to_intseq_le: #t:inttype{unsigned t} -> #l:secrecy_level -> len:nat -> n:nat{n < pow2 (bits t * len)} ->
b:seq (uint_t t l){length b == len /\ n == nat_from_intseq_le b}
val index_nat_to_intseq_le:
#t:inttype{unsigned t}
-> #l:secrecy_level
-> len:size_nat
-> n:nat{n < pow2 (bits t * len)}
-> i:nat{i < len}
-> Lemma (Seq.index (nat_to_intseq_le #t #l len n) i ==
uint #t #l (n / pow2 (bits t * i) % pow2 (bits t)))
val index_nat_to_intseq_be:
#t:inttype{unsigned t}
-> #l:secrecy_level
-> len:size_nat
-> n:nat{n < pow2 (bits t * len)}
-> i:nat{i < len}
-> Lemma (Seq.index (nat_to_intseq_be #t #l len n) (len - i - 1) ==
uint #t #l (n / pow2 (bits t * i) % pow2 (bits t)))
inline_for_extraction
let nat_to_bytes_be (#l:secrecy_level) (len:nat) (n:nat{n < pow2 (8 * len)}) : b:bytes_l l{length b == len /\ n == nat_from_intseq_be #U8 b} =
nat_to_intseq_be #U8 #l len n | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Lib.ByteSequence.fsti"
} | [
{
"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": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"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": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | len: Prims.nat -> n: Prims.nat{n < Prims.pow2 (8 * len)}
-> b:
Lib.ByteSequence.bytes_l l
{Lib.Sequence.length b == len /\ n == Lib.ByteSequence.nat_from_intseq_le b} | Prims.Tot | [
"total"
] | [] | [
"Lib.IntTypes.secrecy_level",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"FStar.Mul.op_Star",
"Lib.ByteSequence.nat_to_intseq_le",
"Lib.IntTypes.U8",
"Lib.ByteSequence.bytes_l",
"Prims.l_and",
"Prims.eq2",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Prims.l_or",
"Lib.IntTypes.bits",
"Lib.ByteSequence.nat_from_intseq_le"
] | [] | false | false | false | false | false | let nat_to_bytes_le (#l: secrecy_level) (len: nat) (n: nat{n < pow2 (8 * len)})
: b: bytes_l l {length b == len /\ n == nat_from_intseq_le #U8 b} =
| nat_to_intseq_le #U8 #l len n | false |
Vale.X64.State.fsti | Vale.X64.State.eval_operand128 | val eval_operand128 (o: operand128) (s: vale_state) : GTot Vale.Def.Types_s.quad32 | val eval_operand128 (o: operand128) (s: vale_state) : GTot Vale.Def.Types_s.quad32 | let eval_operand128 (o:operand128) (s:vale_state) : GTot Vale.Def.Types_s.quad32 =
match o with
| OConst c -> c
| OReg r -> eval_reg_xmm r s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s | {
"file_name": "vale/code/arch/x64/Vale.X64.State.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 53,
"end_line": 67,
"start_col": 0,
"start_line": 62
} | module Vale.X64.State
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
module Flags = Vale.X64.Flags
module Regs = Vale.X64.Regs
module Map16 = Vale.Lib.Map16
noeq type vale_state = {
vs_ok: bool;
vs_regs: Regs.t;
vs_flags: Flags.t;
vs_heap: vale_full_heap;
vs_stack: vale_stack;
vs_stackTaint: memtaint;
}
unfold let vs_get_vale_heap (s:vale_state) : vale_heap = get_vale_heap s.vs_heap
[@va_qattr]
unfold let eval_reg (r:reg) (s:vale_state) : t_reg r = Regs.sel r s.vs_regs
[@va_qattr]
unfold let eval_reg_int (r:reg) (s:vale_state) : int = t_reg_to_int r.rf (eval_reg r s)
[@va_qattr]
unfold let eval_flag (f:flag) (s:vale_state) : Flags.flag_val_t = Flags.sel f s.vs_flags
[@va_qattr]
unfold let eval_mem (ptr:int) (s:vale_state) : GTot nat64 = load_mem64 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_mem128 (ptr:int) (s:vale_state) : GTot Vale.Def.Types_s.quad32 = load_mem128 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_stack (ptr:int) (s:vale_state) : GTot nat64 = load_stack64 ptr s.vs_stack
[@va_qattr]
unfold let eval_stack128 (ptr:int) (s:vale_state) : GTot quad32 = load_stack128 ptr s.vs_stack
[@va_qattr]
unfold let eval_reg_64 (r:reg_64) (s:vale_state) : nat64 = eval_reg (Reg 0 r) s
[@va_qattr]
unfold let eval_reg_xmm (r:reg_xmm) (s:vale_state) : quad32 = eval_reg (Reg 1 r) s
[@va_qattr]
let eval_maddr (m:maddr) (s:vale_state) : int =
match m with
| MConst n -> n
| MReg r offset -> eval_reg_int r s + offset
| MIndex base scale index offset -> eval_reg_int base s + scale * (eval_reg_int index s) + offset
[@va_qattr]
let eval_operand (o:operand64) (s:vale_state) : GTot nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.State.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Regs",
"short_module": "Regs"
},
{
"abbrev": true,
"full_module": "Vale.X64.Flags",
"short_module": "Flags"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | o: Vale.X64.Machine_s.operand128 -> s: Vale.X64.State.vale_state
-> Prims.GTot Vale.Def.Types_s.quad32 | Prims.GTot | [
"sometrivial"
] | [] | [
"Vale.X64.Machine_s.operand128",
"Vale.X64.State.vale_state",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.State.eval_reg_xmm",
"Vale.X64.Machine_s.maddr",
"Vale.Arch.HeapTypes_s.taint",
"Vale.X64.State.eval_mem128",
"Vale.X64.State.eval_maddr",
"Vale.X64.State.eval_stack128",
"Vale.Def.Types_s.quad32"
] | [] | false | false | false | false | false | let eval_operand128 (o: operand128) (s: vale_state) : GTot Vale.Def.Types_s.quad32 =
| match o with
| OConst c -> c
| OReg r -> eval_reg_xmm r s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s | false |
Vale.X64.State.fsti | Vale.X64.State.update_reg_xmm | val update_reg_xmm (r: reg_xmm) (v: quad32) (s: vale_state) : vale_state | val update_reg_xmm (r: reg_xmm) (v: quad32) (s: vale_state) : vale_state | let update_reg_xmm (r:reg_xmm) (v:quad32) (s:vale_state) : vale_state =
update_reg (Reg 1 r) v s | {
"file_name": "vale/code/arch/x64/Vale.X64.State.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 26,
"end_line": 83,
"start_col": 0,
"start_line": 82
} | module Vale.X64.State
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
module Flags = Vale.X64.Flags
module Regs = Vale.X64.Regs
module Map16 = Vale.Lib.Map16
noeq type vale_state = {
vs_ok: bool;
vs_regs: Regs.t;
vs_flags: Flags.t;
vs_heap: vale_full_heap;
vs_stack: vale_stack;
vs_stackTaint: memtaint;
}
unfold let vs_get_vale_heap (s:vale_state) : vale_heap = get_vale_heap s.vs_heap
[@va_qattr]
unfold let eval_reg (r:reg) (s:vale_state) : t_reg r = Regs.sel r s.vs_regs
[@va_qattr]
unfold let eval_reg_int (r:reg) (s:vale_state) : int = t_reg_to_int r.rf (eval_reg r s)
[@va_qattr]
unfold let eval_flag (f:flag) (s:vale_state) : Flags.flag_val_t = Flags.sel f s.vs_flags
[@va_qattr]
unfold let eval_mem (ptr:int) (s:vale_state) : GTot nat64 = load_mem64 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_mem128 (ptr:int) (s:vale_state) : GTot Vale.Def.Types_s.quad32 = load_mem128 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_stack (ptr:int) (s:vale_state) : GTot nat64 = load_stack64 ptr s.vs_stack
[@va_qattr]
unfold let eval_stack128 (ptr:int) (s:vale_state) : GTot quad32 = load_stack128 ptr s.vs_stack
[@va_qattr]
unfold let eval_reg_64 (r:reg_64) (s:vale_state) : nat64 = eval_reg (Reg 0 r) s
[@va_qattr]
unfold let eval_reg_xmm (r:reg_xmm) (s:vale_state) : quad32 = eval_reg (Reg 1 r) s
[@va_qattr]
let eval_maddr (m:maddr) (s:vale_state) : int =
match m with
| MConst n -> n
| MReg r offset -> eval_reg_int r s + offset
| MIndex base scale index offset -> eval_reg_int base s + scale * (eval_reg_int index s) + offset
[@va_qattr]
let eval_operand (o:operand64) (s:vale_state) : GTot nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s
[@va_qattr]
let eval_operand128 (o:operand128) (s:vale_state) : GTot Vale.Def.Types_s.quad32 =
match o with
| OConst c -> c
| OReg r -> eval_reg_xmm r s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s
[@va_qattr]
let update_reg (r:reg) (v:t_reg r) (s:vale_state) : vale_state =
{s with vs_regs = Regs.upd r v s.vs_regs}
[@va_qattr]
let update_reg_64 (r:reg_64) (v:nat64) (s:vale_state) : vale_state =
update_reg (Reg 0 r) v s
[@va_qattr]
let update_flag (f:flag) (v:Flags.flag_val_t) (s:vale_state) : vale_state =
{s with vs_flags = Flags.upd f v s.vs_flags} | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.State.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Regs",
"short_module": "Regs"
},
{
"abbrev": true,
"full_module": "Vale.X64.Flags",
"short_module": "Flags"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | r: Vale.X64.Machine_s.reg_xmm -> v: Vale.X64.Memory.quad32 -> s: Vale.X64.State.vale_state
-> Vale.X64.State.vale_state | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Memory.quad32",
"Vale.X64.State.vale_state",
"Vale.X64.State.update_reg",
"Vale.X64.Machine_s.Reg"
] | [] | false | false | false | true | false | let update_reg_xmm (r: reg_xmm) (v: quad32) (s: vale_state) : vale_state =
| update_reg (Reg 1 r) v s | false |
Vale.X64.State.fsti | Vale.X64.State.eval_maddr | val eval_maddr (m: maddr) (s: vale_state) : int | val eval_maddr (m: maddr) (s: vale_state) : int | let eval_maddr (m:maddr) (s:vale_state) : int =
match m with
| MConst n -> n
| MReg r offset -> eval_reg_int r s + offset
| MIndex base scale index offset -> eval_reg_int base s + scale * (eval_reg_int index s) + offset | {
"file_name": "vale/code/arch/x64/Vale.X64.State.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 99,
"end_line": 51,
"start_col": 0,
"start_line": 47
} | module Vale.X64.State
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
module Flags = Vale.X64.Flags
module Regs = Vale.X64.Regs
module Map16 = Vale.Lib.Map16
noeq type vale_state = {
vs_ok: bool;
vs_regs: Regs.t;
vs_flags: Flags.t;
vs_heap: vale_full_heap;
vs_stack: vale_stack;
vs_stackTaint: memtaint;
}
unfold let vs_get_vale_heap (s:vale_state) : vale_heap = get_vale_heap s.vs_heap
[@va_qattr]
unfold let eval_reg (r:reg) (s:vale_state) : t_reg r = Regs.sel r s.vs_regs
[@va_qattr]
unfold let eval_reg_int (r:reg) (s:vale_state) : int = t_reg_to_int r.rf (eval_reg r s)
[@va_qattr]
unfold let eval_flag (f:flag) (s:vale_state) : Flags.flag_val_t = Flags.sel f s.vs_flags
[@va_qattr]
unfold let eval_mem (ptr:int) (s:vale_state) : GTot nat64 = load_mem64 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_mem128 (ptr:int) (s:vale_state) : GTot Vale.Def.Types_s.quad32 = load_mem128 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_stack (ptr:int) (s:vale_state) : GTot nat64 = load_stack64 ptr s.vs_stack
[@va_qattr]
unfold let eval_stack128 (ptr:int) (s:vale_state) : GTot quad32 = load_stack128 ptr s.vs_stack
[@va_qattr]
unfold let eval_reg_64 (r:reg_64) (s:vale_state) : nat64 = eval_reg (Reg 0 r) s
[@va_qattr]
unfold let eval_reg_xmm (r:reg_xmm) (s:vale_state) : quad32 = eval_reg (Reg 1 r) s | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.State.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Regs",
"short_module": "Regs"
},
{
"abbrev": true,
"full_module": "Vale.X64.Flags",
"short_module": "Flags"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | m: Vale.X64.Machine_s.maddr -> s: Vale.X64.State.vale_state -> Prims.int | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.maddr",
"Vale.X64.State.vale_state",
"Prims.int",
"Vale.X64.Machine_s.reg",
"Prims.op_Addition",
"Vale.X64.State.eval_reg_int",
"FStar.Mul.op_Star"
] | [] | false | false | false | true | false | let eval_maddr (m: maddr) (s: vale_state) : int =
| match m with
| MConst n -> n
| MReg r offset -> eval_reg_int r s + offset
| MIndex base scale index offset -> eval_reg_int base s + scale * (eval_reg_int index s) + offset | false |
Vale.X64.State.fsti | Vale.X64.State.valid_src_operand | val valid_src_operand (o: operand64) (s: vale_state) : prop0 | val valid_src_operand (o: operand64) (s: vale_state) : prop0 | let valid_src_operand (o:operand64) (s:vale_state) : prop0 =
match o with
| OConst c -> True
| OReg r -> True
| OMem (m, _) -> valid_maddr m s
| OStack (m, _) -> valid_src_stack64 (eval_maddr m s) s.vs_stack | {
"file_name": "vale/code/arch/x64/Vale.X64.State.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 66,
"end_line": 115,
"start_col": 0,
"start_line": 110
} | module Vale.X64.State
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
module Flags = Vale.X64.Flags
module Regs = Vale.X64.Regs
module Map16 = Vale.Lib.Map16
noeq type vale_state = {
vs_ok: bool;
vs_regs: Regs.t;
vs_flags: Flags.t;
vs_heap: vale_full_heap;
vs_stack: vale_stack;
vs_stackTaint: memtaint;
}
unfold let vs_get_vale_heap (s:vale_state) : vale_heap = get_vale_heap s.vs_heap
[@va_qattr]
unfold let eval_reg (r:reg) (s:vale_state) : t_reg r = Regs.sel r s.vs_regs
[@va_qattr]
unfold let eval_reg_int (r:reg) (s:vale_state) : int = t_reg_to_int r.rf (eval_reg r s)
[@va_qattr]
unfold let eval_flag (f:flag) (s:vale_state) : Flags.flag_val_t = Flags.sel f s.vs_flags
[@va_qattr]
unfold let eval_mem (ptr:int) (s:vale_state) : GTot nat64 = load_mem64 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_mem128 (ptr:int) (s:vale_state) : GTot Vale.Def.Types_s.quad32 = load_mem128 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_stack (ptr:int) (s:vale_state) : GTot nat64 = load_stack64 ptr s.vs_stack
[@va_qattr]
unfold let eval_stack128 (ptr:int) (s:vale_state) : GTot quad32 = load_stack128 ptr s.vs_stack
[@va_qattr]
unfold let eval_reg_64 (r:reg_64) (s:vale_state) : nat64 = eval_reg (Reg 0 r) s
[@va_qattr]
unfold let eval_reg_xmm (r:reg_xmm) (s:vale_state) : quad32 = eval_reg (Reg 1 r) s
[@va_qattr]
let eval_maddr (m:maddr) (s:vale_state) : int =
match m with
| MConst n -> n
| MReg r offset -> eval_reg_int r s + offset
| MIndex base scale index offset -> eval_reg_int base s + scale * (eval_reg_int index s) + offset
[@va_qattr]
let eval_operand (o:operand64) (s:vale_state) : GTot nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s
[@va_qattr]
let eval_operand128 (o:operand128) (s:vale_state) : GTot Vale.Def.Types_s.quad32 =
match o with
| OConst c -> c
| OReg r -> eval_reg_xmm r s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s
[@va_qattr]
let update_reg (r:reg) (v:t_reg r) (s:vale_state) : vale_state =
{s with vs_regs = Regs.upd r v s.vs_regs}
[@va_qattr]
let update_reg_64 (r:reg_64) (v:nat64) (s:vale_state) : vale_state =
update_reg (Reg 0 r) v s
[@va_qattr]
let update_flag (f:flag) (v:Flags.flag_val_t) (s:vale_state) : vale_state =
{s with vs_flags = Flags.upd f v s.vs_flags}
[@va_qattr]
let update_reg_xmm (r:reg_xmm) (v:quad32) (s:vale_state) : vale_state =
update_reg (Reg 1 r) v s
//[@va_qattr]
//let update_mem (ptr:int) (v:nat64) (s:vale_state) : GTot vale_state =
// {s with vs_heap = set_vale_heap s.vs_heap (store_mem64 ptr v (get_vale_heap s.vs_heap))}
[@va_qattr]
let update_stack64 (ptr:int) (v:nat64) (s:vale_state) : GTot vale_state =
{s with vs_stack = store_stack64 ptr v s.vs_stack}
//[@va_qattr]
//let update_operand64 (o:operand64) (v:nat64) (sM:vale_state) : GTot vale_state =
// match o with
// | OConst n -> sM
// | OReg r -> update_reg (Reg 0 r) v sM
// | OMem (m, _) -> update_mem (eval_maddr m sM) v sM
// | OStack (m, _) -> update_stack64 (eval_maddr m sM) v sM
[@va_qattr]
let valid_maddr (m:maddr) (s:vale_state) : prop0 =
valid_mem64 (eval_maddr m s) (get_vale_heap s.vs_heap)
[@va_qattr]
let valid_maddr128 (m:maddr) (s:vale_state) : prop0 =
valid_mem128 (eval_maddr m s) (get_vale_heap s.vs_heap) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.State.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Regs",
"short_module": "Regs"
},
{
"abbrev": true,
"full_module": "Vale.X64.Flags",
"short_module": "Flags"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | o: Vale.X64.Machine_s.operand64 -> s: Vale.X64.State.vale_state -> Vale.Def.Prop_s.prop0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.operand64",
"Vale.X64.State.vale_state",
"Vale.X64.Machine_s.nat64",
"Prims.l_True",
"Vale.X64.Machine_s.reg_64",
"Vale.X64.Machine_s.maddr",
"Vale.Arch.HeapTypes_s.taint",
"Vale.X64.State.valid_maddr",
"Prims.b2t",
"Vale.X64.Stack_i.valid_src_stack64",
"Vale.X64.State.eval_maddr",
"Vale.X64.State.__proj__Mkvale_state__item__vs_stack",
"Vale.Def.Prop_s.prop0"
] | [] | false | false | false | true | false | let valid_src_operand (o: operand64) (s: vale_state) : prop0 =
| match o with
| OConst c -> True
| OReg r -> True
| OMem (m, _) -> valid_maddr m s
| OStack (m, _) -> valid_src_stack64 (eval_maddr m s) s.vs_stack | false |
Vale.X64.State.fsti | Vale.X64.State.valid_src_operand128 | val valid_src_operand128 (o: operand128) (s: vale_state) : prop0 | val valid_src_operand128 (o: operand128) (s: vale_state) : prop0 | let valid_src_operand128 (o:operand128) (s:vale_state) : prop0 =
match o with
| OConst _ -> False
| OReg _ -> True
| OMem (m, _) -> valid_maddr128 m s
| OStack (m, _) -> valid_src_stack128 (eval_maddr m s) s.vs_stack | {
"file_name": "vale/code/arch/x64/Vale.X64.State.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 67,
"end_line": 123,
"start_col": 0,
"start_line": 118
} | module Vale.X64.State
open FStar.Mul
// This interface should not refer to Machine_Semantics_s
open Vale.Def.Prop_s
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
module Flags = Vale.X64.Flags
module Regs = Vale.X64.Regs
module Map16 = Vale.Lib.Map16
noeq type vale_state = {
vs_ok: bool;
vs_regs: Regs.t;
vs_flags: Flags.t;
vs_heap: vale_full_heap;
vs_stack: vale_stack;
vs_stackTaint: memtaint;
}
unfold let vs_get_vale_heap (s:vale_state) : vale_heap = get_vale_heap s.vs_heap
[@va_qattr]
unfold let eval_reg (r:reg) (s:vale_state) : t_reg r = Regs.sel r s.vs_regs
[@va_qattr]
unfold let eval_reg_int (r:reg) (s:vale_state) : int = t_reg_to_int r.rf (eval_reg r s)
[@va_qattr]
unfold let eval_flag (f:flag) (s:vale_state) : Flags.flag_val_t = Flags.sel f s.vs_flags
[@va_qattr]
unfold let eval_mem (ptr:int) (s:vale_state) : GTot nat64 = load_mem64 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_mem128 (ptr:int) (s:vale_state) : GTot Vale.Def.Types_s.quad32 = load_mem128 ptr (get_vale_heap s.vs_heap)
[@va_qattr]
unfold let eval_stack (ptr:int) (s:vale_state) : GTot nat64 = load_stack64 ptr s.vs_stack
[@va_qattr]
unfold let eval_stack128 (ptr:int) (s:vale_state) : GTot quad32 = load_stack128 ptr s.vs_stack
[@va_qattr]
unfold let eval_reg_64 (r:reg_64) (s:vale_state) : nat64 = eval_reg (Reg 0 r) s
[@va_qattr]
unfold let eval_reg_xmm (r:reg_xmm) (s:vale_state) : quad32 = eval_reg (Reg 1 r) s
[@va_qattr]
let eval_maddr (m:maddr) (s:vale_state) : int =
match m with
| MConst n -> n
| MReg r offset -> eval_reg_int r s + offset
| MIndex base scale index offset -> eval_reg_int base s + scale * (eval_reg_int index s) + offset
[@va_qattr]
let eval_operand (o:operand64) (s:vale_state) : GTot nat64 =
match o with
| OConst n -> n
| OReg r -> eval_reg_64 r s
| OMem (m, _) -> eval_mem (eval_maddr m s) s
| OStack (m, _) -> eval_stack (eval_maddr m s) s
[@va_qattr]
let eval_operand128 (o:operand128) (s:vale_state) : GTot Vale.Def.Types_s.quad32 =
match o with
| OConst c -> c
| OReg r -> eval_reg_xmm r s
| OMem (m, _) -> eval_mem128 (eval_maddr m s) s
| OStack (m, _) -> eval_stack128 (eval_maddr m s) s
[@va_qattr]
let update_reg (r:reg) (v:t_reg r) (s:vale_state) : vale_state =
{s with vs_regs = Regs.upd r v s.vs_regs}
[@va_qattr]
let update_reg_64 (r:reg_64) (v:nat64) (s:vale_state) : vale_state =
update_reg (Reg 0 r) v s
[@va_qattr]
let update_flag (f:flag) (v:Flags.flag_val_t) (s:vale_state) : vale_state =
{s with vs_flags = Flags.upd f v s.vs_flags}
[@va_qattr]
let update_reg_xmm (r:reg_xmm) (v:quad32) (s:vale_state) : vale_state =
update_reg (Reg 1 r) v s
//[@va_qattr]
//let update_mem (ptr:int) (v:nat64) (s:vale_state) : GTot vale_state =
// {s with vs_heap = set_vale_heap s.vs_heap (store_mem64 ptr v (get_vale_heap s.vs_heap))}
[@va_qattr]
let update_stack64 (ptr:int) (v:nat64) (s:vale_state) : GTot vale_state =
{s with vs_stack = store_stack64 ptr v s.vs_stack}
//[@va_qattr]
//let update_operand64 (o:operand64) (v:nat64) (sM:vale_state) : GTot vale_state =
// match o with
// | OConst n -> sM
// | OReg r -> update_reg (Reg 0 r) v sM
// | OMem (m, _) -> update_mem (eval_maddr m sM) v sM
// | OStack (m, _) -> update_stack64 (eval_maddr m sM) v sM
[@va_qattr]
let valid_maddr (m:maddr) (s:vale_state) : prop0 =
valid_mem64 (eval_maddr m s) (get_vale_heap s.vs_heap)
[@va_qattr]
let valid_maddr128 (m:maddr) (s:vale_state) : prop0 =
valid_mem128 (eval_maddr m s) (get_vale_heap s.vs_heap)
[@va_qattr]
let valid_src_operand (o:operand64) (s:vale_state) : prop0 =
match o with
| OConst c -> True
| OReg r -> True
| OMem (m, _) -> valid_maddr m s
| OStack (m, _) -> valid_src_stack64 (eval_maddr m s) s.vs_stack | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.State.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Regs",
"short_module": "Regs"
},
{
"abbrev": true,
"full_module": "Vale.X64.Flags",
"short_module": "Flags"
},
{
"abbrev": false,
"full_module": "Vale.X64.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | o: Vale.X64.Machine_s.operand128 -> s: Vale.X64.State.vale_state -> Vale.Def.Prop_s.prop0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.operand128",
"Vale.X64.State.vale_state",
"Vale.X64.Machine_s.quad32",
"Prims.l_False",
"Vale.X64.Machine_s.reg_xmm",
"Prims.l_True",
"Vale.X64.Machine_s.maddr",
"Vale.Arch.HeapTypes_s.taint",
"Vale.X64.State.valid_maddr128",
"Prims.b2t",
"Vale.X64.Stack_i.valid_src_stack128",
"Vale.X64.State.eval_maddr",
"Vale.X64.State.__proj__Mkvale_state__item__vs_stack",
"Vale.Def.Prop_s.prop0"
] | [] | false | false | false | true | false | let valid_src_operand128 (o: operand128) (s: vale_state) : prop0 =
| match o with
| OConst _ -> False
| OReg _ -> True
| OMem (m, _) -> valid_maddr128 m s
| OStack (m, _) -> valid_src_stack128 (eval_maddr m s) s.vs_stack | false |
Hacl.Spec.Bignum.Base.fst | Hacl.Spec.Bignum.Base.mask_values | val mask_values : x: Hacl.Spec.Bignum.Definitions.limb t -> Prims.logical | let mask_values (#t:limb_t) (x:limb t) =
v x = v (zeros t SEC) \/ v x = v (ones t SEC) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Base.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 47,
"end_line": 138,
"start_col": 0,
"start_line": 137
} | module Hacl.Spec.Bignum.Base
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let carry (t:limb_t) = x:limb t{uint_v x == 0 \/ uint_v x == 1}
(**
This is non-stateful version of code/fallback functions
*)
inline_for_extraction noextract
val addcarry: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r + uint_v c' * pow2 (bits t) == uint_v a + uint_v b + uint_v c)
let addcarry #t cin x y =
let res = x +. cin +. y in
let c = logand (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (lt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res
inline_for_extraction noextract
val subborrow: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r - uint_v c' * pow2 (bits t) == uint_v a - uint_v b - uint_v c)
let subborrow #t cin x y =
let res = x -. y -. cin in
let c = logand (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (gt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res
inline_for_extraction noextract
val mul_wide: #t:limb_t -> a:limb t -> b:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) ->
v lo + v hi * pow2 (bits t) == v a * v b)
let mul_wide #t a b =
Math.Lemmas.lemma_mult_lt_sqr (v a) (v b) (pow2 (bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b in
to_u32 (res >>. 32ul), to_u32 res
| U64 ->
let res = mul64_wide a b in
to_u64 (res >>. 64ul), to_u64 res
val lemma_mul_wide_add: #t:limb_t -> a:limb t -> b:limb t -> c:limb t -> d:limb t ->
Lemma (v a * v b + v c + v d < pow2 (2 * bits t))
let lemma_mul_wide_add #t a b c d =
let n = pow2 (bits t) in
//assert (v a <= n - 1 /\ v b <= n - 1 /\ v c <= n - 1 /\ v d <= n - 1);
Math.Lemmas.lemma_mult_le_left (v a) (v b) (n - 1);
Math.Lemmas.lemma_mult_le_right (n - 1) (v a) (n - 1);
assert (v a * v b + v c + v d <= (n - 1) * (n - 1) + (n - 1) + (n - 1));
assert ((n - 1) * (n - 1) + (n - 1) + (n - 1) == n * n - 1)
val mul_wide_add: #t:limb_t -> a:limb t -> b:limb t -> c:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) -> v lo + v hi * pow2 (bits t) == v a * v b + v c)
let mul_wide_add #t a b c =
lemma_mul_wide_add a b c (uint #t 0);
Math.Lemmas.small_mod (v a * v b + v c) (pow2 (2 * bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b +! to_u64 c in
assert (v res == v a * v b + v c);
let hi = to_u32 (res >>. 32ul) in
assert (v hi == v res / pow2 32);
let lo = to_u32 res in
assert (v lo == v res % pow2 32);
Math.Lemmas.euclidean_division_definition (v res) (pow2 32);
hi, lo
| U64 ->
let res = mul64_wide a b +! to_u128 c in
assert (v res == v a * v b + v c);
let hi = to_u64 (res >>. 64ul) in
assert (v hi == v res / pow2 64);
let lo = to_u64 res in
assert (v lo == v res % pow2 64);
Math.Lemmas.euclidean_division_definition (v res) (pow2 64);
hi, lo
val mul_wide_add2: #t:limb_t -> a:limb t -> b:limb t -> c:limb t -> d:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) -> v lo + v hi * pow2 (bits t) == v a * v b + v c + v d)
let mul_wide_add2 #t a b c d =
lemma_mul_wide_add a b c d;
Math.Lemmas.small_mod (v a * v b + v c + v d) (pow2 (2 * bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b +! to_u64 c +! to_u64 d in
assert (v res == v a * v b + v c + v d);
let hi = to_u32 (res >>. 32ul) in
assert (v hi == v res / pow2 32);
let lo = to_u32 res in
assert (v lo == v res % pow2 32);
Math.Lemmas.euclidean_division_definition (v res) (pow2 32);
hi, lo
| U64 ->
let res = mul64_wide a b +! to_u128 c +! to_u128 d in
assert (v res == v a * v b + v c + v d);
let hi = to_u64 (res >>. 64ul) in
assert (v hi == v res / pow2 64);
let lo = to_u64 res in
assert (v lo == v res % pow2 64);
Math.Lemmas.euclidean_division_definition (v res) (pow2 64);
hi, lo | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Base.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"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
}
] | {
"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"
} | false | x: Hacl.Spec.Bignum.Definitions.limb t -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.l_or",
"Prims.b2t",
"Prims.op_Equality",
"Lib.IntTypes.range_t",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Lib.IntTypes.zeros",
"Lib.IntTypes.ones",
"Prims.logical"
] | [] | false | false | false | false | true | let mask_values (#t: limb_t) (x: limb t) =
| v x = v (zeros t SEC) \/ v x = v (ones t SEC) | false |
|
Hacl.Spec.Bignum.Base.fst | Hacl.Spec.Bignum.Base.mask_select | val mask_select: #t:limb_t -> mask:limb t -> a:limb t -> b:limb t -> limb t | val mask_select: #t:limb_t -> mask:limb t -> a:limb t -> b:limb t -> limb t | let mask_select #t mask a b =
(mask &. a) |. ((lognot mask) &. b) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Base.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 37,
"end_line": 175,
"start_col": 0,
"start_line": 174
} | module Hacl.Spec.Bignum.Base
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let carry (t:limb_t) = x:limb t{uint_v x == 0 \/ uint_v x == 1}
(**
This is non-stateful version of code/fallback functions
*)
inline_for_extraction noextract
val addcarry: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r + uint_v c' * pow2 (bits t) == uint_v a + uint_v b + uint_v c)
let addcarry #t cin x y =
let res = x +. cin +. y in
let c = logand (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (lt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res
inline_for_extraction noextract
val subborrow: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r - uint_v c' * pow2 (bits t) == uint_v a - uint_v b - uint_v c)
let subborrow #t cin x y =
let res = x -. y -. cin in
let c = logand (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (gt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res
inline_for_extraction noextract
val mul_wide: #t:limb_t -> a:limb t -> b:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) ->
v lo + v hi * pow2 (bits t) == v a * v b)
let mul_wide #t a b =
Math.Lemmas.lemma_mult_lt_sqr (v a) (v b) (pow2 (bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b in
to_u32 (res >>. 32ul), to_u32 res
| U64 ->
let res = mul64_wide a b in
to_u64 (res >>. 64ul), to_u64 res
val lemma_mul_wide_add: #t:limb_t -> a:limb t -> b:limb t -> c:limb t -> d:limb t ->
Lemma (v a * v b + v c + v d < pow2 (2 * bits t))
let lemma_mul_wide_add #t a b c d =
let n = pow2 (bits t) in
//assert (v a <= n - 1 /\ v b <= n - 1 /\ v c <= n - 1 /\ v d <= n - 1);
Math.Lemmas.lemma_mult_le_left (v a) (v b) (n - 1);
Math.Lemmas.lemma_mult_le_right (n - 1) (v a) (n - 1);
assert (v a * v b + v c + v d <= (n - 1) * (n - 1) + (n - 1) + (n - 1));
assert ((n - 1) * (n - 1) + (n - 1) + (n - 1) == n * n - 1)
val mul_wide_add: #t:limb_t -> a:limb t -> b:limb t -> c:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) -> v lo + v hi * pow2 (bits t) == v a * v b + v c)
let mul_wide_add #t a b c =
lemma_mul_wide_add a b c (uint #t 0);
Math.Lemmas.small_mod (v a * v b + v c) (pow2 (2 * bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b +! to_u64 c in
assert (v res == v a * v b + v c);
let hi = to_u32 (res >>. 32ul) in
assert (v hi == v res / pow2 32);
let lo = to_u32 res in
assert (v lo == v res % pow2 32);
Math.Lemmas.euclidean_division_definition (v res) (pow2 32);
hi, lo
| U64 ->
let res = mul64_wide a b +! to_u128 c in
assert (v res == v a * v b + v c);
let hi = to_u64 (res >>. 64ul) in
assert (v hi == v res / pow2 64);
let lo = to_u64 res in
assert (v lo == v res % pow2 64);
Math.Lemmas.euclidean_division_definition (v res) (pow2 64);
hi, lo
val mul_wide_add2: #t:limb_t -> a:limb t -> b:limb t -> c:limb t -> d:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) -> v lo + v hi * pow2 (bits t) == v a * v b + v c + v d)
let mul_wide_add2 #t a b c d =
lemma_mul_wide_add a b c d;
Math.Lemmas.small_mod (v a * v b + v c + v d) (pow2 (2 * bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b +! to_u64 c +! to_u64 d in
assert (v res == v a * v b + v c + v d);
let hi = to_u32 (res >>. 32ul) in
assert (v hi == v res / pow2 32);
let lo = to_u32 res in
assert (v lo == v res % pow2 32);
Math.Lemmas.euclidean_division_definition (v res) (pow2 32);
hi, lo
| U64 ->
let res = mul64_wide a b +! to_u128 c +! to_u128 d in
assert (v res == v a * v b + v c + v d);
let hi = to_u64 (res >>. 64ul) in
assert (v hi == v res / pow2 64);
let lo = to_u64 res in
assert (v lo == v res % pow2 64);
Math.Lemmas.euclidean_division_definition (v res) (pow2 64);
hi, lo
inline_for_extraction noextract
let mask_values (#t:limb_t) (x:limb t) =
v x = v (zeros t SEC) \/ v x = v (ones t SEC)
inline_for_extraction noextract
let unsafe_bool_of_limb0 (#t:limb_t) (m:limb t) : b:bool{b <==> v m = 0} =
let open Lib.RawIntTypes in
match t with
| U32 -> FStar.UInt32.(u32_to_UInt32 m =^ 0ul)
| U64 -> FStar.UInt64.(u64_to_UInt64 m =^ 0uL)
inline_for_extraction noextract
let unsafe_bool_of_limb (#t:limb_t) (m:limb t) : b:bool{b <==> v m = v (ones t SEC)} =
let open Lib.RawIntTypes in
match t with
| U32 -> FStar.UInt32.(u32_to_UInt32 m =^ u32_to_UInt32 (ones U32 SEC))
| U64 -> FStar.UInt64.(u64_to_UInt64 m =^ u64_to_UInt64 (ones U64 SEC))
inline_for_extraction noextract
let size_to_limb (#t:limb_t) (x:size_t) : limb t =
match t with
| U32 -> size_to_uint32 x
| U64 -> size_to_uint64 x
inline_for_extraction noextract
let unsafe_size_from_limb (#t:limb_t) (x:limb t{v x <= max_size_t}) : size_t =
let open Lib.RawIntTypes in
match t with
| U32 -> u32_to_UInt32 x
| U64 -> u32_to_UInt32 (to_u32 x)
inline_for_extraction noextract | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Base.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"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
}
] | {
"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"
} | false |
mask: Hacl.Spec.Bignum.Definitions.limb t ->
a: Hacl.Spec.Bignum.Definitions.limb t ->
b: Hacl.Spec.Bignum.Definitions.limb t
-> Hacl.Spec.Bignum.Definitions.limb t | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Definitions.limb",
"Lib.IntTypes.op_Bar_Dot",
"Lib.IntTypes.SEC",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTypes.lognot"
] | [] | false | false | false | false | false | let mask_select #t mask a b =
| (mask &. a) |. ((lognot mask) &. b) | false |
LowParse.Spec.BCVLI.fsti | LowParse.Spec.BCVLI.parse_bcvli_kind | val parse_bcvli_kind : LowParse.Spec.Base.parser_kind' | let parse_bcvli_kind = {
parser_kind_low = 1;
parser_kind_high = Some 5;
parser_kind_subkind = Some ParserStrong;
parser_kind_metadata = None;
} | {
"file_name": "src/lowparse/LowParse.Spec.BCVLI.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 1,
"end_line": 13,
"start_col": 0,
"start_line": 8
} | module LowParse.Spec.BCVLI
include LowParse.Spec.BoundedInt // for bounded_integer
module U32 = FStar.UInt32
module Seq = FStar.Seq | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.BoundedInt.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.BCVLI.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.BoundedInt",
"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
}
] | {
"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"
} | false | LowParse.Spec.Base.parser_kind' | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.Mkparser_kind'",
"FStar.Pervasives.Native.Some",
"Prims.nat",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.ParserStrong",
"FStar.Pervasives.Native.None",
"LowParse.Spec.Base.parser_kind_metadata_some"
] | [] | false | false | false | true | false | let parse_bcvli_kind =
| {
parser_kind_low = 1;
parser_kind_high = Some 5;
parser_kind_subkind = Some ParserStrong;
parser_kind_metadata = None
} | false |
|
LowParse.Spec.BCVLI.fsti | LowParse.Spec.BCVLI.parse_bounded_bcvli_size | val parse_bounded_bcvli_size (max: nat) : Tot nat | val parse_bounded_bcvli_size (max: nat) : Tot nat | let parse_bounded_bcvli_size
(max: nat)
: Tot nat
= if max <= 252
then 1
else if max <= 65535
then 3
else 5 | {
"file_name": "src/lowparse/LowParse.Spec.BCVLI.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 8,
"end_line": 66,
"start_col": 0,
"start_line": 59
} | module LowParse.Spec.BCVLI
include LowParse.Spec.BoundedInt // for bounded_integer
module U32 = FStar.UInt32
module Seq = FStar.Seq
inline_for_extraction
let parse_bcvli_kind = {
parser_kind_low = 1;
parser_kind_high = Some 5;
parser_kind_subkind = Some ParserStrong;
parser_kind_metadata = None;
}
val parse_bcvli : parser parse_bcvli_kind U32.t
val parse_bcvli_eq (b: bytes) : Lemma
(parse parse_bcvli b == (match parse (parse_bounded_integer_le 1) b with
| None -> None
| Some (x32, consumed_x) ->
let x = U32.v x32 in
if x <= 252 then Some (x32, consumed_x) else
let b' = Seq.slice b consumed_x (Seq.length b) in
if x = 253 then
match parse (parse_bounded_integer_le 2) b' with
| None -> None
| Some (y, consumed_y) ->
if U32.v y < 253 then None (* redundant representations not supported, non-malleability *) else Some (y, consumed_x + consumed_y)
else if x = 254 then
match parse (parse_bounded_integer_le 4) b' with
| None -> None
| Some (y, consumed_y) ->
if U32.v y < 65536 then None (* redundant representations not supported, non-malleability *) else Some (y, consumed_x + consumed_y)
else None (* 64-bit integers not supported *)
))
val serialize_bcvli : serializer parse_bcvli
val serialize_bcvli_eq (x: U32.t) : Lemma
(serialize serialize_bcvli x == (
let c1 : bounded_integer 1 =
if U32.v x <= 252 then
x
else if U32.v x <= 65535 then
253ul
else
254ul
in
Seq.append
(serialize (serialize_bounded_integer_le 1) c1)
(
if U32.v c1 <= 252 then Seq.empty else
if U32.v c1 = 253 then serialize (serialize_bounded_integer_le 2) x else
serialize (serialize_bounded_integer_le 4) x
)
)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.BoundedInt.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.BCVLI.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.BoundedInt",
"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
}
] | {
"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"
} | false | max: Prims.nat -> Prims.nat | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Prims.op_LessThanOrEqual",
"Prims.bool"
] | [] | false | false | false | true | false | let parse_bounded_bcvli_size (max: nat) : Tot nat =
| if max <= 252 then 1 else if max <= 65535 then 3 else 5 | false |
Hacl.Spec.Bignum.Base.fst | Hacl.Spec.Bignum.Base.carry | val carry : t: Hacl.Spec.Bignum.Definitions.limb_t -> Type0 | let carry (t:limb_t) = x:limb t{uint_v x == 0 \/ uint_v x == 1} | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Base.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 63,
"end_line": 12,
"start_col": 0,
"start_line": 12
} | module Hacl.Spec.Bignum.Base
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Base.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"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
}
] | {
"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"
} | false | t: Hacl.Spec.Bignum.Definitions.limb_t -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.l_or",
"Prims.eq2",
"Prims.int",
"Lib.IntTypes.uint_v",
"Lib.IntTypes.SEC"
] | [] | false | false | false | true | true | let carry (t: limb_t) =
| x: limb t {uint_v x == 0 \/ uint_v x == 1} | false |
|
Hacl.Spec.Bignum.Base.fst | Hacl.Spec.Bignum.Base.size_to_limb | val size_to_limb (#t: limb_t) (x: size_t) : limb t | val size_to_limb (#t: limb_t) (x: size_t) : limb t | let size_to_limb (#t:limb_t) (x:size_t) : limb t =
match t with
| U32 -> size_to_uint32 x
| U64 -> size_to_uint64 x | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Base.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 27,
"end_line": 161,
"start_col": 0,
"start_line": 158
} | module Hacl.Spec.Bignum.Base
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let carry (t:limb_t) = x:limb t{uint_v x == 0 \/ uint_v x == 1}
(**
This is non-stateful version of code/fallback functions
*)
inline_for_extraction noextract
val addcarry: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r + uint_v c' * pow2 (bits t) == uint_v a + uint_v b + uint_v c)
let addcarry #t cin x y =
let res = x +. cin +. y in
let c = logand (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (lt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res
inline_for_extraction noextract
val subborrow: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r - uint_v c' * pow2 (bits t) == uint_v a - uint_v b - uint_v c)
let subborrow #t cin x y =
let res = x -. y -. cin in
let c = logand (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (gt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res
inline_for_extraction noextract
val mul_wide: #t:limb_t -> a:limb t -> b:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) ->
v lo + v hi * pow2 (bits t) == v a * v b)
let mul_wide #t a b =
Math.Lemmas.lemma_mult_lt_sqr (v a) (v b) (pow2 (bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b in
to_u32 (res >>. 32ul), to_u32 res
| U64 ->
let res = mul64_wide a b in
to_u64 (res >>. 64ul), to_u64 res
val lemma_mul_wide_add: #t:limb_t -> a:limb t -> b:limb t -> c:limb t -> d:limb t ->
Lemma (v a * v b + v c + v d < pow2 (2 * bits t))
let lemma_mul_wide_add #t a b c d =
let n = pow2 (bits t) in
//assert (v a <= n - 1 /\ v b <= n - 1 /\ v c <= n - 1 /\ v d <= n - 1);
Math.Lemmas.lemma_mult_le_left (v a) (v b) (n - 1);
Math.Lemmas.lemma_mult_le_right (n - 1) (v a) (n - 1);
assert (v a * v b + v c + v d <= (n - 1) * (n - 1) + (n - 1) + (n - 1));
assert ((n - 1) * (n - 1) + (n - 1) + (n - 1) == n * n - 1)
val mul_wide_add: #t:limb_t -> a:limb t -> b:limb t -> c:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) -> v lo + v hi * pow2 (bits t) == v a * v b + v c)
let mul_wide_add #t a b c =
lemma_mul_wide_add a b c (uint #t 0);
Math.Lemmas.small_mod (v a * v b + v c) (pow2 (2 * bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b +! to_u64 c in
assert (v res == v a * v b + v c);
let hi = to_u32 (res >>. 32ul) in
assert (v hi == v res / pow2 32);
let lo = to_u32 res in
assert (v lo == v res % pow2 32);
Math.Lemmas.euclidean_division_definition (v res) (pow2 32);
hi, lo
| U64 ->
let res = mul64_wide a b +! to_u128 c in
assert (v res == v a * v b + v c);
let hi = to_u64 (res >>. 64ul) in
assert (v hi == v res / pow2 64);
let lo = to_u64 res in
assert (v lo == v res % pow2 64);
Math.Lemmas.euclidean_division_definition (v res) (pow2 64);
hi, lo
val mul_wide_add2: #t:limb_t -> a:limb t -> b:limb t -> c:limb t -> d:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) -> v lo + v hi * pow2 (bits t) == v a * v b + v c + v d)
let mul_wide_add2 #t a b c d =
lemma_mul_wide_add a b c d;
Math.Lemmas.small_mod (v a * v b + v c + v d) (pow2 (2 * bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b +! to_u64 c +! to_u64 d in
assert (v res == v a * v b + v c + v d);
let hi = to_u32 (res >>. 32ul) in
assert (v hi == v res / pow2 32);
let lo = to_u32 res in
assert (v lo == v res % pow2 32);
Math.Lemmas.euclidean_division_definition (v res) (pow2 32);
hi, lo
| U64 ->
let res = mul64_wide a b +! to_u128 c +! to_u128 d in
assert (v res == v a * v b + v c + v d);
let hi = to_u64 (res >>. 64ul) in
assert (v hi == v res / pow2 64);
let lo = to_u64 res in
assert (v lo == v res % pow2 64);
Math.Lemmas.euclidean_division_definition (v res) (pow2 64);
hi, lo
inline_for_extraction noextract
let mask_values (#t:limb_t) (x:limb t) =
v x = v (zeros t SEC) \/ v x = v (ones t SEC)
inline_for_extraction noextract
let unsafe_bool_of_limb0 (#t:limb_t) (m:limb t) : b:bool{b <==> v m = 0} =
let open Lib.RawIntTypes in
match t with
| U32 -> FStar.UInt32.(u32_to_UInt32 m =^ 0ul)
| U64 -> FStar.UInt64.(u64_to_UInt64 m =^ 0uL)
inline_for_extraction noextract
let unsafe_bool_of_limb (#t:limb_t) (m:limb t) : b:bool{b <==> v m = v (ones t SEC)} =
let open Lib.RawIntTypes in
match t with
| U32 -> FStar.UInt32.(u32_to_UInt32 m =^ u32_to_UInt32 (ones U32 SEC))
| U64 -> FStar.UInt64.(u64_to_UInt64 m =^ u64_to_UInt64 (ones U64 SEC)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Base.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"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
}
] | {
"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"
} | false | x: Lib.IntTypes.size_t -> Hacl.Spec.Bignum.Definitions.limb t | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_t",
"Lib.IntTypes.size_to_uint32",
"Lib.IntTypes.size_to_uint64",
"Hacl.Spec.Bignum.Definitions.limb"
] | [] | false | false | false | false | false | let size_to_limb (#t: limb_t) (x: size_t) : limb t =
| match t with
| U32 -> size_to_uint32 x
| U64 -> size_to_uint64 x | false |
Hacl.Spec.Bignum.Base.fst | Hacl.Spec.Bignum.Base.unsafe_size_from_limb | val unsafe_size_from_limb (#t: limb_t) (x: limb t {v x <= max_size_t}) : size_t | val unsafe_size_from_limb (#t: limb_t) (x: limb t {v x <= max_size_t}) : size_t | let unsafe_size_from_limb (#t:limb_t) (x:limb t{v x <= max_size_t}) : size_t =
let open Lib.RawIntTypes in
match t with
| U32 -> u32_to_UInt32 x
| U64 -> u32_to_UInt32 (to_u32 x) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Base.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 35,
"end_line": 169,
"start_col": 0,
"start_line": 165
} | module Hacl.Spec.Bignum.Base
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let carry (t:limb_t) = x:limb t{uint_v x == 0 \/ uint_v x == 1}
(**
This is non-stateful version of code/fallback functions
*)
inline_for_extraction noextract
val addcarry: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r + uint_v c' * pow2 (bits t) == uint_v a + uint_v b + uint_v c)
let addcarry #t cin x y =
let res = x +. cin +. y in
let c = logand (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (lt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res
inline_for_extraction noextract
val subborrow: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r - uint_v c' * pow2 (bits t) == uint_v a - uint_v b - uint_v c)
let subborrow #t cin x y =
let res = x -. y -. cin in
let c = logand (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (gt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res
inline_for_extraction noextract
val mul_wide: #t:limb_t -> a:limb t -> b:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) ->
v lo + v hi * pow2 (bits t) == v a * v b)
let mul_wide #t a b =
Math.Lemmas.lemma_mult_lt_sqr (v a) (v b) (pow2 (bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b in
to_u32 (res >>. 32ul), to_u32 res
| U64 ->
let res = mul64_wide a b in
to_u64 (res >>. 64ul), to_u64 res
val lemma_mul_wide_add: #t:limb_t -> a:limb t -> b:limb t -> c:limb t -> d:limb t ->
Lemma (v a * v b + v c + v d < pow2 (2 * bits t))
let lemma_mul_wide_add #t a b c d =
let n = pow2 (bits t) in
//assert (v a <= n - 1 /\ v b <= n - 1 /\ v c <= n - 1 /\ v d <= n - 1);
Math.Lemmas.lemma_mult_le_left (v a) (v b) (n - 1);
Math.Lemmas.lemma_mult_le_right (n - 1) (v a) (n - 1);
assert (v a * v b + v c + v d <= (n - 1) * (n - 1) + (n - 1) + (n - 1));
assert ((n - 1) * (n - 1) + (n - 1) + (n - 1) == n * n - 1)
val mul_wide_add: #t:limb_t -> a:limb t -> b:limb t -> c:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) -> v lo + v hi * pow2 (bits t) == v a * v b + v c)
let mul_wide_add #t a b c =
lemma_mul_wide_add a b c (uint #t 0);
Math.Lemmas.small_mod (v a * v b + v c) (pow2 (2 * bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b +! to_u64 c in
assert (v res == v a * v b + v c);
let hi = to_u32 (res >>. 32ul) in
assert (v hi == v res / pow2 32);
let lo = to_u32 res in
assert (v lo == v res % pow2 32);
Math.Lemmas.euclidean_division_definition (v res) (pow2 32);
hi, lo
| U64 ->
let res = mul64_wide a b +! to_u128 c in
assert (v res == v a * v b + v c);
let hi = to_u64 (res >>. 64ul) in
assert (v hi == v res / pow2 64);
let lo = to_u64 res in
assert (v lo == v res % pow2 64);
Math.Lemmas.euclidean_division_definition (v res) (pow2 64);
hi, lo
val mul_wide_add2: #t:limb_t -> a:limb t -> b:limb t -> c:limb t -> d:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) -> v lo + v hi * pow2 (bits t) == v a * v b + v c + v d)
let mul_wide_add2 #t a b c d =
lemma_mul_wide_add a b c d;
Math.Lemmas.small_mod (v a * v b + v c + v d) (pow2 (2 * bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b +! to_u64 c +! to_u64 d in
assert (v res == v a * v b + v c + v d);
let hi = to_u32 (res >>. 32ul) in
assert (v hi == v res / pow2 32);
let lo = to_u32 res in
assert (v lo == v res % pow2 32);
Math.Lemmas.euclidean_division_definition (v res) (pow2 32);
hi, lo
| U64 ->
let res = mul64_wide a b +! to_u128 c +! to_u128 d in
assert (v res == v a * v b + v c + v d);
let hi = to_u64 (res >>. 64ul) in
assert (v hi == v res / pow2 64);
let lo = to_u64 res in
assert (v lo == v res % pow2 64);
Math.Lemmas.euclidean_division_definition (v res) (pow2 64);
hi, lo
inline_for_extraction noextract
let mask_values (#t:limb_t) (x:limb t) =
v x = v (zeros t SEC) \/ v x = v (ones t SEC)
inline_for_extraction noextract
let unsafe_bool_of_limb0 (#t:limb_t) (m:limb t) : b:bool{b <==> v m = 0} =
let open Lib.RawIntTypes in
match t with
| U32 -> FStar.UInt32.(u32_to_UInt32 m =^ 0ul)
| U64 -> FStar.UInt64.(u64_to_UInt64 m =^ 0uL)
inline_for_extraction noextract
let unsafe_bool_of_limb (#t:limb_t) (m:limb t) : b:bool{b <==> v m = v (ones t SEC)} =
let open Lib.RawIntTypes in
match t with
| U32 -> FStar.UInt32.(u32_to_UInt32 m =^ u32_to_UInt32 (ones U32 SEC))
| U64 -> FStar.UInt64.(u64_to_UInt64 m =^ u64_to_UInt64 (ones U64 SEC))
inline_for_extraction noextract
let size_to_limb (#t:limb_t) (x:size_t) : limb t =
match t with
| U32 -> size_to_uint32 x
| U64 -> size_to_uint64 x | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Base.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"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
}
] | {
"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"
} | false | x: Hacl.Spec.Bignum.Definitions.limb t {Lib.IntTypes.v x <= Lib.IntTypes.max_size_t}
-> Lib.IntTypes.size_t | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Lib.IntTypes.max_size_t",
"Lib.RawIntTypes.u32_to_UInt32",
"Lib.IntTypes.to_u32",
"Lib.IntTypes.size_t"
] | [] | false | false | false | false | false | let unsafe_size_from_limb (#t: limb_t) (x: limb t {v x <= max_size_t}) : size_t =
| let open Lib.RawIntTypes in
match t with
| U32 -> u32_to_UInt32 x
| U64 -> u32_to_UInt32 (to_u32 x) | false |
LowParse.Spec.BCVLI.fsti | LowParse.Spec.BCVLI.parse_bounded_bcvli_kind | val parse_bounded_bcvli_kind (min: nat) (max: nat{min <= max}) : Tot parser_kind | val parse_bounded_bcvli_kind (min: nat) (max: nat{min <= max}) : Tot parser_kind | let parse_bounded_bcvli_kind
(min: nat)
(max: nat { min <= max })
: Tot parser_kind
= {
parser_kind_low = parse_bounded_bcvli_size min;
parser_kind_high = Some (parse_bounded_bcvli_size max);
parser_kind_subkind = Some ParserStrong;
parser_kind_metadata = None;
} | {
"file_name": "src/lowparse/LowParse.Spec.BCVLI.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 1,
"end_line": 78,
"start_col": 0,
"start_line": 69
} | module LowParse.Spec.BCVLI
include LowParse.Spec.BoundedInt // for bounded_integer
module U32 = FStar.UInt32
module Seq = FStar.Seq
inline_for_extraction
let parse_bcvli_kind = {
parser_kind_low = 1;
parser_kind_high = Some 5;
parser_kind_subkind = Some ParserStrong;
parser_kind_metadata = None;
}
val parse_bcvli : parser parse_bcvli_kind U32.t
val parse_bcvli_eq (b: bytes) : Lemma
(parse parse_bcvli b == (match parse (parse_bounded_integer_le 1) b with
| None -> None
| Some (x32, consumed_x) ->
let x = U32.v x32 in
if x <= 252 then Some (x32, consumed_x) else
let b' = Seq.slice b consumed_x (Seq.length b) in
if x = 253 then
match parse (parse_bounded_integer_le 2) b' with
| None -> None
| Some (y, consumed_y) ->
if U32.v y < 253 then None (* redundant representations not supported, non-malleability *) else Some (y, consumed_x + consumed_y)
else if x = 254 then
match parse (parse_bounded_integer_le 4) b' with
| None -> None
| Some (y, consumed_y) ->
if U32.v y < 65536 then None (* redundant representations not supported, non-malleability *) else Some (y, consumed_x + consumed_y)
else None (* 64-bit integers not supported *)
))
val serialize_bcvli : serializer parse_bcvli
val serialize_bcvli_eq (x: U32.t) : Lemma
(serialize serialize_bcvli x == (
let c1 : bounded_integer 1 =
if U32.v x <= 252 then
x
else if U32.v x <= 65535 then
253ul
else
254ul
in
Seq.append
(serialize (serialize_bounded_integer_le 1) c1)
(
if U32.v c1 <= 252 then Seq.empty else
if U32.v c1 = 253 then serialize (serialize_bounded_integer_le 2) x else
serialize (serialize_bounded_integer_le 4) x
)
))
inline_for_extraction
let parse_bounded_bcvli_size
(max: nat)
: Tot nat
= if max <= 252
then 1
else if max <= 65535
then 3
else 5 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.BoundedInt.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.BCVLI.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.BoundedInt",
"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
}
] | {
"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"
} | false | min: Prims.nat -> max: Prims.nat{min <= max} -> LowParse.Spec.Base.parser_kind | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.Spec.Base.Mkparser_kind'",
"LowParse.Spec.BCVLI.parse_bounded_bcvli_size",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.ParserStrong",
"FStar.Pervasives.Native.None",
"LowParse.Spec.Base.parser_kind_metadata_some",
"LowParse.Spec.Base.parser_kind"
] | [] | false | false | false | false | false | let parse_bounded_bcvli_kind (min: nat) (max: nat{min <= max}) : Tot parser_kind =
| {
parser_kind_low = parse_bounded_bcvli_size min;
parser_kind_high = Some (parse_bounded_bcvli_size max);
parser_kind_subkind = Some ParserStrong;
parser_kind_metadata = None
} | false |
Hacl.Spec.Bignum.Base.fst | Hacl.Spec.Bignum.Base.unsafe_bool_of_limb0 | val unsafe_bool_of_limb0 (#t: limb_t) (m: limb t) : b: bool{b <==> v m = 0} | val unsafe_bool_of_limb0 (#t: limb_t) (m: limb t) : b: bool{b <==> v m = 0} | let unsafe_bool_of_limb0 (#t:limb_t) (m:limb t) : b:bool{b <==> v m = 0} =
let open Lib.RawIntTypes in
match t with
| U32 -> FStar.UInt32.(u32_to_UInt32 m =^ 0ul)
| U64 -> FStar.UInt64.(u64_to_UInt64 m =^ 0uL) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Base.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 48,
"end_line": 146,
"start_col": 0,
"start_line": 142
} | module Hacl.Spec.Bignum.Base
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let carry (t:limb_t) = x:limb t{uint_v x == 0 \/ uint_v x == 1}
(**
This is non-stateful version of code/fallback functions
*)
inline_for_extraction noextract
val addcarry: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r + uint_v c' * pow2 (bits t) == uint_v a + uint_v b + uint_v c)
let addcarry #t cin x y =
let res = x +. cin +. y in
let c = logand (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (lt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res
inline_for_extraction noextract
val subborrow: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r - uint_v c' * pow2 (bits t) == uint_v a - uint_v b - uint_v c)
let subborrow #t cin x y =
let res = x -. y -. cin in
let c = logand (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (gt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res
inline_for_extraction noextract
val mul_wide: #t:limb_t -> a:limb t -> b:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) ->
v lo + v hi * pow2 (bits t) == v a * v b)
let mul_wide #t a b =
Math.Lemmas.lemma_mult_lt_sqr (v a) (v b) (pow2 (bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b in
to_u32 (res >>. 32ul), to_u32 res
| U64 ->
let res = mul64_wide a b in
to_u64 (res >>. 64ul), to_u64 res
val lemma_mul_wide_add: #t:limb_t -> a:limb t -> b:limb t -> c:limb t -> d:limb t ->
Lemma (v a * v b + v c + v d < pow2 (2 * bits t))
let lemma_mul_wide_add #t a b c d =
let n = pow2 (bits t) in
//assert (v a <= n - 1 /\ v b <= n - 1 /\ v c <= n - 1 /\ v d <= n - 1);
Math.Lemmas.lemma_mult_le_left (v a) (v b) (n - 1);
Math.Lemmas.lemma_mult_le_right (n - 1) (v a) (n - 1);
assert (v a * v b + v c + v d <= (n - 1) * (n - 1) + (n - 1) + (n - 1));
assert ((n - 1) * (n - 1) + (n - 1) + (n - 1) == n * n - 1)
val mul_wide_add: #t:limb_t -> a:limb t -> b:limb t -> c:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) -> v lo + v hi * pow2 (bits t) == v a * v b + v c)
let mul_wide_add #t a b c =
lemma_mul_wide_add a b c (uint #t 0);
Math.Lemmas.small_mod (v a * v b + v c) (pow2 (2 * bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b +! to_u64 c in
assert (v res == v a * v b + v c);
let hi = to_u32 (res >>. 32ul) in
assert (v hi == v res / pow2 32);
let lo = to_u32 res in
assert (v lo == v res % pow2 32);
Math.Lemmas.euclidean_division_definition (v res) (pow2 32);
hi, lo
| U64 ->
let res = mul64_wide a b +! to_u128 c in
assert (v res == v a * v b + v c);
let hi = to_u64 (res >>. 64ul) in
assert (v hi == v res / pow2 64);
let lo = to_u64 res in
assert (v lo == v res % pow2 64);
Math.Lemmas.euclidean_division_definition (v res) (pow2 64);
hi, lo
val mul_wide_add2: #t:limb_t -> a:limb t -> b:limb t -> c:limb t -> d:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) -> v lo + v hi * pow2 (bits t) == v a * v b + v c + v d)
let mul_wide_add2 #t a b c d =
lemma_mul_wide_add a b c d;
Math.Lemmas.small_mod (v a * v b + v c + v d) (pow2 (2 * bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b +! to_u64 c +! to_u64 d in
assert (v res == v a * v b + v c + v d);
let hi = to_u32 (res >>. 32ul) in
assert (v hi == v res / pow2 32);
let lo = to_u32 res in
assert (v lo == v res % pow2 32);
Math.Lemmas.euclidean_division_definition (v res) (pow2 32);
hi, lo
| U64 ->
let res = mul64_wide a b +! to_u128 c +! to_u128 d in
assert (v res == v a * v b + v c + v d);
let hi = to_u64 (res >>. 64ul) in
assert (v hi == v res / pow2 64);
let lo = to_u64 res in
assert (v lo == v res % pow2 64);
Math.Lemmas.euclidean_division_definition (v res) (pow2 64);
hi, lo
inline_for_extraction noextract
let mask_values (#t:limb_t) (x:limb t) =
v x = v (zeros t SEC) \/ v x = v (ones t SEC) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Base.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"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
}
] | {
"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"
} | false | m: Hacl.Spec.Bignum.Definitions.limb t -> b: Prims.bool{b <==> Lib.IntTypes.v m = 0} | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Definitions.limb",
"FStar.UInt32.op_Equals_Hat",
"Lib.RawIntTypes.u32_to_UInt32",
"FStar.UInt32.__uint_to_t",
"FStar.UInt64.op_Equals_Hat",
"Lib.RawIntTypes.u64_to_UInt64",
"FStar.UInt64.__uint_to_t",
"Prims.bool",
"Prims.l_iff",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC"
] | [] | false | false | false | false | false | let unsafe_bool_of_limb0 (#t: limb_t) (m: limb t) : b: bool{b <==> v m = 0} =
| let open Lib.RawIntTypes in
match t with
| U32 -> let open FStar.UInt32 in u32_to_UInt32 m =^ 0ul
| U64 -> let open FStar.UInt64 in u64_to_UInt64 m =^ 0uL | false |
Hacl.Spec.Bignum.Base.fst | Hacl.Spec.Bignum.Base.unsafe_bool_of_limb | val unsafe_bool_of_limb (#t: limb_t) (m: limb t) : b: bool{b <==> v m = v (ones t SEC)} | val unsafe_bool_of_limb (#t: limb_t) (m: limb t) : b: bool{b <==> v m = v (ones t SEC)} | let unsafe_bool_of_limb (#t:limb_t) (m:limb t) : b:bool{b <==> v m = v (ones t SEC)} =
let open Lib.RawIntTypes in
match t with
| U32 -> FStar.UInt32.(u32_to_UInt32 m =^ u32_to_UInt32 (ones U32 SEC))
| U64 -> FStar.UInt64.(u64_to_UInt64 m =^ u64_to_UInt64 (ones U64 SEC)) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Base.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 73,
"end_line": 154,
"start_col": 0,
"start_line": 150
} | module Hacl.Spec.Bignum.Base
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let carry (t:limb_t) = x:limb t{uint_v x == 0 \/ uint_v x == 1}
(**
This is non-stateful version of code/fallback functions
*)
inline_for_extraction noextract
val addcarry: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r + uint_v c' * pow2 (bits t) == uint_v a + uint_v b + uint_v c)
let addcarry #t cin x y =
let res = x +. cin +. y in
let c = logand (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (lt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res
inline_for_extraction noextract
val subborrow: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r - uint_v c' * pow2 (bits t) == uint_v a - uint_v b - uint_v c)
let subborrow #t cin x y =
let res = x -. y -. cin in
let c = logand (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (gt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res
inline_for_extraction noextract
val mul_wide: #t:limb_t -> a:limb t -> b:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) ->
v lo + v hi * pow2 (bits t) == v a * v b)
let mul_wide #t a b =
Math.Lemmas.lemma_mult_lt_sqr (v a) (v b) (pow2 (bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b in
to_u32 (res >>. 32ul), to_u32 res
| U64 ->
let res = mul64_wide a b in
to_u64 (res >>. 64ul), to_u64 res
val lemma_mul_wide_add: #t:limb_t -> a:limb t -> b:limb t -> c:limb t -> d:limb t ->
Lemma (v a * v b + v c + v d < pow2 (2 * bits t))
let lemma_mul_wide_add #t a b c d =
let n = pow2 (bits t) in
//assert (v a <= n - 1 /\ v b <= n - 1 /\ v c <= n - 1 /\ v d <= n - 1);
Math.Lemmas.lemma_mult_le_left (v a) (v b) (n - 1);
Math.Lemmas.lemma_mult_le_right (n - 1) (v a) (n - 1);
assert (v a * v b + v c + v d <= (n - 1) * (n - 1) + (n - 1) + (n - 1));
assert ((n - 1) * (n - 1) + (n - 1) + (n - 1) == n * n - 1)
val mul_wide_add: #t:limb_t -> a:limb t -> b:limb t -> c:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) -> v lo + v hi * pow2 (bits t) == v a * v b + v c)
let mul_wide_add #t a b c =
lemma_mul_wide_add a b c (uint #t 0);
Math.Lemmas.small_mod (v a * v b + v c) (pow2 (2 * bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b +! to_u64 c in
assert (v res == v a * v b + v c);
let hi = to_u32 (res >>. 32ul) in
assert (v hi == v res / pow2 32);
let lo = to_u32 res in
assert (v lo == v res % pow2 32);
Math.Lemmas.euclidean_division_definition (v res) (pow2 32);
hi, lo
| U64 ->
let res = mul64_wide a b +! to_u128 c in
assert (v res == v a * v b + v c);
let hi = to_u64 (res >>. 64ul) in
assert (v hi == v res / pow2 64);
let lo = to_u64 res in
assert (v lo == v res % pow2 64);
Math.Lemmas.euclidean_division_definition (v res) (pow2 64);
hi, lo
val mul_wide_add2: #t:limb_t -> a:limb t -> b:limb t -> c:limb t -> d:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) -> v lo + v hi * pow2 (bits t) == v a * v b + v c + v d)
let mul_wide_add2 #t a b c d =
lemma_mul_wide_add a b c d;
Math.Lemmas.small_mod (v a * v b + v c + v d) (pow2 (2 * bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b +! to_u64 c +! to_u64 d in
assert (v res == v a * v b + v c + v d);
let hi = to_u32 (res >>. 32ul) in
assert (v hi == v res / pow2 32);
let lo = to_u32 res in
assert (v lo == v res % pow2 32);
Math.Lemmas.euclidean_division_definition (v res) (pow2 32);
hi, lo
| U64 ->
let res = mul64_wide a b +! to_u128 c +! to_u128 d in
assert (v res == v a * v b + v c + v d);
let hi = to_u64 (res >>. 64ul) in
assert (v hi == v res / pow2 64);
let lo = to_u64 res in
assert (v lo == v res % pow2 64);
Math.Lemmas.euclidean_division_definition (v res) (pow2 64);
hi, lo
inline_for_extraction noextract
let mask_values (#t:limb_t) (x:limb t) =
v x = v (zeros t SEC) \/ v x = v (ones t SEC)
inline_for_extraction noextract
let unsafe_bool_of_limb0 (#t:limb_t) (m:limb t) : b:bool{b <==> v m = 0} =
let open Lib.RawIntTypes in
match t with
| U32 -> FStar.UInt32.(u32_to_UInt32 m =^ 0ul)
| U64 -> FStar.UInt64.(u64_to_UInt64 m =^ 0uL) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Base.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"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
}
] | {
"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"
} | false | m: Hacl.Spec.Bignum.Definitions.limb t
-> b: Prims.bool{b <==> Lib.IntTypes.v m = Lib.IntTypes.v (Lib.IntTypes.ones t Lib.IntTypes.SEC)} | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Definitions.limb",
"FStar.UInt32.op_Equals_Hat",
"Lib.RawIntTypes.u32_to_UInt32",
"Lib.IntTypes.ones",
"Lib.IntTypes.U32",
"Lib.IntTypes.SEC",
"FStar.UInt64.op_Equals_Hat",
"Lib.RawIntTypes.u64_to_UInt64",
"Lib.IntTypes.U64",
"Prims.bool",
"Prims.l_iff",
"Prims.b2t",
"Prims.op_Equality",
"Lib.IntTypes.range_t",
"Lib.IntTypes.v"
] | [] | false | false | false | false | false | let unsafe_bool_of_limb (#t: limb_t) (m: limb t) : b: bool{b <==> v m = v (ones t SEC)} =
| let open Lib.RawIntTypes in
match t with
| U32 -> let open FStar.UInt32 in u32_to_UInt32 m =^ u32_to_UInt32 (ones U32 SEC)
| U64 -> let open FStar.UInt64 in u64_to_UInt64 m =^ u64_to_UInt64 (ones U64 SEC) | false |
Hacl.Spec.Bignum.Base.fst | Hacl.Spec.Bignum.Base.mask_select_lemma | val mask_select_lemma: #t:limb_t -> mask:limb t -> a:limb t -> b:limb t -> Lemma
(requires mask_values mask)
(ensures mask_select mask a b == (if v mask = 0 then b else a)) | val mask_select_lemma: #t:limb_t -> mask:limb t -> a:limb t -> b:limb t -> Lemma
(requires mask_values mask)
(ensures mask_select mask a b == (if v mask = 0 then b else a)) | let mask_select_lemma #t mask a b =
if v mask = 0 then begin
logand_lemma mask a;
assert (v (mask &. a) = 0);
lognot_lemma mask;
assert (v (lognot mask) = v (ones t SEC));
logand_lemma (lognot mask) b;
assert (v ((lognot mask) &. b) == v b);
logor_lemma (mask &. a) ((lognot mask) &. b);
assert (v (mask_select mask a b) == v b) end
else begin
logand_lemma mask a;
assert (v (mask &. a) = v a);
lognot_lemma mask;
assert (v (lognot mask) = 0);
logand_lemma (lognot mask) b;
assert (v ((lognot mask) &. b) == 0);
logor_zeros (mask &. a);
assert (v (mask_select mask a b) == v a) end | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Base.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 48,
"end_line": 199,
"start_col": 0,
"start_line": 181
} | module Hacl.Spec.Bignum.Base
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let carry (t:limb_t) = x:limb t{uint_v x == 0 \/ uint_v x == 1}
(**
This is non-stateful version of code/fallback functions
*)
inline_for_extraction noextract
val addcarry: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r + uint_v c' * pow2 (bits t) == uint_v a + uint_v b + uint_v c)
let addcarry #t cin x y =
let res = x +. cin +. y in
let c = logand (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (lt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res
inline_for_extraction noextract
val subborrow: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r - uint_v c' * pow2 (bits t) == uint_v a - uint_v b - uint_v c)
let subborrow #t cin x y =
let res = x -. y -. cin in
let c = logand (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (gt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res
inline_for_extraction noextract
val mul_wide: #t:limb_t -> a:limb t -> b:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) ->
v lo + v hi * pow2 (bits t) == v a * v b)
let mul_wide #t a b =
Math.Lemmas.lemma_mult_lt_sqr (v a) (v b) (pow2 (bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b in
to_u32 (res >>. 32ul), to_u32 res
| U64 ->
let res = mul64_wide a b in
to_u64 (res >>. 64ul), to_u64 res
val lemma_mul_wide_add: #t:limb_t -> a:limb t -> b:limb t -> c:limb t -> d:limb t ->
Lemma (v a * v b + v c + v d < pow2 (2 * bits t))
let lemma_mul_wide_add #t a b c d =
let n = pow2 (bits t) in
//assert (v a <= n - 1 /\ v b <= n - 1 /\ v c <= n - 1 /\ v d <= n - 1);
Math.Lemmas.lemma_mult_le_left (v a) (v b) (n - 1);
Math.Lemmas.lemma_mult_le_right (n - 1) (v a) (n - 1);
assert (v a * v b + v c + v d <= (n - 1) * (n - 1) + (n - 1) + (n - 1));
assert ((n - 1) * (n - 1) + (n - 1) + (n - 1) == n * n - 1)
val mul_wide_add: #t:limb_t -> a:limb t -> b:limb t -> c:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) -> v lo + v hi * pow2 (bits t) == v a * v b + v c)
let mul_wide_add #t a b c =
lemma_mul_wide_add a b c (uint #t 0);
Math.Lemmas.small_mod (v a * v b + v c) (pow2 (2 * bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b +! to_u64 c in
assert (v res == v a * v b + v c);
let hi = to_u32 (res >>. 32ul) in
assert (v hi == v res / pow2 32);
let lo = to_u32 res in
assert (v lo == v res % pow2 32);
Math.Lemmas.euclidean_division_definition (v res) (pow2 32);
hi, lo
| U64 ->
let res = mul64_wide a b +! to_u128 c in
assert (v res == v a * v b + v c);
let hi = to_u64 (res >>. 64ul) in
assert (v hi == v res / pow2 64);
let lo = to_u64 res in
assert (v lo == v res % pow2 64);
Math.Lemmas.euclidean_division_definition (v res) (pow2 64);
hi, lo
val mul_wide_add2: #t:limb_t -> a:limb t -> b:limb t -> c:limb t -> d:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) -> v lo + v hi * pow2 (bits t) == v a * v b + v c + v d)
let mul_wide_add2 #t a b c d =
lemma_mul_wide_add a b c d;
Math.Lemmas.small_mod (v a * v b + v c + v d) (pow2 (2 * bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b +! to_u64 c +! to_u64 d in
assert (v res == v a * v b + v c + v d);
let hi = to_u32 (res >>. 32ul) in
assert (v hi == v res / pow2 32);
let lo = to_u32 res in
assert (v lo == v res % pow2 32);
Math.Lemmas.euclidean_division_definition (v res) (pow2 32);
hi, lo
| U64 ->
let res = mul64_wide a b +! to_u128 c +! to_u128 d in
assert (v res == v a * v b + v c + v d);
let hi = to_u64 (res >>. 64ul) in
assert (v hi == v res / pow2 64);
let lo = to_u64 res in
assert (v lo == v res % pow2 64);
Math.Lemmas.euclidean_division_definition (v res) (pow2 64);
hi, lo
inline_for_extraction noextract
let mask_values (#t:limb_t) (x:limb t) =
v x = v (zeros t SEC) \/ v x = v (ones t SEC)
inline_for_extraction noextract
let unsafe_bool_of_limb0 (#t:limb_t) (m:limb t) : b:bool{b <==> v m = 0} =
let open Lib.RawIntTypes in
match t with
| U32 -> FStar.UInt32.(u32_to_UInt32 m =^ 0ul)
| U64 -> FStar.UInt64.(u64_to_UInt64 m =^ 0uL)
inline_for_extraction noextract
let unsafe_bool_of_limb (#t:limb_t) (m:limb t) : b:bool{b <==> v m = v (ones t SEC)} =
let open Lib.RawIntTypes in
match t with
| U32 -> FStar.UInt32.(u32_to_UInt32 m =^ u32_to_UInt32 (ones U32 SEC))
| U64 -> FStar.UInt64.(u64_to_UInt64 m =^ u64_to_UInt64 (ones U64 SEC))
inline_for_extraction noextract
let size_to_limb (#t:limb_t) (x:size_t) : limb t =
match t with
| U32 -> size_to_uint32 x
| U64 -> size_to_uint64 x
inline_for_extraction noextract
let unsafe_size_from_limb (#t:limb_t) (x:limb t{v x <= max_size_t}) : size_t =
let open Lib.RawIntTypes in
match t with
| U32 -> u32_to_UInt32 x
| U64 -> u32_to_UInt32 (to_u32 x)
inline_for_extraction noextract
val mask_select: #t:limb_t -> mask:limb t -> a:limb t -> b:limb t -> limb t
let mask_select #t mask a b =
(mask &. a) |. ((lognot mask) &. b)
val mask_select_lemma: #t:limb_t -> mask:limb t -> a:limb t -> b:limb t -> Lemma
(requires mask_values mask)
(ensures mask_select mask a b == (if v mask = 0 then b else a)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Base.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"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
}
] | {
"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"
} | false |
mask: Hacl.Spec.Bignum.Definitions.limb t ->
a: Hacl.Spec.Bignum.Definitions.limb t ->
b: Hacl.Spec.Bignum.Definitions.limb t
-> FStar.Pervasives.Lemma (requires Hacl.Spec.Bignum.Base.mask_values mask)
(ensures
Hacl.Spec.Bignum.Base.mask_select mask a b ==
(match Lib.IntTypes.v mask = 0 with
| true -> b
| _ -> a)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.op_Equality",
"Prims.int",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Prims._assert",
"Prims.eq2",
"Lib.IntTypes.range_t",
"Hacl.Spec.Bignum.Base.mask_select",
"Prims.unit",
"Lib.IntTypes.logor_lemma",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTypes.lognot",
"Lib.IntTypes.logand_lemma",
"Prims.b2t",
"Lib.IntTypes.ones",
"Lib.IntTypes.lognot_lemma",
"Prims.bool",
"Lib.IntTypes.logor_zeros"
] | [] | false | false | true | false | false | let mask_select_lemma #t mask a b =
| if v mask = 0
then
(logand_lemma mask a;
assert (v (mask &. a) = 0);
lognot_lemma mask;
assert (v (lognot mask) = v (ones t SEC));
logand_lemma (lognot mask) b;
assert (v ((lognot mask) &. b) == v b);
logor_lemma (mask &. a) ((lognot mask) &. b);
assert (v (mask_select mask a b) == v b))
else
(logand_lemma mask a;
assert (v (mask &. a) = v a);
lognot_lemma mask;
assert (v (lognot mask) = 0);
logand_lemma (lognot mask) b;
assert (v ((lognot mask) &. b) == 0);
logor_zeros (mask &. a);
assert (v (mask_select mask a b) == v a)) | false |
Hacl.Spec.Bignum.Base.fst | Hacl.Spec.Bignum.Base.lseq_mask_select_lemma | val lseq_mask_select_lemma: #t:limb_t -> #len:size_nat -> a:lseq (limb t) len -> b:lseq (limb t) len -> mask:limb t -> Lemma
(requires mask_values mask)
(ensures map2 (mask_select mask) a b == (if v mask = 0 then b else a)) | val lseq_mask_select_lemma: #t:limb_t -> #len:size_nat -> a:lseq (limb t) len -> b:lseq (limb t) len -> mask:limb t -> Lemma
(requires mask_values mask)
(ensures map2 (mask_select mask) a b == (if v mask = 0 then b else a)) | let lseq_mask_select_lemma #t #len a b mask =
let res = map2 (mask_select mask) a b in
let lemma_aux (i:nat{i < len}) : Lemma (v res.[i] == (if v mask = 0 then v b.[i] else v a.[i])) =
mask_select_lemma mask a.[i] b.[i] in
Classical.forall_intro lemma_aux;
if v mask = 0 then eq_intro res b else eq_intro res a | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Base.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 55,
"end_line": 233,
"start_col": 0,
"start_line": 226
} | module Hacl.Spec.Bignum.Base
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let carry (t:limb_t) = x:limb t{uint_v x == 0 \/ uint_v x == 1}
(**
This is non-stateful version of code/fallback functions
*)
inline_for_extraction noextract
val addcarry: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r + uint_v c' * pow2 (bits t) == uint_v a + uint_v b + uint_v c)
let addcarry #t cin x y =
let res = x +. cin +. y in
let c = logand (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (lt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res
inline_for_extraction noextract
val subborrow: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r - uint_v c' * pow2 (bits t) == uint_v a - uint_v b - uint_v c)
let subborrow #t cin x y =
let res = x -. y -. cin in
let c = logand (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (gt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res
inline_for_extraction noextract
val mul_wide: #t:limb_t -> a:limb t -> b:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) ->
v lo + v hi * pow2 (bits t) == v a * v b)
let mul_wide #t a b =
Math.Lemmas.lemma_mult_lt_sqr (v a) (v b) (pow2 (bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b in
to_u32 (res >>. 32ul), to_u32 res
| U64 ->
let res = mul64_wide a b in
to_u64 (res >>. 64ul), to_u64 res
val lemma_mul_wide_add: #t:limb_t -> a:limb t -> b:limb t -> c:limb t -> d:limb t ->
Lemma (v a * v b + v c + v d < pow2 (2 * bits t))
let lemma_mul_wide_add #t a b c d =
let n = pow2 (bits t) in
//assert (v a <= n - 1 /\ v b <= n - 1 /\ v c <= n - 1 /\ v d <= n - 1);
Math.Lemmas.lemma_mult_le_left (v a) (v b) (n - 1);
Math.Lemmas.lemma_mult_le_right (n - 1) (v a) (n - 1);
assert (v a * v b + v c + v d <= (n - 1) * (n - 1) + (n - 1) + (n - 1));
assert ((n - 1) * (n - 1) + (n - 1) + (n - 1) == n * n - 1)
val mul_wide_add: #t:limb_t -> a:limb t -> b:limb t -> c:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) -> v lo + v hi * pow2 (bits t) == v a * v b + v c)
let mul_wide_add #t a b c =
lemma_mul_wide_add a b c (uint #t 0);
Math.Lemmas.small_mod (v a * v b + v c) (pow2 (2 * bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b +! to_u64 c in
assert (v res == v a * v b + v c);
let hi = to_u32 (res >>. 32ul) in
assert (v hi == v res / pow2 32);
let lo = to_u32 res in
assert (v lo == v res % pow2 32);
Math.Lemmas.euclidean_division_definition (v res) (pow2 32);
hi, lo
| U64 ->
let res = mul64_wide a b +! to_u128 c in
assert (v res == v a * v b + v c);
let hi = to_u64 (res >>. 64ul) in
assert (v hi == v res / pow2 64);
let lo = to_u64 res in
assert (v lo == v res % pow2 64);
Math.Lemmas.euclidean_division_definition (v res) (pow2 64);
hi, lo
val mul_wide_add2: #t:limb_t -> a:limb t -> b:limb t -> c:limb t -> d:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) -> v lo + v hi * pow2 (bits t) == v a * v b + v c + v d)
let mul_wide_add2 #t a b c d =
lemma_mul_wide_add a b c d;
Math.Lemmas.small_mod (v a * v b + v c + v d) (pow2 (2 * bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b +! to_u64 c +! to_u64 d in
assert (v res == v a * v b + v c + v d);
let hi = to_u32 (res >>. 32ul) in
assert (v hi == v res / pow2 32);
let lo = to_u32 res in
assert (v lo == v res % pow2 32);
Math.Lemmas.euclidean_division_definition (v res) (pow2 32);
hi, lo
| U64 ->
let res = mul64_wide a b +! to_u128 c +! to_u128 d in
assert (v res == v a * v b + v c + v d);
let hi = to_u64 (res >>. 64ul) in
assert (v hi == v res / pow2 64);
let lo = to_u64 res in
assert (v lo == v res % pow2 64);
Math.Lemmas.euclidean_division_definition (v res) (pow2 64);
hi, lo
inline_for_extraction noextract
let mask_values (#t:limb_t) (x:limb t) =
v x = v (zeros t SEC) \/ v x = v (ones t SEC)
inline_for_extraction noextract
let unsafe_bool_of_limb0 (#t:limb_t) (m:limb t) : b:bool{b <==> v m = 0} =
let open Lib.RawIntTypes in
match t with
| U32 -> FStar.UInt32.(u32_to_UInt32 m =^ 0ul)
| U64 -> FStar.UInt64.(u64_to_UInt64 m =^ 0uL)
inline_for_extraction noextract
let unsafe_bool_of_limb (#t:limb_t) (m:limb t) : b:bool{b <==> v m = v (ones t SEC)} =
let open Lib.RawIntTypes in
match t with
| U32 -> FStar.UInt32.(u32_to_UInt32 m =^ u32_to_UInt32 (ones U32 SEC))
| U64 -> FStar.UInt64.(u64_to_UInt64 m =^ u64_to_UInt64 (ones U64 SEC))
inline_for_extraction noextract
let size_to_limb (#t:limb_t) (x:size_t) : limb t =
match t with
| U32 -> size_to_uint32 x
| U64 -> size_to_uint64 x
inline_for_extraction noextract
let unsafe_size_from_limb (#t:limb_t) (x:limb t{v x <= max_size_t}) : size_t =
let open Lib.RawIntTypes in
match t with
| U32 -> u32_to_UInt32 x
| U64 -> u32_to_UInt32 (to_u32 x)
inline_for_extraction noextract
val mask_select: #t:limb_t -> mask:limb t -> a:limb t -> b:limb t -> limb t
let mask_select #t mask a b =
(mask &. a) |. ((lognot mask) &. b)
val mask_select_lemma: #t:limb_t -> mask:limb t -> a:limb t -> b:limb t -> Lemma
(requires mask_values mask)
(ensures mask_select mask a b == (if v mask = 0 then b else a))
let mask_select_lemma #t mask a b =
if v mask = 0 then begin
logand_lemma mask a;
assert (v (mask &. a) = 0);
lognot_lemma mask;
assert (v (lognot mask) = v (ones t SEC));
logand_lemma (lognot mask) b;
assert (v ((lognot mask) &. b) == v b);
logor_lemma (mask &. a) ((lognot mask) &. b);
assert (v (mask_select mask a b) == v b) end
else begin
logand_lemma mask a;
assert (v (mask &. a) = v a);
lognot_lemma mask;
assert (v (lognot mask) = 0);
logand_lemma (lognot mask) b;
assert (v ((lognot mask) &. b) == 0);
logor_zeros (mask &. a);
assert (v (mask_select mask a b) == v a) end
val mask_select_lemma1: #t:limb_t -> mask:limb t -> a:limb t -> b:limb t -> Lemma
(requires mask_values mask)
(ensures b ^. (mask &. (a ^. b)) == (if v mask = 0 then b else a))
let mask_select_lemma1 #t mask a b =
let t1 = mask &. (a ^. b) in
let t2 = b ^. t1 in
logand_lemma mask (a ^.b);
if v mask = 0 then begin
assert (v t1 == 0);
logxor_lemma b t1;
assert (v t2 = v b);
() end
else begin
assert (v t1 == v (a ^. b));
logxor_lemma b a;
assert (v t2 = v a);
() end
val lseq_mask_select_lemma: #t:limb_t -> #len:size_nat -> a:lseq (limb t) len -> b:lseq (limb t) len -> mask:limb t -> Lemma
(requires mask_values mask)
(ensures map2 (mask_select mask) a b == (if v mask = 0 then b else a)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Base.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"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
}
] | {
"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"
} | false |
a: Lib.Sequence.lseq (Hacl.Spec.Bignum.Definitions.limb t) len ->
b: Lib.Sequence.lseq (Hacl.Spec.Bignum.Definitions.limb t) len ->
mask: Hacl.Spec.Bignum.Definitions.limb t
-> FStar.Pervasives.Lemma (requires Hacl.Spec.Bignum.Base.mask_values mask)
(ensures
Lib.Sequence.map2 (Hacl.Spec.Bignum.Base.mask_select mask) a b ==
(match Lib.IntTypes.v mask = 0 with
| true -> b
| _ -> a)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Lib.Sequence.lseq",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.op_Equality",
"Prims.int",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Lib.Sequence.eq_intro",
"Lib.IntTypes.int_t",
"Prims.bool",
"Prims.unit",
"FStar.Classical.forall_intro",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.eq2",
"Lib.IntTypes.range_t",
"Lib.Sequence.op_String_Access",
"Prims.l_True",
"Prims.squash",
"Lib.IntTypes.range",
"Lib.Sequence.index",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Hacl.Spec.Bignum.Base.mask_select_lemma",
"Prims.l_Forall",
"Prims.l_imp",
"Hacl.Spec.Bignum.Base.mask_select",
"Lib.Sequence.map2"
] | [] | false | false | true | false | false | let lseq_mask_select_lemma #t #len a b mask =
| let res = map2 (mask_select mask) a b in
let lemma_aux (i: nat{i < len})
: Lemma (v res.[ i ] == (if v mask = 0 then v b.[ i ] else v a.[ i ])) =
mask_select_lemma mask a.[ i ] b.[ i ]
in
Classical.forall_intro lemma_aux;
if v mask = 0 then eq_intro res b else eq_intro res a | false |
Hacl.Spec.Bignum.Base.fst | Hacl.Spec.Bignum.Base.mask_select_lemma1 | val mask_select_lemma1: #t:limb_t -> mask:limb t -> a:limb t -> b:limb t -> Lemma
(requires mask_values mask)
(ensures b ^. (mask &. (a ^. b)) == (if v mask = 0 then b else a)) | val mask_select_lemma1: #t:limb_t -> mask:limb t -> a:limb t -> b:limb t -> Lemma
(requires mask_values mask)
(ensures b ^. (mask &. (a ^. b)) == (if v mask = 0 then b else a)) | let mask_select_lemma1 #t mask a b =
let t1 = mask &. (a ^. b) in
let t2 = b ^. t1 in
logand_lemma mask (a ^.b);
if v mask = 0 then begin
assert (v t1 == 0);
logxor_lemma b t1;
assert (v t2 = v b);
() end
else begin
assert (v t1 == v (a ^. b));
logxor_lemma b a;
assert (v t2 = v a);
() end | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Base.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 219,
"start_col": 0,
"start_line": 206
} | module Hacl.Spec.Bignum.Base
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let carry (t:limb_t) = x:limb t{uint_v x == 0 \/ uint_v x == 1}
(**
This is non-stateful version of code/fallback functions
*)
inline_for_extraction noextract
val addcarry: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r + uint_v c' * pow2 (bits t) == uint_v a + uint_v b + uint_v c)
let addcarry #t cin x y =
let res = x +. cin +. y in
let c = logand (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (lt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res
inline_for_extraction noextract
val subborrow: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r - uint_v c' * pow2 (bits t) == uint_v a - uint_v b - uint_v c)
let subborrow #t cin x y =
let res = x -. y -. cin in
let c = logand (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (gt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res
inline_for_extraction noextract
val mul_wide: #t:limb_t -> a:limb t -> b:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) ->
v lo + v hi * pow2 (bits t) == v a * v b)
let mul_wide #t a b =
Math.Lemmas.lemma_mult_lt_sqr (v a) (v b) (pow2 (bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b in
to_u32 (res >>. 32ul), to_u32 res
| U64 ->
let res = mul64_wide a b in
to_u64 (res >>. 64ul), to_u64 res
val lemma_mul_wide_add: #t:limb_t -> a:limb t -> b:limb t -> c:limb t -> d:limb t ->
Lemma (v a * v b + v c + v d < pow2 (2 * bits t))
let lemma_mul_wide_add #t a b c d =
let n = pow2 (bits t) in
//assert (v a <= n - 1 /\ v b <= n - 1 /\ v c <= n - 1 /\ v d <= n - 1);
Math.Lemmas.lemma_mult_le_left (v a) (v b) (n - 1);
Math.Lemmas.lemma_mult_le_right (n - 1) (v a) (n - 1);
assert (v a * v b + v c + v d <= (n - 1) * (n - 1) + (n - 1) + (n - 1));
assert ((n - 1) * (n - 1) + (n - 1) + (n - 1) == n * n - 1)
val mul_wide_add: #t:limb_t -> a:limb t -> b:limb t -> c:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) -> v lo + v hi * pow2 (bits t) == v a * v b + v c)
let mul_wide_add #t a b c =
lemma_mul_wide_add a b c (uint #t 0);
Math.Lemmas.small_mod (v a * v b + v c) (pow2 (2 * bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b +! to_u64 c in
assert (v res == v a * v b + v c);
let hi = to_u32 (res >>. 32ul) in
assert (v hi == v res / pow2 32);
let lo = to_u32 res in
assert (v lo == v res % pow2 32);
Math.Lemmas.euclidean_division_definition (v res) (pow2 32);
hi, lo
| U64 ->
let res = mul64_wide a b +! to_u128 c in
assert (v res == v a * v b + v c);
let hi = to_u64 (res >>. 64ul) in
assert (v hi == v res / pow2 64);
let lo = to_u64 res in
assert (v lo == v res % pow2 64);
Math.Lemmas.euclidean_division_definition (v res) (pow2 64);
hi, lo
val mul_wide_add2: #t:limb_t -> a:limb t -> b:limb t -> c:limb t -> d:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) -> v lo + v hi * pow2 (bits t) == v a * v b + v c + v d)
let mul_wide_add2 #t a b c d =
lemma_mul_wide_add a b c d;
Math.Lemmas.small_mod (v a * v b + v c + v d) (pow2 (2 * bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b +! to_u64 c +! to_u64 d in
assert (v res == v a * v b + v c + v d);
let hi = to_u32 (res >>. 32ul) in
assert (v hi == v res / pow2 32);
let lo = to_u32 res in
assert (v lo == v res % pow2 32);
Math.Lemmas.euclidean_division_definition (v res) (pow2 32);
hi, lo
| U64 ->
let res = mul64_wide a b +! to_u128 c +! to_u128 d in
assert (v res == v a * v b + v c + v d);
let hi = to_u64 (res >>. 64ul) in
assert (v hi == v res / pow2 64);
let lo = to_u64 res in
assert (v lo == v res % pow2 64);
Math.Lemmas.euclidean_division_definition (v res) (pow2 64);
hi, lo
inline_for_extraction noextract
let mask_values (#t:limb_t) (x:limb t) =
v x = v (zeros t SEC) \/ v x = v (ones t SEC)
inline_for_extraction noextract
let unsafe_bool_of_limb0 (#t:limb_t) (m:limb t) : b:bool{b <==> v m = 0} =
let open Lib.RawIntTypes in
match t with
| U32 -> FStar.UInt32.(u32_to_UInt32 m =^ 0ul)
| U64 -> FStar.UInt64.(u64_to_UInt64 m =^ 0uL)
inline_for_extraction noextract
let unsafe_bool_of_limb (#t:limb_t) (m:limb t) : b:bool{b <==> v m = v (ones t SEC)} =
let open Lib.RawIntTypes in
match t with
| U32 -> FStar.UInt32.(u32_to_UInt32 m =^ u32_to_UInt32 (ones U32 SEC))
| U64 -> FStar.UInt64.(u64_to_UInt64 m =^ u64_to_UInt64 (ones U64 SEC))
inline_for_extraction noextract
let size_to_limb (#t:limb_t) (x:size_t) : limb t =
match t with
| U32 -> size_to_uint32 x
| U64 -> size_to_uint64 x
inline_for_extraction noextract
let unsafe_size_from_limb (#t:limb_t) (x:limb t{v x <= max_size_t}) : size_t =
let open Lib.RawIntTypes in
match t with
| U32 -> u32_to_UInt32 x
| U64 -> u32_to_UInt32 (to_u32 x)
inline_for_extraction noextract
val mask_select: #t:limb_t -> mask:limb t -> a:limb t -> b:limb t -> limb t
let mask_select #t mask a b =
(mask &. a) |. ((lognot mask) &. b)
val mask_select_lemma: #t:limb_t -> mask:limb t -> a:limb t -> b:limb t -> Lemma
(requires mask_values mask)
(ensures mask_select mask a b == (if v mask = 0 then b else a))
let mask_select_lemma #t mask a b =
if v mask = 0 then begin
logand_lemma mask a;
assert (v (mask &. a) = 0);
lognot_lemma mask;
assert (v (lognot mask) = v (ones t SEC));
logand_lemma (lognot mask) b;
assert (v ((lognot mask) &. b) == v b);
logor_lemma (mask &. a) ((lognot mask) &. b);
assert (v (mask_select mask a b) == v b) end
else begin
logand_lemma mask a;
assert (v (mask &. a) = v a);
lognot_lemma mask;
assert (v (lognot mask) = 0);
logand_lemma (lognot mask) b;
assert (v ((lognot mask) &. b) == 0);
logor_zeros (mask &. a);
assert (v (mask_select mask a b) == v a) end
val mask_select_lemma1: #t:limb_t -> mask:limb t -> a:limb t -> b:limb t -> Lemma
(requires mask_values mask)
(ensures b ^. (mask &. (a ^. b)) == (if v mask = 0 then b else a)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Base.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"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
}
] | {
"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"
} | false |
mask: Hacl.Spec.Bignum.Definitions.limb t ->
a: Hacl.Spec.Bignum.Definitions.limb t ->
b: Hacl.Spec.Bignum.Definitions.limb t
-> FStar.Pervasives.Lemma (requires Hacl.Spec.Bignum.Base.mask_values mask)
(ensures
b ^. (mask &. a ^. b) ==
(match Lib.IntTypes.v mask = 0 with
| true -> b
| _ -> a)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.op_Equality",
"Prims.int",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Prims.unit",
"Prims._assert",
"Prims.b2t",
"Lib.IntTypes.range_t",
"Lib.IntTypes.logxor_lemma",
"Prims.eq2",
"Prims.bool",
"Lib.IntTypes.op_Hat_Dot",
"Lib.IntTypes.logand_lemma",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Amp_Dot"
] | [] | false | false | true | false | false | let mask_select_lemma1 #t mask a b =
| let t1 = mask &. (a ^. b) in
let t2 = b ^. t1 in
logand_lemma mask (a ^. b);
if v mask = 0
then
(assert (v t1 == 0);
logxor_lemma b t1;
assert (v t2 = v b);
())
else
(assert (v t1 == v (a ^. b));
logxor_lemma b a;
assert (v t2 = v a);
()) | false |
Hacl.Spec.Bignum.Base.fst | Hacl.Spec.Bignum.Base.lemma_mul_wide_add | val lemma_mul_wide_add: #t:limb_t -> a:limb t -> b:limb t -> c:limb t -> d:limb t ->
Lemma (v a * v b + v c + v d < pow2 (2 * bits t)) | val lemma_mul_wide_add: #t:limb_t -> a:limb t -> b:limb t -> c:limb t -> d:limb t ->
Lemma (v a * v b + v c + v d < pow2 (2 * bits t)) | let lemma_mul_wide_add #t a b c d =
let n = pow2 (bits t) in
//assert (v a <= n - 1 /\ v b <= n - 1 /\ v c <= n - 1 /\ v d <= n - 1);
Math.Lemmas.lemma_mult_le_left (v a) (v b) (n - 1);
Math.Lemmas.lemma_mult_le_right (n - 1) (v a) (n - 1);
assert (v a * v b + v c + v d <= (n - 1) * (n - 1) + (n - 1) + (n - 1));
assert ((n - 1) * (n - 1) + (n - 1) + (n - 1) == n * n - 1) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Base.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 61,
"end_line": 75,
"start_col": 0,
"start_line": 69
} | module Hacl.Spec.Bignum.Base
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let carry (t:limb_t) = x:limb t{uint_v x == 0 \/ uint_v x == 1}
(**
This is non-stateful version of code/fallback functions
*)
inline_for_extraction noextract
val addcarry: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r + uint_v c' * pow2 (bits t) == uint_v a + uint_v b + uint_v c)
let addcarry #t cin x y =
let res = x +. cin +. y in
let c = logand (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (lt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res
inline_for_extraction noextract
val subborrow: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r - uint_v c' * pow2 (bits t) == uint_v a - uint_v b - uint_v c)
let subborrow #t cin x y =
let res = x -. y -. cin in
let c = logand (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (gt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res
inline_for_extraction noextract
val mul_wide: #t:limb_t -> a:limb t -> b:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) ->
v lo + v hi * pow2 (bits t) == v a * v b)
let mul_wide #t a b =
Math.Lemmas.lemma_mult_lt_sqr (v a) (v b) (pow2 (bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b in
to_u32 (res >>. 32ul), to_u32 res
| U64 ->
let res = mul64_wide a b in
to_u64 (res >>. 64ul), to_u64 res
val lemma_mul_wide_add: #t:limb_t -> a:limb t -> b:limb t -> c:limb t -> d:limb t -> | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Base.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"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
}
] | {
"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"
} | false |
a: Hacl.Spec.Bignum.Definitions.limb t ->
b: Hacl.Spec.Bignum.Definitions.limb t ->
c: Hacl.Spec.Bignum.Definitions.limb t ->
d: Hacl.Spec.Bignum.Definitions.limb t
-> FStar.Pervasives.Lemma
(ensures
Lib.IntTypes.v a * Lib.IntTypes.v b + Lib.IntTypes.v c + Lib.IntTypes.v d <
Prims.pow2 (2 * Lib.IntTypes.bits t)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"FStar.Math.Lemmas.lemma_mult_le_right",
"FStar.Math.Lemmas.lemma_mult_le_left",
"Prims.pos",
"Prims.pow2",
"Lib.IntTypes.bits"
] | [] | true | false | true | false | false | let lemma_mul_wide_add #t a b c d =
| let n = pow2 (bits t) in
Math.Lemmas.lemma_mult_le_left (v a) (v b) (n - 1);
Math.Lemmas.lemma_mult_le_right (n - 1) (v a) (n - 1);
assert (v a * v b + v c + v d <= (n - 1) * (n - 1) + (n - 1) + (n - 1));
assert ((n - 1) * (n - 1) + (n - 1) + (n - 1) == n * n - 1) | false |
Hacl.Spec.Bignum.Base.fst | Hacl.Spec.Bignum.Base.mul_wide | val mul_wide: #t:limb_t -> a:limb t -> b:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) ->
v lo + v hi * pow2 (bits t) == v a * v b) | val mul_wide: #t:limb_t -> a:limb t -> b:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) ->
v lo + v hi * pow2 (bits t) == v a * v b) | let mul_wide #t a b =
Math.Lemmas.lemma_mult_lt_sqr (v a) (v b) (pow2 (bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b in
to_u32 (res >>. 32ul), to_u32 res
| U64 ->
let res = mul64_wide a b in
to_u64 (res >>. 64ul), to_u64 res | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Base.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 37,
"end_line": 64,
"start_col": 0,
"start_line": 56
} | module Hacl.Spec.Bignum.Base
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let carry (t:limb_t) = x:limb t{uint_v x == 0 \/ uint_v x == 1}
(**
This is non-stateful version of code/fallback functions
*)
inline_for_extraction noextract
val addcarry: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r + uint_v c' * pow2 (bits t) == uint_v a + uint_v b + uint_v c)
let addcarry #t cin x y =
let res = x +. cin +. y in
let c = logand (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (lt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res
inline_for_extraction noextract
val subborrow: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r - uint_v c' * pow2 (bits t) == uint_v a - uint_v b - uint_v c)
let subborrow #t cin x y =
let res = x -. y -. cin in
let c = logand (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (gt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res
inline_for_extraction noextract
val mul_wide: #t:limb_t -> a:limb t -> b:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) ->
v lo + v hi * pow2 (bits t) == v a * v b) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Base.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"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
}
] | {
"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"
} | false | a: Hacl.Spec.Bignum.Definitions.limb t -> b: Hacl.Spec.Bignum.Definitions.limb t
-> Prims.Pure (Hacl.Spec.Bignum.Definitions.limb t * Hacl.Spec.Bignum.Definitions.limb t) | Prims.Pure | [] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Definitions.limb",
"FStar.Pervasives.Native.Mktuple2",
"Lib.IntTypes.to_u32",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Lib.IntTypes.op_Greater_Greater_Dot",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Star_Bang",
"Lib.IntTypes.to_u64",
"Lib.IntTypes.U128",
"Lib.IntTypes.mul64_wide",
"FStar.Pervasives.Native.tuple2",
"Prims.unit",
"FStar.Math.Lemmas.lemma_mult_lt_sqr",
"Lib.IntTypes.v",
"Prims.pow2",
"Lib.IntTypes.bits"
] | [] | false | false | false | false | false | let mul_wide #t a b =
| Math.Lemmas.lemma_mult_lt_sqr (v a) (v b) (pow2 (bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b in
to_u32 (res >>. 32ul), to_u32 res
| U64 ->
let res = mul64_wide a b in
to_u64 (res >>. 64ul), to_u64 res | false |
Hacl.Spec.Bignum.Base.fst | Hacl.Spec.Bignum.Base.addcarry | val addcarry: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r + uint_v c' * pow2 (bits t) == uint_v a + uint_v b + uint_v c) | val addcarry: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r + uint_v c' * pow2 (bits t) == uint_v a + uint_v b + uint_v c) | let addcarry #t cin x y =
let res = x +. cin +. y in
let c = logand (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (lt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Base.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 8,
"end_line": 30,
"start_col": 0,
"start_line": 24
} | module Hacl.Spec.Bignum.Base
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let carry (t:limb_t) = x:limb t{uint_v x == 0 \/ uint_v x == 1}
(**
This is non-stateful version of code/fallback functions
*)
inline_for_extraction noextract
val addcarry: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r + uint_v c' * pow2 (bits t) == uint_v a + uint_v b + uint_v c) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Base.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"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
}
] | {
"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"
} | false |
c: Hacl.Spec.Bignum.Base.carry t ->
a: Hacl.Spec.Bignum.Definitions.limb t ->
b: Hacl.Spec.Bignum.Definitions.limb t
-> Prims.Pure (Hacl.Spec.Bignum.Base.carry t * Hacl.Spec.Bignum.Definitions.limb t) | Prims.Pure | [] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Base.carry",
"Hacl.Spec.Bignum.Definitions.limb",
"FStar.Pervasives.Native.Mktuple2",
"Prims.unit",
"Lib.IntTypes.logand_mask",
"Lib.IntTypes.SEC",
"Lib.IntTypes.logor",
"Lib.IntTypes.lt_mask",
"Lib.IntTypes.logand",
"Lib.IntTypes.eq_mask",
"Lib.IntTypes.uint",
"Lib.IntTypes.logor_lemma",
"Lib.IntTypes.logand_lemma",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Plus_Dot",
"FStar.Pervasives.Native.tuple2"
] | [] | false | false | false | false | false | let addcarry #t cin x y =
| let res = x +. cin +. y in
let c = logand (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (lt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res | false |
Hacl.Spec.Bignum.Base.fst | Hacl.Spec.Bignum.Base.mul_wide_add | val mul_wide_add: #t:limb_t -> a:limb t -> b:limb t -> c:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) -> v lo + v hi * pow2 (bits t) == v a * v b + v c) | val mul_wide_add: #t:limb_t -> a:limb t -> b:limb t -> c:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) -> v lo + v hi * pow2 (bits t) == v a * v b + v c) | let mul_wide_add #t a b c =
lemma_mul_wide_add a b c (uint #t 0);
Math.Lemmas.small_mod (v a * v b + v c) (pow2 (2 * bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b +! to_u64 c in
assert (v res == v a * v b + v c);
let hi = to_u32 (res >>. 32ul) in
assert (v hi == v res / pow2 32);
let lo = to_u32 res in
assert (v lo == v res % pow2 32);
Math.Lemmas.euclidean_division_definition (v res) (pow2 32);
hi, lo
| U64 ->
let res = mul64_wide a b +! to_u128 c in
assert (v res == v a * v b + v c);
let hi = to_u64 (res >>. 64ul) in
assert (v hi == v res / pow2 64);
let lo = to_u64 res in
assert (v lo == v res % pow2 64);
Math.Lemmas.euclidean_division_definition (v res) (pow2 64);
hi, lo | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Base.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 104,
"start_col": 0,
"start_line": 83
} | module Hacl.Spec.Bignum.Base
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let carry (t:limb_t) = x:limb t{uint_v x == 0 \/ uint_v x == 1}
(**
This is non-stateful version of code/fallback functions
*)
inline_for_extraction noextract
val addcarry: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r + uint_v c' * pow2 (bits t) == uint_v a + uint_v b + uint_v c)
let addcarry #t cin x y =
let res = x +. cin +. y in
let c = logand (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (lt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res
inline_for_extraction noextract
val subborrow: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r - uint_v c' * pow2 (bits t) == uint_v a - uint_v b - uint_v c)
let subborrow #t cin x y =
let res = x -. y -. cin in
let c = logand (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (gt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res
inline_for_extraction noextract
val mul_wide: #t:limb_t -> a:limb t -> b:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) ->
v lo + v hi * pow2 (bits t) == v a * v b)
let mul_wide #t a b =
Math.Lemmas.lemma_mult_lt_sqr (v a) (v b) (pow2 (bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b in
to_u32 (res >>. 32ul), to_u32 res
| U64 ->
let res = mul64_wide a b in
to_u64 (res >>. 64ul), to_u64 res
val lemma_mul_wide_add: #t:limb_t -> a:limb t -> b:limb t -> c:limb t -> d:limb t ->
Lemma (v a * v b + v c + v d < pow2 (2 * bits t))
let lemma_mul_wide_add #t a b c d =
let n = pow2 (bits t) in
//assert (v a <= n - 1 /\ v b <= n - 1 /\ v c <= n - 1 /\ v d <= n - 1);
Math.Lemmas.lemma_mult_le_left (v a) (v b) (n - 1);
Math.Lemmas.lemma_mult_le_right (n - 1) (v a) (n - 1);
assert (v a * v b + v c + v d <= (n - 1) * (n - 1) + (n - 1) + (n - 1));
assert ((n - 1) * (n - 1) + (n - 1) + (n - 1) == n * n - 1)
val mul_wide_add: #t:limb_t -> a:limb t -> b:limb t -> c:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) -> v lo + v hi * pow2 (bits t) == v a * v b + v c) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Base.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"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
}
] | {
"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"
} | false |
a: Hacl.Spec.Bignum.Definitions.limb t ->
b: Hacl.Spec.Bignum.Definitions.limb t ->
c: Hacl.Spec.Bignum.Definitions.limb t
-> Prims.Pure (Hacl.Spec.Bignum.Definitions.limb t * Hacl.Spec.Bignum.Definitions.limb t) | Prims.Pure | [] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Definitions.limb",
"FStar.Pervasives.Native.Mktuple2",
"Prims.unit",
"FStar.Math.Lemmas.euclidean_division_definition",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.pow2",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Lib.IntTypes.U32",
"Prims.op_Modulus",
"Lib.IntTypes.int_t",
"Lib.IntTypes.to_u32",
"Prims.op_Division",
"Lib.IntTypes.op_Greater_Greater_Dot",
"FStar.UInt32.__uint_to_t",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Lib.IntTypes.op_Plus_Bang",
"Lib.IntTypes.op_Star_Bang",
"Lib.IntTypes.to_u64",
"Lib.IntTypes.U128",
"Lib.IntTypes.mul64_wide",
"Lib.IntTypes.to_u128",
"FStar.Pervasives.Native.tuple2",
"FStar.Math.Lemmas.small_mod",
"Lib.IntTypes.bits",
"Hacl.Spec.Bignum.Base.lemma_mul_wide_add",
"Lib.IntTypes.uint"
] | [] | false | false | false | false | false | let mul_wide_add #t a b c =
| lemma_mul_wide_add a b c (uint #t 0);
Math.Lemmas.small_mod (v a * v b + v c) (pow2 (2 * bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b +! to_u64 c in
assert (v res == v a * v b + v c);
let hi = to_u32 (res >>. 32ul) in
assert (v hi == v res / pow2 32);
let lo = to_u32 res in
assert (v lo == v res % pow2 32);
Math.Lemmas.euclidean_division_definition (v res) (pow2 32);
hi, lo
| U64 ->
let res = mul64_wide a b +! to_u128 c in
assert (v res == v a * v b + v c);
let hi = to_u64 (res >>. 64ul) in
assert (v hi == v res / pow2 64);
let lo = to_u64 res in
assert (v lo == v res % pow2 64);
Math.Lemmas.euclidean_division_definition (v res) (pow2 64);
hi, lo | false |
Hacl.Spec.Bignum.Base.fst | Hacl.Spec.Bignum.Base.subborrow | val subborrow: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r - uint_v c' * pow2 (bits t) == uint_v a - uint_v b - uint_v c) | val subborrow: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r - uint_v c' * pow2 (bits t) == uint_v a - uint_v b - uint_v c) | let subborrow #t cin x y =
let res = x -. y -. cin in
let c = logand (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (gt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Base.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 8,
"end_line": 46,
"start_col": 0,
"start_line": 40
} | module Hacl.Spec.Bignum.Base
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let carry (t:limb_t) = x:limb t{uint_v x == 0 \/ uint_v x == 1}
(**
This is non-stateful version of code/fallback functions
*)
inline_for_extraction noextract
val addcarry: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r + uint_v c' * pow2 (bits t) == uint_v a + uint_v b + uint_v c)
let addcarry #t cin x y =
let res = x +. cin +. y in
let c = logand (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (lt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res
inline_for_extraction noextract
val subborrow: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r - uint_v c' * pow2 (bits t) == uint_v a - uint_v b - uint_v c) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Base.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"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
}
] | {
"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"
} | false |
c: Hacl.Spec.Bignum.Base.carry t ->
a: Hacl.Spec.Bignum.Definitions.limb t ->
b: Hacl.Spec.Bignum.Definitions.limb t
-> Prims.Pure (Hacl.Spec.Bignum.Base.carry t * Hacl.Spec.Bignum.Definitions.limb t) | Prims.Pure | [] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Base.carry",
"Hacl.Spec.Bignum.Definitions.limb",
"FStar.Pervasives.Native.Mktuple2",
"Prims.unit",
"Lib.IntTypes.logand_mask",
"Lib.IntTypes.SEC",
"Lib.IntTypes.logor",
"Lib.IntTypes.gt_mask",
"Lib.IntTypes.logand",
"Lib.IntTypes.eq_mask",
"Lib.IntTypes.uint",
"Lib.IntTypes.logor_lemma",
"Lib.IntTypes.logand_lemma",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Subtraction_Dot",
"FStar.Pervasives.Native.tuple2"
] | [] | false | false | false | false | false | let subborrow #t cin x y =
| let res = x -. y -. cin in
let c = logand (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (gt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res | false |
Hacl.Spec.Bignum.Base.fst | Hacl.Spec.Bignum.Base.mul_wide_add2 | val mul_wide_add2: #t:limb_t -> a:limb t -> b:limb t -> c:limb t -> d:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) -> v lo + v hi * pow2 (bits t) == v a * v b + v c + v d) | val mul_wide_add2: #t:limb_t -> a:limb t -> b:limb t -> c:limb t -> d:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) -> v lo + v hi * pow2 (bits t) == v a * v b + v c + v d) | let mul_wide_add2 #t a b c d =
lemma_mul_wide_add a b c d;
Math.Lemmas.small_mod (v a * v b + v c + v d) (pow2 (2 * bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b +! to_u64 c +! to_u64 d in
assert (v res == v a * v b + v c + v d);
let hi = to_u32 (res >>. 32ul) in
assert (v hi == v res / pow2 32);
let lo = to_u32 res in
assert (v lo == v res % pow2 32);
Math.Lemmas.euclidean_division_definition (v res) (pow2 32);
hi, lo
| U64 ->
let res = mul64_wide a b +! to_u128 c +! to_u128 d in
assert (v res == v a * v b + v c + v d);
let hi = to_u64 (res >>. 64ul) in
assert (v hi == v res / pow2 64);
let lo = to_u64 res in
assert (v lo == v res % pow2 64);
Math.Lemmas.euclidean_division_definition (v res) (pow2 64);
hi, lo | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Base.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 133,
"start_col": 0,
"start_line": 112
} | module Hacl.Spec.Bignum.Base
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let carry (t:limb_t) = x:limb t{uint_v x == 0 \/ uint_v x == 1}
(**
This is non-stateful version of code/fallback functions
*)
inline_for_extraction noextract
val addcarry: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r + uint_v c' * pow2 (bits t) == uint_v a + uint_v b + uint_v c)
let addcarry #t cin x y =
let res = x +. cin +. y in
let c = logand (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (lt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (lt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res
inline_for_extraction noextract
val subborrow: #t:limb_t -> c:carry t -> a:limb t -> b:limb t ->
Pure (carry t & limb t)
(requires True)
(ensures fun (c', r) ->
uint_v r - uint_v c' * pow2 (bits t) == uint_v a - uint_v b - uint_v c)
let subborrow #t cin x y =
let res = x -. y -. cin in
let c = logand (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) in
logand_lemma (eq_mask res x) cin;
logor_lemma (gt_mask res x) (logand (eq_mask res x) cin);
logand_mask (logor (gt_mask res x) (logand (eq_mask res x) cin)) (uint #t 1) 1;
c, res
inline_for_extraction noextract
val mul_wide: #t:limb_t -> a:limb t -> b:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) ->
v lo + v hi * pow2 (bits t) == v a * v b)
let mul_wide #t a b =
Math.Lemmas.lemma_mult_lt_sqr (v a) (v b) (pow2 (bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b in
to_u32 (res >>. 32ul), to_u32 res
| U64 ->
let res = mul64_wide a b in
to_u64 (res >>. 64ul), to_u64 res
val lemma_mul_wide_add: #t:limb_t -> a:limb t -> b:limb t -> c:limb t -> d:limb t ->
Lemma (v a * v b + v c + v d < pow2 (2 * bits t))
let lemma_mul_wide_add #t a b c d =
let n = pow2 (bits t) in
//assert (v a <= n - 1 /\ v b <= n - 1 /\ v c <= n - 1 /\ v d <= n - 1);
Math.Lemmas.lemma_mult_le_left (v a) (v b) (n - 1);
Math.Lemmas.lemma_mult_le_right (n - 1) (v a) (n - 1);
assert (v a * v b + v c + v d <= (n - 1) * (n - 1) + (n - 1) + (n - 1));
assert ((n - 1) * (n - 1) + (n - 1) + (n - 1) == n * n - 1)
val mul_wide_add: #t:limb_t -> a:limb t -> b:limb t -> c:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) -> v lo + v hi * pow2 (bits t) == v a * v b + v c)
let mul_wide_add #t a b c =
lemma_mul_wide_add a b c (uint #t 0);
Math.Lemmas.small_mod (v a * v b + v c) (pow2 (2 * bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b +! to_u64 c in
assert (v res == v a * v b + v c);
let hi = to_u32 (res >>. 32ul) in
assert (v hi == v res / pow2 32);
let lo = to_u32 res in
assert (v lo == v res % pow2 32);
Math.Lemmas.euclidean_division_definition (v res) (pow2 32);
hi, lo
| U64 ->
let res = mul64_wide a b +! to_u128 c in
assert (v res == v a * v b + v c);
let hi = to_u64 (res >>. 64ul) in
assert (v hi == v res / pow2 64);
let lo = to_u64 res in
assert (v lo == v res % pow2 64);
Math.Lemmas.euclidean_division_definition (v res) (pow2 64);
hi, lo
val mul_wide_add2: #t:limb_t -> a:limb t -> b:limb t -> c:limb t -> d:limb t ->
Pure (tuple2 (limb t) (limb t))
(requires True)
(ensures fun (hi, lo) -> v lo + v hi * pow2 (bits t) == v a * v b + v c + v d) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Base.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"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
}
] | {
"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"
} | false |
a: Hacl.Spec.Bignum.Definitions.limb t ->
b: Hacl.Spec.Bignum.Definitions.limb t ->
c: Hacl.Spec.Bignum.Definitions.limb t ->
d: Hacl.Spec.Bignum.Definitions.limb t
-> Prims.Pure (Hacl.Spec.Bignum.Definitions.limb t * Hacl.Spec.Bignum.Definitions.limb t) | Prims.Pure | [] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Definitions.limb",
"FStar.Pervasives.Native.Mktuple2",
"Prims.unit",
"FStar.Math.Lemmas.euclidean_division_definition",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.pow2",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Lib.IntTypes.U32",
"Prims.op_Modulus",
"Lib.IntTypes.int_t",
"Lib.IntTypes.to_u32",
"Prims.op_Division",
"Lib.IntTypes.op_Greater_Greater_Dot",
"FStar.UInt32.__uint_to_t",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Lib.IntTypes.op_Plus_Bang",
"Lib.IntTypes.op_Star_Bang",
"Lib.IntTypes.to_u64",
"Lib.IntTypes.U128",
"Lib.IntTypes.mul64_wide",
"Lib.IntTypes.to_u128",
"FStar.Pervasives.Native.tuple2",
"FStar.Math.Lemmas.small_mod",
"Lib.IntTypes.bits",
"Hacl.Spec.Bignum.Base.lemma_mul_wide_add"
] | [] | false | false | false | false | false | let mul_wide_add2 #t a b c d =
| lemma_mul_wide_add a b c d;
Math.Lemmas.small_mod (v a * v b + v c + v d) (pow2 (2 * bits t));
match t with
| U32 ->
let res = to_u64 a *! to_u64 b +! to_u64 c +! to_u64 d in
assert (v res == v a * v b + v c + v d);
let hi = to_u32 (res >>. 32ul) in
assert (v hi == v res / pow2 32);
let lo = to_u32 res in
assert (v lo == v res % pow2 32);
Math.Lemmas.euclidean_division_definition (v res) (pow2 32);
hi, lo
| U64 ->
let res = mul64_wide a b +! to_u128 c +! to_u128 d in
assert (v res == v a * v b + v c + v d);
let hi = to_u64 (res >>. 64ul) in
assert (v hi == v res / pow2 64);
let lo = to_u64 res in
assert (v lo == v res % pow2 64);
Math.Lemmas.euclidean_division_definition (v res) (pow2 64);
hi, lo | false |
Spec.Ed25519.Test.fst | Spec.Ed25519.Test.test1_msg | val test1_msg:lbytes 0 | val test1_msg:lbytes 0 | let test1_msg : lbytes 0 =
let l = List.Tot.map u8_from_UInt8 [] in
assert_norm (List.Tot.length l == 0);
of_list l | {
"file_name": "specs/tests/Spec.Ed25519.Test.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 41,
"start_col": 0,
"start_line": 38
} | module Spec.Ed25519.Test
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module PS = Lib.PrintSequence
open Spec.Ed25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Test 1
let test1_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x9duy; 0x61uy; 0xb1uy; 0x9duy; 0xefuy; 0xfduy; 0x5auy; 0x60uy;
0xbauy; 0x84uy; 0x4auy; 0xf4uy; 0x92uy; 0xecuy; 0x2cuy; 0xc4uy;
0x44uy; 0x49uy; 0xc5uy; 0x69uy; 0x7buy; 0x32uy; 0x69uy; 0x19uy;
0x70uy; 0x3buy; 0xacuy; 0x03uy; 0x1cuy; 0xaeuy; 0x7fuy; 0x60uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xd7uy; 0x5auy; 0x98uy; 0x01uy; 0x82uy; 0xb1uy; 0x0auy; 0xb7uy;
0xd5uy; 0x4buy; 0xfeuy; 0xd3uy; 0xc9uy; 0x64uy; 0x07uy; 0x3auy;
0x0euy; 0xe1uy; 0x72uy; 0xf3uy; 0xdauy; 0xa6uy; 0x23uy; 0x25uy;
0xafuy; 0x02uy; 0x1auy; 0x68uy; 0xf7uy; 0x07uy; 0x51uy; 0x1auy
] in
assert_norm (List.Tot.length l == 32);
of_list l | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.PrintSequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Ed25519.Test.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.PrintSequence",
"short_module": "PS"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"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": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"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
}
] | {
"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"
} | false | Lib.Sequence.lseq (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.SEC) 0 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.of_list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.list",
"FStar.List.Tot.Base.map",
"FStar.UInt8.t",
"Lib.RawIntTypes.u8_from_UInt8",
"Prims.Nil"
] | [] | false | false | false | false | false | let test1_msg:lbytes 0 =
| let l = List.Tot.map u8_from_UInt8 [] in
assert_norm (List.Tot.length l == 0);
of_list l | false |
Spec.Ed25519.Test.fst | Spec.Ed25519.Test.test1_sk | val test1_sk:lbytes 32 | val test1_sk:lbytes 32 | let test1_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x9duy; 0x61uy; 0xb1uy; 0x9duy; 0xefuy; 0xfduy; 0x5auy; 0x60uy;
0xbauy; 0x84uy; 0x4auy; 0xf4uy; 0x92uy; 0xecuy; 0x2cuy; 0xc4uy;
0x44uy; 0x49uy; 0xc5uy; 0x69uy; 0x7buy; 0x32uy; 0x69uy; 0x19uy;
0x70uy; 0x3buy; 0xacuy; 0x03uy; 0x1cuy; 0xaeuy; 0x7fuy; 0x60uy
] in
assert_norm (List.Tot.length l == 32);
of_list l | {
"file_name": "specs/tests/Spec.Ed25519.Test.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 24,
"start_col": 0,
"start_line": 16
} | module Spec.Ed25519.Test
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module PS = Lib.PrintSequence
open Spec.Ed25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Test 1 | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.PrintSequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Ed25519.Test.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.PrintSequence",
"short_module": "PS"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"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": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"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
}
] | {
"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"
} | false | Lib.Sequence.lseq (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.SEC) 32 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.of_list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.list",
"FStar.List.Tot.Base.map",
"FStar.UInt8.t",
"Lib.RawIntTypes.u8_from_UInt8",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | false | false | false | false | false | let test1_sk:lbytes 32 =
| let l =
List.Tot.map u8_from_UInt8
[
0x9duy; 0x61uy; 0xb1uy; 0x9duy; 0xefuy; 0xfduy; 0x5auy; 0x60uy; 0xbauy; 0x84uy; 0x4auy; 0xf4uy;
0x92uy; 0xecuy; 0x2cuy; 0xc4uy; 0x44uy; 0x49uy; 0xc5uy; 0x69uy; 0x7buy; 0x32uy; 0x69uy; 0x19uy;
0x70uy; 0x3buy; 0xacuy; 0x03uy; 0x1cuy; 0xaeuy; 0x7fuy; 0x60uy
]
in
assert_norm (List.Tot.length l == 32);
of_list l | false |
Spec.Ed25519.Test.fst | Spec.Ed25519.Test.test2_msg | val test2_msg:lbytes 1 | val test2_msg:lbytes 1 | let test2_msg : lbytes 1 =
let l = List.Tot.map u8_from_UInt8 [ 0x72uy ] in
assert_norm (List.Tot.length l == 1);
of_list l | {
"file_name": "specs/tests/Spec.Ed25519.Test.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 86,
"start_col": 0,
"start_line": 83
} | module Spec.Ed25519.Test
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module PS = Lib.PrintSequence
open Spec.Ed25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Test 1
let test1_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x9duy; 0x61uy; 0xb1uy; 0x9duy; 0xefuy; 0xfduy; 0x5auy; 0x60uy;
0xbauy; 0x84uy; 0x4auy; 0xf4uy; 0x92uy; 0xecuy; 0x2cuy; 0xc4uy;
0x44uy; 0x49uy; 0xc5uy; 0x69uy; 0x7buy; 0x32uy; 0x69uy; 0x19uy;
0x70uy; 0x3buy; 0xacuy; 0x03uy; 0x1cuy; 0xaeuy; 0x7fuy; 0x60uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xd7uy; 0x5auy; 0x98uy; 0x01uy; 0x82uy; 0xb1uy; 0x0auy; 0xb7uy;
0xd5uy; 0x4buy; 0xfeuy; 0xd3uy; 0xc9uy; 0x64uy; 0x07uy; 0x3auy;
0x0euy; 0xe1uy; 0x72uy; 0xf3uy; 0xdauy; 0xa6uy; 0x23uy; 0x25uy;
0xafuy; 0x02uy; 0x1auy; 0x68uy; 0xf7uy; 0x07uy; 0x51uy; 0x1auy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_msg : lbytes 0 =
let l = List.Tot.map u8_from_UInt8 [] in
assert_norm (List.Tot.length l == 0);
of_list l
let test1_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0xe5uy; 0x56uy; 0x43uy; 0x00uy; 0xc3uy; 0x60uy; 0xacuy; 0x72uy;
0x90uy; 0x86uy; 0xe2uy; 0xccuy; 0x80uy; 0x6euy; 0x82uy; 0x8auy;
0x84uy; 0x87uy; 0x7fuy; 0x1euy; 0xb8uy; 0xe5uy; 0xd9uy; 0x74uy;
0xd8uy; 0x73uy; 0xe0uy; 0x65uy; 0x22uy; 0x49uy; 0x01uy; 0x55uy;
0x5fuy; 0xb8uy; 0x82uy; 0x15uy; 0x90uy; 0xa3uy; 0x3buy; 0xacuy;
0xc6uy; 0x1euy; 0x39uy; 0x70uy; 0x1cuy; 0xf9uy; 0xb4uy; 0x6buy;
0xd2uy; 0x5buy; 0xf5uy; 0xf0uy; 0x59uy; 0x5buy; 0xbeuy; 0x24uy;
0x65uy; 0x51uy; 0x41uy; 0x43uy; 0x8euy; 0x7auy; 0x10uy; 0x0buy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 2
let test2_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x4cuy; 0xcduy; 0x08uy; 0x9buy; 0x28uy; 0xffuy; 0x96uy; 0xdauy;
0x9duy; 0xb6uy; 0xc3uy; 0x46uy; 0xecuy; 0x11uy; 0x4euy; 0x0fuy;
0x5buy; 0x8auy; 0x31uy; 0x9fuy; 0x35uy; 0xabuy; 0xa6uy; 0x24uy;
0xdauy; 0x8cuy; 0xf6uy; 0xeduy; 0x4fuy; 0xb8uy; 0xa6uy; 0xfbuy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test2_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x3duy; 0x40uy; 0x17uy; 0xc3uy; 0xe8uy; 0x43uy; 0x89uy; 0x5auy;
0x92uy; 0xb7uy; 0x0auy; 0xa7uy; 0x4duy; 0x1buy; 0x7euy; 0xbcuy;
0x9cuy; 0x98uy; 0x2cuy; 0xcfuy; 0x2euy; 0xc4uy; 0x96uy; 0x8cuy;
0xc0uy; 0xcduy; 0x55uy; 0xf1uy; 0x2auy; 0xf4uy; 0x66uy; 0x0cuy
] in
assert_norm (List.Tot.length l == 32);
of_list l | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.PrintSequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Ed25519.Test.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.PrintSequence",
"short_module": "PS"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"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": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"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
}
] | {
"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"
} | false | Lib.Sequence.lseq (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.SEC) 1 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.of_list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.list",
"FStar.List.Tot.Base.map",
"FStar.UInt8.t",
"Lib.RawIntTypes.u8_from_UInt8",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | false | false | false | false | false | let test2_msg:lbytes 1 =
| let l = List.Tot.map u8_from_UInt8 [0x72uy] in
assert_norm (List.Tot.length l == 1);
of_list l | false |
Spec.Ed25519.Test.fst | Spec.Ed25519.Test.test2_pk | val test2_pk:lbytes 32 | val test2_pk:lbytes 32 | let test2_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x3duy; 0x40uy; 0x17uy; 0xc3uy; 0xe8uy; 0x43uy; 0x89uy; 0x5auy;
0x92uy; 0xb7uy; 0x0auy; 0xa7uy; 0x4duy; 0x1buy; 0x7euy; 0xbcuy;
0x9cuy; 0x98uy; 0x2cuy; 0xcfuy; 0x2euy; 0xc4uy; 0x96uy; 0x8cuy;
0xc0uy; 0xcduy; 0x55uy; 0xf1uy; 0x2auy; 0xf4uy; 0x66uy; 0x0cuy
] in
assert_norm (List.Tot.length l == 32);
of_list l | {
"file_name": "specs/tests/Spec.Ed25519.Test.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 80,
"start_col": 0,
"start_line": 72
} | module Spec.Ed25519.Test
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module PS = Lib.PrintSequence
open Spec.Ed25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Test 1
let test1_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x9duy; 0x61uy; 0xb1uy; 0x9duy; 0xefuy; 0xfduy; 0x5auy; 0x60uy;
0xbauy; 0x84uy; 0x4auy; 0xf4uy; 0x92uy; 0xecuy; 0x2cuy; 0xc4uy;
0x44uy; 0x49uy; 0xc5uy; 0x69uy; 0x7buy; 0x32uy; 0x69uy; 0x19uy;
0x70uy; 0x3buy; 0xacuy; 0x03uy; 0x1cuy; 0xaeuy; 0x7fuy; 0x60uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xd7uy; 0x5auy; 0x98uy; 0x01uy; 0x82uy; 0xb1uy; 0x0auy; 0xb7uy;
0xd5uy; 0x4buy; 0xfeuy; 0xd3uy; 0xc9uy; 0x64uy; 0x07uy; 0x3auy;
0x0euy; 0xe1uy; 0x72uy; 0xf3uy; 0xdauy; 0xa6uy; 0x23uy; 0x25uy;
0xafuy; 0x02uy; 0x1auy; 0x68uy; 0xf7uy; 0x07uy; 0x51uy; 0x1auy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_msg : lbytes 0 =
let l = List.Tot.map u8_from_UInt8 [] in
assert_norm (List.Tot.length l == 0);
of_list l
let test1_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0xe5uy; 0x56uy; 0x43uy; 0x00uy; 0xc3uy; 0x60uy; 0xacuy; 0x72uy;
0x90uy; 0x86uy; 0xe2uy; 0xccuy; 0x80uy; 0x6euy; 0x82uy; 0x8auy;
0x84uy; 0x87uy; 0x7fuy; 0x1euy; 0xb8uy; 0xe5uy; 0xd9uy; 0x74uy;
0xd8uy; 0x73uy; 0xe0uy; 0x65uy; 0x22uy; 0x49uy; 0x01uy; 0x55uy;
0x5fuy; 0xb8uy; 0x82uy; 0x15uy; 0x90uy; 0xa3uy; 0x3buy; 0xacuy;
0xc6uy; 0x1euy; 0x39uy; 0x70uy; 0x1cuy; 0xf9uy; 0xb4uy; 0x6buy;
0xd2uy; 0x5buy; 0xf5uy; 0xf0uy; 0x59uy; 0x5buy; 0xbeuy; 0x24uy;
0x65uy; 0x51uy; 0x41uy; 0x43uy; 0x8euy; 0x7auy; 0x10uy; 0x0buy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 2
let test2_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x4cuy; 0xcduy; 0x08uy; 0x9buy; 0x28uy; 0xffuy; 0x96uy; 0xdauy;
0x9duy; 0xb6uy; 0xc3uy; 0x46uy; 0xecuy; 0x11uy; 0x4euy; 0x0fuy;
0x5buy; 0x8auy; 0x31uy; 0x9fuy; 0x35uy; 0xabuy; 0xa6uy; 0x24uy;
0xdauy; 0x8cuy; 0xf6uy; 0xeduy; 0x4fuy; 0xb8uy; 0xa6uy; 0xfbuy
] in
assert_norm (List.Tot.length l == 32);
of_list l | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.PrintSequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Ed25519.Test.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.PrintSequence",
"short_module": "PS"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"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": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"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
}
] | {
"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"
} | false | Lib.Sequence.lseq (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.SEC) 32 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.of_list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.list",
"FStar.List.Tot.Base.map",
"FStar.UInt8.t",
"Lib.RawIntTypes.u8_from_UInt8",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | false | false | false | false | false | let test2_pk:lbytes 32 =
| let l =
List.Tot.map u8_from_UInt8
[
0x3duy; 0x40uy; 0x17uy; 0xc3uy; 0xe8uy; 0x43uy; 0x89uy; 0x5auy; 0x92uy; 0xb7uy; 0x0auy; 0xa7uy;
0x4duy; 0x1buy; 0x7euy; 0xbcuy; 0x9cuy; 0x98uy; 0x2cuy; 0xcfuy; 0x2euy; 0xc4uy; 0x96uy; 0x8cuy;
0xc0uy; 0xcduy; 0x55uy; 0xf1uy; 0x2auy; 0xf4uy; 0x66uy; 0x0cuy
]
in
assert_norm (List.Tot.length l == 32);
of_list l | false |
Spec.Ed25519.Test.fst | Spec.Ed25519.Test.test1_pk | val test1_pk:lbytes 32 | val test1_pk:lbytes 32 | let test1_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xd7uy; 0x5auy; 0x98uy; 0x01uy; 0x82uy; 0xb1uy; 0x0auy; 0xb7uy;
0xd5uy; 0x4buy; 0xfeuy; 0xd3uy; 0xc9uy; 0x64uy; 0x07uy; 0x3auy;
0x0euy; 0xe1uy; 0x72uy; 0xf3uy; 0xdauy; 0xa6uy; 0x23uy; 0x25uy;
0xafuy; 0x02uy; 0x1auy; 0x68uy; 0xf7uy; 0x07uy; 0x51uy; 0x1auy
] in
assert_norm (List.Tot.length l == 32);
of_list l | {
"file_name": "specs/tests/Spec.Ed25519.Test.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 35,
"start_col": 0,
"start_line": 27
} | module Spec.Ed25519.Test
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module PS = Lib.PrintSequence
open Spec.Ed25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Test 1
let test1_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x9duy; 0x61uy; 0xb1uy; 0x9duy; 0xefuy; 0xfduy; 0x5auy; 0x60uy;
0xbauy; 0x84uy; 0x4auy; 0xf4uy; 0x92uy; 0xecuy; 0x2cuy; 0xc4uy;
0x44uy; 0x49uy; 0xc5uy; 0x69uy; 0x7buy; 0x32uy; 0x69uy; 0x19uy;
0x70uy; 0x3buy; 0xacuy; 0x03uy; 0x1cuy; 0xaeuy; 0x7fuy; 0x60uy
] in
assert_norm (List.Tot.length l == 32);
of_list l | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.PrintSequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Ed25519.Test.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.PrintSequence",
"short_module": "PS"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"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": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"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
}
] | {
"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"
} | false | Lib.Sequence.lseq (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.SEC) 32 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.of_list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.list",
"FStar.List.Tot.Base.map",
"FStar.UInt8.t",
"Lib.RawIntTypes.u8_from_UInt8",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | false | false | false | false | false | let test1_pk:lbytes 32 =
| let l =
List.Tot.map u8_from_UInt8
[
0xd7uy; 0x5auy; 0x98uy; 0x01uy; 0x82uy; 0xb1uy; 0x0auy; 0xb7uy; 0xd5uy; 0x4buy; 0xfeuy; 0xd3uy;
0xc9uy; 0x64uy; 0x07uy; 0x3auy; 0x0euy; 0xe1uy; 0x72uy; 0xf3uy; 0xdauy; 0xa6uy; 0x23uy; 0x25uy;
0xafuy; 0x02uy; 0x1auy; 0x68uy; 0xf7uy; 0x07uy; 0x51uy; 0x1auy
]
in
assert_norm (List.Tot.length l == 32);
of_list l | false |
Spec.Ed25519.Test.fst | Spec.Ed25519.Test.test3_msg | val test3_msg:lbytes 2 | val test3_msg:lbytes 2 | let test3_msg : lbytes 2 =
let l = List.Tot.map u8_from_UInt8 [ 0xafuy; 0x82uy ] in
assert_norm (List.Tot.length l == 2);
of_list l | {
"file_name": "specs/tests/Spec.Ed25519.Test.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 131,
"start_col": 0,
"start_line": 128
} | module Spec.Ed25519.Test
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module PS = Lib.PrintSequence
open Spec.Ed25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Test 1
let test1_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x9duy; 0x61uy; 0xb1uy; 0x9duy; 0xefuy; 0xfduy; 0x5auy; 0x60uy;
0xbauy; 0x84uy; 0x4auy; 0xf4uy; 0x92uy; 0xecuy; 0x2cuy; 0xc4uy;
0x44uy; 0x49uy; 0xc5uy; 0x69uy; 0x7buy; 0x32uy; 0x69uy; 0x19uy;
0x70uy; 0x3buy; 0xacuy; 0x03uy; 0x1cuy; 0xaeuy; 0x7fuy; 0x60uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xd7uy; 0x5auy; 0x98uy; 0x01uy; 0x82uy; 0xb1uy; 0x0auy; 0xb7uy;
0xd5uy; 0x4buy; 0xfeuy; 0xd3uy; 0xc9uy; 0x64uy; 0x07uy; 0x3auy;
0x0euy; 0xe1uy; 0x72uy; 0xf3uy; 0xdauy; 0xa6uy; 0x23uy; 0x25uy;
0xafuy; 0x02uy; 0x1auy; 0x68uy; 0xf7uy; 0x07uy; 0x51uy; 0x1auy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_msg : lbytes 0 =
let l = List.Tot.map u8_from_UInt8 [] in
assert_norm (List.Tot.length l == 0);
of_list l
let test1_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0xe5uy; 0x56uy; 0x43uy; 0x00uy; 0xc3uy; 0x60uy; 0xacuy; 0x72uy;
0x90uy; 0x86uy; 0xe2uy; 0xccuy; 0x80uy; 0x6euy; 0x82uy; 0x8auy;
0x84uy; 0x87uy; 0x7fuy; 0x1euy; 0xb8uy; 0xe5uy; 0xd9uy; 0x74uy;
0xd8uy; 0x73uy; 0xe0uy; 0x65uy; 0x22uy; 0x49uy; 0x01uy; 0x55uy;
0x5fuy; 0xb8uy; 0x82uy; 0x15uy; 0x90uy; 0xa3uy; 0x3buy; 0xacuy;
0xc6uy; 0x1euy; 0x39uy; 0x70uy; 0x1cuy; 0xf9uy; 0xb4uy; 0x6buy;
0xd2uy; 0x5buy; 0xf5uy; 0xf0uy; 0x59uy; 0x5buy; 0xbeuy; 0x24uy;
0x65uy; 0x51uy; 0x41uy; 0x43uy; 0x8euy; 0x7auy; 0x10uy; 0x0buy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 2
let test2_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x4cuy; 0xcduy; 0x08uy; 0x9buy; 0x28uy; 0xffuy; 0x96uy; 0xdauy;
0x9duy; 0xb6uy; 0xc3uy; 0x46uy; 0xecuy; 0x11uy; 0x4euy; 0x0fuy;
0x5buy; 0x8auy; 0x31uy; 0x9fuy; 0x35uy; 0xabuy; 0xa6uy; 0x24uy;
0xdauy; 0x8cuy; 0xf6uy; 0xeduy; 0x4fuy; 0xb8uy; 0xa6uy; 0xfbuy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test2_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x3duy; 0x40uy; 0x17uy; 0xc3uy; 0xe8uy; 0x43uy; 0x89uy; 0x5auy;
0x92uy; 0xb7uy; 0x0auy; 0xa7uy; 0x4duy; 0x1buy; 0x7euy; 0xbcuy;
0x9cuy; 0x98uy; 0x2cuy; 0xcfuy; 0x2euy; 0xc4uy; 0x96uy; 0x8cuy;
0xc0uy; 0xcduy; 0x55uy; 0xf1uy; 0x2auy; 0xf4uy; 0x66uy; 0x0cuy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test2_msg : lbytes 1 =
let l = List.Tot.map u8_from_UInt8 [ 0x72uy ] in
assert_norm (List.Tot.length l == 1);
of_list l
let test2_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0x92uy; 0xa0uy; 0x09uy; 0xa9uy; 0xf0uy; 0xd4uy; 0xcauy; 0xb8uy;
0x72uy; 0x0euy; 0x82uy; 0x0buy; 0x5fuy; 0x64uy; 0x25uy; 0x40uy;
0xa2uy; 0xb2uy; 0x7buy; 0x54uy; 0x16uy; 0x50uy; 0x3fuy; 0x8fuy;
0xb3uy; 0x76uy; 0x22uy; 0x23uy; 0xebuy; 0xdbuy; 0x69uy; 0xdauy;
0x08uy; 0x5auy; 0xc1uy; 0xe4uy; 0x3euy; 0x15uy; 0x99uy; 0x6euy;
0x45uy; 0x8fuy; 0x36uy; 0x13uy; 0xd0uy; 0xf1uy; 0x1duy; 0x8cuy;
0x38uy; 0x7buy; 0x2euy; 0xaeuy; 0xb4uy; 0x30uy; 0x2auy; 0xeeuy;
0xb0uy; 0x0duy; 0x29uy; 0x16uy; 0x12uy; 0xbbuy; 0x0cuy; 0x00uy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 3
let test3_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xc5uy; 0xaauy; 0x8duy; 0xf4uy; 0x3fuy; 0x9fuy; 0x83uy; 0x7buy;
0xeduy; 0xb7uy; 0x44uy; 0x2fuy; 0x31uy; 0xdcuy; 0xb7uy; 0xb1uy;
0x66uy; 0xd3uy; 0x85uy; 0x35uy; 0x07uy; 0x6fuy; 0x09uy; 0x4buy;
0x85uy; 0xceuy; 0x3auy; 0x2euy; 0x0buy; 0x44uy; 0x58uy; 0xf7uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test3_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xfcuy; 0x51uy; 0xcduy; 0x8euy; 0x62uy; 0x18uy; 0xa1uy; 0xa3uy;
0x8duy; 0xa4uy; 0x7euy; 0xd0uy; 0x02uy; 0x30uy; 0xf0uy; 0x58uy;
0x08uy; 0x16uy; 0xeduy; 0x13uy; 0xbauy; 0x33uy; 0x03uy; 0xacuy;
0x5duy; 0xebuy; 0x91uy; 0x15uy; 0x48uy; 0x90uy; 0x80uy; 0x25uy
] in
assert_norm (List.Tot.length l == 32);
of_list l | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.PrintSequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Ed25519.Test.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.PrintSequence",
"short_module": "PS"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"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": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"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
}
] | {
"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"
} | false | Lib.Sequence.lseq (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.SEC) 2 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.of_list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.list",
"FStar.List.Tot.Base.map",
"FStar.UInt8.t",
"Lib.RawIntTypes.u8_from_UInt8",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | false | false | false | false | false | let test3_msg:lbytes 2 =
| let l = List.Tot.map u8_from_UInt8 [0xafuy; 0x82uy] in
assert_norm (List.Tot.length l == 2);
of_list l | false |
Spec.Ed25519.Test.fst | Spec.Ed25519.Test.test2_sk | val test2_sk:lbytes 32 | val test2_sk:lbytes 32 | let test2_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x4cuy; 0xcduy; 0x08uy; 0x9buy; 0x28uy; 0xffuy; 0x96uy; 0xdauy;
0x9duy; 0xb6uy; 0xc3uy; 0x46uy; 0xecuy; 0x11uy; 0x4euy; 0x0fuy;
0x5buy; 0x8auy; 0x31uy; 0x9fuy; 0x35uy; 0xabuy; 0xa6uy; 0x24uy;
0xdauy; 0x8cuy; 0xf6uy; 0xeduy; 0x4fuy; 0xb8uy; 0xa6uy; 0xfbuy
] in
assert_norm (List.Tot.length l == 32);
of_list l | {
"file_name": "specs/tests/Spec.Ed25519.Test.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 69,
"start_col": 0,
"start_line": 61
} | module Spec.Ed25519.Test
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module PS = Lib.PrintSequence
open Spec.Ed25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Test 1
let test1_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x9duy; 0x61uy; 0xb1uy; 0x9duy; 0xefuy; 0xfduy; 0x5auy; 0x60uy;
0xbauy; 0x84uy; 0x4auy; 0xf4uy; 0x92uy; 0xecuy; 0x2cuy; 0xc4uy;
0x44uy; 0x49uy; 0xc5uy; 0x69uy; 0x7buy; 0x32uy; 0x69uy; 0x19uy;
0x70uy; 0x3buy; 0xacuy; 0x03uy; 0x1cuy; 0xaeuy; 0x7fuy; 0x60uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xd7uy; 0x5auy; 0x98uy; 0x01uy; 0x82uy; 0xb1uy; 0x0auy; 0xb7uy;
0xd5uy; 0x4buy; 0xfeuy; 0xd3uy; 0xc9uy; 0x64uy; 0x07uy; 0x3auy;
0x0euy; 0xe1uy; 0x72uy; 0xf3uy; 0xdauy; 0xa6uy; 0x23uy; 0x25uy;
0xafuy; 0x02uy; 0x1auy; 0x68uy; 0xf7uy; 0x07uy; 0x51uy; 0x1auy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_msg : lbytes 0 =
let l = List.Tot.map u8_from_UInt8 [] in
assert_norm (List.Tot.length l == 0);
of_list l
let test1_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0xe5uy; 0x56uy; 0x43uy; 0x00uy; 0xc3uy; 0x60uy; 0xacuy; 0x72uy;
0x90uy; 0x86uy; 0xe2uy; 0xccuy; 0x80uy; 0x6euy; 0x82uy; 0x8auy;
0x84uy; 0x87uy; 0x7fuy; 0x1euy; 0xb8uy; 0xe5uy; 0xd9uy; 0x74uy;
0xd8uy; 0x73uy; 0xe0uy; 0x65uy; 0x22uy; 0x49uy; 0x01uy; 0x55uy;
0x5fuy; 0xb8uy; 0x82uy; 0x15uy; 0x90uy; 0xa3uy; 0x3buy; 0xacuy;
0xc6uy; 0x1euy; 0x39uy; 0x70uy; 0x1cuy; 0xf9uy; 0xb4uy; 0x6buy;
0xd2uy; 0x5buy; 0xf5uy; 0xf0uy; 0x59uy; 0x5buy; 0xbeuy; 0x24uy;
0x65uy; 0x51uy; 0x41uy; 0x43uy; 0x8euy; 0x7auy; 0x10uy; 0x0buy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 2 | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.PrintSequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Ed25519.Test.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.PrintSequence",
"short_module": "PS"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"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": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"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
}
] | {
"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"
} | false | Lib.Sequence.lseq (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.SEC) 32 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.of_list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.list",
"FStar.List.Tot.Base.map",
"FStar.UInt8.t",
"Lib.RawIntTypes.u8_from_UInt8",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | false | false | false | false | false | let test2_sk:lbytes 32 =
| let l =
List.Tot.map u8_from_UInt8
[
0x4cuy; 0xcduy; 0x08uy; 0x9buy; 0x28uy; 0xffuy; 0x96uy; 0xdauy; 0x9duy; 0xb6uy; 0xc3uy; 0x46uy;
0xecuy; 0x11uy; 0x4euy; 0x0fuy; 0x5buy; 0x8auy; 0x31uy; 0x9fuy; 0x35uy; 0xabuy; 0xa6uy; 0x24uy;
0xdauy; 0x8cuy; 0xf6uy; 0xeduy; 0x4fuy; 0xb8uy; 0xa6uy; 0xfbuy
]
in
assert_norm (List.Tot.length l == 32);
of_list l | false |
Vale.X64.Flags.fst | Vale.X64.Flags.sel | val sel (f:flag) (m:t) : flag_val_t | val sel (f:flag) (m:t) : flag_val_t | let sel (r:flag) (m:t) : flag_val_t =
Map.sel m r | {
"file_name": "vale/code/arch/x64/Vale.X64.Flags.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 13,
"end_line": 9,
"start_col": 0,
"start_line": 8
} | module Vale.X64.Flags
open FStar.Mul
open Vale.X64.Machine_s
type t = (m:Map.t flag flag_val_t{Set.equal (Map.domain m) (Set.complement Set.empty)}) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Flags.fst"
} | [
{
"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.Lib.Map16",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | f: Vale.X64.Machine_s.flag -> m: Vale.X64.Flags.t -> Vale.X64.Flags.flag_val_t | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.flag",
"Vale.X64.Flags.t",
"FStar.Map.sel",
"Vale.X64.Flags.flag_val_t"
] | [] | false | false | false | true | false | let sel (r: flag) (m: t) : flag_val_t =
| Map.sel m r | false |
Spec.Ed25519.Test.fst | Spec.Ed25519.Test.test2_expected_sig | val test2_expected_sig:lbytes 64 | val test2_expected_sig:lbytes 64 | let test2_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0x92uy; 0xa0uy; 0x09uy; 0xa9uy; 0xf0uy; 0xd4uy; 0xcauy; 0xb8uy;
0x72uy; 0x0euy; 0x82uy; 0x0buy; 0x5fuy; 0x64uy; 0x25uy; 0x40uy;
0xa2uy; 0xb2uy; 0x7buy; 0x54uy; 0x16uy; 0x50uy; 0x3fuy; 0x8fuy;
0xb3uy; 0x76uy; 0x22uy; 0x23uy; 0xebuy; 0xdbuy; 0x69uy; 0xdauy;
0x08uy; 0x5auy; 0xc1uy; 0xe4uy; 0x3euy; 0x15uy; 0x99uy; 0x6euy;
0x45uy; 0x8fuy; 0x36uy; 0x13uy; 0xd0uy; 0xf1uy; 0x1duy; 0x8cuy;
0x38uy; 0x7buy; 0x2euy; 0xaeuy; 0xb4uy; 0x30uy; 0x2auy; 0xeeuy;
0xb0uy; 0x0duy; 0x29uy; 0x16uy; 0x12uy; 0xbbuy; 0x0cuy; 0x00uy
] in
assert_norm (List.Tot.length l == 64);
of_list l | {
"file_name": "specs/tests/Spec.Ed25519.Test.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 101,
"start_col": 0,
"start_line": 89
} | module Spec.Ed25519.Test
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module PS = Lib.PrintSequence
open Spec.Ed25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Test 1
let test1_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x9duy; 0x61uy; 0xb1uy; 0x9duy; 0xefuy; 0xfduy; 0x5auy; 0x60uy;
0xbauy; 0x84uy; 0x4auy; 0xf4uy; 0x92uy; 0xecuy; 0x2cuy; 0xc4uy;
0x44uy; 0x49uy; 0xc5uy; 0x69uy; 0x7buy; 0x32uy; 0x69uy; 0x19uy;
0x70uy; 0x3buy; 0xacuy; 0x03uy; 0x1cuy; 0xaeuy; 0x7fuy; 0x60uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xd7uy; 0x5auy; 0x98uy; 0x01uy; 0x82uy; 0xb1uy; 0x0auy; 0xb7uy;
0xd5uy; 0x4buy; 0xfeuy; 0xd3uy; 0xc9uy; 0x64uy; 0x07uy; 0x3auy;
0x0euy; 0xe1uy; 0x72uy; 0xf3uy; 0xdauy; 0xa6uy; 0x23uy; 0x25uy;
0xafuy; 0x02uy; 0x1auy; 0x68uy; 0xf7uy; 0x07uy; 0x51uy; 0x1auy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_msg : lbytes 0 =
let l = List.Tot.map u8_from_UInt8 [] in
assert_norm (List.Tot.length l == 0);
of_list l
let test1_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0xe5uy; 0x56uy; 0x43uy; 0x00uy; 0xc3uy; 0x60uy; 0xacuy; 0x72uy;
0x90uy; 0x86uy; 0xe2uy; 0xccuy; 0x80uy; 0x6euy; 0x82uy; 0x8auy;
0x84uy; 0x87uy; 0x7fuy; 0x1euy; 0xb8uy; 0xe5uy; 0xd9uy; 0x74uy;
0xd8uy; 0x73uy; 0xe0uy; 0x65uy; 0x22uy; 0x49uy; 0x01uy; 0x55uy;
0x5fuy; 0xb8uy; 0x82uy; 0x15uy; 0x90uy; 0xa3uy; 0x3buy; 0xacuy;
0xc6uy; 0x1euy; 0x39uy; 0x70uy; 0x1cuy; 0xf9uy; 0xb4uy; 0x6buy;
0xd2uy; 0x5buy; 0xf5uy; 0xf0uy; 0x59uy; 0x5buy; 0xbeuy; 0x24uy;
0x65uy; 0x51uy; 0x41uy; 0x43uy; 0x8euy; 0x7auy; 0x10uy; 0x0buy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 2
let test2_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x4cuy; 0xcduy; 0x08uy; 0x9buy; 0x28uy; 0xffuy; 0x96uy; 0xdauy;
0x9duy; 0xb6uy; 0xc3uy; 0x46uy; 0xecuy; 0x11uy; 0x4euy; 0x0fuy;
0x5buy; 0x8auy; 0x31uy; 0x9fuy; 0x35uy; 0xabuy; 0xa6uy; 0x24uy;
0xdauy; 0x8cuy; 0xf6uy; 0xeduy; 0x4fuy; 0xb8uy; 0xa6uy; 0xfbuy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test2_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x3duy; 0x40uy; 0x17uy; 0xc3uy; 0xe8uy; 0x43uy; 0x89uy; 0x5auy;
0x92uy; 0xb7uy; 0x0auy; 0xa7uy; 0x4duy; 0x1buy; 0x7euy; 0xbcuy;
0x9cuy; 0x98uy; 0x2cuy; 0xcfuy; 0x2euy; 0xc4uy; 0x96uy; 0x8cuy;
0xc0uy; 0xcduy; 0x55uy; 0xf1uy; 0x2auy; 0xf4uy; 0x66uy; 0x0cuy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test2_msg : lbytes 1 =
let l = List.Tot.map u8_from_UInt8 [ 0x72uy ] in
assert_norm (List.Tot.length l == 1);
of_list l | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.PrintSequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Ed25519.Test.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.PrintSequence",
"short_module": "PS"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"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": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"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
}
] | {
"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"
} | false | Lib.Sequence.lseq (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.SEC) 64 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.of_list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.list",
"FStar.List.Tot.Base.map",
"FStar.UInt8.t",
"Lib.RawIntTypes.u8_from_UInt8",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | false | false | false | false | false | let test2_expected_sig:lbytes 64 =
| let l =
List.Tot.map u8_from_UInt8
[
0x92uy; 0xa0uy; 0x09uy; 0xa9uy; 0xf0uy; 0xd4uy; 0xcauy; 0xb8uy; 0x72uy; 0x0euy; 0x82uy; 0x0buy;
0x5fuy; 0x64uy; 0x25uy; 0x40uy; 0xa2uy; 0xb2uy; 0x7buy; 0x54uy; 0x16uy; 0x50uy; 0x3fuy; 0x8fuy;
0xb3uy; 0x76uy; 0x22uy; 0x23uy; 0xebuy; 0xdbuy; 0x69uy; 0xdauy; 0x08uy; 0x5auy; 0xc1uy; 0xe4uy;
0x3euy; 0x15uy; 0x99uy; 0x6euy; 0x45uy; 0x8fuy; 0x36uy; 0x13uy; 0xd0uy; 0xf1uy; 0x1duy; 0x8cuy;
0x38uy; 0x7buy; 0x2euy; 0xaeuy; 0xb4uy; 0x30uy; 0x2auy; 0xeeuy; 0xb0uy; 0x0duy; 0x29uy; 0x16uy;
0x12uy; 0xbbuy; 0x0cuy; 0x00uy
]
in
assert_norm (List.Tot.length l == 64);
of_list l | false |
Spec.Ed25519.Test.fst | Spec.Ed25519.Test.test3_sk | val test3_sk:lbytes 32 | val test3_sk:lbytes 32 | let test3_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xc5uy; 0xaauy; 0x8duy; 0xf4uy; 0x3fuy; 0x9fuy; 0x83uy; 0x7buy;
0xeduy; 0xb7uy; 0x44uy; 0x2fuy; 0x31uy; 0xdcuy; 0xb7uy; 0xb1uy;
0x66uy; 0xd3uy; 0x85uy; 0x35uy; 0x07uy; 0x6fuy; 0x09uy; 0x4buy;
0x85uy; 0xceuy; 0x3auy; 0x2euy; 0x0buy; 0x44uy; 0x58uy; 0xf7uy
] in
assert_norm (List.Tot.length l == 32);
of_list l | {
"file_name": "specs/tests/Spec.Ed25519.Test.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 114,
"start_col": 0,
"start_line": 106
} | module Spec.Ed25519.Test
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module PS = Lib.PrintSequence
open Spec.Ed25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Test 1
let test1_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x9duy; 0x61uy; 0xb1uy; 0x9duy; 0xefuy; 0xfduy; 0x5auy; 0x60uy;
0xbauy; 0x84uy; 0x4auy; 0xf4uy; 0x92uy; 0xecuy; 0x2cuy; 0xc4uy;
0x44uy; 0x49uy; 0xc5uy; 0x69uy; 0x7buy; 0x32uy; 0x69uy; 0x19uy;
0x70uy; 0x3buy; 0xacuy; 0x03uy; 0x1cuy; 0xaeuy; 0x7fuy; 0x60uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xd7uy; 0x5auy; 0x98uy; 0x01uy; 0x82uy; 0xb1uy; 0x0auy; 0xb7uy;
0xd5uy; 0x4buy; 0xfeuy; 0xd3uy; 0xc9uy; 0x64uy; 0x07uy; 0x3auy;
0x0euy; 0xe1uy; 0x72uy; 0xf3uy; 0xdauy; 0xa6uy; 0x23uy; 0x25uy;
0xafuy; 0x02uy; 0x1auy; 0x68uy; 0xf7uy; 0x07uy; 0x51uy; 0x1auy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_msg : lbytes 0 =
let l = List.Tot.map u8_from_UInt8 [] in
assert_norm (List.Tot.length l == 0);
of_list l
let test1_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0xe5uy; 0x56uy; 0x43uy; 0x00uy; 0xc3uy; 0x60uy; 0xacuy; 0x72uy;
0x90uy; 0x86uy; 0xe2uy; 0xccuy; 0x80uy; 0x6euy; 0x82uy; 0x8auy;
0x84uy; 0x87uy; 0x7fuy; 0x1euy; 0xb8uy; 0xe5uy; 0xd9uy; 0x74uy;
0xd8uy; 0x73uy; 0xe0uy; 0x65uy; 0x22uy; 0x49uy; 0x01uy; 0x55uy;
0x5fuy; 0xb8uy; 0x82uy; 0x15uy; 0x90uy; 0xa3uy; 0x3buy; 0xacuy;
0xc6uy; 0x1euy; 0x39uy; 0x70uy; 0x1cuy; 0xf9uy; 0xb4uy; 0x6buy;
0xd2uy; 0x5buy; 0xf5uy; 0xf0uy; 0x59uy; 0x5buy; 0xbeuy; 0x24uy;
0x65uy; 0x51uy; 0x41uy; 0x43uy; 0x8euy; 0x7auy; 0x10uy; 0x0buy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 2
let test2_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x4cuy; 0xcduy; 0x08uy; 0x9buy; 0x28uy; 0xffuy; 0x96uy; 0xdauy;
0x9duy; 0xb6uy; 0xc3uy; 0x46uy; 0xecuy; 0x11uy; 0x4euy; 0x0fuy;
0x5buy; 0x8auy; 0x31uy; 0x9fuy; 0x35uy; 0xabuy; 0xa6uy; 0x24uy;
0xdauy; 0x8cuy; 0xf6uy; 0xeduy; 0x4fuy; 0xb8uy; 0xa6uy; 0xfbuy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test2_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x3duy; 0x40uy; 0x17uy; 0xc3uy; 0xe8uy; 0x43uy; 0x89uy; 0x5auy;
0x92uy; 0xb7uy; 0x0auy; 0xa7uy; 0x4duy; 0x1buy; 0x7euy; 0xbcuy;
0x9cuy; 0x98uy; 0x2cuy; 0xcfuy; 0x2euy; 0xc4uy; 0x96uy; 0x8cuy;
0xc0uy; 0xcduy; 0x55uy; 0xf1uy; 0x2auy; 0xf4uy; 0x66uy; 0x0cuy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test2_msg : lbytes 1 =
let l = List.Tot.map u8_from_UInt8 [ 0x72uy ] in
assert_norm (List.Tot.length l == 1);
of_list l
let test2_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0x92uy; 0xa0uy; 0x09uy; 0xa9uy; 0xf0uy; 0xd4uy; 0xcauy; 0xb8uy;
0x72uy; 0x0euy; 0x82uy; 0x0buy; 0x5fuy; 0x64uy; 0x25uy; 0x40uy;
0xa2uy; 0xb2uy; 0x7buy; 0x54uy; 0x16uy; 0x50uy; 0x3fuy; 0x8fuy;
0xb3uy; 0x76uy; 0x22uy; 0x23uy; 0xebuy; 0xdbuy; 0x69uy; 0xdauy;
0x08uy; 0x5auy; 0xc1uy; 0xe4uy; 0x3euy; 0x15uy; 0x99uy; 0x6euy;
0x45uy; 0x8fuy; 0x36uy; 0x13uy; 0xd0uy; 0xf1uy; 0x1duy; 0x8cuy;
0x38uy; 0x7buy; 0x2euy; 0xaeuy; 0xb4uy; 0x30uy; 0x2auy; 0xeeuy;
0xb0uy; 0x0duy; 0x29uy; 0x16uy; 0x12uy; 0xbbuy; 0x0cuy; 0x00uy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 3 | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.PrintSequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Ed25519.Test.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.PrintSequence",
"short_module": "PS"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"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": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"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
}
] | {
"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"
} | false | Lib.Sequence.lseq (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.SEC) 32 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.of_list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.list",
"FStar.List.Tot.Base.map",
"FStar.UInt8.t",
"Lib.RawIntTypes.u8_from_UInt8",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | false | false | false | false | false | let test3_sk:lbytes 32 =
| let l =
List.Tot.map u8_from_UInt8
[
0xc5uy; 0xaauy; 0x8duy; 0xf4uy; 0x3fuy; 0x9fuy; 0x83uy; 0x7buy; 0xeduy; 0xb7uy; 0x44uy; 0x2fuy;
0x31uy; 0xdcuy; 0xb7uy; 0xb1uy; 0x66uy; 0xd3uy; 0x85uy; 0x35uy; 0x07uy; 0x6fuy; 0x09uy; 0x4buy;
0x85uy; 0xceuy; 0x3auy; 0x2euy; 0x0buy; 0x44uy; 0x58uy; 0xf7uy
]
in
assert_norm (List.Tot.length l == 32);
of_list l | false |
Spec.Ed25519.Test.fst | Spec.Ed25519.Test.test3_pk | val test3_pk:lbytes 32 | val test3_pk:lbytes 32 | let test3_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xfcuy; 0x51uy; 0xcduy; 0x8euy; 0x62uy; 0x18uy; 0xa1uy; 0xa3uy;
0x8duy; 0xa4uy; 0x7euy; 0xd0uy; 0x02uy; 0x30uy; 0xf0uy; 0x58uy;
0x08uy; 0x16uy; 0xeduy; 0x13uy; 0xbauy; 0x33uy; 0x03uy; 0xacuy;
0x5duy; 0xebuy; 0x91uy; 0x15uy; 0x48uy; 0x90uy; 0x80uy; 0x25uy
] in
assert_norm (List.Tot.length l == 32);
of_list l | {
"file_name": "specs/tests/Spec.Ed25519.Test.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 125,
"start_col": 0,
"start_line": 117
} | module Spec.Ed25519.Test
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module PS = Lib.PrintSequence
open Spec.Ed25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Test 1
let test1_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x9duy; 0x61uy; 0xb1uy; 0x9duy; 0xefuy; 0xfduy; 0x5auy; 0x60uy;
0xbauy; 0x84uy; 0x4auy; 0xf4uy; 0x92uy; 0xecuy; 0x2cuy; 0xc4uy;
0x44uy; 0x49uy; 0xc5uy; 0x69uy; 0x7buy; 0x32uy; 0x69uy; 0x19uy;
0x70uy; 0x3buy; 0xacuy; 0x03uy; 0x1cuy; 0xaeuy; 0x7fuy; 0x60uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xd7uy; 0x5auy; 0x98uy; 0x01uy; 0x82uy; 0xb1uy; 0x0auy; 0xb7uy;
0xd5uy; 0x4buy; 0xfeuy; 0xd3uy; 0xc9uy; 0x64uy; 0x07uy; 0x3auy;
0x0euy; 0xe1uy; 0x72uy; 0xf3uy; 0xdauy; 0xa6uy; 0x23uy; 0x25uy;
0xafuy; 0x02uy; 0x1auy; 0x68uy; 0xf7uy; 0x07uy; 0x51uy; 0x1auy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_msg : lbytes 0 =
let l = List.Tot.map u8_from_UInt8 [] in
assert_norm (List.Tot.length l == 0);
of_list l
let test1_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0xe5uy; 0x56uy; 0x43uy; 0x00uy; 0xc3uy; 0x60uy; 0xacuy; 0x72uy;
0x90uy; 0x86uy; 0xe2uy; 0xccuy; 0x80uy; 0x6euy; 0x82uy; 0x8auy;
0x84uy; 0x87uy; 0x7fuy; 0x1euy; 0xb8uy; 0xe5uy; 0xd9uy; 0x74uy;
0xd8uy; 0x73uy; 0xe0uy; 0x65uy; 0x22uy; 0x49uy; 0x01uy; 0x55uy;
0x5fuy; 0xb8uy; 0x82uy; 0x15uy; 0x90uy; 0xa3uy; 0x3buy; 0xacuy;
0xc6uy; 0x1euy; 0x39uy; 0x70uy; 0x1cuy; 0xf9uy; 0xb4uy; 0x6buy;
0xd2uy; 0x5buy; 0xf5uy; 0xf0uy; 0x59uy; 0x5buy; 0xbeuy; 0x24uy;
0x65uy; 0x51uy; 0x41uy; 0x43uy; 0x8euy; 0x7auy; 0x10uy; 0x0buy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 2
let test2_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x4cuy; 0xcduy; 0x08uy; 0x9buy; 0x28uy; 0xffuy; 0x96uy; 0xdauy;
0x9duy; 0xb6uy; 0xc3uy; 0x46uy; 0xecuy; 0x11uy; 0x4euy; 0x0fuy;
0x5buy; 0x8auy; 0x31uy; 0x9fuy; 0x35uy; 0xabuy; 0xa6uy; 0x24uy;
0xdauy; 0x8cuy; 0xf6uy; 0xeduy; 0x4fuy; 0xb8uy; 0xa6uy; 0xfbuy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test2_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x3duy; 0x40uy; 0x17uy; 0xc3uy; 0xe8uy; 0x43uy; 0x89uy; 0x5auy;
0x92uy; 0xb7uy; 0x0auy; 0xa7uy; 0x4duy; 0x1buy; 0x7euy; 0xbcuy;
0x9cuy; 0x98uy; 0x2cuy; 0xcfuy; 0x2euy; 0xc4uy; 0x96uy; 0x8cuy;
0xc0uy; 0xcduy; 0x55uy; 0xf1uy; 0x2auy; 0xf4uy; 0x66uy; 0x0cuy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test2_msg : lbytes 1 =
let l = List.Tot.map u8_from_UInt8 [ 0x72uy ] in
assert_norm (List.Tot.length l == 1);
of_list l
let test2_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0x92uy; 0xa0uy; 0x09uy; 0xa9uy; 0xf0uy; 0xd4uy; 0xcauy; 0xb8uy;
0x72uy; 0x0euy; 0x82uy; 0x0buy; 0x5fuy; 0x64uy; 0x25uy; 0x40uy;
0xa2uy; 0xb2uy; 0x7buy; 0x54uy; 0x16uy; 0x50uy; 0x3fuy; 0x8fuy;
0xb3uy; 0x76uy; 0x22uy; 0x23uy; 0xebuy; 0xdbuy; 0x69uy; 0xdauy;
0x08uy; 0x5auy; 0xc1uy; 0xe4uy; 0x3euy; 0x15uy; 0x99uy; 0x6euy;
0x45uy; 0x8fuy; 0x36uy; 0x13uy; 0xd0uy; 0xf1uy; 0x1duy; 0x8cuy;
0x38uy; 0x7buy; 0x2euy; 0xaeuy; 0xb4uy; 0x30uy; 0x2auy; 0xeeuy;
0xb0uy; 0x0duy; 0x29uy; 0x16uy; 0x12uy; 0xbbuy; 0x0cuy; 0x00uy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 3
let test3_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xc5uy; 0xaauy; 0x8duy; 0xf4uy; 0x3fuy; 0x9fuy; 0x83uy; 0x7buy;
0xeduy; 0xb7uy; 0x44uy; 0x2fuy; 0x31uy; 0xdcuy; 0xb7uy; 0xb1uy;
0x66uy; 0xd3uy; 0x85uy; 0x35uy; 0x07uy; 0x6fuy; 0x09uy; 0x4buy;
0x85uy; 0xceuy; 0x3auy; 0x2euy; 0x0buy; 0x44uy; 0x58uy; 0xf7uy
] in
assert_norm (List.Tot.length l == 32);
of_list l | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.PrintSequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Ed25519.Test.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.PrintSequence",
"short_module": "PS"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"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": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"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
}
] | {
"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"
} | false | Lib.Sequence.lseq (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.SEC) 32 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.of_list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.list",
"FStar.List.Tot.Base.map",
"FStar.UInt8.t",
"Lib.RawIntTypes.u8_from_UInt8",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | false | false | false | false | false | let test3_pk:lbytes 32 =
| let l =
List.Tot.map u8_from_UInt8
[
0xfcuy; 0x51uy; 0xcduy; 0x8euy; 0x62uy; 0x18uy; 0xa1uy; 0xa3uy; 0x8duy; 0xa4uy; 0x7euy; 0xd0uy;
0x02uy; 0x30uy; 0xf0uy; 0x58uy; 0x08uy; 0x16uy; 0xeduy; 0x13uy; 0xbauy; 0x33uy; 0x03uy; 0xacuy;
0x5duy; 0xebuy; 0x91uy; 0x15uy; 0x48uy; 0x90uy; 0x80uy; 0x25uy
]
in
assert_norm (List.Tot.length l == 32);
of_list l | false |
Vale.X64.Flags.fst | Vale.X64.Flags.equal | val equal (flags1:t) (flags2:t) : prop0 | val equal (flags1:t) (flags2:t) : prop0 | let equal m1 m2 = m1 == m2 | {
"file_name": "vale/code/arch/x64/Vale.X64.Flags.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 26,
"end_line": 62,
"start_col": 0,
"start_line": 62
} | module Vale.X64.Flags
open FStar.Mul
open Vale.X64.Machine_s
type t = (m:Map.t flag flag_val_t{Set.equal (Map.domain m) (Set.complement Set.empty)})
[@va_qattr "opaque_to_smt"]
let sel (r:flag) (m:t) : flag_val_t =
Map.sel m r
[@va_qattr "opaque_to_smt"]
let upd (r:flag) (v:flag_val_t) (m:t) : t =
reveal_opaque (`%t) t;
Map.upd m r v
let of_fun m =
let m' = Map.const None in
let m' = Map.upd m' 0 (m 0) in
let m' = Map.upd m' 1 (m 1) in
let m' = Map.upd m' 2 (m 2) in
let m' = Map.upd m' 3 (m 3) in
let m' = Map.upd m' 4 (m 4) in
let m' = Map.upd m' 5 (m 5) in
let m' = Map.upd m' 6 (m 6) in
let m' = Map.upd m' 7 (m 7) in
let m' = Map.upd m' 8 (m 8) in
let m' = Map.upd m' 9 (m 9) in
let m' = Map.upd m' 10 (m 10) in
let m' = Map.upd m' 11 (m 11) in
let m' = Map.upd m' 12 (m 12) in
let m' = Map.upd m' 13 (m 13) in
let m' = Map.upd m' 14 (m 14) in
let m' = Map.upd m' 15 (m 15) in
assert_norm (m 0 == sel 0 m');
assert_norm (m 1 == sel 1 m');
assert_norm (m 2 == sel 2 m');
assert_norm (m 3 == sel 3 m');
assert_norm (m 4 == sel 4 m');
assert_norm (m 5 == sel 5 m');
assert_norm (m 6 == sel 6 m');
assert_norm (m 7 == sel 7 m');
assert_norm (m 8 == sel 8 m');
assert_norm (m 9 == sel 9 m');
assert_norm (m 10 == sel 10 m');
assert_norm (m 11 == sel 11 m');
assert_norm (m 12 == sel 12 m');
assert_norm (m 13 == sel 13 m');
assert_norm (m 14 == sel 14 m');
assert_norm (m 15 == sel 15 m');
m'
let lemma_upd_eq r v m =
reveal_opaque (`%sel) sel;
reveal_opaque (`%upd) upd;
Map.lemma_SelUpd1 m r v
let lemma_upd_ne r r' v m =
reveal_opaque (`%sel) sel;
reveal_opaque (`%upd) upd;
Map.lemma_SelUpd2 m r r' v | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Flags.fst"
} | [
{
"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.Lib.Map16",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | flags1: Vale.X64.Flags.t -> flags2: Vale.X64.Flags.t -> Vale.Def.Prop_s.prop0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Flags.t",
"Prims.eq2",
"Vale.Def.Prop_s.prop0"
] | [] | false | false | false | true | false | let equal m1 m2 =
| m1 == m2 | false |
Spec.Ed25519.Test.fst | Spec.Ed25519.Test.test1_expected_sig | val test1_expected_sig:lbytes 64 | val test1_expected_sig:lbytes 64 | let test1_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0xe5uy; 0x56uy; 0x43uy; 0x00uy; 0xc3uy; 0x60uy; 0xacuy; 0x72uy;
0x90uy; 0x86uy; 0xe2uy; 0xccuy; 0x80uy; 0x6euy; 0x82uy; 0x8auy;
0x84uy; 0x87uy; 0x7fuy; 0x1euy; 0xb8uy; 0xe5uy; 0xd9uy; 0x74uy;
0xd8uy; 0x73uy; 0xe0uy; 0x65uy; 0x22uy; 0x49uy; 0x01uy; 0x55uy;
0x5fuy; 0xb8uy; 0x82uy; 0x15uy; 0x90uy; 0xa3uy; 0x3buy; 0xacuy;
0xc6uy; 0x1euy; 0x39uy; 0x70uy; 0x1cuy; 0xf9uy; 0xb4uy; 0x6buy;
0xd2uy; 0x5buy; 0xf5uy; 0xf0uy; 0x59uy; 0x5buy; 0xbeuy; 0x24uy;
0x65uy; 0x51uy; 0x41uy; 0x43uy; 0x8euy; 0x7auy; 0x10uy; 0x0buy
] in
assert_norm (List.Tot.length l == 64);
of_list l | {
"file_name": "specs/tests/Spec.Ed25519.Test.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 56,
"start_col": 0,
"start_line": 44
} | module Spec.Ed25519.Test
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module PS = Lib.PrintSequence
open Spec.Ed25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Test 1
let test1_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x9duy; 0x61uy; 0xb1uy; 0x9duy; 0xefuy; 0xfduy; 0x5auy; 0x60uy;
0xbauy; 0x84uy; 0x4auy; 0xf4uy; 0x92uy; 0xecuy; 0x2cuy; 0xc4uy;
0x44uy; 0x49uy; 0xc5uy; 0x69uy; 0x7buy; 0x32uy; 0x69uy; 0x19uy;
0x70uy; 0x3buy; 0xacuy; 0x03uy; 0x1cuy; 0xaeuy; 0x7fuy; 0x60uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xd7uy; 0x5auy; 0x98uy; 0x01uy; 0x82uy; 0xb1uy; 0x0auy; 0xb7uy;
0xd5uy; 0x4buy; 0xfeuy; 0xd3uy; 0xc9uy; 0x64uy; 0x07uy; 0x3auy;
0x0euy; 0xe1uy; 0x72uy; 0xf3uy; 0xdauy; 0xa6uy; 0x23uy; 0x25uy;
0xafuy; 0x02uy; 0x1auy; 0x68uy; 0xf7uy; 0x07uy; 0x51uy; 0x1auy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_msg : lbytes 0 =
let l = List.Tot.map u8_from_UInt8 [] in
assert_norm (List.Tot.length l == 0);
of_list l | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.PrintSequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Ed25519.Test.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.PrintSequence",
"short_module": "PS"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"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": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"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
}
] | {
"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"
} | false | Lib.Sequence.lseq (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.SEC) 64 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.of_list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.list",
"FStar.List.Tot.Base.map",
"FStar.UInt8.t",
"Lib.RawIntTypes.u8_from_UInt8",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | false | false | false | false | false | let test1_expected_sig:lbytes 64 =
| let l =
List.Tot.map u8_from_UInt8
[
0xe5uy; 0x56uy; 0x43uy; 0x00uy; 0xc3uy; 0x60uy; 0xacuy; 0x72uy; 0x90uy; 0x86uy; 0xe2uy; 0xccuy;
0x80uy; 0x6euy; 0x82uy; 0x8auy; 0x84uy; 0x87uy; 0x7fuy; 0x1euy; 0xb8uy; 0xe5uy; 0xd9uy; 0x74uy;
0xd8uy; 0x73uy; 0xe0uy; 0x65uy; 0x22uy; 0x49uy; 0x01uy; 0x55uy; 0x5fuy; 0xb8uy; 0x82uy; 0x15uy;
0x90uy; 0xa3uy; 0x3buy; 0xacuy; 0xc6uy; 0x1euy; 0x39uy; 0x70uy; 0x1cuy; 0xf9uy; 0xb4uy; 0x6buy;
0xd2uy; 0x5buy; 0xf5uy; 0xf0uy; 0x59uy; 0x5buy; 0xbeuy; 0x24uy; 0x65uy; 0x51uy; 0x41uy; 0x43uy;
0x8euy; 0x7auy; 0x10uy; 0x0buy
]
in
assert_norm (List.Tot.length l == 64);
of_list l | false |
Spec.Ed25519.Test.fst | Spec.Ed25519.Test.test4_pk | val test4_pk:lbytes 32 | val test4_pk:lbytes 32 | let test4_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x27uy; 0x81uy; 0x17uy; 0xfcuy; 0x14uy; 0x4cuy; 0x72uy; 0x34uy;
0x0fuy; 0x67uy; 0xd0uy; 0xf2uy; 0x31uy; 0x6euy; 0x83uy; 0x86uy;
0xceuy; 0xffuy; 0xbfuy; 0x2buy; 0x24uy; 0x28uy; 0xc9uy; 0xc5uy;
0x1fuy; 0xefuy; 0x7cuy; 0x59uy; 0x7fuy; 0x1duy; 0x42uy; 0x6euy
] in
assert_norm (List.Tot.length l == 32);
of_list l | {
"file_name": "specs/tests/Spec.Ed25519.Test.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 170,
"start_col": 0,
"start_line": 162
} | module Spec.Ed25519.Test
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module PS = Lib.PrintSequence
open Spec.Ed25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Test 1
let test1_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x9duy; 0x61uy; 0xb1uy; 0x9duy; 0xefuy; 0xfduy; 0x5auy; 0x60uy;
0xbauy; 0x84uy; 0x4auy; 0xf4uy; 0x92uy; 0xecuy; 0x2cuy; 0xc4uy;
0x44uy; 0x49uy; 0xc5uy; 0x69uy; 0x7buy; 0x32uy; 0x69uy; 0x19uy;
0x70uy; 0x3buy; 0xacuy; 0x03uy; 0x1cuy; 0xaeuy; 0x7fuy; 0x60uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xd7uy; 0x5auy; 0x98uy; 0x01uy; 0x82uy; 0xb1uy; 0x0auy; 0xb7uy;
0xd5uy; 0x4buy; 0xfeuy; 0xd3uy; 0xc9uy; 0x64uy; 0x07uy; 0x3auy;
0x0euy; 0xe1uy; 0x72uy; 0xf3uy; 0xdauy; 0xa6uy; 0x23uy; 0x25uy;
0xafuy; 0x02uy; 0x1auy; 0x68uy; 0xf7uy; 0x07uy; 0x51uy; 0x1auy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_msg : lbytes 0 =
let l = List.Tot.map u8_from_UInt8 [] in
assert_norm (List.Tot.length l == 0);
of_list l
let test1_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0xe5uy; 0x56uy; 0x43uy; 0x00uy; 0xc3uy; 0x60uy; 0xacuy; 0x72uy;
0x90uy; 0x86uy; 0xe2uy; 0xccuy; 0x80uy; 0x6euy; 0x82uy; 0x8auy;
0x84uy; 0x87uy; 0x7fuy; 0x1euy; 0xb8uy; 0xe5uy; 0xd9uy; 0x74uy;
0xd8uy; 0x73uy; 0xe0uy; 0x65uy; 0x22uy; 0x49uy; 0x01uy; 0x55uy;
0x5fuy; 0xb8uy; 0x82uy; 0x15uy; 0x90uy; 0xa3uy; 0x3buy; 0xacuy;
0xc6uy; 0x1euy; 0x39uy; 0x70uy; 0x1cuy; 0xf9uy; 0xb4uy; 0x6buy;
0xd2uy; 0x5buy; 0xf5uy; 0xf0uy; 0x59uy; 0x5buy; 0xbeuy; 0x24uy;
0x65uy; 0x51uy; 0x41uy; 0x43uy; 0x8euy; 0x7auy; 0x10uy; 0x0buy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 2
let test2_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x4cuy; 0xcduy; 0x08uy; 0x9buy; 0x28uy; 0xffuy; 0x96uy; 0xdauy;
0x9duy; 0xb6uy; 0xc3uy; 0x46uy; 0xecuy; 0x11uy; 0x4euy; 0x0fuy;
0x5buy; 0x8auy; 0x31uy; 0x9fuy; 0x35uy; 0xabuy; 0xa6uy; 0x24uy;
0xdauy; 0x8cuy; 0xf6uy; 0xeduy; 0x4fuy; 0xb8uy; 0xa6uy; 0xfbuy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test2_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x3duy; 0x40uy; 0x17uy; 0xc3uy; 0xe8uy; 0x43uy; 0x89uy; 0x5auy;
0x92uy; 0xb7uy; 0x0auy; 0xa7uy; 0x4duy; 0x1buy; 0x7euy; 0xbcuy;
0x9cuy; 0x98uy; 0x2cuy; 0xcfuy; 0x2euy; 0xc4uy; 0x96uy; 0x8cuy;
0xc0uy; 0xcduy; 0x55uy; 0xf1uy; 0x2auy; 0xf4uy; 0x66uy; 0x0cuy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test2_msg : lbytes 1 =
let l = List.Tot.map u8_from_UInt8 [ 0x72uy ] in
assert_norm (List.Tot.length l == 1);
of_list l
let test2_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0x92uy; 0xa0uy; 0x09uy; 0xa9uy; 0xf0uy; 0xd4uy; 0xcauy; 0xb8uy;
0x72uy; 0x0euy; 0x82uy; 0x0buy; 0x5fuy; 0x64uy; 0x25uy; 0x40uy;
0xa2uy; 0xb2uy; 0x7buy; 0x54uy; 0x16uy; 0x50uy; 0x3fuy; 0x8fuy;
0xb3uy; 0x76uy; 0x22uy; 0x23uy; 0xebuy; 0xdbuy; 0x69uy; 0xdauy;
0x08uy; 0x5auy; 0xc1uy; 0xe4uy; 0x3euy; 0x15uy; 0x99uy; 0x6euy;
0x45uy; 0x8fuy; 0x36uy; 0x13uy; 0xd0uy; 0xf1uy; 0x1duy; 0x8cuy;
0x38uy; 0x7buy; 0x2euy; 0xaeuy; 0xb4uy; 0x30uy; 0x2auy; 0xeeuy;
0xb0uy; 0x0duy; 0x29uy; 0x16uy; 0x12uy; 0xbbuy; 0x0cuy; 0x00uy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 3
let test3_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xc5uy; 0xaauy; 0x8duy; 0xf4uy; 0x3fuy; 0x9fuy; 0x83uy; 0x7buy;
0xeduy; 0xb7uy; 0x44uy; 0x2fuy; 0x31uy; 0xdcuy; 0xb7uy; 0xb1uy;
0x66uy; 0xd3uy; 0x85uy; 0x35uy; 0x07uy; 0x6fuy; 0x09uy; 0x4buy;
0x85uy; 0xceuy; 0x3auy; 0x2euy; 0x0buy; 0x44uy; 0x58uy; 0xf7uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test3_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xfcuy; 0x51uy; 0xcduy; 0x8euy; 0x62uy; 0x18uy; 0xa1uy; 0xa3uy;
0x8duy; 0xa4uy; 0x7euy; 0xd0uy; 0x02uy; 0x30uy; 0xf0uy; 0x58uy;
0x08uy; 0x16uy; 0xeduy; 0x13uy; 0xbauy; 0x33uy; 0x03uy; 0xacuy;
0x5duy; 0xebuy; 0x91uy; 0x15uy; 0x48uy; 0x90uy; 0x80uy; 0x25uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test3_msg : lbytes 2 =
let l = List.Tot.map u8_from_UInt8 [ 0xafuy; 0x82uy ] in
assert_norm (List.Tot.length l == 2);
of_list l
let test3_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0x62uy; 0x91uy; 0xd6uy; 0x57uy; 0xdeuy; 0xecuy; 0x24uy; 0x02uy;
0x48uy; 0x27uy; 0xe6uy; 0x9cuy; 0x3auy; 0xbeuy; 0x01uy; 0xa3uy;
0x0cuy; 0xe5uy; 0x48uy; 0xa2uy; 0x84uy; 0x74uy; 0x3auy; 0x44uy;
0x5euy; 0x36uy; 0x80uy; 0xd7uy; 0xdbuy; 0x5auy; 0xc3uy; 0xacuy;
0x18uy; 0xffuy; 0x9buy; 0x53uy; 0x8duy; 0x16uy; 0xf2uy; 0x90uy;
0xaeuy; 0x67uy; 0xf7uy; 0x60uy; 0x98uy; 0x4duy; 0xc6uy; 0x59uy;
0x4auy; 0x7cuy; 0x15uy; 0xe9uy; 0x71uy; 0x6euy; 0xd2uy; 0x8duy;
0xc0uy; 0x27uy; 0xbeuy; 0xceuy; 0xeauy; 0x1euy; 0xc4uy; 0x0auy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 4
let test4_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xf5uy; 0xe5uy; 0x76uy; 0x7cuy; 0xf1uy; 0x53uy; 0x31uy; 0x95uy;
0x17uy; 0x63uy; 0x0fuy; 0x22uy; 0x68uy; 0x76uy; 0xb8uy; 0x6cuy;
0x81uy; 0x60uy; 0xccuy; 0x58uy; 0x3buy; 0xc0uy; 0x13uy; 0x74uy;
0x4cuy; 0x6buy; 0xf2uy; 0x55uy; 0xf5uy; 0xccuy; 0x0euy; 0xe5uy
] in
assert_norm (List.Tot.length l == 32);
of_list l | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.PrintSequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Ed25519.Test.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.PrintSequence",
"short_module": "PS"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"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": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"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
}
] | {
"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"
} | false | Lib.Sequence.lseq (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.SEC) 32 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.of_list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.list",
"FStar.List.Tot.Base.map",
"FStar.UInt8.t",
"Lib.RawIntTypes.u8_from_UInt8",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | false | false | false | false | false | let test4_pk:lbytes 32 =
| let l =
List.Tot.map u8_from_UInt8
[
0x27uy; 0x81uy; 0x17uy; 0xfcuy; 0x14uy; 0x4cuy; 0x72uy; 0x34uy; 0x0fuy; 0x67uy; 0xd0uy; 0xf2uy;
0x31uy; 0x6euy; 0x83uy; 0x86uy; 0xceuy; 0xffuy; 0xbfuy; 0x2buy; 0x24uy; 0x28uy; 0xc9uy; 0xc5uy;
0x1fuy; 0xefuy; 0x7cuy; 0x59uy; 0x7fuy; 0x1duy; 0x42uy; 0x6euy
]
in
assert_norm (List.Tot.length l == 32);
of_list l | false |
Vale.X64.Flags.fst | Vale.X64.Flags.upd | val upd (f:flag) (v:flag_val_t) (m:t) : t | val upd (f:flag) (v:flag_val_t) (m:t) : t | let upd (r:flag) (v:flag_val_t) (m:t) : t =
reveal_opaque (`%t) t;
Map.upd m r v | {
"file_name": "vale/code/arch/x64/Vale.X64.Flags.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 14,
"start_col": 0,
"start_line": 12
} | module Vale.X64.Flags
open FStar.Mul
open Vale.X64.Machine_s
type t = (m:Map.t flag flag_val_t{Set.equal (Map.domain m) (Set.complement Set.empty)})
[@va_qattr "opaque_to_smt"]
let sel (r:flag) (m:t) : flag_val_t =
Map.sel m r | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Flags.fst"
} | [
{
"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.Lib.Map16",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | f: Vale.X64.Machine_s.flag -> v: Vale.X64.Flags.flag_val_t -> m: Vale.X64.Flags.t
-> Vale.X64.Flags.t | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.flag",
"Vale.X64.Flags.flag_val_t",
"Vale.X64.Flags.t",
"FStar.Map.upd",
"Prims.unit",
"FStar.Pervasives.reveal_opaque"
] | [] | false | false | false | true | false | let upd (r: flag) (v: flag_val_t) (m: t) : t =
| reveal_opaque (`%t) t;
Map.upd m r v | false |
Spec.Ed25519.Test.fst | Spec.Ed25519.Test.test4_sk | val test4_sk:lbytes 32 | val test4_sk:lbytes 32 | let test4_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xf5uy; 0xe5uy; 0x76uy; 0x7cuy; 0xf1uy; 0x53uy; 0x31uy; 0x95uy;
0x17uy; 0x63uy; 0x0fuy; 0x22uy; 0x68uy; 0x76uy; 0xb8uy; 0x6cuy;
0x81uy; 0x60uy; 0xccuy; 0x58uy; 0x3buy; 0xc0uy; 0x13uy; 0x74uy;
0x4cuy; 0x6buy; 0xf2uy; 0x55uy; 0xf5uy; 0xccuy; 0x0euy; 0xe5uy
] in
assert_norm (List.Tot.length l == 32);
of_list l | {
"file_name": "specs/tests/Spec.Ed25519.Test.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 159,
"start_col": 0,
"start_line": 151
} | module Spec.Ed25519.Test
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module PS = Lib.PrintSequence
open Spec.Ed25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Test 1
let test1_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x9duy; 0x61uy; 0xb1uy; 0x9duy; 0xefuy; 0xfduy; 0x5auy; 0x60uy;
0xbauy; 0x84uy; 0x4auy; 0xf4uy; 0x92uy; 0xecuy; 0x2cuy; 0xc4uy;
0x44uy; 0x49uy; 0xc5uy; 0x69uy; 0x7buy; 0x32uy; 0x69uy; 0x19uy;
0x70uy; 0x3buy; 0xacuy; 0x03uy; 0x1cuy; 0xaeuy; 0x7fuy; 0x60uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xd7uy; 0x5auy; 0x98uy; 0x01uy; 0x82uy; 0xb1uy; 0x0auy; 0xb7uy;
0xd5uy; 0x4buy; 0xfeuy; 0xd3uy; 0xc9uy; 0x64uy; 0x07uy; 0x3auy;
0x0euy; 0xe1uy; 0x72uy; 0xf3uy; 0xdauy; 0xa6uy; 0x23uy; 0x25uy;
0xafuy; 0x02uy; 0x1auy; 0x68uy; 0xf7uy; 0x07uy; 0x51uy; 0x1auy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_msg : lbytes 0 =
let l = List.Tot.map u8_from_UInt8 [] in
assert_norm (List.Tot.length l == 0);
of_list l
let test1_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0xe5uy; 0x56uy; 0x43uy; 0x00uy; 0xc3uy; 0x60uy; 0xacuy; 0x72uy;
0x90uy; 0x86uy; 0xe2uy; 0xccuy; 0x80uy; 0x6euy; 0x82uy; 0x8auy;
0x84uy; 0x87uy; 0x7fuy; 0x1euy; 0xb8uy; 0xe5uy; 0xd9uy; 0x74uy;
0xd8uy; 0x73uy; 0xe0uy; 0x65uy; 0x22uy; 0x49uy; 0x01uy; 0x55uy;
0x5fuy; 0xb8uy; 0x82uy; 0x15uy; 0x90uy; 0xa3uy; 0x3buy; 0xacuy;
0xc6uy; 0x1euy; 0x39uy; 0x70uy; 0x1cuy; 0xf9uy; 0xb4uy; 0x6buy;
0xd2uy; 0x5buy; 0xf5uy; 0xf0uy; 0x59uy; 0x5buy; 0xbeuy; 0x24uy;
0x65uy; 0x51uy; 0x41uy; 0x43uy; 0x8euy; 0x7auy; 0x10uy; 0x0buy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 2
let test2_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x4cuy; 0xcduy; 0x08uy; 0x9buy; 0x28uy; 0xffuy; 0x96uy; 0xdauy;
0x9duy; 0xb6uy; 0xc3uy; 0x46uy; 0xecuy; 0x11uy; 0x4euy; 0x0fuy;
0x5buy; 0x8auy; 0x31uy; 0x9fuy; 0x35uy; 0xabuy; 0xa6uy; 0x24uy;
0xdauy; 0x8cuy; 0xf6uy; 0xeduy; 0x4fuy; 0xb8uy; 0xa6uy; 0xfbuy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test2_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x3duy; 0x40uy; 0x17uy; 0xc3uy; 0xe8uy; 0x43uy; 0x89uy; 0x5auy;
0x92uy; 0xb7uy; 0x0auy; 0xa7uy; 0x4duy; 0x1buy; 0x7euy; 0xbcuy;
0x9cuy; 0x98uy; 0x2cuy; 0xcfuy; 0x2euy; 0xc4uy; 0x96uy; 0x8cuy;
0xc0uy; 0xcduy; 0x55uy; 0xf1uy; 0x2auy; 0xf4uy; 0x66uy; 0x0cuy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test2_msg : lbytes 1 =
let l = List.Tot.map u8_from_UInt8 [ 0x72uy ] in
assert_norm (List.Tot.length l == 1);
of_list l
let test2_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0x92uy; 0xa0uy; 0x09uy; 0xa9uy; 0xf0uy; 0xd4uy; 0xcauy; 0xb8uy;
0x72uy; 0x0euy; 0x82uy; 0x0buy; 0x5fuy; 0x64uy; 0x25uy; 0x40uy;
0xa2uy; 0xb2uy; 0x7buy; 0x54uy; 0x16uy; 0x50uy; 0x3fuy; 0x8fuy;
0xb3uy; 0x76uy; 0x22uy; 0x23uy; 0xebuy; 0xdbuy; 0x69uy; 0xdauy;
0x08uy; 0x5auy; 0xc1uy; 0xe4uy; 0x3euy; 0x15uy; 0x99uy; 0x6euy;
0x45uy; 0x8fuy; 0x36uy; 0x13uy; 0xd0uy; 0xf1uy; 0x1duy; 0x8cuy;
0x38uy; 0x7buy; 0x2euy; 0xaeuy; 0xb4uy; 0x30uy; 0x2auy; 0xeeuy;
0xb0uy; 0x0duy; 0x29uy; 0x16uy; 0x12uy; 0xbbuy; 0x0cuy; 0x00uy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 3
let test3_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xc5uy; 0xaauy; 0x8duy; 0xf4uy; 0x3fuy; 0x9fuy; 0x83uy; 0x7buy;
0xeduy; 0xb7uy; 0x44uy; 0x2fuy; 0x31uy; 0xdcuy; 0xb7uy; 0xb1uy;
0x66uy; 0xd3uy; 0x85uy; 0x35uy; 0x07uy; 0x6fuy; 0x09uy; 0x4buy;
0x85uy; 0xceuy; 0x3auy; 0x2euy; 0x0buy; 0x44uy; 0x58uy; 0xf7uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test3_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xfcuy; 0x51uy; 0xcduy; 0x8euy; 0x62uy; 0x18uy; 0xa1uy; 0xa3uy;
0x8duy; 0xa4uy; 0x7euy; 0xd0uy; 0x02uy; 0x30uy; 0xf0uy; 0x58uy;
0x08uy; 0x16uy; 0xeduy; 0x13uy; 0xbauy; 0x33uy; 0x03uy; 0xacuy;
0x5duy; 0xebuy; 0x91uy; 0x15uy; 0x48uy; 0x90uy; 0x80uy; 0x25uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test3_msg : lbytes 2 =
let l = List.Tot.map u8_from_UInt8 [ 0xafuy; 0x82uy ] in
assert_norm (List.Tot.length l == 2);
of_list l
let test3_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0x62uy; 0x91uy; 0xd6uy; 0x57uy; 0xdeuy; 0xecuy; 0x24uy; 0x02uy;
0x48uy; 0x27uy; 0xe6uy; 0x9cuy; 0x3auy; 0xbeuy; 0x01uy; 0xa3uy;
0x0cuy; 0xe5uy; 0x48uy; 0xa2uy; 0x84uy; 0x74uy; 0x3auy; 0x44uy;
0x5euy; 0x36uy; 0x80uy; 0xd7uy; 0xdbuy; 0x5auy; 0xc3uy; 0xacuy;
0x18uy; 0xffuy; 0x9buy; 0x53uy; 0x8duy; 0x16uy; 0xf2uy; 0x90uy;
0xaeuy; 0x67uy; 0xf7uy; 0x60uy; 0x98uy; 0x4duy; 0xc6uy; 0x59uy;
0x4auy; 0x7cuy; 0x15uy; 0xe9uy; 0x71uy; 0x6euy; 0xd2uy; 0x8duy;
0xc0uy; 0x27uy; 0xbeuy; 0xceuy; 0xeauy; 0x1euy; 0xc4uy; 0x0auy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 4 | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.PrintSequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Ed25519.Test.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.PrintSequence",
"short_module": "PS"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"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": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"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
}
] | {
"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"
} | false | Lib.Sequence.lseq (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.SEC) 32 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.of_list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.list",
"FStar.List.Tot.Base.map",
"FStar.UInt8.t",
"Lib.RawIntTypes.u8_from_UInt8",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | false | false | false | false | false | let test4_sk:lbytes 32 =
| let l =
List.Tot.map u8_from_UInt8
[
0xf5uy; 0xe5uy; 0x76uy; 0x7cuy; 0xf1uy; 0x53uy; 0x31uy; 0x95uy; 0x17uy; 0x63uy; 0x0fuy; 0x22uy;
0x68uy; 0x76uy; 0xb8uy; 0x6cuy; 0x81uy; 0x60uy; 0xccuy; 0x58uy; 0x3buy; 0xc0uy; 0x13uy; 0x74uy;
0x4cuy; 0x6buy; 0xf2uy; 0x55uy; 0xf5uy; 0xccuy; 0x0euy; 0xe5uy
]
in
assert_norm (List.Tot.length l == 32);
of_list l | false |
Vale.X64.Flags.fst | Vale.X64.Flags.lemma_upd_eq | val lemma_upd_eq (r:flag) (v:flag_val_t) (m:t) : Lemma
(requires True)
(ensures sel r (upd r v m) == v)
[SMTPat (sel r (upd r v m))] | val lemma_upd_eq (r:flag) (v:flag_val_t) (m:t) : Lemma
(requires True)
(ensures sel r (upd r v m) == v)
[SMTPat (sel r (upd r v m))] | let lemma_upd_eq r v m =
reveal_opaque (`%sel) sel;
reveal_opaque (`%upd) upd;
Map.lemma_SelUpd1 m r v | {
"file_name": "vale/code/arch/x64/Vale.X64.Flags.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 25,
"end_line": 55,
"start_col": 0,
"start_line": 52
} | module Vale.X64.Flags
open FStar.Mul
open Vale.X64.Machine_s
type t = (m:Map.t flag flag_val_t{Set.equal (Map.domain m) (Set.complement Set.empty)})
[@va_qattr "opaque_to_smt"]
let sel (r:flag) (m:t) : flag_val_t =
Map.sel m r
[@va_qattr "opaque_to_smt"]
let upd (r:flag) (v:flag_val_t) (m:t) : t =
reveal_opaque (`%t) t;
Map.upd m r v
let of_fun m =
let m' = Map.const None in
let m' = Map.upd m' 0 (m 0) in
let m' = Map.upd m' 1 (m 1) in
let m' = Map.upd m' 2 (m 2) in
let m' = Map.upd m' 3 (m 3) in
let m' = Map.upd m' 4 (m 4) in
let m' = Map.upd m' 5 (m 5) in
let m' = Map.upd m' 6 (m 6) in
let m' = Map.upd m' 7 (m 7) in
let m' = Map.upd m' 8 (m 8) in
let m' = Map.upd m' 9 (m 9) in
let m' = Map.upd m' 10 (m 10) in
let m' = Map.upd m' 11 (m 11) in
let m' = Map.upd m' 12 (m 12) in
let m' = Map.upd m' 13 (m 13) in
let m' = Map.upd m' 14 (m 14) in
let m' = Map.upd m' 15 (m 15) in
assert_norm (m 0 == sel 0 m');
assert_norm (m 1 == sel 1 m');
assert_norm (m 2 == sel 2 m');
assert_norm (m 3 == sel 3 m');
assert_norm (m 4 == sel 4 m');
assert_norm (m 5 == sel 5 m');
assert_norm (m 6 == sel 6 m');
assert_norm (m 7 == sel 7 m');
assert_norm (m 8 == sel 8 m');
assert_norm (m 9 == sel 9 m');
assert_norm (m 10 == sel 10 m');
assert_norm (m 11 == sel 11 m');
assert_norm (m 12 == sel 12 m');
assert_norm (m 13 == sel 13 m');
assert_norm (m 14 == sel 14 m');
assert_norm (m 15 == sel 15 m');
m' | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Flags.fst"
} | [
{
"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.Lib.Map16",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | r: Vale.X64.Machine_s.flag -> v: Vale.X64.Flags.flag_val_t -> m: Vale.X64.Flags.t
-> FStar.Pervasives.Lemma (ensures Vale.X64.Flags.sel r (Vale.X64.Flags.upd r v m) == v)
[SMTPat (Vale.X64.Flags.sel r (Vale.X64.Flags.upd r v m))] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.X64.Machine_s.flag",
"Vale.X64.Flags.flag_val_t",
"Vale.X64.Flags.t",
"FStar.Map.lemma_SelUpd1",
"Prims.unit",
"FStar.Pervasives.reveal_opaque",
"Vale.X64.Flags.upd",
"Vale.X64.Flags.sel"
] | [] | true | false | true | false | false | let lemma_upd_eq r v m =
| reveal_opaque (`%sel) sel;
reveal_opaque (`%upd) upd;
Map.lemma_SelUpd1 m r v | false |
Spec.Ed25519.Test.fst | Spec.Ed25519.Test.test | val test: unit -> FStar.All.ML bool | val test: unit -> FStar.All.ML bool | let test () =
let res = List.for_all test_one test_vectors in
if res then begin IO.print_string "\n\nEd25519 : Success!\n"; true end
else begin IO.print_string "\n\nEd25519: Failure :(\n"; false end | {
"file_name": "specs/tests/Spec.Ed25519.Test.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 67,
"end_line": 355,
"start_col": 0,
"start_line": 352
} | module Spec.Ed25519.Test
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module PS = Lib.PrintSequence
open Spec.Ed25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Test 1
let test1_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x9duy; 0x61uy; 0xb1uy; 0x9duy; 0xefuy; 0xfduy; 0x5auy; 0x60uy;
0xbauy; 0x84uy; 0x4auy; 0xf4uy; 0x92uy; 0xecuy; 0x2cuy; 0xc4uy;
0x44uy; 0x49uy; 0xc5uy; 0x69uy; 0x7buy; 0x32uy; 0x69uy; 0x19uy;
0x70uy; 0x3buy; 0xacuy; 0x03uy; 0x1cuy; 0xaeuy; 0x7fuy; 0x60uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xd7uy; 0x5auy; 0x98uy; 0x01uy; 0x82uy; 0xb1uy; 0x0auy; 0xb7uy;
0xd5uy; 0x4buy; 0xfeuy; 0xd3uy; 0xc9uy; 0x64uy; 0x07uy; 0x3auy;
0x0euy; 0xe1uy; 0x72uy; 0xf3uy; 0xdauy; 0xa6uy; 0x23uy; 0x25uy;
0xafuy; 0x02uy; 0x1auy; 0x68uy; 0xf7uy; 0x07uy; 0x51uy; 0x1auy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_msg : lbytes 0 =
let l = List.Tot.map u8_from_UInt8 [] in
assert_norm (List.Tot.length l == 0);
of_list l
let test1_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0xe5uy; 0x56uy; 0x43uy; 0x00uy; 0xc3uy; 0x60uy; 0xacuy; 0x72uy;
0x90uy; 0x86uy; 0xe2uy; 0xccuy; 0x80uy; 0x6euy; 0x82uy; 0x8auy;
0x84uy; 0x87uy; 0x7fuy; 0x1euy; 0xb8uy; 0xe5uy; 0xd9uy; 0x74uy;
0xd8uy; 0x73uy; 0xe0uy; 0x65uy; 0x22uy; 0x49uy; 0x01uy; 0x55uy;
0x5fuy; 0xb8uy; 0x82uy; 0x15uy; 0x90uy; 0xa3uy; 0x3buy; 0xacuy;
0xc6uy; 0x1euy; 0x39uy; 0x70uy; 0x1cuy; 0xf9uy; 0xb4uy; 0x6buy;
0xd2uy; 0x5buy; 0xf5uy; 0xf0uy; 0x59uy; 0x5buy; 0xbeuy; 0x24uy;
0x65uy; 0x51uy; 0x41uy; 0x43uy; 0x8euy; 0x7auy; 0x10uy; 0x0buy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 2
let test2_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x4cuy; 0xcduy; 0x08uy; 0x9buy; 0x28uy; 0xffuy; 0x96uy; 0xdauy;
0x9duy; 0xb6uy; 0xc3uy; 0x46uy; 0xecuy; 0x11uy; 0x4euy; 0x0fuy;
0x5buy; 0x8auy; 0x31uy; 0x9fuy; 0x35uy; 0xabuy; 0xa6uy; 0x24uy;
0xdauy; 0x8cuy; 0xf6uy; 0xeduy; 0x4fuy; 0xb8uy; 0xa6uy; 0xfbuy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test2_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x3duy; 0x40uy; 0x17uy; 0xc3uy; 0xe8uy; 0x43uy; 0x89uy; 0x5auy;
0x92uy; 0xb7uy; 0x0auy; 0xa7uy; 0x4duy; 0x1buy; 0x7euy; 0xbcuy;
0x9cuy; 0x98uy; 0x2cuy; 0xcfuy; 0x2euy; 0xc4uy; 0x96uy; 0x8cuy;
0xc0uy; 0xcduy; 0x55uy; 0xf1uy; 0x2auy; 0xf4uy; 0x66uy; 0x0cuy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test2_msg : lbytes 1 =
let l = List.Tot.map u8_from_UInt8 [ 0x72uy ] in
assert_norm (List.Tot.length l == 1);
of_list l
let test2_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0x92uy; 0xa0uy; 0x09uy; 0xa9uy; 0xf0uy; 0xd4uy; 0xcauy; 0xb8uy;
0x72uy; 0x0euy; 0x82uy; 0x0buy; 0x5fuy; 0x64uy; 0x25uy; 0x40uy;
0xa2uy; 0xb2uy; 0x7buy; 0x54uy; 0x16uy; 0x50uy; 0x3fuy; 0x8fuy;
0xb3uy; 0x76uy; 0x22uy; 0x23uy; 0xebuy; 0xdbuy; 0x69uy; 0xdauy;
0x08uy; 0x5auy; 0xc1uy; 0xe4uy; 0x3euy; 0x15uy; 0x99uy; 0x6euy;
0x45uy; 0x8fuy; 0x36uy; 0x13uy; 0xd0uy; 0xf1uy; 0x1duy; 0x8cuy;
0x38uy; 0x7buy; 0x2euy; 0xaeuy; 0xb4uy; 0x30uy; 0x2auy; 0xeeuy;
0xb0uy; 0x0duy; 0x29uy; 0x16uy; 0x12uy; 0xbbuy; 0x0cuy; 0x00uy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 3
let test3_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xc5uy; 0xaauy; 0x8duy; 0xf4uy; 0x3fuy; 0x9fuy; 0x83uy; 0x7buy;
0xeduy; 0xb7uy; 0x44uy; 0x2fuy; 0x31uy; 0xdcuy; 0xb7uy; 0xb1uy;
0x66uy; 0xd3uy; 0x85uy; 0x35uy; 0x07uy; 0x6fuy; 0x09uy; 0x4buy;
0x85uy; 0xceuy; 0x3auy; 0x2euy; 0x0buy; 0x44uy; 0x58uy; 0xf7uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test3_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xfcuy; 0x51uy; 0xcduy; 0x8euy; 0x62uy; 0x18uy; 0xa1uy; 0xa3uy;
0x8duy; 0xa4uy; 0x7euy; 0xd0uy; 0x02uy; 0x30uy; 0xf0uy; 0x58uy;
0x08uy; 0x16uy; 0xeduy; 0x13uy; 0xbauy; 0x33uy; 0x03uy; 0xacuy;
0x5duy; 0xebuy; 0x91uy; 0x15uy; 0x48uy; 0x90uy; 0x80uy; 0x25uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test3_msg : lbytes 2 =
let l = List.Tot.map u8_from_UInt8 [ 0xafuy; 0x82uy ] in
assert_norm (List.Tot.length l == 2);
of_list l
let test3_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0x62uy; 0x91uy; 0xd6uy; 0x57uy; 0xdeuy; 0xecuy; 0x24uy; 0x02uy;
0x48uy; 0x27uy; 0xe6uy; 0x9cuy; 0x3auy; 0xbeuy; 0x01uy; 0xa3uy;
0x0cuy; 0xe5uy; 0x48uy; 0xa2uy; 0x84uy; 0x74uy; 0x3auy; 0x44uy;
0x5euy; 0x36uy; 0x80uy; 0xd7uy; 0xdbuy; 0x5auy; 0xc3uy; 0xacuy;
0x18uy; 0xffuy; 0x9buy; 0x53uy; 0x8duy; 0x16uy; 0xf2uy; 0x90uy;
0xaeuy; 0x67uy; 0xf7uy; 0x60uy; 0x98uy; 0x4duy; 0xc6uy; 0x59uy;
0x4auy; 0x7cuy; 0x15uy; 0xe9uy; 0x71uy; 0x6euy; 0xd2uy; 0x8duy;
0xc0uy; 0x27uy; 0xbeuy; 0xceuy; 0xeauy; 0x1euy; 0xc4uy; 0x0auy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 4
let test4_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xf5uy; 0xe5uy; 0x76uy; 0x7cuy; 0xf1uy; 0x53uy; 0x31uy; 0x95uy;
0x17uy; 0x63uy; 0x0fuy; 0x22uy; 0x68uy; 0x76uy; 0xb8uy; 0x6cuy;
0x81uy; 0x60uy; 0xccuy; 0x58uy; 0x3buy; 0xc0uy; 0x13uy; 0x74uy;
0x4cuy; 0x6buy; 0xf2uy; 0x55uy; 0xf5uy; 0xccuy; 0x0euy; 0xe5uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test4_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x27uy; 0x81uy; 0x17uy; 0xfcuy; 0x14uy; 0x4cuy; 0x72uy; 0x34uy;
0x0fuy; 0x67uy; 0xd0uy; 0xf2uy; 0x31uy; 0x6euy; 0x83uy; 0x86uy;
0xceuy; 0xffuy; 0xbfuy; 0x2buy; 0x24uy; 0x28uy; 0xc9uy; 0xc5uy;
0x1fuy; 0xefuy; 0x7cuy; 0x59uy; 0x7fuy; 0x1duy; 0x42uy; 0x6euy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test4_msg : lbytes 1023 =
let l = List.Tot.map u8_from_UInt8 [
0x08uy; 0xb8uy; 0xb2uy; 0xb7uy; 0x33uy; 0x42uy; 0x42uy; 0x43uy;
0x76uy; 0x0fuy; 0xe4uy; 0x26uy; 0xa4uy; 0xb5uy; 0x49uy; 0x08uy;
0x63uy; 0x21uy; 0x10uy; 0xa6uy; 0x6cuy; 0x2fuy; 0x65uy; 0x91uy;
0xeauy; 0xbduy; 0x33uy; 0x45uy; 0xe3uy; 0xe4uy; 0xebuy; 0x98uy;
0xfauy; 0x6euy; 0x26uy; 0x4buy; 0xf0uy; 0x9euy; 0xfeuy; 0x12uy;
0xeeuy; 0x50uy; 0xf8uy; 0xf5uy; 0x4euy; 0x9fuy; 0x77uy; 0xb1uy;
0xe3uy; 0x55uy; 0xf6uy; 0xc5uy; 0x05uy; 0x44uy; 0xe2uy; 0x3fuy;
0xb1uy; 0x43uy; 0x3duy; 0xdfuy; 0x73uy; 0xbeuy; 0x84uy; 0xd8uy;
0x79uy; 0xdeuy; 0x7cuy; 0x00uy; 0x46uy; 0xdcuy; 0x49uy; 0x96uy;
0xd9uy; 0xe7uy; 0x73uy; 0xf4uy; 0xbcuy; 0x9euy; 0xfeuy; 0x57uy;
0x38uy; 0x82uy; 0x9auy; 0xdbuy; 0x26uy; 0xc8uy; 0x1buy; 0x37uy;
0xc9uy; 0x3auy; 0x1buy; 0x27uy; 0x0buy; 0x20uy; 0x32uy; 0x9duy;
0x65uy; 0x86uy; 0x75uy; 0xfcuy; 0x6euy; 0xa5uy; 0x34uy; 0xe0uy;
0x81uy; 0x0auy; 0x44uy; 0x32uy; 0x82uy; 0x6buy; 0xf5uy; 0x8cuy;
0x94uy; 0x1euy; 0xfbuy; 0x65uy; 0xd5uy; 0x7auy; 0x33uy; 0x8buy;
0xbduy; 0x2euy; 0x26uy; 0x64uy; 0x0fuy; 0x89uy; 0xffuy; 0xbcuy;
0x1auy; 0x85uy; 0x8euy; 0xfcuy; 0xb8uy; 0x55uy; 0x0euy; 0xe3uy;
0xa5uy; 0xe1uy; 0x99uy; 0x8buy; 0xd1uy; 0x77uy; 0xe9uy; 0x3auy;
0x73uy; 0x63uy; 0xc3uy; 0x44uy; 0xfeuy; 0x6buy; 0x19uy; 0x9euy;
0xe5uy; 0xd0uy; 0x2euy; 0x82uy; 0xd5uy; 0x22uy; 0xc4uy; 0xfeuy;
0xbauy; 0x15uy; 0x45uy; 0x2fuy; 0x80uy; 0x28uy; 0x8auy; 0x82uy;
0x1auy; 0x57uy; 0x91uy; 0x16uy; 0xecuy; 0x6duy; 0xaduy; 0x2buy;
0x3buy; 0x31uy; 0x0duy; 0xa9uy; 0x03uy; 0x40uy; 0x1auy; 0xa6uy;
0x21uy; 0x00uy; 0xabuy; 0x5duy; 0x1auy; 0x36uy; 0x55uy; 0x3euy;
0x06uy; 0x20uy; 0x3buy; 0x33uy; 0x89uy; 0x0cuy; 0xc9uy; 0xb8uy;
0x32uy; 0xf7uy; 0x9euy; 0xf8uy; 0x05uy; 0x60uy; 0xccuy; 0xb9uy;
0xa3uy; 0x9cuy; 0xe7uy; 0x67uy; 0x96uy; 0x7euy; 0xd6uy; 0x28uy;
0xc6uy; 0xaduy; 0x57uy; 0x3cuy; 0xb1uy; 0x16uy; 0xdbuy; 0xefuy;
0xefuy; 0xd7uy; 0x54uy; 0x99uy; 0xdauy; 0x96uy; 0xbduy; 0x68uy;
0xa8uy; 0xa9uy; 0x7buy; 0x92uy; 0x8auy; 0x8buy; 0xbcuy; 0x10uy;
0x3buy; 0x66uy; 0x21uy; 0xfcuy; 0xdeuy; 0x2buy; 0xecuy; 0xa1uy;
0x23uy; 0x1duy; 0x20uy; 0x6buy; 0xe6uy; 0xcduy; 0x9euy; 0xc7uy;
0xafuy; 0xf6uy; 0xf6uy; 0xc9uy; 0x4fuy; 0xcduy; 0x72uy; 0x04uy;
0xeduy; 0x34uy; 0x55uy; 0xc6uy; 0x8cuy; 0x83uy; 0xf4uy; 0xa4uy;
0x1duy; 0xa4uy; 0xafuy; 0x2buy; 0x74uy; 0xefuy; 0x5cuy; 0x53uy;
0xf1uy; 0xd8uy; 0xacuy; 0x70uy; 0xbduy; 0xcbuy; 0x7euy; 0xd1uy;
0x85uy; 0xceuy; 0x81uy; 0xbduy; 0x84uy; 0x35uy; 0x9duy; 0x44uy;
0x25uy; 0x4duy; 0x95uy; 0x62uy; 0x9euy; 0x98uy; 0x55uy; 0xa9uy;
0x4auy; 0x7cuy; 0x19uy; 0x58uy; 0xd1uy; 0xf8uy; 0xaduy; 0xa5uy;
0xd0uy; 0x53uy; 0x2euy; 0xd8uy; 0xa5uy; 0xaauy; 0x3fuy; 0xb2uy;
0xd1uy; 0x7buy; 0xa7uy; 0x0euy; 0xb6uy; 0x24uy; 0x8euy; 0x59uy;
0x4euy; 0x1auy; 0x22uy; 0x97uy; 0xacuy; 0xbbuy; 0xb3uy; 0x9duy;
0x50uy; 0x2fuy; 0x1auy; 0x8cuy; 0x6euy; 0xb6uy; 0xf1uy; 0xceuy;
0x22uy; 0xb3uy; 0xdeuy; 0x1auy; 0x1fuy; 0x40uy; 0xccuy; 0x24uy;
0x55uy; 0x41uy; 0x19uy; 0xa8uy; 0x31uy; 0xa9uy; 0xaauy; 0xd6uy;
0x07uy; 0x9cuy; 0xaduy; 0x88uy; 0x42uy; 0x5duy; 0xe6uy; 0xbduy;
0xe1uy; 0xa9uy; 0x18uy; 0x7euy; 0xbbuy; 0x60uy; 0x92uy; 0xcfuy;
0x67uy; 0xbfuy; 0x2buy; 0x13uy; 0xfduy; 0x65uy; 0xf2uy; 0x70uy;
0x88uy; 0xd7uy; 0x8buy; 0x7euy; 0x88uy; 0x3cuy; 0x87uy; 0x59uy;
0xd2uy; 0xc4uy; 0xf5uy; 0xc6uy; 0x5auy; 0xdbuy; 0x75uy; 0x53uy;
0x87uy; 0x8auy; 0xd5uy; 0x75uy; 0xf9uy; 0xfauy; 0xd8uy; 0x78uy;
0xe8uy; 0x0auy; 0x0cuy; 0x9buy; 0xa6uy; 0x3buy; 0xcbuy; 0xccuy;
0x27uy; 0x32uy; 0xe6uy; 0x94uy; 0x85uy; 0xbbuy; 0xc9uy; 0xc9uy;
0x0buy; 0xfbuy; 0xd6uy; 0x24uy; 0x81uy; 0xd9uy; 0x08uy; 0x9buy;
0xecuy; 0xcfuy; 0x80uy; 0xcfuy; 0xe2uy; 0xdfuy; 0x16uy; 0xa2uy;
0xcfuy; 0x65uy; 0xbduy; 0x92uy; 0xdduy; 0x59uy; 0x7buy; 0x07uy;
0x07uy; 0xe0uy; 0x91uy; 0x7auy; 0xf4uy; 0x8buy; 0xbbuy; 0x75uy;
0xfeuy; 0xd4uy; 0x13uy; 0xd2uy; 0x38uy; 0xf5uy; 0x55uy; 0x5auy;
0x7auy; 0x56uy; 0x9duy; 0x80uy; 0xc3uy; 0x41uy; 0x4auy; 0x8duy;
0x08uy; 0x59uy; 0xdcuy; 0x65uy; 0xa4uy; 0x61uy; 0x28uy; 0xbauy;
0xb2uy; 0x7auy; 0xf8uy; 0x7auy; 0x71uy; 0x31uy; 0x4fuy; 0x31uy;
0x8cuy; 0x78uy; 0x2buy; 0x23uy; 0xebuy; 0xfeuy; 0x80uy; 0x8buy;
0x82uy; 0xb0uy; 0xceuy; 0x26uy; 0x40uy; 0x1duy; 0x2euy; 0x22uy;
0xf0uy; 0x4duy; 0x83uy; 0xd1uy; 0x25uy; 0x5duy; 0xc5uy; 0x1auy;
0xdduy; 0xd3uy; 0xb7uy; 0x5auy; 0x2buy; 0x1auy; 0xe0uy; 0x78uy;
0x45uy; 0x04uy; 0xdfuy; 0x54uy; 0x3auy; 0xf8uy; 0x96uy; 0x9buy;
0xe3uy; 0xeauy; 0x70uy; 0x82uy; 0xffuy; 0x7fuy; 0xc9uy; 0x88uy;
0x8cuy; 0x14uy; 0x4duy; 0xa2uy; 0xafuy; 0x58uy; 0x42uy; 0x9euy;
0xc9uy; 0x60uy; 0x31uy; 0xdbuy; 0xcauy; 0xd3uy; 0xdauy; 0xd9uy;
0xafuy; 0x0duy; 0xcbuy; 0xaauy; 0xafuy; 0x26uy; 0x8cuy; 0xb8uy;
0xfcuy; 0xffuy; 0xeauy; 0xd9uy; 0x4fuy; 0x3cuy; 0x7cuy; 0xa4uy;
0x95uy; 0xe0uy; 0x56uy; 0xa9uy; 0xb4uy; 0x7auy; 0xcduy; 0xb7uy;
0x51uy; 0xfbuy; 0x73uy; 0xe6uy; 0x66uy; 0xc6uy; 0xc6uy; 0x55uy;
0xaduy; 0xe8uy; 0x29uy; 0x72uy; 0x97uy; 0xd0uy; 0x7auy; 0xd1uy;
0xbauy; 0x5euy; 0x43uy; 0xf1uy; 0xbcuy; 0xa3uy; 0x23uy; 0x01uy;
0x65uy; 0x13uy; 0x39uy; 0xe2uy; 0x29uy; 0x04uy; 0xccuy; 0x8cuy;
0x42uy; 0xf5uy; 0x8cuy; 0x30uy; 0xc0uy; 0x4auy; 0xafuy; 0xdbuy;
0x03uy; 0x8duy; 0xdauy; 0x08uy; 0x47uy; 0xdduy; 0x98uy; 0x8duy;
0xcduy; 0xa6uy; 0xf3uy; 0xbfuy; 0xd1uy; 0x5cuy; 0x4buy; 0x4cuy;
0x45uy; 0x25uy; 0x00uy; 0x4auy; 0xa0uy; 0x6euy; 0xefuy; 0xf8uy;
0xcauy; 0x61uy; 0x78uy; 0x3auy; 0xacuy; 0xecuy; 0x57uy; 0xfbuy;
0x3duy; 0x1fuy; 0x92uy; 0xb0uy; 0xfeuy; 0x2fuy; 0xd1uy; 0xa8uy;
0x5fuy; 0x67uy; 0x24uy; 0x51uy; 0x7buy; 0x65uy; 0xe6uy; 0x14uy;
0xaduy; 0x68uy; 0x08uy; 0xd6uy; 0xf6uy; 0xeeuy; 0x34uy; 0xdfuy;
0xf7uy; 0x31uy; 0x0fuy; 0xdcuy; 0x82uy; 0xaeuy; 0xbfuy; 0xd9uy;
0x04uy; 0xb0uy; 0x1euy; 0x1duy; 0xc5uy; 0x4buy; 0x29uy; 0x27uy;
0x09uy; 0x4buy; 0x2duy; 0xb6uy; 0x8duy; 0x6fuy; 0x90uy; 0x3buy;
0x68uy; 0x40uy; 0x1auy; 0xdeuy; 0xbfuy; 0x5auy; 0x7euy; 0x08uy;
0xd7uy; 0x8fuy; 0xf4uy; 0xefuy; 0x5duy; 0x63uy; 0x65uy; 0x3auy;
0x65uy; 0x04uy; 0x0cuy; 0xf9uy; 0xbfuy; 0xd4uy; 0xacuy; 0xa7uy;
0x98uy; 0x4auy; 0x74uy; 0xd3uy; 0x71uy; 0x45uy; 0x98uy; 0x67uy;
0x80uy; 0xfcuy; 0x0buy; 0x16uy; 0xacuy; 0x45uy; 0x16uy; 0x49uy;
0xdeuy; 0x61uy; 0x88uy; 0xa7uy; 0xdbuy; 0xdfuy; 0x19uy; 0x1fuy;
0x64uy; 0xb5uy; 0xfcuy; 0x5euy; 0x2auy; 0xb4uy; 0x7buy; 0x57uy;
0xf7uy; 0xf7uy; 0x27uy; 0x6cuy; 0xd4uy; 0x19uy; 0xc1uy; 0x7auy;
0x3cuy; 0xa8uy; 0xe1uy; 0xb9uy; 0x39uy; 0xaeuy; 0x49uy; 0xe4uy;
0x88uy; 0xacuy; 0xbauy; 0x6buy; 0x96uy; 0x56uy; 0x10uy; 0xb5uy;
0x48uy; 0x01uy; 0x09uy; 0xc8uy; 0xb1uy; 0x7buy; 0x80uy; 0xe1uy;
0xb7uy; 0xb7uy; 0x50uy; 0xdfuy; 0xc7uy; 0x59uy; 0x8duy; 0x5duy;
0x50uy; 0x11uy; 0xfduy; 0x2duy; 0xccuy; 0x56uy; 0x00uy; 0xa3uy;
0x2euy; 0xf5uy; 0xb5uy; 0x2auy; 0x1euy; 0xccuy; 0x82uy; 0x0euy;
0x30uy; 0x8auy; 0xa3uy; 0x42uy; 0x72uy; 0x1auy; 0xacuy; 0x09uy;
0x43uy; 0xbfuy; 0x66uy; 0x86uy; 0xb6uy; 0x4buy; 0x25uy; 0x79uy;
0x37uy; 0x65uy; 0x04uy; 0xccuy; 0xc4uy; 0x93uy; 0xd9uy; 0x7euy;
0x6auy; 0xeduy; 0x3fuy; 0xb0uy; 0xf9uy; 0xcduy; 0x71uy; 0xa4uy;
0x3duy; 0xd4uy; 0x97uy; 0xf0uy; 0x1fuy; 0x17uy; 0xc0uy; 0xe2uy;
0xcbuy; 0x37uy; 0x97uy; 0xaauy; 0x2auy; 0x2fuy; 0x25uy; 0x66uy;
0x56uy; 0x16uy; 0x8euy; 0x6cuy; 0x49uy; 0x6auy; 0xfcuy; 0x5fuy;
0xb9uy; 0x32uy; 0x46uy; 0xf6uy; 0xb1uy; 0x11uy; 0x63uy; 0x98uy;
0xa3uy; 0x46uy; 0xf1uy; 0xa6uy; 0x41uy; 0xf3uy; 0xb0uy; 0x41uy;
0xe9uy; 0x89uy; 0xf7uy; 0x91uy; 0x4fuy; 0x90uy; 0xccuy; 0x2cuy;
0x7fuy; 0xffuy; 0x35uy; 0x78uy; 0x76uy; 0xe5uy; 0x06uy; 0xb5uy;
0x0duy; 0x33uy; 0x4buy; 0xa7uy; 0x7cuy; 0x22uy; 0x5buy; 0xc3uy;
0x07uy; 0xbauy; 0x53uy; 0x71uy; 0x52uy; 0xf3uy; 0xf1uy; 0x61uy;
0x0euy; 0x4euy; 0xafuy; 0xe5uy; 0x95uy; 0xf6uy; 0xd9uy; 0xd9uy;
0x0duy; 0x11uy; 0xfauy; 0xa9uy; 0x33uy; 0xa1uy; 0x5euy; 0xf1uy;
0x36uy; 0x95uy; 0x46uy; 0x86uy; 0x8auy; 0x7fuy; 0x3auy; 0x45uy;
0xa9uy; 0x67uy; 0x68uy; 0xd4uy; 0x0fuy; 0xd9uy; 0xd0uy; 0x34uy;
0x12uy; 0xc0uy; 0x91uy; 0xc6uy; 0x31uy; 0x5cuy; 0xf4uy; 0xfduy;
0xe7uy; 0xcbuy; 0x68uy; 0x60uy; 0x69uy; 0x37uy; 0x38uy; 0x0duy;
0xb2uy; 0xeauy; 0xaauy; 0x70uy; 0x7buy; 0x4cuy; 0x41uy; 0x85uy;
0xc3uy; 0x2euy; 0xdduy; 0xcduy; 0xd3uy; 0x06uy; 0x70uy; 0x5euy;
0x4duy; 0xc1uy; 0xffuy; 0xc8uy; 0x72uy; 0xeeuy; 0xeeuy; 0x47uy;
0x5auy; 0x64uy; 0xdfuy; 0xacuy; 0x86uy; 0xabuy; 0xa4uy; 0x1cuy;
0x06uy; 0x18uy; 0x98uy; 0x3fuy; 0x87uy; 0x41uy; 0xc5uy; 0xefuy;
0x68uy; 0xd3uy; 0xa1uy; 0x01uy; 0xe8uy; 0xa3uy; 0xb8uy; 0xcauy;
0xc6uy; 0x0cuy; 0x90uy; 0x5cuy; 0x15uy; 0xfcuy; 0x91uy; 0x08uy;
0x40uy; 0xb9uy; 0x4cuy; 0x00uy; 0xa0uy; 0xb9uy; 0xd0uy
] in
assert_norm (List.Tot.length l == 1023);
of_list l
let test4_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0x0auy; 0xabuy; 0x4cuy; 0x90uy; 0x05uy; 0x01uy; 0xb3uy; 0xe2uy;
0x4duy; 0x7cuy; 0xdfuy; 0x46uy; 0x63uy; 0x32uy; 0x6auy; 0x3auy;
0x87uy; 0xdfuy; 0x5euy; 0x48uy; 0x43uy; 0xb2uy; 0xcbuy; 0xdbuy;
0x67uy; 0xcbuy; 0xf6uy; 0xe4uy; 0x60uy; 0xfeuy; 0xc3uy; 0x50uy;
0xaauy; 0x53uy; 0x71uy; 0xb1uy; 0x50uy; 0x8fuy; 0x9fuy; 0x45uy;
0x28uy; 0xecuy; 0xeauy; 0x23uy; 0xc4uy; 0x36uy; 0xd9uy; 0x4buy;
0x5euy; 0x8fuy; 0xcduy; 0x4fuy; 0x68uy; 0x1euy; 0x30uy; 0xa6uy;
0xacuy; 0x00uy; 0xa9uy; 0x70uy; 0x4auy; 0x18uy; 0x8auy; 0x03uy
] in
assert_norm (List.Tot.length l == 64);
of_list l
noeq type vec =
| Vec :
sk:lbytes 32
-> pk:lbytes 32
-> msg:bytes{length msg <= max_size_t}
-> expected_sig:lbytes 64 -> vec
let test_vectors : list vec = [
Vec test1_sk test1_pk test1_msg test1_expected_sig;
Vec test2_sk test2_pk test2_msg test2_expected_sig;
Vec test3_sk test3_pk test3_msg test3_expected_sig;
Vec test4_sk test4_pk test4_msg test4_expected_sig ]
let test_one (v:vec) =
let Vec sk pk msg expected_sig = v in
let sig = Spec.Ed25519.sign sk msg in
let verify = Spec.Ed25519.verify pk msg sig in
let res = PS.print_compare true 64 expected_sig sig in
if res then IO.print_string "\nTest signature: Success!\n"
else IO.print_string "\nTest signature: Failure :(\n";
if verify then IO.print_string "Test verification: Success!\n"
else IO.print_string "Test verification: Failure :(\n";
res && verify | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.PrintSequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Ed25519.Test.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.PrintSequence",
"short_module": "PS"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"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": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"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
}
] | {
"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"
} | false | _: Prims.unit -> FStar.All.ML Prims.bool | FStar.All.ML | [
"ml"
] | [] | [
"Prims.unit",
"Prims.bool",
"FStar.IO.print_string",
"FStar.List.for_all",
"Spec.Ed25519.Test.vec",
"Spec.Ed25519.Test.test_one",
"Spec.Ed25519.Test.test_vectors"
] | [] | false | true | false | false | false | let test () =
| let res = List.for_all test_one test_vectors in
if res
then
(IO.print_string "\n\nEd25519 : Success!\n";
true)
else
(IO.print_string "\n\nEd25519: Failure :(\n";
false) | false |
Vale.X64.Flags.fst | Vale.X64.Flags.lemma_upd_ne | val lemma_upd_ne (r r':flag) (v:flag_val_t) (m:t) : Lemma
(requires r =!= r')
(ensures sel r (upd r' v m) == sel r m)
[SMTPat (sel r (upd r' v m))] | val lemma_upd_ne (r r':flag) (v:flag_val_t) (m:t) : Lemma
(requires r =!= r')
(ensures sel r (upd r' v m) == sel r m)
[SMTPat (sel r (upd r' v m))] | let lemma_upd_ne r r' v m =
reveal_opaque (`%sel) sel;
reveal_opaque (`%upd) upd;
Map.lemma_SelUpd2 m r r' v | {
"file_name": "vale/code/arch/x64/Vale.X64.Flags.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 28,
"end_line": 60,
"start_col": 0,
"start_line": 57
} | module Vale.X64.Flags
open FStar.Mul
open Vale.X64.Machine_s
type t = (m:Map.t flag flag_val_t{Set.equal (Map.domain m) (Set.complement Set.empty)})
[@va_qattr "opaque_to_smt"]
let sel (r:flag) (m:t) : flag_val_t =
Map.sel m r
[@va_qattr "opaque_to_smt"]
let upd (r:flag) (v:flag_val_t) (m:t) : t =
reveal_opaque (`%t) t;
Map.upd m r v
let of_fun m =
let m' = Map.const None in
let m' = Map.upd m' 0 (m 0) in
let m' = Map.upd m' 1 (m 1) in
let m' = Map.upd m' 2 (m 2) in
let m' = Map.upd m' 3 (m 3) in
let m' = Map.upd m' 4 (m 4) in
let m' = Map.upd m' 5 (m 5) in
let m' = Map.upd m' 6 (m 6) in
let m' = Map.upd m' 7 (m 7) in
let m' = Map.upd m' 8 (m 8) in
let m' = Map.upd m' 9 (m 9) in
let m' = Map.upd m' 10 (m 10) in
let m' = Map.upd m' 11 (m 11) in
let m' = Map.upd m' 12 (m 12) in
let m' = Map.upd m' 13 (m 13) in
let m' = Map.upd m' 14 (m 14) in
let m' = Map.upd m' 15 (m 15) in
assert_norm (m 0 == sel 0 m');
assert_norm (m 1 == sel 1 m');
assert_norm (m 2 == sel 2 m');
assert_norm (m 3 == sel 3 m');
assert_norm (m 4 == sel 4 m');
assert_norm (m 5 == sel 5 m');
assert_norm (m 6 == sel 6 m');
assert_norm (m 7 == sel 7 m');
assert_norm (m 8 == sel 8 m');
assert_norm (m 9 == sel 9 m');
assert_norm (m 10 == sel 10 m');
assert_norm (m 11 == sel 11 m');
assert_norm (m 12 == sel 12 m');
assert_norm (m 13 == sel 13 m');
assert_norm (m 14 == sel 14 m');
assert_norm (m 15 == sel 15 m');
m'
let lemma_upd_eq r v m =
reveal_opaque (`%sel) sel;
reveal_opaque (`%upd) upd;
Map.lemma_SelUpd1 m r v | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Flags.fst"
} | [
{
"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.Lib.Map16",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false |
r: Vale.X64.Machine_s.flag ->
r': Vale.X64.Machine_s.flag ->
v: Vale.X64.Flags.flag_val_t ->
m: Vale.X64.Flags.t
-> FStar.Pervasives.Lemma (requires ~(r == r'))
(ensures Vale.X64.Flags.sel r (Vale.X64.Flags.upd r' v m) == Vale.X64.Flags.sel r m)
[SMTPat (Vale.X64.Flags.sel r (Vale.X64.Flags.upd r' v m))] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.X64.Machine_s.flag",
"Vale.X64.Flags.flag_val_t",
"Vale.X64.Flags.t",
"FStar.Map.lemma_SelUpd2",
"Prims.unit",
"FStar.Pervasives.reveal_opaque",
"Vale.X64.Flags.upd",
"Vale.X64.Flags.sel"
] | [] | true | false | true | false | false | let lemma_upd_ne r r' v m =
| reveal_opaque (`%sel) sel;
reveal_opaque (`%upd) upd;
Map.lemma_SelUpd2 m r r' v | false |
Vale.X64.Flags.fst | Vale.X64.Flags.lemma_equal_intro | val lemma_equal_intro (flags1:t) (flags2:t) : Lemma
(requires forall (r:flag). sel r flags1 == sel r flags2)
(ensures equal flags1 flags2)
[SMTPat (equal flags1 flags2)] | val lemma_equal_intro (flags1:t) (flags2:t) : Lemma
(requires forall (r:flag). sel r flags1 == sel r flags2)
(ensures equal flags1 flags2)
[SMTPat (equal flags1 flags2)] | let lemma_equal_intro m1 m2 =
assert_norm (forall (r:flag). sel r m1 == Map.sel m1 r);
assert_norm (forall (r:flag). sel r m2 == Map.sel m2 r);
reveal_opaque (`%t) t;
Map.lemma_equal_intro m1 m2 | {
"file_name": "vale/code/arch/x64/Vale.X64.Flags.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 29,
"end_line": 68,
"start_col": 0,
"start_line": 64
} | module Vale.X64.Flags
open FStar.Mul
open Vale.X64.Machine_s
type t = (m:Map.t flag flag_val_t{Set.equal (Map.domain m) (Set.complement Set.empty)})
[@va_qattr "opaque_to_smt"]
let sel (r:flag) (m:t) : flag_val_t =
Map.sel m r
[@va_qattr "opaque_to_smt"]
let upd (r:flag) (v:flag_val_t) (m:t) : t =
reveal_opaque (`%t) t;
Map.upd m r v
let of_fun m =
let m' = Map.const None in
let m' = Map.upd m' 0 (m 0) in
let m' = Map.upd m' 1 (m 1) in
let m' = Map.upd m' 2 (m 2) in
let m' = Map.upd m' 3 (m 3) in
let m' = Map.upd m' 4 (m 4) in
let m' = Map.upd m' 5 (m 5) in
let m' = Map.upd m' 6 (m 6) in
let m' = Map.upd m' 7 (m 7) in
let m' = Map.upd m' 8 (m 8) in
let m' = Map.upd m' 9 (m 9) in
let m' = Map.upd m' 10 (m 10) in
let m' = Map.upd m' 11 (m 11) in
let m' = Map.upd m' 12 (m 12) in
let m' = Map.upd m' 13 (m 13) in
let m' = Map.upd m' 14 (m 14) in
let m' = Map.upd m' 15 (m 15) in
assert_norm (m 0 == sel 0 m');
assert_norm (m 1 == sel 1 m');
assert_norm (m 2 == sel 2 m');
assert_norm (m 3 == sel 3 m');
assert_norm (m 4 == sel 4 m');
assert_norm (m 5 == sel 5 m');
assert_norm (m 6 == sel 6 m');
assert_norm (m 7 == sel 7 m');
assert_norm (m 8 == sel 8 m');
assert_norm (m 9 == sel 9 m');
assert_norm (m 10 == sel 10 m');
assert_norm (m 11 == sel 11 m');
assert_norm (m 12 == sel 12 m');
assert_norm (m 13 == sel 13 m');
assert_norm (m 14 == sel 14 m');
assert_norm (m 15 == sel 15 m');
m'
let lemma_upd_eq r v m =
reveal_opaque (`%sel) sel;
reveal_opaque (`%upd) upd;
Map.lemma_SelUpd1 m r v
let lemma_upd_ne r r' v m =
reveal_opaque (`%sel) sel;
reveal_opaque (`%upd) upd;
Map.lemma_SelUpd2 m r r' v
let equal m1 m2 = m1 == m2 | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Flags.fst"
} | [
{
"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.Lib.Map16",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | flags1: Vale.X64.Flags.t -> flags2: Vale.X64.Flags.t
-> FStar.Pervasives.Lemma
(requires
forall (r: Vale.X64.Machine_s.flag).
Vale.X64.Flags.sel r flags1 == Vale.X64.Flags.sel r flags2)
(ensures Vale.X64.Flags.equal flags1 flags2)
[SMTPat (Vale.X64.Flags.equal flags1 flags2)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.X64.Flags.t",
"FStar.Map.lemma_equal_intro",
"Vale.X64.Machine_s.flag",
"Vale.X64.Flags.flag_val_t",
"Prims.unit",
"FStar.Pervasives.reveal_opaque",
"FStar.Pervasives.assert_norm",
"Prims.l_Forall",
"Prims.eq2",
"Vale.X64.Flags.sel",
"FStar.Map.sel"
] | [] | false | false | true | false | false | let lemma_equal_intro m1 m2 =
| assert_norm (forall (r: flag). sel r m1 == Map.sel m1 r);
assert_norm (forall (r: flag). sel r m2 == Map.sel m2 r);
reveal_opaque (`%t) t;
Map.lemma_equal_intro m1 m2 | false |
Spec.Ed25519.Test.fst | Spec.Ed25519.Test.test_one | val test_one : v: Spec.Ed25519.Test.vec -> FStar.All.ALL Prims.bool | let test_one (v:vec) =
let Vec sk pk msg expected_sig = v in
let sig = Spec.Ed25519.sign sk msg in
let verify = Spec.Ed25519.verify pk msg sig in
let res = PS.print_compare true 64 expected_sig sig in
if res then IO.print_string "\nTest signature: Success!\n"
else IO.print_string "\nTest signature: Failure :(\n";
if verify then IO.print_string "Test verification: Success!\n"
else IO.print_string "Test verification: Failure :(\n";
res && verify | {
"file_name": "specs/tests/Spec.Ed25519.Test.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 348,
"start_col": 0,
"start_line": 336
} | module Spec.Ed25519.Test
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module PS = Lib.PrintSequence
open Spec.Ed25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Test 1
let test1_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x9duy; 0x61uy; 0xb1uy; 0x9duy; 0xefuy; 0xfduy; 0x5auy; 0x60uy;
0xbauy; 0x84uy; 0x4auy; 0xf4uy; 0x92uy; 0xecuy; 0x2cuy; 0xc4uy;
0x44uy; 0x49uy; 0xc5uy; 0x69uy; 0x7buy; 0x32uy; 0x69uy; 0x19uy;
0x70uy; 0x3buy; 0xacuy; 0x03uy; 0x1cuy; 0xaeuy; 0x7fuy; 0x60uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xd7uy; 0x5auy; 0x98uy; 0x01uy; 0x82uy; 0xb1uy; 0x0auy; 0xb7uy;
0xd5uy; 0x4buy; 0xfeuy; 0xd3uy; 0xc9uy; 0x64uy; 0x07uy; 0x3auy;
0x0euy; 0xe1uy; 0x72uy; 0xf3uy; 0xdauy; 0xa6uy; 0x23uy; 0x25uy;
0xafuy; 0x02uy; 0x1auy; 0x68uy; 0xf7uy; 0x07uy; 0x51uy; 0x1auy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_msg : lbytes 0 =
let l = List.Tot.map u8_from_UInt8 [] in
assert_norm (List.Tot.length l == 0);
of_list l
let test1_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0xe5uy; 0x56uy; 0x43uy; 0x00uy; 0xc3uy; 0x60uy; 0xacuy; 0x72uy;
0x90uy; 0x86uy; 0xe2uy; 0xccuy; 0x80uy; 0x6euy; 0x82uy; 0x8auy;
0x84uy; 0x87uy; 0x7fuy; 0x1euy; 0xb8uy; 0xe5uy; 0xd9uy; 0x74uy;
0xd8uy; 0x73uy; 0xe0uy; 0x65uy; 0x22uy; 0x49uy; 0x01uy; 0x55uy;
0x5fuy; 0xb8uy; 0x82uy; 0x15uy; 0x90uy; 0xa3uy; 0x3buy; 0xacuy;
0xc6uy; 0x1euy; 0x39uy; 0x70uy; 0x1cuy; 0xf9uy; 0xb4uy; 0x6buy;
0xd2uy; 0x5buy; 0xf5uy; 0xf0uy; 0x59uy; 0x5buy; 0xbeuy; 0x24uy;
0x65uy; 0x51uy; 0x41uy; 0x43uy; 0x8euy; 0x7auy; 0x10uy; 0x0buy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 2
let test2_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x4cuy; 0xcduy; 0x08uy; 0x9buy; 0x28uy; 0xffuy; 0x96uy; 0xdauy;
0x9duy; 0xb6uy; 0xc3uy; 0x46uy; 0xecuy; 0x11uy; 0x4euy; 0x0fuy;
0x5buy; 0x8auy; 0x31uy; 0x9fuy; 0x35uy; 0xabuy; 0xa6uy; 0x24uy;
0xdauy; 0x8cuy; 0xf6uy; 0xeduy; 0x4fuy; 0xb8uy; 0xa6uy; 0xfbuy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test2_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x3duy; 0x40uy; 0x17uy; 0xc3uy; 0xe8uy; 0x43uy; 0x89uy; 0x5auy;
0x92uy; 0xb7uy; 0x0auy; 0xa7uy; 0x4duy; 0x1buy; 0x7euy; 0xbcuy;
0x9cuy; 0x98uy; 0x2cuy; 0xcfuy; 0x2euy; 0xc4uy; 0x96uy; 0x8cuy;
0xc0uy; 0xcduy; 0x55uy; 0xf1uy; 0x2auy; 0xf4uy; 0x66uy; 0x0cuy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test2_msg : lbytes 1 =
let l = List.Tot.map u8_from_UInt8 [ 0x72uy ] in
assert_norm (List.Tot.length l == 1);
of_list l
let test2_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0x92uy; 0xa0uy; 0x09uy; 0xa9uy; 0xf0uy; 0xd4uy; 0xcauy; 0xb8uy;
0x72uy; 0x0euy; 0x82uy; 0x0buy; 0x5fuy; 0x64uy; 0x25uy; 0x40uy;
0xa2uy; 0xb2uy; 0x7buy; 0x54uy; 0x16uy; 0x50uy; 0x3fuy; 0x8fuy;
0xb3uy; 0x76uy; 0x22uy; 0x23uy; 0xebuy; 0xdbuy; 0x69uy; 0xdauy;
0x08uy; 0x5auy; 0xc1uy; 0xe4uy; 0x3euy; 0x15uy; 0x99uy; 0x6euy;
0x45uy; 0x8fuy; 0x36uy; 0x13uy; 0xd0uy; 0xf1uy; 0x1duy; 0x8cuy;
0x38uy; 0x7buy; 0x2euy; 0xaeuy; 0xb4uy; 0x30uy; 0x2auy; 0xeeuy;
0xb0uy; 0x0duy; 0x29uy; 0x16uy; 0x12uy; 0xbbuy; 0x0cuy; 0x00uy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 3
let test3_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xc5uy; 0xaauy; 0x8duy; 0xf4uy; 0x3fuy; 0x9fuy; 0x83uy; 0x7buy;
0xeduy; 0xb7uy; 0x44uy; 0x2fuy; 0x31uy; 0xdcuy; 0xb7uy; 0xb1uy;
0x66uy; 0xd3uy; 0x85uy; 0x35uy; 0x07uy; 0x6fuy; 0x09uy; 0x4buy;
0x85uy; 0xceuy; 0x3auy; 0x2euy; 0x0buy; 0x44uy; 0x58uy; 0xf7uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test3_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xfcuy; 0x51uy; 0xcduy; 0x8euy; 0x62uy; 0x18uy; 0xa1uy; 0xa3uy;
0x8duy; 0xa4uy; 0x7euy; 0xd0uy; 0x02uy; 0x30uy; 0xf0uy; 0x58uy;
0x08uy; 0x16uy; 0xeduy; 0x13uy; 0xbauy; 0x33uy; 0x03uy; 0xacuy;
0x5duy; 0xebuy; 0x91uy; 0x15uy; 0x48uy; 0x90uy; 0x80uy; 0x25uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test3_msg : lbytes 2 =
let l = List.Tot.map u8_from_UInt8 [ 0xafuy; 0x82uy ] in
assert_norm (List.Tot.length l == 2);
of_list l
let test3_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0x62uy; 0x91uy; 0xd6uy; 0x57uy; 0xdeuy; 0xecuy; 0x24uy; 0x02uy;
0x48uy; 0x27uy; 0xe6uy; 0x9cuy; 0x3auy; 0xbeuy; 0x01uy; 0xa3uy;
0x0cuy; 0xe5uy; 0x48uy; 0xa2uy; 0x84uy; 0x74uy; 0x3auy; 0x44uy;
0x5euy; 0x36uy; 0x80uy; 0xd7uy; 0xdbuy; 0x5auy; 0xc3uy; 0xacuy;
0x18uy; 0xffuy; 0x9buy; 0x53uy; 0x8duy; 0x16uy; 0xf2uy; 0x90uy;
0xaeuy; 0x67uy; 0xf7uy; 0x60uy; 0x98uy; 0x4duy; 0xc6uy; 0x59uy;
0x4auy; 0x7cuy; 0x15uy; 0xe9uy; 0x71uy; 0x6euy; 0xd2uy; 0x8duy;
0xc0uy; 0x27uy; 0xbeuy; 0xceuy; 0xeauy; 0x1euy; 0xc4uy; 0x0auy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 4
let test4_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xf5uy; 0xe5uy; 0x76uy; 0x7cuy; 0xf1uy; 0x53uy; 0x31uy; 0x95uy;
0x17uy; 0x63uy; 0x0fuy; 0x22uy; 0x68uy; 0x76uy; 0xb8uy; 0x6cuy;
0x81uy; 0x60uy; 0xccuy; 0x58uy; 0x3buy; 0xc0uy; 0x13uy; 0x74uy;
0x4cuy; 0x6buy; 0xf2uy; 0x55uy; 0xf5uy; 0xccuy; 0x0euy; 0xe5uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test4_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x27uy; 0x81uy; 0x17uy; 0xfcuy; 0x14uy; 0x4cuy; 0x72uy; 0x34uy;
0x0fuy; 0x67uy; 0xd0uy; 0xf2uy; 0x31uy; 0x6euy; 0x83uy; 0x86uy;
0xceuy; 0xffuy; 0xbfuy; 0x2buy; 0x24uy; 0x28uy; 0xc9uy; 0xc5uy;
0x1fuy; 0xefuy; 0x7cuy; 0x59uy; 0x7fuy; 0x1duy; 0x42uy; 0x6euy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test4_msg : lbytes 1023 =
let l = List.Tot.map u8_from_UInt8 [
0x08uy; 0xb8uy; 0xb2uy; 0xb7uy; 0x33uy; 0x42uy; 0x42uy; 0x43uy;
0x76uy; 0x0fuy; 0xe4uy; 0x26uy; 0xa4uy; 0xb5uy; 0x49uy; 0x08uy;
0x63uy; 0x21uy; 0x10uy; 0xa6uy; 0x6cuy; 0x2fuy; 0x65uy; 0x91uy;
0xeauy; 0xbduy; 0x33uy; 0x45uy; 0xe3uy; 0xe4uy; 0xebuy; 0x98uy;
0xfauy; 0x6euy; 0x26uy; 0x4buy; 0xf0uy; 0x9euy; 0xfeuy; 0x12uy;
0xeeuy; 0x50uy; 0xf8uy; 0xf5uy; 0x4euy; 0x9fuy; 0x77uy; 0xb1uy;
0xe3uy; 0x55uy; 0xf6uy; 0xc5uy; 0x05uy; 0x44uy; 0xe2uy; 0x3fuy;
0xb1uy; 0x43uy; 0x3duy; 0xdfuy; 0x73uy; 0xbeuy; 0x84uy; 0xd8uy;
0x79uy; 0xdeuy; 0x7cuy; 0x00uy; 0x46uy; 0xdcuy; 0x49uy; 0x96uy;
0xd9uy; 0xe7uy; 0x73uy; 0xf4uy; 0xbcuy; 0x9euy; 0xfeuy; 0x57uy;
0x38uy; 0x82uy; 0x9auy; 0xdbuy; 0x26uy; 0xc8uy; 0x1buy; 0x37uy;
0xc9uy; 0x3auy; 0x1buy; 0x27uy; 0x0buy; 0x20uy; 0x32uy; 0x9duy;
0x65uy; 0x86uy; 0x75uy; 0xfcuy; 0x6euy; 0xa5uy; 0x34uy; 0xe0uy;
0x81uy; 0x0auy; 0x44uy; 0x32uy; 0x82uy; 0x6buy; 0xf5uy; 0x8cuy;
0x94uy; 0x1euy; 0xfbuy; 0x65uy; 0xd5uy; 0x7auy; 0x33uy; 0x8buy;
0xbduy; 0x2euy; 0x26uy; 0x64uy; 0x0fuy; 0x89uy; 0xffuy; 0xbcuy;
0x1auy; 0x85uy; 0x8euy; 0xfcuy; 0xb8uy; 0x55uy; 0x0euy; 0xe3uy;
0xa5uy; 0xe1uy; 0x99uy; 0x8buy; 0xd1uy; 0x77uy; 0xe9uy; 0x3auy;
0x73uy; 0x63uy; 0xc3uy; 0x44uy; 0xfeuy; 0x6buy; 0x19uy; 0x9euy;
0xe5uy; 0xd0uy; 0x2euy; 0x82uy; 0xd5uy; 0x22uy; 0xc4uy; 0xfeuy;
0xbauy; 0x15uy; 0x45uy; 0x2fuy; 0x80uy; 0x28uy; 0x8auy; 0x82uy;
0x1auy; 0x57uy; 0x91uy; 0x16uy; 0xecuy; 0x6duy; 0xaduy; 0x2buy;
0x3buy; 0x31uy; 0x0duy; 0xa9uy; 0x03uy; 0x40uy; 0x1auy; 0xa6uy;
0x21uy; 0x00uy; 0xabuy; 0x5duy; 0x1auy; 0x36uy; 0x55uy; 0x3euy;
0x06uy; 0x20uy; 0x3buy; 0x33uy; 0x89uy; 0x0cuy; 0xc9uy; 0xb8uy;
0x32uy; 0xf7uy; 0x9euy; 0xf8uy; 0x05uy; 0x60uy; 0xccuy; 0xb9uy;
0xa3uy; 0x9cuy; 0xe7uy; 0x67uy; 0x96uy; 0x7euy; 0xd6uy; 0x28uy;
0xc6uy; 0xaduy; 0x57uy; 0x3cuy; 0xb1uy; 0x16uy; 0xdbuy; 0xefuy;
0xefuy; 0xd7uy; 0x54uy; 0x99uy; 0xdauy; 0x96uy; 0xbduy; 0x68uy;
0xa8uy; 0xa9uy; 0x7buy; 0x92uy; 0x8auy; 0x8buy; 0xbcuy; 0x10uy;
0x3buy; 0x66uy; 0x21uy; 0xfcuy; 0xdeuy; 0x2buy; 0xecuy; 0xa1uy;
0x23uy; 0x1duy; 0x20uy; 0x6buy; 0xe6uy; 0xcduy; 0x9euy; 0xc7uy;
0xafuy; 0xf6uy; 0xf6uy; 0xc9uy; 0x4fuy; 0xcduy; 0x72uy; 0x04uy;
0xeduy; 0x34uy; 0x55uy; 0xc6uy; 0x8cuy; 0x83uy; 0xf4uy; 0xa4uy;
0x1duy; 0xa4uy; 0xafuy; 0x2buy; 0x74uy; 0xefuy; 0x5cuy; 0x53uy;
0xf1uy; 0xd8uy; 0xacuy; 0x70uy; 0xbduy; 0xcbuy; 0x7euy; 0xd1uy;
0x85uy; 0xceuy; 0x81uy; 0xbduy; 0x84uy; 0x35uy; 0x9duy; 0x44uy;
0x25uy; 0x4duy; 0x95uy; 0x62uy; 0x9euy; 0x98uy; 0x55uy; 0xa9uy;
0x4auy; 0x7cuy; 0x19uy; 0x58uy; 0xd1uy; 0xf8uy; 0xaduy; 0xa5uy;
0xd0uy; 0x53uy; 0x2euy; 0xd8uy; 0xa5uy; 0xaauy; 0x3fuy; 0xb2uy;
0xd1uy; 0x7buy; 0xa7uy; 0x0euy; 0xb6uy; 0x24uy; 0x8euy; 0x59uy;
0x4euy; 0x1auy; 0x22uy; 0x97uy; 0xacuy; 0xbbuy; 0xb3uy; 0x9duy;
0x50uy; 0x2fuy; 0x1auy; 0x8cuy; 0x6euy; 0xb6uy; 0xf1uy; 0xceuy;
0x22uy; 0xb3uy; 0xdeuy; 0x1auy; 0x1fuy; 0x40uy; 0xccuy; 0x24uy;
0x55uy; 0x41uy; 0x19uy; 0xa8uy; 0x31uy; 0xa9uy; 0xaauy; 0xd6uy;
0x07uy; 0x9cuy; 0xaduy; 0x88uy; 0x42uy; 0x5duy; 0xe6uy; 0xbduy;
0xe1uy; 0xa9uy; 0x18uy; 0x7euy; 0xbbuy; 0x60uy; 0x92uy; 0xcfuy;
0x67uy; 0xbfuy; 0x2buy; 0x13uy; 0xfduy; 0x65uy; 0xf2uy; 0x70uy;
0x88uy; 0xd7uy; 0x8buy; 0x7euy; 0x88uy; 0x3cuy; 0x87uy; 0x59uy;
0xd2uy; 0xc4uy; 0xf5uy; 0xc6uy; 0x5auy; 0xdbuy; 0x75uy; 0x53uy;
0x87uy; 0x8auy; 0xd5uy; 0x75uy; 0xf9uy; 0xfauy; 0xd8uy; 0x78uy;
0xe8uy; 0x0auy; 0x0cuy; 0x9buy; 0xa6uy; 0x3buy; 0xcbuy; 0xccuy;
0x27uy; 0x32uy; 0xe6uy; 0x94uy; 0x85uy; 0xbbuy; 0xc9uy; 0xc9uy;
0x0buy; 0xfbuy; 0xd6uy; 0x24uy; 0x81uy; 0xd9uy; 0x08uy; 0x9buy;
0xecuy; 0xcfuy; 0x80uy; 0xcfuy; 0xe2uy; 0xdfuy; 0x16uy; 0xa2uy;
0xcfuy; 0x65uy; 0xbduy; 0x92uy; 0xdduy; 0x59uy; 0x7buy; 0x07uy;
0x07uy; 0xe0uy; 0x91uy; 0x7auy; 0xf4uy; 0x8buy; 0xbbuy; 0x75uy;
0xfeuy; 0xd4uy; 0x13uy; 0xd2uy; 0x38uy; 0xf5uy; 0x55uy; 0x5auy;
0x7auy; 0x56uy; 0x9duy; 0x80uy; 0xc3uy; 0x41uy; 0x4auy; 0x8duy;
0x08uy; 0x59uy; 0xdcuy; 0x65uy; 0xa4uy; 0x61uy; 0x28uy; 0xbauy;
0xb2uy; 0x7auy; 0xf8uy; 0x7auy; 0x71uy; 0x31uy; 0x4fuy; 0x31uy;
0x8cuy; 0x78uy; 0x2buy; 0x23uy; 0xebuy; 0xfeuy; 0x80uy; 0x8buy;
0x82uy; 0xb0uy; 0xceuy; 0x26uy; 0x40uy; 0x1duy; 0x2euy; 0x22uy;
0xf0uy; 0x4duy; 0x83uy; 0xd1uy; 0x25uy; 0x5duy; 0xc5uy; 0x1auy;
0xdduy; 0xd3uy; 0xb7uy; 0x5auy; 0x2buy; 0x1auy; 0xe0uy; 0x78uy;
0x45uy; 0x04uy; 0xdfuy; 0x54uy; 0x3auy; 0xf8uy; 0x96uy; 0x9buy;
0xe3uy; 0xeauy; 0x70uy; 0x82uy; 0xffuy; 0x7fuy; 0xc9uy; 0x88uy;
0x8cuy; 0x14uy; 0x4duy; 0xa2uy; 0xafuy; 0x58uy; 0x42uy; 0x9euy;
0xc9uy; 0x60uy; 0x31uy; 0xdbuy; 0xcauy; 0xd3uy; 0xdauy; 0xd9uy;
0xafuy; 0x0duy; 0xcbuy; 0xaauy; 0xafuy; 0x26uy; 0x8cuy; 0xb8uy;
0xfcuy; 0xffuy; 0xeauy; 0xd9uy; 0x4fuy; 0x3cuy; 0x7cuy; 0xa4uy;
0x95uy; 0xe0uy; 0x56uy; 0xa9uy; 0xb4uy; 0x7auy; 0xcduy; 0xb7uy;
0x51uy; 0xfbuy; 0x73uy; 0xe6uy; 0x66uy; 0xc6uy; 0xc6uy; 0x55uy;
0xaduy; 0xe8uy; 0x29uy; 0x72uy; 0x97uy; 0xd0uy; 0x7auy; 0xd1uy;
0xbauy; 0x5euy; 0x43uy; 0xf1uy; 0xbcuy; 0xa3uy; 0x23uy; 0x01uy;
0x65uy; 0x13uy; 0x39uy; 0xe2uy; 0x29uy; 0x04uy; 0xccuy; 0x8cuy;
0x42uy; 0xf5uy; 0x8cuy; 0x30uy; 0xc0uy; 0x4auy; 0xafuy; 0xdbuy;
0x03uy; 0x8duy; 0xdauy; 0x08uy; 0x47uy; 0xdduy; 0x98uy; 0x8duy;
0xcduy; 0xa6uy; 0xf3uy; 0xbfuy; 0xd1uy; 0x5cuy; 0x4buy; 0x4cuy;
0x45uy; 0x25uy; 0x00uy; 0x4auy; 0xa0uy; 0x6euy; 0xefuy; 0xf8uy;
0xcauy; 0x61uy; 0x78uy; 0x3auy; 0xacuy; 0xecuy; 0x57uy; 0xfbuy;
0x3duy; 0x1fuy; 0x92uy; 0xb0uy; 0xfeuy; 0x2fuy; 0xd1uy; 0xa8uy;
0x5fuy; 0x67uy; 0x24uy; 0x51uy; 0x7buy; 0x65uy; 0xe6uy; 0x14uy;
0xaduy; 0x68uy; 0x08uy; 0xd6uy; 0xf6uy; 0xeeuy; 0x34uy; 0xdfuy;
0xf7uy; 0x31uy; 0x0fuy; 0xdcuy; 0x82uy; 0xaeuy; 0xbfuy; 0xd9uy;
0x04uy; 0xb0uy; 0x1euy; 0x1duy; 0xc5uy; 0x4buy; 0x29uy; 0x27uy;
0x09uy; 0x4buy; 0x2duy; 0xb6uy; 0x8duy; 0x6fuy; 0x90uy; 0x3buy;
0x68uy; 0x40uy; 0x1auy; 0xdeuy; 0xbfuy; 0x5auy; 0x7euy; 0x08uy;
0xd7uy; 0x8fuy; 0xf4uy; 0xefuy; 0x5duy; 0x63uy; 0x65uy; 0x3auy;
0x65uy; 0x04uy; 0x0cuy; 0xf9uy; 0xbfuy; 0xd4uy; 0xacuy; 0xa7uy;
0x98uy; 0x4auy; 0x74uy; 0xd3uy; 0x71uy; 0x45uy; 0x98uy; 0x67uy;
0x80uy; 0xfcuy; 0x0buy; 0x16uy; 0xacuy; 0x45uy; 0x16uy; 0x49uy;
0xdeuy; 0x61uy; 0x88uy; 0xa7uy; 0xdbuy; 0xdfuy; 0x19uy; 0x1fuy;
0x64uy; 0xb5uy; 0xfcuy; 0x5euy; 0x2auy; 0xb4uy; 0x7buy; 0x57uy;
0xf7uy; 0xf7uy; 0x27uy; 0x6cuy; 0xd4uy; 0x19uy; 0xc1uy; 0x7auy;
0x3cuy; 0xa8uy; 0xe1uy; 0xb9uy; 0x39uy; 0xaeuy; 0x49uy; 0xe4uy;
0x88uy; 0xacuy; 0xbauy; 0x6buy; 0x96uy; 0x56uy; 0x10uy; 0xb5uy;
0x48uy; 0x01uy; 0x09uy; 0xc8uy; 0xb1uy; 0x7buy; 0x80uy; 0xe1uy;
0xb7uy; 0xb7uy; 0x50uy; 0xdfuy; 0xc7uy; 0x59uy; 0x8duy; 0x5duy;
0x50uy; 0x11uy; 0xfduy; 0x2duy; 0xccuy; 0x56uy; 0x00uy; 0xa3uy;
0x2euy; 0xf5uy; 0xb5uy; 0x2auy; 0x1euy; 0xccuy; 0x82uy; 0x0euy;
0x30uy; 0x8auy; 0xa3uy; 0x42uy; 0x72uy; 0x1auy; 0xacuy; 0x09uy;
0x43uy; 0xbfuy; 0x66uy; 0x86uy; 0xb6uy; 0x4buy; 0x25uy; 0x79uy;
0x37uy; 0x65uy; 0x04uy; 0xccuy; 0xc4uy; 0x93uy; 0xd9uy; 0x7euy;
0x6auy; 0xeduy; 0x3fuy; 0xb0uy; 0xf9uy; 0xcduy; 0x71uy; 0xa4uy;
0x3duy; 0xd4uy; 0x97uy; 0xf0uy; 0x1fuy; 0x17uy; 0xc0uy; 0xe2uy;
0xcbuy; 0x37uy; 0x97uy; 0xaauy; 0x2auy; 0x2fuy; 0x25uy; 0x66uy;
0x56uy; 0x16uy; 0x8euy; 0x6cuy; 0x49uy; 0x6auy; 0xfcuy; 0x5fuy;
0xb9uy; 0x32uy; 0x46uy; 0xf6uy; 0xb1uy; 0x11uy; 0x63uy; 0x98uy;
0xa3uy; 0x46uy; 0xf1uy; 0xa6uy; 0x41uy; 0xf3uy; 0xb0uy; 0x41uy;
0xe9uy; 0x89uy; 0xf7uy; 0x91uy; 0x4fuy; 0x90uy; 0xccuy; 0x2cuy;
0x7fuy; 0xffuy; 0x35uy; 0x78uy; 0x76uy; 0xe5uy; 0x06uy; 0xb5uy;
0x0duy; 0x33uy; 0x4buy; 0xa7uy; 0x7cuy; 0x22uy; 0x5buy; 0xc3uy;
0x07uy; 0xbauy; 0x53uy; 0x71uy; 0x52uy; 0xf3uy; 0xf1uy; 0x61uy;
0x0euy; 0x4euy; 0xafuy; 0xe5uy; 0x95uy; 0xf6uy; 0xd9uy; 0xd9uy;
0x0duy; 0x11uy; 0xfauy; 0xa9uy; 0x33uy; 0xa1uy; 0x5euy; 0xf1uy;
0x36uy; 0x95uy; 0x46uy; 0x86uy; 0x8auy; 0x7fuy; 0x3auy; 0x45uy;
0xa9uy; 0x67uy; 0x68uy; 0xd4uy; 0x0fuy; 0xd9uy; 0xd0uy; 0x34uy;
0x12uy; 0xc0uy; 0x91uy; 0xc6uy; 0x31uy; 0x5cuy; 0xf4uy; 0xfduy;
0xe7uy; 0xcbuy; 0x68uy; 0x60uy; 0x69uy; 0x37uy; 0x38uy; 0x0duy;
0xb2uy; 0xeauy; 0xaauy; 0x70uy; 0x7buy; 0x4cuy; 0x41uy; 0x85uy;
0xc3uy; 0x2euy; 0xdduy; 0xcduy; 0xd3uy; 0x06uy; 0x70uy; 0x5euy;
0x4duy; 0xc1uy; 0xffuy; 0xc8uy; 0x72uy; 0xeeuy; 0xeeuy; 0x47uy;
0x5auy; 0x64uy; 0xdfuy; 0xacuy; 0x86uy; 0xabuy; 0xa4uy; 0x1cuy;
0x06uy; 0x18uy; 0x98uy; 0x3fuy; 0x87uy; 0x41uy; 0xc5uy; 0xefuy;
0x68uy; 0xd3uy; 0xa1uy; 0x01uy; 0xe8uy; 0xa3uy; 0xb8uy; 0xcauy;
0xc6uy; 0x0cuy; 0x90uy; 0x5cuy; 0x15uy; 0xfcuy; 0x91uy; 0x08uy;
0x40uy; 0xb9uy; 0x4cuy; 0x00uy; 0xa0uy; 0xb9uy; 0xd0uy
] in
assert_norm (List.Tot.length l == 1023);
of_list l
let test4_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0x0auy; 0xabuy; 0x4cuy; 0x90uy; 0x05uy; 0x01uy; 0xb3uy; 0xe2uy;
0x4duy; 0x7cuy; 0xdfuy; 0x46uy; 0x63uy; 0x32uy; 0x6auy; 0x3auy;
0x87uy; 0xdfuy; 0x5euy; 0x48uy; 0x43uy; 0xb2uy; 0xcbuy; 0xdbuy;
0x67uy; 0xcbuy; 0xf6uy; 0xe4uy; 0x60uy; 0xfeuy; 0xc3uy; 0x50uy;
0xaauy; 0x53uy; 0x71uy; 0xb1uy; 0x50uy; 0x8fuy; 0x9fuy; 0x45uy;
0x28uy; 0xecuy; 0xeauy; 0x23uy; 0xc4uy; 0x36uy; 0xd9uy; 0x4buy;
0x5euy; 0x8fuy; 0xcduy; 0x4fuy; 0x68uy; 0x1euy; 0x30uy; 0xa6uy;
0xacuy; 0x00uy; 0xa9uy; 0x70uy; 0x4auy; 0x18uy; 0x8auy; 0x03uy
] in
assert_norm (List.Tot.length l == 64);
of_list l
noeq type vec =
| Vec :
sk:lbytes 32
-> pk:lbytes 32
-> msg:bytes{length msg <= max_size_t}
-> expected_sig:lbytes 64 -> vec
let test_vectors : list vec = [
Vec test1_sk test1_pk test1_msg test1_expected_sig;
Vec test2_sk test2_pk test2_msg test2_expected_sig;
Vec test3_sk test3_pk test3_msg test3_expected_sig;
Vec test4_sk test4_pk test4_msg test4_expected_sig ] | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.PrintSequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Ed25519.Test.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.PrintSequence",
"short_module": "PS"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"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": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"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
}
] | {
"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"
} | false | v: Spec.Ed25519.Test.vec -> FStar.All.ALL Prims.bool | FStar.All.ALL | [] | [] | [
"Spec.Ed25519.Test.vec",
"Lib.ByteSequence.lbytes",
"Lib.ByteSequence.bytes",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.IntTypes.max_size_t",
"Prims.op_AmpAmp",
"Prims.bool",
"Prims.unit",
"FStar.IO.print_string",
"Lib.PrintSequence.print_compare",
"Spec.Ed25519.verify",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Spec.Ed25519.sign"
] | [] | false | true | false | false | false | let test_one (v: vec) =
| let Vec sk pk msg expected_sig = v in
let sig = Spec.Ed25519.sign sk msg in
let verify = Spec.Ed25519.verify pk msg sig in
let res = PS.print_compare true 64 expected_sig sig in
if res
then IO.print_string "\nTest signature: Success!\n"
else IO.print_string "\nTest signature: Failure :(\n";
if verify
then IO.print_string "Test verification: Success!\n"
else IO.print_string "Test verification: Failure :(\n";
res && verify | false |
|
Spec.Ed25519.Test.fst | Spec.Ed25519.Test.test3_expected_sig | val test3_expected_sig:lbytes 64 | val test3_expected_sig:lbytes 64 | let test3_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0x62uy; 0x91uy; 0xd6uy; 0x57uy; 0xdeuy; 0xecuy; 0x24uy; 0x02uy;
0x48uy; 0x27uy; 0xe6uy; 0x9cuy; 0x3auy; 0xbeuy; 0x01uy; 0xa3uy;
0x0cuy; 0xe5uy; 0x48uy; 0xa2uy; 0x84uy; 0x74uy; 0x3auy; 0x44uy;
0x5euy; 0x36uy; 0x80uy; 0xd7uy; 0xdbuy; 0x5auy; 0xc3uy; 0xacuy;
0x18uy; 0xffuy; 0x9buy; 0x53uy; 0x8duy; 0x16uy; 0xf2uy; 0x90uy;
0xaeuy; 0x67uy; 0xf7uy; 0x60uy; 0x98uy; 0x4duy; 0xc6uy; 0x59uy;
0x4auy; 0x7cuy; 0x15uy; 0xe9uy; 0x71uy; 0x6euy; 0xd2uy; 0x8duy;
0xc0uy; 0x27uy; 0xbeuy; 0xceuy; 0xeauy; 0x1euy; 0xc4uy; 0x0auy
] in
assert_norm (List.Tot.length l == 64);
of_list l | {
"file_name": "specs/tests/Spec.Ed25519.Test.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 146,
"start_col": 0,
"start_line": 134
} | module Spec.Ed25519.Test
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module PS = Lib.PrintSequence
open Spec.Ed25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Test 1
let test1_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x9duy; 0x61uy; 0xb1uy; 0x9duy; 0xefuy; 0xfduy; 0x5auy; 0x60uy;
0xbauy; 0x84uy; 0x4auy; 0xf4uy; 0x92uy; 0xecuy; 0x2cuy; 0xc4uy;
0x44uy; 0x49uy; 0xc5uy; 0x69uy; 0x7buy; 0x32uy; 0x69uy; 0x19uy;
0x70uy; 0x3buy; 0xacuy; 0x03uy; 0x1cuy; 0xaeuy; 0x7fuy; 0x60uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xd7uy; 0x5auy; 0x98uy; 0x01uy; 0x82uy; 0xb1uy; 0x0auy; 0xb7uy;
0xd5uy; 0x4buy; 0xfeuy; 0xd3uy; 0xc9uy; 0x64uy; 0x07uy; 0x3auy;
0x0euy; 0xe1uy; 0x72uy; 0xf3uy; 0xdauy; 0xa6uy; 0x23uy; 0x25uy;
0xafuy; 0x02uy; 0x1auy; 0x68uy; 0xf7uy; 0x07uy; 0x51uy; 0x1auy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_msg : lbytes 0 =
let l = List.Tot.map u8_from_UInt8 [] in
assert_norm (List.Tot.length l == 0);
of_list l
let test1_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0xe5uy; 0x56uy; 0x43uy; 0x00uy; 0xc3uy; 0x60uy; 0xacuy; 0x72uy;
0x90uy; 0x86uy; 0xe2uy; 0xccuy; 0x80uy; 0x6euy; 0x82uy; 0x8auy;
0x84uy; 0x87uy; 0x7fuy; 0x1euy; 0xb8uy; 0xe5uy; 0xd9uy; 0x74uy;
0xd8uy; 0x73uy; 0xe0uy; 0x65uy; 0x22uy; 0x49uy; 0x01uy; 0x55uy;
0x5fuy; 0xb8uy; 0x82uy; 0x15uy; 0x90uy; 0xa3uy; 0x3buy; 0xacuy;
0xc6uy; 0x1euy; 0x39uy; 0x70uy; 0x1cuy; 0xf9uy; 0xb4uy; 0x6buy;
0xd2uy; 0x5buy; 0xf5uy; 0xf0uy; 0x59uy; 0x5buy; 0xbeuy; 0x24uy;
0x65uy; 0x51uy; 0x41uy; 0x43uy; 0x8euy; 0x7auy; 0x10uy; 0x0buy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 2
let test2_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x4cuy; 0xcduy; 0x08uy; 0x9buy; 0x28uy; 0xffuy; 0x96uy; 0xdauy;
0x9duy; 0xb6uy; 0xc3uy; 0x46uy; 0xecuy; 0x11uy; 0x4euy; 0x0fuy;
0x5buy; 0x8auy; 0x31uy; 0x9fuy; 0x35uy; 0xabuy; 0xa6uy; 0x24uy;
0xdauy; 0x8cuy; 0xf6uy; 0xeduy; 0x4fuy; 0xb8uy; 0xa6uy; 0xfbuy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test2_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x3duy; 0x40uy; 0x17uy; 0xc3uy; 0xe8uy; 0x43uy; 0x89uy; 0x5auy;
0x92uy; 0xb7uy; 0x0auy; 0xa7uy; 0x4duy; 0x1buy; 0x7euy; 0xbcuy;
0x9cuy; 0x98uy; 0x2cuy; 0xcfuy; 0x2euy; 0xc4uy; 0x96uy; 0x8cuy;
0xc0uy; 0xcduy; 0x55uy; 0xf1uy; 0x2auy; 0xf4uy; 0x66uy; 0x0cuy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test2_msg : lbytes 1 =
let l = List.Tot.map u8_from_UInt8 [ 0x72uy ] in
assert_norm (List.Tot.length l == 1);
of_list l
let test2_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0x92uy; 0xa0uy; 0x09uy; 0xa9uy; 0xf0uy; 0xd4uy; 0xcauy; 0xb8uy;
0x72uy; 0x0euy; 0x82uy; 0x0buy; 0x5fuy; 0x64uy; 0x25uy; 0x40uy;
0xa2uy; 0xb2uy; 0x7buy; 0x54uy; 0x16uy; 0x50uy; 0x3fuy; 0x8fuy;
0xb3uy; 0x76uy; 0x22uy; 0x23uy; 0xebuy; 0xdbuy; 0x69uy; 0xdauy;
0x08uy; 0x5auy; 0xc1uy; 0xe4uy; 0x3euy; 0x15uy; 0x99uy; 0x6euy;
0x45uy; 0x8fuy; 0x36uy; 0x13uy; 0xd0uy; 0xf1uy; 0x1duy; 0x8cuy;
0x38uy; 0x7buy; 0x2euy; 0xaeuy; 0xb4uy; 0x30uy; 0x2auy; 0xeeuy;
0xb0uy; 0x0duy; 0x29uy; 0x16uy; 0x12uy; 0xbbuy; 0x0cuy; 0x00uy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 3
let test3_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xc5uy; 0xaauy; 0x8duy; 0xf4uy; 0x3fuy; 0x9fuy; 0x83uy; 0x7buy;
0xeduy; 0xb7uy; 0x44uy; 0x2fuy; 0x31uy; 0xdcuy; 0xb7uy; 0xb1uy;
0x66uy; 0xd3uy; 0x85uy; 0x35uy; 0x07uy; 0x6fuy; 0x09uy; 0x4buy;
0x85uy; 0xceuy; 0x3auy; 0x2euy; 0x0buy; 0x44uy; 0x58uy; 0xf7uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test3_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xfcuy; 0x51uy; 0xcduy; 0x8euy; 0x62uy; 0x18uy; 0xa1uy; 0xa3uy;
0x8duy; 0xa4uy; 0x7euy; 0xd0uy; 0x02uy; 0x30uy; 0xf0uy; 0x58uy;
0x08uy; 0x16uy; 0xeduy; 0x13uy; 0xbauy; 0x33uy; 0x03uy; 0xacuy;
0x5duy; 0xebuy; 0x91uy; 0x15uy; 0x48uy; 0x90uy; 0x80uy; 0x25uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test3_msg : lbytes 2 =
let l = List.Tot.map u8_from_UInt8 [ 0xafuy; 0x82uy ] in
assert_norm (List.Tot.length l == 2);
of_list l | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.PrintSequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Ed25519.Test.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.PrintSequence",
"short_module": "PS"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"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": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"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
}
] | {
"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"
} | false | Lib.Sequence.lseq (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.SEC) 64 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.of_list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.list",
"FStar.List.Tot.Base.map",
"FStar.UInt8.t",
"Lib.RawIntTypes.u8_from_UInt8",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | false | false | false | false | false | let test3_expected_sig:lbytes 64 =
| let l =
List.Tot.map u8_from_UInt8
[
0x62uy; 0x91uy; 0xd6uy; 0x57uy; 0xdeuy; 0xecuy; 0x24uy; 0x02uy; 0x48uy; 0x27uy; 0xe6uy; 0x9cuy;
0x3auy; 0xbeuy; 0x01uy; 0xa3uy; 0x0cuy; 0xe5uy; 0x48uy; 0xa2uy; 0x84uy; 0x74uy; 0x3auy; 0x44uy;
0x5euy; 0x36uy; 0x80uy; 0xd7uy; 0xdbuy; 0x5auy; 0xc3uy; 0xacuy; 0x18uy; 0xffuy; 0x9buy; 0x53uy;
0x8duy; 0x16uy; 0xf2uy; 0x90uy; 0xaeuy; 0x67uy; 0xf7uy; 0x60uy; 0x98uy; 0x4duy; 0xc6uy; 0x59uy;
0x4auy; 0x7cuy; 0x15uy; 0xe9uy; 0x71uy; 0x6euy; 0xd2uy; 0x8duy; 0xc0uy; 0x27uy; 0xbeuy; 0xceuy;
0xeauy; 0x1euy; 0xc4uy; 0x0auy
]
in
assert_norm (List.Tot.length l == 64);
of_list l | false |
Spec.Ed25519.Test.fst | Spec.Ed25519.Test.test4_expected_sig | val test4_expected_sig:lbytes 64 | val test4_expected_sig:lbytes 64 | let test4_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0x0auy; 0xabuy; 0x4cuy; 0x90uy; 0x05uy; 0x01uy; 0xb3uy; 0xe2uy;
0x4duy; 0x7cuy; 0xdfuy; 0x46uy; 0x63uy; 0x32uy; 0x6auy; 0x3auy;
0x87uy; 0xdfuy; 0x5euy; 0x48uy; 0x43uy; 0xb2uy; 0xcbuy; 0xdbuy;
0x67uy; 0xcbuy; 0xf6uy; 0xe4uy; 0x60uy; 0xfeuy; 0xc3uy; 0x50uy;
0xaauy; 0x53uy; 0x71uy; 0xb1uy; 0x50uy; 0x8fuy; 0x9fuy; 0x45uy;
0x28uy; 0xecuy; 0xeauy; 0x23uy; 0xc4uy; 0x36uy; 0xd9uy; 0x4buy;
0x5euy; 0x8fuy; 0xcduy; 0x4fuy; 0x68uy; 0x1euy; 0x30uy; 0xa6uy;
0xacuy; 0x00uy; 0xa9uy; 0x70uy; 0x4auy; 0x18uy; 0x8auy; 0x03uy
] in
assert_norm (List.Tot.length l == 64);
of_list l | {
"file_name": "specs/tests/Spec.Ed25519.Test.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 320,
"start_col": 0,
"start_line": 308
} | module Spec.Ed25519.Test
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module PS = Lib.PrintSequence
open Spec.Ed25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Test 1
let test1_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x9duy; 0x61uy; 0xb1uy; 0x9duy; 0xefuy; 0xfduy; 0x5auy; 0x60uy;
0xbauy; 0x84uy; 0x4auy; 0xf4uy; 0x92uy; 0xecuy; 0x2cuy; 0xc4uy;
0x44uy; 0x49uy; 0xc5uy; 0x69uy; 0x7buy; 0x32uy; 0x69uy; 0x19uy;
0x70uy; 0x3buy; 0xacuy; 0x03uy; 0x1cuy; 0xaeuy; 0x7fuy; 0x60uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xd7uy; 0x5auy; 0x98uy; 0x01uy; 0x82uy; 0xb1uy; 0x0auy; 0xb7uy;
0xd5uy; 0x4buy; 0xfeuy; 0xd3uy; 0xc9uy; 0x64uy; 0x07uy; 0x3auy;
0x0euy; 0xe1uy; 0x72uy; 0xf3uy; 0xdauy; 0xa6uy; 0x23uy; 0x25uy;
0xafuy; 0x02uy; 0x1auy; 0x68uy; 0xf7uy; 0x07uy; 0x51uy; 0x1auy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_msg : lbytes 0 =
let l = List.Tot.map u8_from_UInt8 [] in
assert_norm (List.Tot.length l == 0);
of_list l
let test1_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0xe5uy; 0x56uy; 0x43uy; 0x00uy; 0xc3uy; 0x60uy; 0xacuy; 0x72uy;
0x90uy; 0x86uy; 0xe2uy; 0xccuy; 0x80uy; 0x6euy; 0x82uy; 0x8auy;
0x84uy; 0x87uy; 0x7fuy; 0x1euy; 0xb8uy; 0xe5uy; 0xd9uy; 0x74uy;
0xd8uy; 0x73uy; 0xe0uy; 0x65uy; 0x22uy; 0x49uy; 0x01uy; 0x55uy;
0x5fuy; 0xb8uy; 0x82uy; 0x15uy; 0x90uy; 0xa3uy; 0x3buy; 0xacuy;
0xc6uy; 0x1euy; 0x39uy; 0x70uy; 0x1cuy; 0xf9uy; 0xb4uy; 0x6buy;
0xd2uy; 0x5buy; 0xf5uy; 0xf0uy; 0x59uy; 0x5buy; 0xbeuy; 0x24uy;
0x65uy; 0x51uy; 0x41uy; 0x43uy; 0x8euy; 0x7auy; 0x10uy; 0x0buy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 2
let test2_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x4cuy; 0xcduy; 0x08uy; 0x9buy; 0x28uy; 0xffuy; 0x96uy; 0xdauy;
0x9duy; 0xb6uy; 0xc3uy; 0x46uy; 0xecuy; 0x11uy; 0x4euy; 0x0fuy;
0x5buy; 0x8auy; 0x31uy; 0x9fuy; 0x35uy; 0xabuy; 0xa6uy; 0x24uy;
0xdauy; 0x8cuy; 0xf6uy; 0xeduy; 0x4fuy; 0xb8uy; 0xa6uy; 0xfbuy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test2_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x3duy; 0x40uy; 0x17uy; 0xc3uy; 0xe8uy; 0x43uy; 0x89uy; 0x5auy;
0x92uy; 0xb7uy; 0x0auy; 0xa7uy; 0x4duy; 0x1buy; 0x7euy; 0xbcuy;
0x9cuy; 0x98uy; 0x2cuy; 0xcfuy; 0x2euy; 0xc4uy; 0x96uy; 0x8cuy;
0xc0uy; 0xcduy; 0x55uy; 0xf1uy; 0x2auy; 0xf4uy; 0x66uy; 0x0cuy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test2_msg : lbytes 1 =
let l = List.Tot.map u8_from_UInt8 [ 0x72uy ] in
assert_norm (List.Tot.length l == 1);
of_list l
let test2_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0x92uy; 0xa0uy; 0x09uy; 0xa9uy; 0xf0uy; 0xd4uy; 0xcauy; 0xb8uy;
0x72uy; 0x0euy; 0x82uy; 0x0buy; 0x5fuy; 0x64uy; 0x25uy; 0x40uy;
0xa2uy; 0xb2uy; 0x7buy; 0x54uy; 0x16uy; 0x50uy; 0x3fuy; 0x8fuy;
0xb3uy; 0x76uy; 0x22uy; 0x23uy; 0xebuy; 0xdbuy; 0x69uy; 0xdauy;
0x08uy; 0x5auy; 0xc1uy; 0xe4uy; 0x3euy; 0x15uy; 0x99uy; 0x6euy;
0x45uy; 0x8fuy; 0x36uy; 0x13uy; 0xd0uy; 0xf1uy; 0x1duy; 0x8cuy;
0x38uy; 0x7buy; 0x2euy; 0xaeuy; 0xb4uy; 0x30uy; 0x2auy; 0xeeuy;
0xb0uy; 0x0duy; 0x29uy; 0x16uy; 0x12uy; 0xbbuy; 0x0cuy; 0x00uy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 3
let test3_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xc5uy; 0xaauy; 0x8duy; 0xf4uy; 0x3fuy; 0x9fuy; 0x83uy; 0x7buy;
0xeduy; 0xb7uy; 0x44uy; 0x2fuy; 0x31uy; 0xdcuy; 0xb7uy; 0xb1uy;
0x66uy; 0xd3uy; 0x85uy; 0x35uy; 0x07uy; 0x6fuy; 0x09uy; 0x4buy;
0x85uy; 0xceuy; 0x3auy; 0x2euy; 0x0buy; 0x44uy; 0x58uy; 0xf7uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test3_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xfcuy; 0x51uy; 0xcduy; 0x8euy; 0x62uy; 0x18uy; 0xa1uy; 0xa3uy;
0x8duy; 0xa4uy; 0x7euy; 0xd0uy; 0x02uy; 0x30uy; 0xf0uy; 0x58uy;
0x08uy; 0x16uy; 0xeduy; 0x13uy; 0xbauy; 0x33uy; 0x03uy; 0xacuy;
0x5duy; 0xebuy; 0x91uy; 0x15uy; 0x48uy; 0x90uy; 0x80uy; 0x25uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test3_msg : lbytes 2 =
let l = List.Tot.map u8_from_UInt8 [ 0xafuy; 0x82uy ] in
assert_norm (List.Tot.length l == 2);
of_list l
let test3_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0x62uy; 0x91uy; 0xd6uy; 0x57uy; 0xdeuy; 0xecuy; 0x24uy; 0x02uy;
0x48uy; 0x27uy; 0xe6uy; 0x9cuy; 0x3auy; 0xbeuy; 0x01uy; 0xa3uy;
0x0cuy; 0xe5uy; 0x48uy; 0xa2uy; 0x84uy; 0x74uy; 0x3auy; 0x44uy;
0x5euy; 0x36uy; 0x80uy; 0xd7uy; 0xdbuy; 0x5auy; 0xc3uy; 0xacuy;
0x18uy; 0xffuy; 0x9buy; 0x53uy; 0x8duy; 0x16uy; 0xf2uy; 0x90uy;
0xaeuy; 0x67uy; 0xf7uy; 0x60uy; 0x98uy; 0x4duy; 0xc6uy; 0x59uy;
0x4auy; 0x7cuy; 0x15uy; 0xe9uy; 0x71uy; 0x6euy; 0xd2uy; 0x8duy;
0xc0uy; 0x27uy; 0xbeuy; 0xceuy; 0xeauy; 0x1euy; 0xc4uy; 0x0auy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 4
let test4_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xf5uy; 0xe5uy; 0x76uy; 0x7cuy; 0xf1uy; 0x53uy; 0x31uy; 0x95uy;
0x17uy; 0x63uy; 0x0fuy; 0x22uy; 0x68uy; 0x76uy; 0xb8uy; 0x6cuy;
0x81uy; 0x60uy; 0xccuy; 0x58uy; 0x3buy; 0xc0uy; 0x13uy; 0x74uy;
0x4cuy; 0x6buy; 0xf2uy; 0x55uy; 0xf5uy; 0xccuy; 0x0euy; 0xe5uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test4_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x27uy; 0x81uy; 0x17uy; 0xfcuy; 0x14uy; 0x4cuy; 0x72uy; 0x34uy;
0x0fuy; 0x67uy; 0xd0uy; 0xf2uy; 0x31uy; 0x6euy; 0x83uy; 0x86uy;
0xceuy; 0xffuy; 0xbfuy; 0x2buy; 0x24uy; 0x28uy; 0xc9uy; 0xc5uy;
0x1fuy; 0xefuy; 0x7cuy; 0x59uy; 0x7fuy; 0x1duy; 0x42uy; 0x6euy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test4_msg : lbytes 1023 =
let l = List.Tot.map u8_from_UInt8 [
0x08uy; 0xb8uy; 0xb2uy; 0xb7uy; 0x33uy; 0x42uy; 0x42uy; 0x43uy;
0x76uy; 0x0fuy; 0xe4uy; 0x26uy; 0xa4uy; 0xb5uy; 0x49uy; 0x08uy;
0x63uy; 0x21uy; 0x10uy; 0xa6uy; 0x6cuy; 0x2fuy; 0x65uy; 0x91uy;
0xeauy; 0xbduy; 0x33uy; 0x45uy; 0xe3uy; 0xe4uy; 0xebuy; 0x98uy;
0xfauy; 0x6euy; 0x26uy; 0x4buy; 0xf0uy; 0x9euy; 0xfeuy; 0x12uy;
0xeeuy; 0x50uy; 0xf8uy; 0xf5uy; 0x4euy; 0x9fuy; 0x77uy; 0xb1uy;
0xe3uy; 0x55uy; 0xf6uy; 0xc5uy; 0x05uy; 0x44uy; 0xe2uy; 0x3fuy;
0xb1uy; 0x43uy; 0x3duy; 0xdfuy; 0x73uy; 0xbeuy; 0x84uy; 0xd8uy;
0x79uy; 0xdeuy; 0x7cuy; 0x00uy; 0x46uy; 0xdcuy; 0x49uy; 0x96uy;
0xd9uy; 0xe7uy; 0x73uy; 0xf4uy; 0xbcuy; 0x9euy; 0xfeuy; 0x57uy;
0x38uy; 0x82uy; 0x9auy; 0xdbuy; 0x26uy; 0xc8uy; 0x1buy; 0x37uy;
0xc9uy; 0x3auy; 0x1buy; 0x27uy; 0x0buy; 0x20uy; 0x32uy; 0x9duy;
0x65uy; 0x86uy; 0x75uy; 0xfcuy; 0x6euy; 0xa5uy; 0x34uy; 0xe0uy;
0x81uy; 0x0auy; 0x44uy; 0x32uy; 0x82uy; 0x6buy; 0xf5uy; 0x8cuy;
0x94uy; 0x1euy; 0xfbuy; 0x65uy; 0xd5uy; 0x7auy; 0x33uy; 0x8buy;
0xbduy; 0x2euy; 0x26uy; 0x64uy; 0x0fuy; 0x89uy; 0xffuy; 0xbcuy;
0x1auy; 0x85uy; 0x8euy; 0xfcuy; 0xb8uy; 0x55uy; 0x0euy; 0xe3uy;
0xa5uy; 0xe1uy; 0x99uy; 0x8buy; 0xd1uy; 0x77uy; 0xe9uy; 0x3auy;
0x73uy; 0x63uy; 0xc3uy; 0x44uy; 0xfeuy; 0x6buy; 0x19uy; 0x9euy;
0xe5uy; 0xd0uy; 0x2euy; 0x82uy; 0xd5uy; 0x22uy; 0xc4uy; 0xfeuy;
0xbauy; 0x15uy; 0x45uy; 0x2fuy; 0x80uy; 0x28uy; 0x8auy; 0x82uy;
0x1auy; 0x57uy; 0x91uy; 0x16uy; 0xecuy; 0x6duy; 0xaduy; 0x2buy;
0x3buy; 0x31uy; 0x0duy; 0xa9uy; 0x03uy; 0x40uy; 0x1auy; 0xa6uy;
0x21uy; 0x00uy; 0xabuy; 0x5duy; 0x1auy; 0x36uy; 0x55uy; 0x3euy;
0x06uy; 0x20uy; 0x3buy; 0x33uy; 0x89uy; 0x0cuy; 0xc9uy; 0xb8uy;
0x32uy; 0xf7uy; 0x9euy; 0xf8uy; 0x05uy; 0x60uy; 0xccuy; 0xb9uy;
0xa3uy; 0x9cuy; 0xe7uy; 0x67uy; 0x96uy; 0x7euy; 0xd6uy; 0x28uy;
0xc6uy; 0xaduy; 0x57uy; 0x3cuy; 0xb1uy; 0x16uy; 0xdbuy; 0xefuy;
0xefuy; 0xd7uy; 0x54uy; 0x99uy; 0xdauy; 0x96uy; 0xbduy; 0x68uy;
0xa8uy; 0xa9uy; 0x7buy; 0x92uy; 0x8auy; 0x8buy; 0xbcuy; 0x10uy;
0x3buy; 0x66uy; 0x21uy; 0xfcuy; 0xdeuy; 0x2buy; 0xecuy; 0xa1uy;
0x23uy; 0x1duy; 0x20uy; 0x6buy; 0xe6uy; 0xcduy; 0x9euy; 0xc7uy;
0xafuy; 0xf6uy; 0xf6uy; 0xc9uy; 0x4fuy; 0xcduy; 0x72uy; 0x04uy;
0xeduy; 0x34uy; 0x55uy; 0xc6uy; 0x8cuy; 0x83uy; 0xf4uy; 0xa4uy;
0x1duy; 0xa4uy; 0xafuy; 0x2buy; 0x74uy; 0xefuy; 0x5cuy; 0x53uy;
0xf1uy; 0xd8uy; 0xacuy; 0x70uy; 0xbduy; 0xcbuy; 0x7euy; 0xd1uy;
0x85uy; 0xceuy; 0x81uy; 0xbduy; 0x84uy; 0x35uy; 0x9duy; 0x44uy;
0x25uy; 0x4duy; 0x95uy; 0x62uy; 0x9euy; 0x98uy; 0x55uy; 0xa9uy;
0x4auy; 0x7cuy; 0x19uy; 0x58uy; 0xd1uy; 0xf8uy; 0xaduy; 0xa5uy;
0xd0uy; 0x53uy; 0x2euy; 0xd8uy; 0xa5uy; 0xaauy; 0x3fuy; 0xb2uy;
0xd1uy; 0x7buy; 0xa7uy; 0x0euy; 0xb6uy; 0x24uy; 0x8euy; 0x59uy;
0x4euy; 0x1auy; 0x22uy; 0x97uy; 0xacuy; 0xbbuy; 0xb3uy; 0x9duy;
0x50uy; 0x2fuy; 0x1auy; 0x8cuy; 0x6euy; 0xb6uy; 0xf1uy; 0xceuy;
0x22uy; 0xb3uy; 0xdeuy; 0x1auy; 0x1fuy; 0x40uy; 0xccuy; 0x24uy;
0x55uy; 0x41uy; 0x19uy; 0xa8uy; 0x31uy; 0xa9uy; 0xaauy; 0xd6uy;
0x07uy; 0x9cuy; 0xaduy; 0x88uy; 0x42uy; 0x5duy; 0xe6uy; 0xbduy;
0xe1uy; 0xa9uy; 0x18uy; 0x7euy; 0xbbuy; 0x60uy; 0x92uy; 0xcfuy;
0x67uy; 0xbfuy; 0x2buy; 0x13uy; 0xfduy; 0x65uy; 0xf2uy; 0x70uy;
0x88uy; 0xd7uy; 0x8buy; 0x7euy; 0x88uy; 0x3cuy; 0x87uy; 0x59uy;
0xd2uy; 0xc4uy; 0xf5uy; 0xc6uy; 0x5auy; 0xdbuy; 0x75uy; 0x53uy;
0x87uy; 0x8auy; 0xd5uy; 0x75uy; 0xf9uy; 0xfauy; 0xd8uy; 0x78uy;
0xe8uy; 0x0auy; 0x0cuy; 0x9buy; 0xa6uy; 0x3buy; 0xcbuy; 0xccuy;
0x27uy; 0x32uy; 0xe6uy; 0x94uy; 0x85uy; 0xbbuy; 0xc9uy; 0xc9uy;
0x0buy; 0xfbuy; 0xd6uy; 0x24uy; 0x81uy; 0xd9uy; 0x08uy; 0x9buy;
0xecuy; 0xcfuy; 0x80uy; 0xcfuy; 0xe2uy; 0xdfuy; 0x16uy; 0xa2uy;
0xcfuy; 0x65uy; 0xbduy; 0x92uy; 0xdduy; 0x59uy; 0x7buy; 0x07uy;
0x07uy; 0xe0uy; 0x91uy; 0x7auy; 0xf4uy; 0x8buy; 0xbbuy; 0x75uy;
0xfeuy; 0xd4uy; 0x13uy; 0xd2uy; 0x38uy; 0xf5uy; 0x55uy; 0x5auy;
0x7auy; 0x56uy; 0x9duy; 0x80uy; 0xc3uy; 0x41uy; 0x4auy; 0x8duy;
0x08uy; 0x59uy; 0xdcuy; 0x65uy; 0xa4uy; 0x61uy; 0x28uy; 0xbauy;
0xb2uy; 0x7auy; 0xf8uy; 0x7auy; 0x71uy; 0x31uy; 0x4fuy; 0x31uy;
0x8cuy; 0x78uy; 0x2buy; 0x23uy; 0xebuy; 0xfeuy; 0x80uy; 0x8buy;
0x82uy; 0xb0uy; 0xceuy; 0x26uy; 0x40uy; 0x1duy; 0x2euy; 0x22uy;
0xf0uy; 0x4duy; 0x83uy; 0xd1uy; 0x25uy; 0x5duy; 0xc5uy; 0x1auy;
0xdduy; 0xd3uy; 0xb7uy; 0x5auy; 0x2buy; 0x1auy; 0xe0uy; 0x78uy;
0x45uy; 0x04uy; 0xdfuy; 0x54uy; 0x3auy; 0xf8uy; 0x96uy; 0x9buy;
0xe3uy; 0xeauy; 0x70uy; 0x82uy; 0xffuy; 0x7fuy; 0xc9uy; 0x88uy;
0x8cuy; 0x14uy; 0x4duy; 0xa2uy; 0xafuy; 0x58uy; 0x42uy; 0x9euy;
0xc9uy; 0x60uy; 0x31uy; 0xdbuy; 0xcauy; 0xd3uy; 0xdauy; 0xd9uy;
0xafuy; 0x0duy; 0xcbuy; 0xaauy; 0xafuy; 0x26uy; 0x8cuy; 0xb8uy;
0xfcuy; 0xffuy; 0xeauy; 0xd9uy; 0x4fuy; 0x3cuy; 0x7cuy; 0xa4uy;
0x95uy; 0xe0uy; 0x56uy; 0xa9uy; 0xb4uy; 0x7auy; 0xcduy; 0xb7uy;
0x51uy; 0xfbuy; 0x73uy; 0xe6uy; 0x66uy; 0xc6uy; 0xc6uy; 0x55uy;
0xaduy; 0xe8uy; 0x29uy; 0x72uy; 0x97uy; 0xd0uy; 0x7auy; 0xd1uy;
0xbauy; 0x5euy; 0x43uy; 0xf1uy; 0xbcuy; 0xa3uy; 0x23uy; 0x01uy;
0x65uy; 0x13uy; 0x39uy; 0xe2uy; 0x29uy; 0x04uy; 0xccuy; 0x8cuy;
0x42uy; 0xf5uy; 0x8cuy; 0x30uy; 0xc0uy; 0x4auy; 0xafuy; 0xdbuy;
0x03uy; 0x8duy; 0xdauy; 0x08uy; 0x47uy; 0xdduy; 0x98uy; 0x8duy;
0xcduy; 0xa6uy; 0xf3uy; 0xbfuy; 0xd1uy; 0x5cuy; 0x4buy; 0x4cuy;
0x45uy; 0x25uy; 0x00uy; 0x4auy; 0xa0uy; 0x6euy; 0xefuy; 0xf8uy;
0xcauy; 0x61uy; 0x78uy; 0x3auy; 0xacuy; 0xecuy; 0x57uy; 0xfbuy;
0x3duy; 0x1fuy; 0x92uy; 0xb0uy; 0xfeuy; 0x2fuy; 0xd1uy; 0xa8uy;
0x5fuy; 0x67uy; 0x24uy; 0x51uy; 0x7buy; 0x65uy; 0xe6uy; 0x14uy;
0xaduy; 0x68uy; 0x08uy; 0xd6uy; 0xf6uy; 0xeeuy; 0x34uy; 0xdfuy;
0xf7uy; 0x31uy; 0x0fuy; 0xdcuy; 0x82uy; 0xaeuy; 0xbfuy; 0xd9uy;
0x04uy; 0xb0uy; 0x1euy; 0x1duy; 0xc5uy; 0x4buy; 0x29uy; 0x27uy;
0x09uy; 0x4buy; 0x2duy; 0xb6uy; 0x8duy; 0x6fuy; 0x90uy; 0x3buy;
0x68uy; 0x40uy; 0x1auy; 0xdeuy; 0xbfuy; 0x5auy; 0x7euy; 0x08uy;
0xd7uy; 0x8fuy; 0xf4uy; 0xefuy; 0x5duy; 0x63uy; 0x65uy; 0x3auy;
0x65uy; 0x04uy; 0x0cuy; 0xf9uy; 0xbfuy; 0xd4uy; 0xacuy; 0xa7uy;
0x98uy; 0x4auy; 0x74uy; 0xd3uy; 0x71uy; 0x45uy; 0x98uy; 0x67uy;
0x80uy; 0xfcuy; 0x0buy; 0x16uy; 0xacuy; 0x45uy; 0x16uy; 0x49uy;
0xdeuy; 0x61uy; 0x88uy; 0xa7uy; 0xdbuy; 0xdfuy; 0x19uy; 0x1fuy;
0x64uy; 0xb5uy; 0xfcuy; 0x5euy; 0x2auy; 0xb4uy; 0x7buy; 0x57uy;
0xf7uy; 0xf7uy; 0x27uy; 0x6cuy; 0xd4uy; 0x19uy; 0xc1uy; 0x7auy;
0x3cuy; 0xa8uy; 0xe1uy; 0xb9uy; 0x39uy; 0xaeuy; 0x49uy; 0xe4uy;
0x88uy; 0xacuy; 0xbauy; 0x6buy; 0x96uy; 0x56uy; 0x10uy; 0xb5uy;
0x48uy; 0x01uy; 0x09uy; 0xc8uy; 0xb1uy; 0x7buy; 0x80uy; 0xe1uy;
0xb7uy; 0xb7uy; 0x50uy; 0xdfuy; 0xc7uy; 0x59uy; 0x8duy; 0x5duy;
0x50uy; 0x11uy; 0xfduy; 0x2duy; 0xccuy; 0x56uy; 0x00uy; 0xa3uy;
0x2euy; 0xf5uy; 0xb5uy; 0x2auy; 0x1euy; 0xccuy; 0x82uy; 0x0euy;
0x30uy; 0x8auy; 0xa3uy; 0x42uy; 0x72uy; 0x1auy; 0xacuy; 0x09uy;
0x43uy; 0xbfuy; 0x66uy; 0x86uy; 0xb6uy; 0x4buy; 0x25uy; 0x79uy;
0x37uy; 0x65uy; 0x04uy; 0xccuy; 0xc4uy; 0x93uy; 0xd9uy; 0x7euy;
0x6auy; 0xeduy; 0x3fuy; 0xb0uy; 0xf9uy; 0xcduy; 0x71uy; 0xa4uy;
0x3duy; 0xd4uy; 0x97uy; 0xf0uy; 0x1fuy; 0x17uy; 0xc0uy; 0xe2uy;
0xcbuy; 0x37uy; 0x97uy; 0xaauy; 0x2auy; 0x2fuy; 0x25uy; 0x66uy;
0x56uy; 0x16uy; 0x8euy; 0x6cuy; 0x49uy; 0x6auy; 0xfcuy; 0x5fuy;
0xb9uy; 0x32uy; 0x46uy; 0xf6uy; 0xb1uy; 0x11uy; 0x63uy; 0x98uy;
0xa3uy; 0x46uy; 0xf1uy; 0xa6uy; 0x41uy; 0xf3uy; 0xb0uy; 0x41uy;
0xe9uy; 0x89uy; 0xf7uy; 0x91uy; 0x4fuy; 0x90uy; 0xccuy; 0x2cuy;
0x7fuy; 0xffuy; 0x35uy; 0x78uy; 0x76uy; 0xe5uy; 0x06uy; 0xb5uy;
0x0duy; 0x33uy; 0x4buy; 0xa7uy; 0x7cuy; 0x22uy; 0x5buy; 0xc3uy;
0x07uy; 0xbauy; 0x53uy; 0x71uy; 0x52uy; 0xf3uy; 0xf1uy; 0x61uy;
0x0euy; 0x4euy; 0xafuy; 0xe5uy; 0x95uy; 0xf6uy; 0xd9uy; 0xd9uy;
0x0duy; 0x11uy; 0xfauy; 0xa9uy; 0x33uy; 0xa1uy; 0x5euy; 0xf1uy;
0x36uy; 0x95uy; 0x46uy; 0x86uy; 0x8auy; 0x7fuy; 0x3auy; 0x45uy;
0xa9uy; 0x67uy; 0x68uy; 0xd4uy; 0x0fuy; 0xd9uy; 0xd0uy; 0x34uy;
0x12uy; 0xc0uy; 0x91uy; 0xc6uy; 0x31uy; 0x5cuy; 0xf4uy; 0xfduy;
0xe7uy; 0xcbuy; 0x68uy; 0x60uy; 0x69uy; 0x37uy; 0x38uy; 0x0duy;
0xb2uy; 0xeauy; 0xaauy; 0x70uy; 0x7buy; 0x4cuy; 0x41uy; 0x85uy;
0xc3uy; 0x2euy; 0xdduy; 0xcduy; 0xd3uy; 0x06uy; 0x70uy; 0x5euy;
0x4duy; 0xc1uy; 0xffuy; 0xc8uy; 0x72uy; 0xeeuy; 0xeeuy; 0x47uy;
0x5auy; 0x64uy; 0xdfuy; 0xacuy; 0x86uy; 0xabuy; 0xa4uy; 0x1cuy;
0x06uy; 0x18uy; 0x98uy; 0x3fuy; 0x87uy; 0x41uy; 0xc5uy; 0xefuy;
0x68uy; 0xd3uy; 0xa1uy; 0x01uy; 0xe8uy; 0xa3uy; 0xb8uy; 0xcauy;
0xc6uy; 0x0cuy; 0x90uy; 0x5cuy; 0x15uy; 0xfcuy; 0x91uy; 0x08uy;
0x40uy; 0xb9uy; 0x4cuy; 0x00uy; 0xa0uy; 0xb9uy; 0xd0uy
] in
assert_norm (List.Tot.length l == 1023);
of_list l | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.PrintSequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Ed25519.Test.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.PrintSequence",
"short_module": "PS"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"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": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"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
}
] | {
"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"
} | false | Lib.Sequence.lseq (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.SEC) 64 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.of_list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.list",
"FStar.List.Tot.Base.map",
"FStar.UInt8.t",
"Lib.RawIntTypes.u8_from_UInt8",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | false | false | false | false | false | let test4_expected_sig:lbytes 64 =
| let l =
List.Tot.map u8_from_UInt8
[
0x0auy; 0xabuy; 0x4cuy; 0x90uy; 0x05uy; 0x01uy; 0xb3uy; 0xe2uy; 0x4duy; 0x7cuy; 0xdfuy; 0x46uy;
0x63uy; 0x32uy; 0x6auy; 0x3auy; 0x87uy; 0xdfuy; 0x5euy; 0x48uy; 0x43uy; 0xb2uy; 0xcbuy; 0xdbuy;
0x67uy; 0xcbuy; 0xf6uy; 0xe4uy; 0x60uy; 0xfeuy; 0xc3uy; 0x50uy; 0xaauy; 0x53uy; 0x71uy; 0xb1uy;
0x50uy; 0x8fuy; 0x9fuy; 0x45uy; 0x28uy; 0xecuy; 0xeauy; 0x23uy; 0xc4uy; 0x36uy; 0xd9uy; 0x4buy;
0x5euy; 0x8fuy; 0xcduy; 0x4fuy; 0x68uy; 0x1euy; 0x30uy; 0xa6uy; 0xacuy; 0x00uy; 0xa9uy; 0x70uy;
0x4auy; 0x18uy; 0x8auy; 0x03uy
]
in
assert_norm (List.Tot.length l == 64);
of_list l | false |
Vale.X64.Flags.fst | Vale.X64.Flags.of_fun | val of_fun (m:flag -> flag_val_t) : Pure t
(requires True)
(ensures fun m' -> (forall (r:flag).{:pattern (m r) \/ (sel r m')} m r == sel r m')) | val of_fun (m:flag -> flag_val_t) : Pure t
(requires True)
(ensures fun m' -> (forall (r:flag).{:pattern (m r) \/ (sel r m')} m r == sel r m')) | let of_fun m =
let m' = Map.const None in
let m' = Map.upd m' 0 (m 0) in
let m' = Map.upd m' 1 (m 1) in
let m' = Map.upd m' 2 (m 2) in
let m' = Map.upd m' 3 (m 3) in
let m' = Map.upd m' 4 (m 4) in
let m' = Map.upd m' 5 (m 5) in
let m' = Map.upd m' 6 (m 6) in
let m' = Map.upd m' 7 (m 7) in
let m' = Map.upd m' 8 (m 8) in
let m' = Map.upd m' 9 (m 9) in
let m' = Map.upd m' 10 (m 10) in
let m' = Map.upd m' 11 (m 11) in
let m' = Map.upd m' 12 (m 12) in
let m' = Map.upd m' 13 (m 13) in
let m' = Map.upd m' 14 (m 14) in
let m' = Map.upd m' 15 (m 15) in
assert_norm (m 0 == sel 0 m');
assert_norm (m 1 == sel 1 m');
assert_norm (m 2 == sel 2 m');
assert_norm (m 3 == sel 3 m');
assert_norm (m 4 == sel 4 m');
assert_norm (m 5 == sel 5 m');
assert_norm (m 6 == sel 6 m');
assert_norm (m 7 == sel 7 m');
assert_norm (m 8 == sel 8 m');
assert_norm (m 9 == sel 9 m');
assert_norm (m 10 == sel 10 m');
assert_norm (m 11 == sel 11 m');
assert_norm (m 12 == sel 12 m');
assert_norm (m 13 == sel 13 m');
assert_norm (m 14 == sel 14 m');
assert_norm (m 15 == sel 15 m');
m' | {
"file_name": "vale/code/arch/x64/Vale.X64.Flags.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 50,
"start_col": 0,
"start_line": 16
} | module Vale.X64.Flags
open FStar.Mul
open Vale.X64.Machine_s
type t = (m:Map.t flag flag_val_t{Set.equal (Map.domain m) (Set.complement Set.empty)})
[@va_qattr "opaque_to_smt"]
let sel (r:flag) (m:t) : flag_val_t =
Map.sel m r
[@va_qattr "opaque_to_smt"]
let upd (r:flag) (v:flag_val_t) (m:t) : t =
reveal_opaque (`%t) t;
Map.upd m r v | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Flags.fst"
} | [
{
"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.Lib.Map16",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_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
}
] | {
"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"
} | false | m: (_: Vale.X64.Machine_s.flag -> Vale.X64.Flags.flag_val_t) -> Prims.Pure Vale.X64.Flags.t | Prims.Pure | [] | [] | [
"Vale.X64.Machine_s.flag",
"Vale.X64.Flags.flag_val_t",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Vale.X64.Flags.sel",
"FStar.Map.t",
"FStar.Pervasives.Native.option",
"Prims.bool",
"FStar.Map.upd",
"FStar.Map.const",
"FStar.Pervasives.Native.None",
"Vale.X64.Flags.t"
] | [] | false | false | false | false | false | let of_fun m =
| let m' = Map.const None in
let m' = Map.upd m' 0 (m 0) in
let m' = Map.upd m' 1 (m 1) in
let m' = Map.upd m' 2 (m 2) in
let m' = Map.upd m' 3 (m 3) in
let m' = Map.upd m' 4 (m 4) in
let m' = Map.upd m' 5 (m 5) in
let m' = Map.upd m' 6 (m 6) in
let m' = Map.upd m' 7 (m 7) in
let m' = Map.upd m' 8 (m 8) in
let m' = Map.upd m' 9 (m 9) in
let m' = Map.upd m' 10 (m 10) in
let m' = Map.upd m' 11 (m 11) in
let m' = Map.upd m' 12 (m 12) in
let m' = Map.upd m' 13 (m 13) in
let m' = Map.upd m' 14 (m 14) in
let m' = Map.upd m' 15 (m 15) in
assert_norm (m 0 == sel 0 m');
assert_norm (m 1 == sel 1 m');
assert_norm (m 2 == sel 2 m');
assert_norm (m 3 == sel 3 m');
assert_norm (m 4 == sel 4 m');
assert_norm (m 5 == sel 5 m');
assert_norm (m 6 == sel 6 m');
assert_norm (m 7 == sel 7 m');
assert_norm (m 8 == sel 8 m');
assert_norm (m 9 == sel 9 m');
assert_norm (m 10 == sel 10 m');
assert_norm (m 11 == sel 11 m');
assert_norm (m 12 == sel 12 m');
assert_norm (m 13 == sel 13 m');
assert_norm (m 14 == sel 14 m');
assert_norm (m 15 == sel 15 m');
m' | false |
Spec.Ed25519.Test.fst | Spec.Ed25519.Test.test_vectors | val test_vectors:list vec | val test_vectors:list vec | let test_vectors : list vec = [
Vec test1_sk test1_pk test1_msg test1_expected_sig;
Vec test2_sk test2_pk test2_msg test2_expected_sig;
Vec test3_sk test3_pk test3_msg test3_expected_sig;
Vec test4_sk test4_pk test4_msg test4_expected_sig ] | {
"file_name": "specs/tests/Spec.Ed25519.Test.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 54,
"end_line": 334,
"start_col": 0,
"start_line": 330
} | module Spec.Ed25519.Test
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
module PS = Lib.PrintSequence
open Spec.Ed25519
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Test 1
let test1_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x9duy; 0x61uy; 0xb1uy; 0x9duy; 0xefuy; 0xfduy; 0x5auy; 0x60uy;
0xbauy; 0x84uy; 0x4auy; 0xf4uy; 0x92uy; 0xecuy; 0x2cuy; 0xc4uy;
0x44uy; 0x49uy; 0xc5uy; 0x69uy; 0x7buy; 0x32uy; 0x69uy; 0x19uy;
0x70uy; 0x3buy; 0xacuy; 0x03uy; 0x1cuy; 0xaeuy; 0x7fuy; 0x60uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xd7uy; 0x5auy; 0x98uy; 0x01uy; 0x82uy; 0xb1uy; 0x0auy; 0xb7uy;
0xd5uy; 0x4buy; 0xfeuy; 0xd3uy; 0xc9uy; 0x64uy; 0x07uy; 0x3auy;
0x0euy; 0xe1uy; 0x72uy; 0xf3uy; 0xdauy; 0xa6uy; 0x23uy; 0x25uy;
0xafuy; 0x02uy; 0x1auy; 0x68uy; 0xf7uy; 0x07uy; 0x51uy; 0x1auy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test1_msg : lbytes 0 =
let l = List.Tot.map u8_from_UInt8 [] in
assert_norm (List.Tot.length l == 0);
of_list l
let test1_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0xe5uy; 0x56uy; 0x43uy; 0x00uy; 0xc3uy; 0x60uy; 0xacuy; 0x72uy;
0x90uy; 0x86uy; 0xe2uy; 0xccuy; 0x80uy; 0x6euy; 0x82uy; 0x8auy;
0x84uy; 0x87uy; 0x7fuy; 0x1euy; 0xb8uy; 0xe5uy; 0xd9uy; 0x74uy;
0xd8uy; 0x73uy; 0xe0uy; 0x65uy; 0x22uy; 0x49uy; 0x01uy; 0x55uy;
0x5fuy; 0xb8uy; 0x82uy; 0x15uy; 0x90uy; 0xa3uy; 0x3buy; 0xacuy;
0xc6uy; 0x1euy; 0x39uy; 0x70uy; 0x1cuy; 0xf9uy; 0xb4uy; 0x6buy;
0xd2uy; 0x5buy; 0xf5uy; 0xf0uy; 0x59uy; 0x5buy; 0xbeuy; 0x24uy;
0x65uy; 0x51uy; 0x41uy; 0x43uy; 0x8euy; 0x7auy; 0x10uy; 0x0buy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 2
let test2_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x4cuy; 0xcduy; 0x08uy; 0x9buy; 0x28uy; 0xffuy; 0x96uy; 0xdauy;
0x9duy; 0xb6uy; 0xc3uy; 0x46uy; 0xecuy; 0x11uy; 0x4euy; 0x0fuy;
0x5buy; 0x8auy; 0x31uy; 0x9fuy; 0x35uy; 0xabuy; 0xa6uy; 0x24uy;
0xdauy; 0x8cuy; 0xf6uy; 0xeduy; 0x4fuy; 0xb8uy; 0xa6uy; 0xfbuy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test2_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x3duy; 0x40uy; 0x17uy; 0xc3uy; 0xe8uy; 0x43uy; 0x89uy; 0x5auy;
0x92uy; 0xb7uy; 0x0auy; 0xa7uy; 0x4duy; 0x1buy; 0x7euy; 0xbcuy;
0x9cuy; 0x98uy; 0x2cuy; 0xcfuy; 0x2euy; 0xc4uy; 0x96uy; 0x8cuy;
0xc0uy; 0xcduy; 0x55uy; 0xf1uy; 0x2auy; 0xf4uy; 0x66uy; 0x0cuy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test2_msg : lbytes 1 =
let l = List.Tot.map u8_from_UInt8 [ 0x72uy ] in
assert_norm (List.Tot.length l == 1);
of_list l
let test2_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0x92uy; 0xa0uy; 0x09uy; 0xa9uy; 0xf0uy; 0xd4uy; 0xcauy; 0xb8uy;
0x72uy; 0x0euy; 0x82uy; 0x0buy; 0x5fuy; 0x64uy; 0x25uy; 0x40uy;
0xa2uy; 0xb2uy; 0x7buy; 0x54uy; 0x16uy; 0x50uy; 0x3fuy; 0x8fuy;
0xb3uy; 0x76uy; 0x22uy; 0x23uy; 0xebuy; 0xdbuy; 0x69uy; 0xdauy;
0x08uy; 0x5auy; 0xc1uy; 0xe4uy; 0x3euy; 0x15uy; 0x99uy; 0x6euy;
0x45uy; 0x8fuy; 0x36uy; 0x13uy; 0xd0uy; 0xf1uy; 0x1duy; 0x8cuy;
0x38uy; 0x7buy; 0x2euy; 0xaeuy; 0xb4uy; 0x30uy; 0x2auy; 0xeeuy;
0xb0uy; 0x0duy; 0x29uy; 0x16uy; 0x12uy; 0xbbuy; 0x0cuy; 0x00uy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 3
let test3_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xc5uy; 0xaauy; 0x8duy; 0xf4uy; 0x3fuy; 0x9fuy; 0x83uy; 0x7buy;
0xeduy; 0xb7uy; 0x44uy; 0x2fuy; 0x31uy; 0xdcuy; 0xb7uy; 0xb1uy;
0x66uy; 0xd3uy; 0x85uy; 0x35uy; 0x07uy; 0x6fuy; 0x09uy; 0x4buy;
0x85uy; 0xceuy; 0x3auy; 0x2euy; 0x0buy; 0x44uy; 0x58uy; 0xf7uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test3_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xfcuy; 0x51uy; 0xcduy; 0x8euy; 0x62uy; 0x18uy; 0xa1uy; 0xa3uy;
0x8duy; 0xa4uy; 0x7euy; 0xd0uy; 0x02uy; 0x30uy; 0xf0uy; 0x58uy;
0x08uy; 0x16uy; 0xeduy; 0x13uy; 0xbauy; 0x33uy; 0x03uy; 0xacuy;
0x5duy; 0xebuy; 0x91uy; 0x15uy; 0x48uy; 0x90uy; 0x80uy; 0x25uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test3_msg : lbytes 2 =
let l = List.Tot.map u8_from_UInt8 [ 0xafuy; 0x82uy ] in
assert_norm (List.Tot.length l == 2);
of_list l
let test3_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0x62uy; 0x91uy; 0xd6uy; 0x57uy; 0xdeuy; 0xecuy; 0x24uy; 0x02uy;
0x48uy; 0x27uy; 0xe6uy; 0x9cuy; 0x3auy; 0xbeuy; 0x01uy; 0xa3uy;
0x0cuy; 0xe5uy; 0x48uy; 0xa2uy; 0x84uy; 0x74uy; 0x3auy; 0x44uy;
0x5euy; 0x36uy; 0x80uy; 0xd7uy; 0xdbuy; 0x5auy; 0xc3uy; 0xacuy;
0x18uy; 0xffuy; 0x9buy; 0x53uy; 0x8duy; 0x16uy; 0xf2uy; 0x90uy;
0xaeuy; 0x67uy; 0xf7uy; 0x60uy; 0x98uy; 0x4duy; 0xc6uy; 0x59uy;
0x4auy; 0x7cuy; 0x15uy; 0xe9uy; 0x71uy; 0x6euy; 0xd2uy; 0x8duy;
0xc0uy; 0x27uy; 0xbeuy; 0xceuy; 0xeauy; 0x1euy; 0xc4uy; 0x0auy
] in
assert_norm (List.Tot.length l == 64);
of_list l
/// Test 4
let test4_sk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0xf5uy; 0xe5uy; 0x76uy; 0x7cuy; 0xf1uy; 0x53uy; 0x31uy; 0x95uy;
0x17uy; 0x63uy; 0x0fuy; 0x22uy; 0x68uy; 0x76uy; 0xb8uy; 0x6cuy;
0x81uy; 0x60uy; 0xccuy; 0x58uy; 0x3buy; 0xc0uy; 0x13uy; 0x74uy;
0x4cuy; 0x6buy; 0xf2uy; 0x55uy; 0xf5uy; 0xccuy; 0x0euy; 0xe5uy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test4_pk : lbytes 32 =
let l = List.Tot.map u8_from_UInt8 [
0x27uy; 0x81uy; 0x17uy; 0xfcuy; 0x14uy; 0x4cuy; 0x72uy; 0x34uy;
0x0fuy; 0x67uy; 0xd0uy; 0xf2uy; 0x31uy; 0x6euy; 0x83uy; 0x86uy;
0xceuy; 0xffuy; 0xbfuy; 0x2buy; 0x24uy; 0x28uy; 0xc9uy; 0xc5uy;
0x1fuy; 0xefuy; 0x7cuy; 0x59uy; 0x7fuy; 0x1duy; 0x42uy; 0x6euy
] in
assert_norm (List.Tot.length l == 32);
of_list l
let test4_msg : lbytes 1023 =
let l = List.Tot.map u8_from_UInt8 [
0x08uy; 0xb8uy; 0xb2uy; 0xb7uy; 0x33uy; 0x42uy; 0x42uy; 0x43uy;
0x76uy; 0x0fuy; 0xe4uy; 0x26uy; 0xa4uy; 0xb5uy; 0x49uy; 0x08uy;
0x63uy; 0x21uy; 0x10uy; 0xa6uy; 0x6cuy; 0x2fuy; 0x65uy; 0x91uy;
0xeauy; 0xbduy; 0x33uy; 0x45uy; 0xe3uy; 0xe4uy; 0xebuy; 0x98uy;
0xfauy; 0x6euy; 0x26uy; 0x4buy; 0xf0uy; 0x9euy; 0xfeuy; 0x12uy;
0xeeuy; 0x50uy; 0xf8uy; 0xf5uy; 0x4euy; 0x9fuy; 0x77uy; 0xb1uy;
0xe3uy; 0x55uy; 0xf6uy; 0xc5uy; 0x05uy; 0x44uy; 0xe2uy; 0x3fuy;
0xb1uy; 0x43uy; 0x3duy; 0xdfuy; 0x73uy; 0xbeuy; 0x84uy; 0xd8uy;
0x79uy; 0xdeuy; 0x7cuy; 0x00uy; 0x46uy; 0xdcuy; 0x49uy; 0x96uy;
0xd9uy; 0xe7uy; 0x73uy; 0xf4uy; 0xbcuy; 0x9euy; 0xfeuy; 0x57uy;
0x38uy; 0x82uy; 0x9auy; 0xdbuy; 0x26uy; 0xc8uy; 0x1buy; 0x37uy;
0xc9uy; 0x3auy; 0x1buy; 0x27uy; 0x0buy; 0x20uy; 0x32uy; 0x9duy;
0x65uy; 0x86uy; 0x75uy; 0xfcuy; 0x6euy; 0xa5uy; 0x34uy; 0xe0uy;
0x81uy; 0x0auy; 0x44uy; 0x32uy; 0x82uy; 0x6buy; 0xf5uy; 0x8cuy;
0x94uy; 0x1euy; 0xfbuy; 0x65uy; 0xd5uy; 0x7auy; 0x33uy; 0x8buy;
0xbduy; 0x2euy; 0x26uy; 0x64uy; 0x0fuy; 0x89uy; 0xffuy; 0xbcuy;
0x1auy; 0x85uy; 0x8euy; 0xfcuy; 0xb8uy; 0x55uy; 0x0euy; 0xe3uy;
0xa5uy; 0xe1uy; 0x99uy; 0x8buy; 0xd1uy; 0x77uy; 0xe9uy; 0x3auy;
0x73uy; 0x63uy; 0xc3uy; 0x44uy; 0xfeuy; 0x6buy; 0x19uy; 0x9euy;
0xe5uy; 0xd0uy; 0x2euy; 0x82uy; 0xd5uy; 0x22uy; 0xc4uy; 0xfeuy;
0xbauy; 0x15uy; 0x45uy; 0x2fuy; 0x80uy; 0x28uy; 0x8auy; 0x82uy;
0x1auy; 0x57uy; 0x91uy; 0x16uy; 0xecuy; 0x6duy; 0xaduy; 0x2buy;
0x3buy; 0x31uy; 0x0duy; 0xa9uy; 0x03uy; 0x40uy; 0x1auy; 0xa6uy;
0x21uy; 0x00uy; 0xabuy; 0x5duy; 0x1auy; 0x36uy; 0x55uy; 0x3euy;
0x06uy; 0x20uy; 0x3buy; 0x33uy; 0x89uy; 0x0cuy; 0xc9uy; 0xb8uy;
0x32uy; 0xf7uy; 0x9euy; 0xf8uy; 0x05uy; 0x60uy; 0xccuy; 0xb9uy;
0xa3uy; 0x9cuy; 0xe7uy; 0x67uy; 0x96uy; 0x7euy; 0xd6uy; 0x28uy;
0xc6uy; 0xaduy; 0x57uy; 0x3cuy; 0xb1uy; 0x16uy; 0xdbuy; 0xefuy;
0xefuy; 0xd7uy; 0x54uy; 0x99uy; 0xdauy; 0x96uy; 0xbduy; 0x68uy;
0xa8uy; 0xa9uy; 0x7buy; 0x92uy; 0x8auy; 0x8buy; 0xbcuy; 0x10uy;
0x3buy; 0x66uy; 0x21uy; 0xfcuy; 0xdeuy; 0x2buy; 0xecuy; 0xa1uy;
0x23uy; 0x1duy; 0x20uy; 0x6buy; 0xe6uy; 0xcduy; 0x9euy; 0xc7uy;
0xafuy; 0xf6uy; 0xf6uy; 0xc9uy; 0x4fuy; 0xcduy; 0x72uy; 0x04uy;
0xeduy; 0x34uy; 0x55uy; 0xc6uy; 0x8cuy; 0x83uy; 0xf4uy; 0xa4uy;
0x1duy; 0xa4uy; 0xafuy; 0x2buy; 0x74uy; 0xefuy; 0x5cuy; 0x53uy;
0xf1uy; 0xd8uy; 0xacuy; 0x70uy; 0xbduy; 0xcbuy; 0x7euy; 0xd1uy;
0x85uy; 0xceuy; 0x81uy; 0xbduy; 0x84uy; 0x35uy; 0x9duy; 0x44uy;
0x25uy; 0x4duy; 0x95uy; 0x62uy; 0x9euy; 0x98uy; 0x55uy; 0xa9uy;
0x4auy; 0x7cuy; 0x19uy; 0x58uy; 0xd1uy; 0xf8uy; 0xaduy; 0xa5uy;
0xd0uy; 0x53uy; 0x2euy; 0xd8uy; 0xa5uy; 0xaauy; 0x3fuy; 0xb2uy;
0xd1uy; 0x7buy; 0xa7uy; 0x0euy; 0xb6uy; 0x24uy; 0x8euy; 0x59uy;
0x4euy; 0x1auy; 0x22uy; 0x97uy; 0xacuy; 0xbbuy; 0xb3uy; 0x9duy;
0x50uy; 0x2fuy; 0x1auy; 0x8cuy; 0x6euy; 0xb6uy; 0xf1uy; 0xceuy;
0x22uy; 0xb3uy; 0xdeuy; 0x1auy; 0x1fuy; 0x40uy; 0xccuy; 0x24uy;
0x55uy; 0x41uy; 0x19uy; 0xa8uy; 0x31uy; 0xa9uy; 0xaauy; 0xd6uy;
0x07uy; 0x9cuy; 0xaduy; 0x88uy; 0x42uy; 0x5duy; 0xe6uy; 0xbduy;
0xe1uy; 0xa9uy; 0x18uy; 0x7euy; 0xbbuy; 0x60uy; 0x92uy; 0xcfuy;
0x67uy; 0xbfuy; 0x2buy; 0x13uy; 0xfduy; 0x65uy; 0xf2uy; 0x70uy;
0x88uy; 0xd7uy; 0x8buy; 0x7euy; 0x88uy; 0x3cuy; 0x87uy; 0x59uy;
0xd2uy; 0xc4uy; 0xf5uy; 0xc6uy; 0x5auy; 0xdbuy; 0x75uy; 0x53uy;
0x87uy; 0x8auy; 0xd5uy; 0x75uy; 0xf9uy; 0xfauy; 0xd8uy; 0x78uy;
0xe8uy; 0x0auy; 0x0cuy; 0x9buy; 0xa6uy; 0x3buy; 0xcbuy; 0xccuy;
0x27uy; 0x32uy; 0xe6uy; 0x94uy; 0x85uy; 0xbbuy; 0xc9uy; 0xc9uy;
0x0buy; 0xfbuy; 0xd6uy; 0x24uy; 0x81uy; 0xd9uy; 0x08uy; 0x9buy;
0xecuy; 0xcfuy; 0x80uy; 0xcfuy; 0xe2uy; 0xdfuy; 0x16uy; 0xa2uy;
0xcfuy; 0x65uy; 0xbduy; 0x92uy; 0xdduy; 0x59uy; 0x7buy; 0x07uy;
0x07uy; 0xe0uy; 0x91uy; 0x7auy; 0xf4uy; 0x8buy; 0xbbuy; 0x75uy;
0xfeuy; 0xd4uy; 0x13uy; 0xd2uy; 0x38uy; 0xf5uy; 0x55uy; 0x5auy;
0x7auy; 0x56uy; 0x9duy; 0x80uy; 0xc3uy; 0x41uy; 0x4auy; 0x8duy;
0x08uy; 0x59uy; 0xdcuy; 0x65uy; 0xa4uy; 0x61uy; 0x28uy; 0xbauy;
0xb2uy; 0x7auy; 0xf8uy; 0x7auy; 0x71uy; 0x31uy; 0x4fuy; 0x31uy;
0x8cuy; 0x78uy; 0x2buy; 0x23uy; 0xebuy; 0xfeuy; 0x80uy; 0x8buy;
0x82uy; 0xb0uy; 0xceuy; 0x26uy; 0x40uy; 0x1duy; 0x2euy; 0x22uy;
0xf0uy; 0x4duy; 0x83uy; 0xd1uy; 0x25uy; 0x5duy; 0xc5uy; 0x1auy;
0xdduy; 0xd3uy; 0xb7uy; 0x5auy; 0x2buy; 0x1auy; 0xe0uy; 0x78uy;
0x45uy; 0x04uy; 0xdfuy; 0x54uy; 0x3auy; 0xf8uy; 0x96uy; 0x9buy;
0xe3uy; 0xeauy; 0x70uy; 0x82uy; 0xffuy; 0x7fuy; 0xc9uy; 0x88uy;
0x8cuy; 0x14uy; 0x4duy; 0xa2uy; 0xafuy; 0x58uy; 0x42uy; 0x9euy;
0xc9uy; 0x60uy; 0x31uy; 0xdbuy; 0xcauy; 0xd3uy; 0xdauy; 0xd9uy;
0xafuy; 0x0duy; 0xcbuy; 0xaauy; 0xafuy; 0x26uy; 0x8cuy; 0xb8uy;
0xfcuy; 0xffuy; 0xeauy; 0xd9uy; 0x4fuy; 0x3cuy; 0x7cuy; 0xa4uy;
0x95uy; 0xe0uy; 0x56uy; 0xa9uy; 0xb4uy; 0x7auy; 0xcduy; 0xb7uy;
0x51uy; 0xfbuy; 0x73uy; 0xe6uy; 0x66uy; 0xc6uy; 0xc6uy; 0x55uy;
0xaduy; 0xe8uy; 0x29uy; 0x72uy; 0x97uy; 0xd0uy; 0x7auy; 0xd1uy;
0xbauy; 0x5euy; 0x43uy; 0xf1uy; 0xbcuy; 0xa3uy; 0x23uy; 0x01uy;
0x65uy; 0x13uy; 0x39uy; 0xe2uy; 0x29uy; 0x04uy; 0xccuy; 0x8cuy;
0x42uy; 0xf5uy; 0x8cuy; 0x30uy; 0xc0uy; 0x4auy; 0xafuy; 0xdbuy;
0x03uy; 0x8duy; 0xdauy; 0x08uy; 0x47uy; 0xdduy; 0x98uy; 0x8duy;
0xcduy; 0xa6uy; 0xf3uy; 0xbfuy; 0xd1uy; 0x5cuy; 0x4buy; 0x4cuy;
0x45uy; 0x25uy; 0x00uy; 0x4auy; 0xa0uy; 0x6euy; 0xefuy; 0xf8uy;
0xcauy; 0x61uy; 0x78uy; 0x3auy; 0xacuy; 0xecuy; 0x57uy; 0xfbuy;
0x3duy; 0x1fuy; 0x92uy; 0xb0uy; 0xfeuy; 0x2fuy; 0xd1uy; 0xa8uy;
0x5fuy; 0x67uy; 0x24uy; 0x51uy; 0x7buy; 0x65uy; 0xe6uy; 0x14uy;
0xaduy; 0x68uy; 0x08uy; 0xd6uy; 0xf6uy; 0xeeuy; 0x34uy; 0xdfuy;
0xf7uy; 0x31uy; 0x0fuy; 0xdcuy; 0x82uy; 0xaeuy; 0xbfuy; 0xd9uy;
0x04uy; 0xb0uy; 0x1euy; 0x1duy; 0xc5uy; 0x4buy; 0x29uy; 0x27uy;
0x09uy; 0x4buy; 0x2duy; 0xb6uy; 0x8duy; 0x6fuy; 0x90uy; 0x3buy;
0x68uy; 0x40uy; 0x1auy; 0xdeuy; 0xbfuy; 0x5auy; 0x7euy; 0x08uy;
0xd7uy; 0x8fuy; 0xf4uy; 0xefuy; 0x5duy; 0x63uy; 0x65uy; 0x3auy;
0x65uy; 0x04uy; 0x0cuy; 0xf9uy; 0xbfuy; 0xd4uy; 0xacuy; 0xa7uy;
0x98uy; 0x4auy; 0x74uy; 0xd3uy; 0x71uy; 0x45uy; 0x98uy; 0x67uy;
0x80uy; 0xfcuy; 0x0buy; 0x16uy; 0xacuy; 0x45uy; 0x16uy; 0x49uy;
0xdeuy; 0x61uy; 0x88uy; 0xa7uy; 0xdbuy; 0xdfuy; 0x19uy; 0x1fuy;
0x64uy; 0xb5uy; 0xfcuy; 0x5euy; 0x2auy; 0xb4uy; 0x7buy; 0x57uy;
0xf7uy; 0xf7uy; 0x27uy; 0x6cuy; 0xd4uy; 0x19uy; 0xc1uy; 0x7auy;
0x3cuy; 0xa8uy; 0xe1uy; 0xb9uy; 0x39uy; 0xaeuy; 0x49uy; 0xe4uy;
0x88uy; 0xacuy; 0xbauy; 0x6buy; 0x96uy; 0x56uy; 0x10uy; 0xb5uy;
0x48uy; 0x01uy; 0x09uy; 0xc8uy; 0xb1uy; 0x7buy; 0x80uy; 0xe1uy;
0xb7uy; 0xb7uy; 0x50uy; 0xdfuy; 0xc7uy; 0x59uy; 0x8duy; 0x5duy;
0x50uy; 0x11uy; 0xfduy; 0x2duy; 0xccuy; 0x56uy; 0x00uy; 0xa3uy;
0x2euy; 0xf5uy; 0xb5uy; 0x2auy; 0x1euy; 0xccuy; 0x82uy; 0x0euy;
0x30uy; 0x8auy; 0xa3uy; 0x42uy; 0x72uy; 0x1auy; 0xacuy; 0x09uy;
0x43uy; 0xbfuy; 0x66uy; 0x86uy; 0xb6uy; 0x4buy; 0x25uy; 0x79uy;
0x37uy; 0x65uy; 0x04uy; 0xccuy; 0xc4uy; 0x93uy; 0xd9uy; 0x7euy;
0x6auy; 0xeduy; 0x3fuy; 0xb0uy; 0xf9uy; 0xcduy; 0x71uy; 0xa4uy;
0x3duy; 0xd4uy; 0x97uy; 0xf0uy; 0x1fuy; 0x17uy; 0xc0uy; 0xe2uy;
0xcbuy; 0x37uy; 0x97uy; 0xaauy; 0x2auy; 0x2fuy; 0x25uy; 0x66uy;
0x56uy; 0x16uy; 0x8euy; 0x6cuy; 0x49uy; 0x6auy; 0xfcuy; 0x5fuy;
0xb9uy; 0x32uy; 0x46uy; 0xf6uy; 0xb1uy; 0x11uy; 0x63uy; 0x98uy;
0xa3uy; 0x46uy; 0xf1uy; 0xa6uy; 0x41uy; 0xf3uy; 0xb0uy; 0x41uy;
0xe9uy; 0x89uy; 0xf7uy; 0x91uy; 0x4fuy; 0x90uy; 0xccuy; 0x2cuy;
0x7fuy; 0xffuy; 0x35uy; 0x78uy; 0x76uy; 0xe5uy; 0x06uy; 0xb5uy;
0x0duy; 0x33uy; 0x4buy; 0xa7uy; 0x7cuy; 0x22uy; 0x5buy; 0xc3uy;
0x07uy; 0xbauy; 0x53uy; 0x71uy; 0x52uy; 0xf3uy; 0xf1uy; 0x61uy;
0x0euy; 0x4euy; 0xafuy; 0xe5uy; 0x95uy; 0xf6uy; 0xd9uy; 0xd9uy;
0x0duy; 0x11uy; 0xfauy; 0xa9uy; 0x33uy; 0xa1uy; 0x5euy; 0xf1uy;
0x36uy; 0x95uy; 0x46uy; 0x86uy; 0x8auy; 0x7fuy; 0x3auy; 0x45uy;
0xa9uy; 0x67uy; 0x68uy; 0xd4uy; 0x0fuy; 0xd9uy; 0xd0uy; 0x34uy;
0x12uy; 0xc0uy; 0x91uy; 0xc6uy; 0x31uy; 0x5cuy; 0xf4uy; 0xfduy;
0xe7uy; 0xcbuy; 0x68uy; 0x60uy; 0x69uy; 0x37uy; 0x38uy; 0x0duy;
0xb2uy; 0xeauy; 0xaauy; 0x70uy; 0x7buy; 0x4cuy; 0x41uy; 0x85uy;
0xc3uy; 0x2euy; 0xdduy; 0xcduy; 0xd3uy; 0x06uy; 0x70uy; 0x5euy;
0x4duy; 0xc1uy; 0xffuy; 0xc8uy; 0x72uy; 0xeeuy; 0xeeuy; 0x47uy;
0x5auy; 0x64uy; 0xdfuy; 0xacuy; 0x86uy; 0xabuy; 0xa4uy; 0x1cuy;
0x06uy; 0x18uy; 0x98uy; 0x3fuy; 0x87uy; 0x41uy; 0xc5uy; 0xefuy;
0x68uy; 0xd3uy; 0xa1uy; 0x01uy; 0xe8uy; 0xa3uy; 0xb8uy; 0xcauy;
0xc6uy; 0x0cuy; 0x90uy; 0x5cuy; 0x15uy; 0xfcuy; 0x91uy; 0x08uy;
0x40uy; 0xb9uy; 0x4cuy; 0x00uy; 0xa0uy; 0xb9uy; 0xd0uy
] in
assert_norm (List.Tot.length l == 1023);
of_list l
let test4_expected_sig : lbytes 64 =
let l = List.Tot.map u8_from_UInt8 [
0x0auy; 0xabuy; 0x4cuy; 0x90uy; 0x05uy; 0x01uy; 0xb3uy; 0xe2uy;
0x4duy; 0x7cuy; 0xdfuy; 0x46uy; 0x63uy; 0x32uy; 0x6auy; 0x3auy;
0x87uy; 0xdfuy; 0x5euy; 0x48uy; 0x43uy; 0xb2uy; 0xcbuy; 0xdbuy;
0x67uy; 0xcbuy; 0xf6uy; 0xe4uy; 0x60uy; 0xfeuy; 0xc3uy; 0x50uy;
0xaauy; 0x53uy; 0x71uy; 0xb1uy; 0x50uy; 0x8fuy; 0x9fuy; 0x45uy;
0x28uy; 0xecuy; 0xeauy; 0x23uy; 0xc4uy; 0x36uy; 0xd9uy; 0x4buy;
0x5euy; 0x8fuy; 0xcduy; 0x4fuy; 0x68uy; 0x1euy; 0x30uy; 0xa6uy;
0xacuy; 0x00uy; 0xa9uy; 0x70uy; 0x4auy; 0x18uy; 0x8auy; 0x03uy
] in
assert_norm (List.Tot.length l == 64);
of_list l
noeq type vec =
| Vec :
sk:lbytes 32
-> pk:lbytes 32
-> msg:bytes{length msg <= max_size_t}
-> expected_sig:lbytes 64 -> vec | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.PrintSequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Ed25519.Test.fst"
} | [
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.PrintSequence",
"short_module": "PS"
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.RawIntTypes",
"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": "Spec.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Ed25519",
"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
}
] | {
"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"
} | false | Prims.list Spec.Ed25519.Test.vec | Prims.Tot | [
"total"
] | [] | [
"Prims.Cons",
"Spec.Ed25519.Test.vec",
"Spec.Ed25519.Test.Vec",
"Spec.Ed25519.Test.test1_sk",
"Spec.Ed25519.Test.test1_pk",
"Spec.Ed25519.Test.test1_msg",
"Spec.Ed25519.Test.test1_expected_sig",
"Spec.Ed25519.Test.test2_sk",
"Spec.Ed25519.Test.test2_pk",
"Spec.Ed25519.Test.test2_msg",
"Spec.Ed25519.Test.test2_expected_sig",
"Spec.Ed25519.Test.test3_sk",
"Spec.Ed25519.Test.test3_pk",
"Spec.Ed25519.Test.test3_msg",
"Spec.Ed25519.Test.test3_expected_sig",
"Spec.Ed25519.Test.test4_sk",
"Spec.Ed25519.Test.test4_pk",
"Spec.Ed25519.Test.test4_msg",
"Spec.Ed25519.Test.test4_expected_sig",
"Prims.Nil"
] | [] | false | false | false | true | false | let test_vectors:list vec =
| [
Vec test1_sk test1_pk test1_msg test1_expected_sig;
Vec test2_sk test2_pk test2_msg test2_expected_sig;
Vec test3_sk test3_pk test3_msg test3_expected_sig;
Vec test4_sk test4_pk test4_msg test4_expected_sig
] | false |
Lib.LoopCombinators.fst | Lib.LoopCombinators.repeati | val repeati:
#a:Type
-> n:nat
-> f:(i:nat{i < n} -> a -> a)
-> acc0:a
-> a | val repeati:
#a:Type
-> n:nat
-> f:(i:nat{i < n} -> a -> a)
-> acc0:a
-> a | let repeati #a n f acc0 =
repeat_gen n (fixed_a a) f acc0 | {
"file_name": "lib/Lib.LoopCombinators.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 33,
"end_line": 52,
"start_col": 0,
"start_line": 51
} | module Lib.LoopCombinators
let rec repeat_left lo hi a f acc =
if lo = hi then acc
else repeat_left (lo + 1) hi a f (f lo acc)
let rec repeat_left_all_ml lo hi a f acc =
if lo = hi then acc
else repeat_left_all_ml (lo + 1) hi a f (f lo acc)
let rec repeat_right lo hi a f acc =
if lo = hi then acc
else f (hi - 1) (repeat_right lo (hi - 1) a f acc)
let rec repeat_right_all_ml lo hi a f acc =
if lo = hi then acc
else f (hi - 1) (repeat_right_all_ml lo (hi - 1) a f acc)
let rec repeat_right_plus lo mi hi a f acc =
if hi = mi then ()
else repeat_right_plus lo mi (hi - 1) a f acc
let unfold_repeat_right lo hi a f acc0 i = ()
let eq_repeat_right lo hi a f acc0 = ()
let rec repeat_left_right lo hi a f acc =
if lo = hi then ()
else
begin
repeat_right_plus lo (lo + 1) hi a f acc;
repeat_left_right (lo + 1) hi a f (f lo acc)
end
let repeat_gen n a f acc0 =
repeat_right 0 n a f acc0
let repeat_gen_all_ml n a f acc0 =
repeat_right_all_ml 0 n a f acc0
let unfold_repeat_gen n a f acc0 i = ()
(* // Proof when using [repeat_left]:
repeat_left_right 0 (i + 1) a f acc0;
repeat_left_right 0 i a f acc0
*)
let eq_repeat_gen0 n a f acc0 = ()
let repeat_gen_def n a f acc0 = () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.LoopCombinators.fst"
} | [
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"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": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | n: Prims.nat -> f: (i: Prims.nat{i < n} -> _: a -> a) -> acc0: a -> a | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.LoopCombinators.repeat_gen",
"Lib.LoopCombinators.fixed_a"
] | [] | false | false | false | false | false | let repeati #a n f acc0 =
| repeat_gen n (fixed_a a) f acc0 | false |
Lib.LoopCombinators.fst | Lib.LoopCombinators.repeati_all_ml | val repeati_all_ml:
#a:Type
-> n:nat
-> f:(i:nat{i < n} -> a -> FStar.All.ML a)
-> acc0:a
-> FStar.All.ML a | val repeati_all_ml:
#a:Type
-> n:nat
-> f:(i:nat{i < n} -> a -> FStar.All.ML a)
-> acc0:a
-> FStar.All.ML a | let repeati_all_ml #a n f acc0 =
repeat_gen_all_ml n (fixed_a a) f acc0 | {
"file_name": "lib/Lib.LoopCombinators.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 40,
"end_line": 55,
"start_col": 0,
"start_line": 54
} | module Lib.LoopCombinators
let rec repeat_left lo hi a f acc =
if lo = hi then acc
else repeat_left (lo + 1) hi a f (f lo acc)
let rec repeat_left_all_ml lo hi a f acc =
if lo = hi then acc
else repeat_left_all_ml (lo + 1) hi a f (f lo acc)
let rec repeat_right lo hi a f acc =
if lo = hi then acc
else f (hi - 1) (repeat_right lo (hi - 1) a f acc)
let rec repeat_right_all_ml lo hi a f acc =
if lo = hi then acc
else f (hi - 1) (repeat_right_all_ml lo (hi - 1) a f acc)
let rec repeat_right_plus lo mi hi a f acc =
if hi = mi then ()
else repeat_right_plus lo mi (hi - 1) a f acc
let unfold_repeat_right lo hi a f acc0 i = ()
let eq_repeat_right lo hi a f acc0 = ()
let rec repeat_left_right lo hi a f acc =
if lo = hi then ()
else
begin
repeat_right_plus lo (lo + 1) hi a f acc;
repeat_left_right (lo + 1) hi a f (f lo acc)
end
let repeat_gen n a f acc0 =
repeat_right 0 n a f acc0
let repeat_gen_all_ml n a f acc0 =
repeat_right_all_ml 0 n a f acc0
let unfold_repeat_gen n a f acc0 i = ()
(* // Proof when using [repeat_left]:
repeat_left_right 0 (i + 1) a f acc0;
repeat_left_right 0 i a f acc0
*)
let eq_repeat_gen0 n a f acc0 = ()
let repeat_gen_def n a f acc0 = ()
let repeati #a n f acc0 =
repeat_gen n (fixed_a a) f acc0 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.LoopCombinators.fst"
} | [
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"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": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | n: Prims.nat -> f: (i: Prims.nat{i < n} -> _: a -> FStar.All.ML a) -> acc0: a -> FStar.All.ML a | FStar.All.ML | [
"ml"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.LoopCombinators.repeat_gen_all_ml",
"Lib.LoopCombinators.fixed_a"
] | [] | false | true | false | false | false | let repeati_all_ml #a n f acc0 =
| repeat_gen_all_ml n (fixed_a a) f acc0 | false |
Lib.LoopCombinators.fst | Lib.LoopCombinators.repeat_right | val repeat_right:
lo:nat
-> hi:nat{lo <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> a (i + 1))
-> acc:a lo
-> Tot (a hi) (decreases (hi - lo)) | val repeat_right:
lo:nat
-> hi:nat{lo <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> a (i + 1))
-> acc:a lo
-> Tot (a hi) (decreases (hi - lo)) | let rec repeat_right lo hi a f acc =
if lo = hi then acc
else f (hi - 1) (repeat_right lo (hi - 1) a f acc) | {
"file_name": "lib/Lib.LoopCombinators.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 52,
"end_line": 13,
"start_col": 0,
"start_line": 11
} | module Lib.LoopCombinators
let rec repeat_left lo hi a f acc =
if lo = hi then acc
else repeat_left (lo + 1) hi a f (f lo acc)
let rec repeat_left_all_ml lo hi a f acc =
if lo = hi then acc
else repeat_left_all_ml (lo + 1) hi a f (f lo acc) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.LoopCombinators.fst"
} | [
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"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": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
lo: Prims.nat ->
hi: Prims.nat{lo <= hi} ->
a: (i: Prims.nat{lo <= i /\ i <= hi} -> Type) ->
f: (i: Prims.nat{lo <= i /\ i < hi} -> _: a i -> a (i + 1)) ->
acc: a lo
-> Prims.Tot (a hi) | Prims.Tot | [
"total",
""
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.l_and",
"Prims.op_LessThan",
"Prims.op_Addition",
"Prims.op_Equality",
"Prims.bool",
"Prims.op_Subtraction",
"Lib.LoopCombinators.repeat_right"
] | [
"recursion"
] | false | false | false | false | false | let rec repeat_right lo hi a f acc =
| if lo = hi then acc else f (hi - 1) (repeat_right lo (hi - 1) a f acc) | false |
Lib.LoopCombinators.fst | Lib.LoopCombinators.repeat_right_all_ml | val repeat_right_all_ml:
lo:nat
-> hi:nat{lo <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> FStar.All.ML (a (i + 1)))
-> acc:a lo
-> FStar.All.ML (a hi) (decreases (hi - lo)) | val repeat_right_all_ml:
lo:nat
-> hi:nat{lo <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> FStar.All.ML (a (i + 1)))
-> acc:a lo
-> FStar.All.ML (a hi) (decreases (hi - lo)) | let rec repeat_right_all_ml lo hi a f acc =
if lo = hi then acc
else f (hi - 1) (repeat_right_all_ml lo (hi - 1) a f acc) | {
"file_name": "lib/Lib.LoopCombinators.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 59,
"end_line": 17,
"start_col": 0,
"start_line": 15
} | module Lib.LoopCombinators
let rec repeat_left lo hi a f acc =
if lo = hi then acc
else repeat_left (lo + 1) hi a f (f lo acc)
let rec repeat_left_all_ml lo hi a f acc =
if lo = hi then acc
else repeat_left_all_ml (lo + 1) hi a f (f lo acc)
let rec repeat_right lo hi a f acc =
if lo = hi then acc
else f (hi - 1) (repeat_right lo (hi - 1) a f acc) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.LoopCombinators.fst"
} | [
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"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": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
lo: Prims.nat ->
hi: Prims.nat{lo <= hi} ->
a: (i: Prims.nat{lo <= i /\ i <= hi} -> Type) ->
f: (i: Prims.nat{lo <= i /\ i < hi} -> _: a i -> FStar.All.ML (a (i + 1))) ->
acc: a lo
-> FStar.All.ML (a hi) | FStar.All.ML | [
"ml",
""
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.l_and",
"Prims.op_LessThan",
"Prims.op_Addition",
"Prims.op_Equality",
"Prims.bool",
"Prims.op_Subtraction",
"Lib.LoopCombinators.repeat_right_all_ml"
] | [
"recursion"
] | false | true | false | false | false | let rec repeat_right_all_ml lo hi a f acc =
| if lo = hi then acc else f (hi - 1) (repeat_right_all_ml lo (hi - 1) a f acc) | false |
Lib.LoopCombinators.fst | Lib.LoopCombinators.repeat | val repeat:
#a:Type
-> n:nat
-> f:(a -> a)
-> acc0:a
-> a | val repeat:
#a:Type
-> n:nat
-> f:(a -> a)
-> acc0:a
-> a | let repeat #a n f acc0 =
repeati n (fixed_i f) acc0 | {
"file_name": "lib/Lib.LoopCombinators.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 28,
"end_line": 65,
"start_col": 0,
"start_line": 64
} | module Lib.LoopCombinators
let rec repeat_left lo hi a f acc =
if lo = hi then acc
else repeat_left (lo + 1) hi a f (f lo acc)
let rec repeat_left_all_ml lo hi a f acc =
if lo = hi then acc
else repeat_left_all_ml (lo + 1) hi a f (f lo acc)
let rec repeat_right lo hi a f acc =
if lo = hi then acc
else f (hi - 1) (repeat_right lo (hi - 1) a f acc)
let rec repeat_right_all_ml lo hi a f acc =
if lo = hi then acc
else f (hi - 1) (repeat_right_all_ml lo (hi - 1) a f acc)
let rec repeat_right_plus lo mi hi a f acc =
if hi = mi then ()
else repeat_right_plus lo mi (hi - 1) a f acc
let unfold_repeat_right lo hi a f acc0 i = ()
let eq_repeat_right lo hi a f acc0 = ()
let rec repeat_left_right lo hi a f acc =
if lo = hi then ()
else
begin
repeat_right_plus lo (lo + 1) hi a f acc;
repeat_left_right (lo + 1) hi a f (f lo acc)
end
let repeat_gen n a f acc0 =
repeat_right 0 n a f acc0
let repeat_gen_all_ml n a f acc0 =
repeat_right_all_ml 0 n a f acc0
let unfold_repeat_gen n a f acc0 i = ()
(* // Proof when using [repeat_left]:
repeat_left_right 0 (i + 1) a f acc0;
repeat_left_right 0 i a f acc0
*)
let eq_repeat_gen0 n a f acc0 = ()
let repeat_gen_def n a f acc0 = ()
let repeati #a n f acc0 =
repeat_gen n (fixed_a a) f acc0
let repeati_all_ml #a n f acc0 =
repeat_gen_all_ml n (fixed_a a) f acc0
let eq_repeati0 #a n f acc0 = ()
let unfold_repeati #a n f acc0 i =
unfold_repeat_gen n (fixed_a a) f acc0 i
let repeati_def #a n f acc0 = () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.LoopCombinators.fst"
} | [
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"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": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | n: Prims.nat -> f: (_: a -> a) -> acc0: a -> a | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Lib.LoopCombinators.repeati",
"Lib.LoopCombinators.fixed_i"
] | [] | false | false | false | true | false | let repeat #a n f acc0 =
| repeati n (fixed_i f) acc0 | false |
Lib.LoopCombinators.fst | Lib.LoopCombinators.repeat_left_all_ml | val repeat_left_all_ml:
lo:nat
-> hi:nat{lo <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> FStar.All.ML (a (i + 1)))
-> acc:a lo
-> FStar.All.ML (a hi) | val repeat_left_all_ml:
lo:nat
-> hi:nat{lo <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> FStar.All.ML (a (i + 1)))
-> acc:a lo
-> FStar.All.ML (a hi) | let rec repeat_left_all_ml lo hi a f acc =
if lo = hi then acc
else repeat_left_all_ml (lo + 1) hi a f (f lo acc) | {
"file_name": "lib/Lib.LoopCombinators.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 52,
"end_line": 9,
"start_col": 0,
"start_line": 7
} | module Lib.LoopCombinators
let rec repeat_left lo hi a f acc =
if lo = hi then acc
else repeat_left (lo + 1) hi a f (f lo acc) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.LoopCombinators.fst"
} | [
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"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": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
lo: Prims.nat ->
hi: Prims.nat{lo <= hi} ->
a: (i: Prims.nat{lo <= i /\ i <= hi} -> Type) ->
f: (i: Prims.nat{lo <= i /\ i < hi} -> _: a i -> FStar.All.ML (a (i + 1))) ->
acc: a lo
-> FStar.All.ML (a hi) | FStar.All.ML | [
"ml"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.l_and",
"Prims.op_LessThan",
"Prims.op_Addition",
"Prims.op_Equality",
"Prims.bool",
"Lib.LoopCombinators.repeat_left_all_ml"
] | [
"recursion"
] | false | true | false | false | false | let rec repeat_left_all_ml lo hi a f acc =
| if lo = hi then acc else repeat_left_all_ml (lo + 1) hi a f (f lo acc) | false |
Lib.LoopCombinators.fst | Lib.LoopCombinators.repeat_left | val repeat_left:
lo:nat
-> hi:nat{lo <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> a (i + 1))
-> acc:a lo
-> Tot (a hi) (decreases (hi - lo)) | val repeat_left:
lo:nat
-> hi:nat{lo <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> a (i + 1))
-> acc:a lo
-> Tot (a hi) (decreases (hi - lo)) | let rec repeat_left lo hi a f acc =
if lo = hi then acc
else repeat_left (lo + 1) hi a f (f lo acc) | {
"file_name": "lib/Lib.LoopCombinators.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 45,
"end_line": 5,
"start_col": 0,
"start_line": 3
} | module Lib.LoopCombinators | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.LoopCombinators.fst"
} | [
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"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": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
lo: Prims.nat ->
hi: Prims.nat{lo <= hi} ->
a: (i: Prims.nat{lo <= i /\ i <= hi} -> Type) ->
f: (i: Prims.nat{lo <= i /\ i < hi} -> _: a i -> a (i + 1)) ->
acc: a lo
-> Prims.Tot (a hi) | Prims.Tot | [
"total",
""
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.l_and",
"Prims.op_LessThan",
"Prims.op_Addition",
"Prims.op_Equality",
"Prims.bool",
"Lib.LoopCombinators.repeat_left"
] | [
"recursion"
] | false | false | false | false | false | let rec repeat_left lo hi a f acc =
| if lo = hi then acc else repeat_left (lo + 1) hi a f (f lo acc) | false |
Lib.LoopCombinators.fst | Lib.LoopCombinators.repeat_gen | val repeat_gen:
n:nat
-> a:(i:nat{i <= n} -> Type)
-> f:(i:nat{i < n} -> a i -> a (i + 1))
-> acc0:a 0
-> a n | val repeat_gen:
n:nat
-> a:(i:nat{i <= n} -> Type)
-> f:(i:nat{i < n} -> a i -> a (i + 1))
-> acc0:a 0
-> a n | let repeat_gen n a f acc0 =
repeat_right 0 n a f acc0 | {
"file_name": "lib/Lib.LoopCombinators.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 27,
"end_line": 36,
"start_col": 0,
"start_line": 35
} | module Lib.LoopCombinators
let rec repeat_left lo hi a f acc =
if lo = hi then acc
else repeat_left (lo + 1) hi a f (f lo acc)
let rec repeat_left_all_ml lo hi a f acc =
if lo = hi then acc
else repeat_left_all_ml (lo + 1) hi a f (f lo acc)
let rec repeat_right lo hi a f acc =
if lo = hi then acc
else f (hi - 1) (repeat_right lo (hi - 1) a f acc)
let rec repeat_right_all_ml lo hi a f acc =
if lo = hi then acc
else f (hi - 1) (repeat_right_all_ml lo (hi - 1) a f acc)
let rec repeat_right_plus lo mi hi a f acc =
if hi = mi then ()
else repeat_right_plus lo mi (hi - 1) a f acc
let unfold_repeat_right lo hi a f acc0 i = ()
let eq_repeat_right lo hi a f acc0 = ()
let rec repeat_left_right lo hi a f acc =
if lo = hi then ()
else
begin
repeat_right_plus lo (lo + 1) hi a f acc;
repeat_left_right (lo + 1) hi a f (f lo acc)
end | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.LoopCombinators.fst"
} | [
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"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": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
n: Prims.nat ->
a: (i: Prims.nat{i <= n} -> Type) ->
f: (i: Prims.nat{i < n} -> _: a i -> a (i + 1)) ->
acc0: a 0
-> a n | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.op_Addition",
"Lib.LoopCombinators.repeat_right"
] | [] | false | false | false | false | false | let repeat_gen n a f acc0 =
| repeat_right 0 n a f acc0 | false |
Lib.LoopCombinators.fst | Lib.LoopCombinators.repeat_right_plus | val repeat_right_plus:
lo:nat
-> mi:nat{lo <= mi}
-> hi:nat{mi <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> a (i + 1))
-> acc:a lo
-> Lemma (ensures
repeat_right lo hi a f acc ==
repeat_right mi hi a f (repeat_right lo mi a f acc))
(decreases hi) | val repeat_right_plus:
lo:nat
-> mi:nat{lo <= mi}
-> hi:nat{mi <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> a (i + 1))
-> acc:a lo
-> Lemma (ensures
repeat_right lo hi a f acc ==
repeat_right mi hi a f (repeat_right lo mi a f acc))
(decreases hi) | let rec repeat_right_plus lo mi hi a f acc =
if hi = mi then ()
else repeat_right_plus lo mi (hi - 1) a f acc | {
"file_name": "lib/Lib.LoopCombinators.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 47,
"end_line": 21,
"start_col": 0,
"start_line": 19
} | module Lib.LoopCombinators
let rec repeat_left lo hi a f acc =
if lo = hi then acc
else repeat_left (lo + 1) hi a f (f lo acc)
let rec repeat_left_all_ml lo hi a f acc =
if lo = hi then acc
else repeat_left_all_ml (lo + 1) hi a f (f lo acc)
let rec repeat_right lo hi a f acc =
if lo = hi then acc
else f (hi - 1) (repeat_right lo (hi - 1) a f acc)
let rec repeat_right_all_ml lo hi a f acc =
if lo = hi then acc
else f (hi - 1) (repeat_right_all_ml lo (hi - 1) a f acc) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.LoopCombinators.fst"
} | [
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"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": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
lo: Prims.nat ->
mi: Prims.nat{lo <= mi} ->
hi: Prims.nat{mi <= hi} ->
a: (i: Prims.nat{lo <= i /\ i <= hi} -> Type) ->
f: (i: Prims.nat{lo <= i /\ i < hi} -> _: a i -> a (i + 1)) ->
acc: a lo
-> FStar.Pervasives.Lemma
(ensures
Lib.LoopCombinators.repeat_right lo hi a f acc ==
Lib.LoopCombinators.repeat_right mi hi a f (Lib.LoopCombinators.repeat_right lo mi a f acc))
(decreases hi) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.l_and",
"Prims.op_LessThan",
"Prims.op_Addition",
"Prims.op_Equality",
"Prims.l_or",
"Prims.bool",
"Lib.LoopCombinators.repeat_right_plus",
"Prims.op_Subtraction",
"Prims.unit"
] | [
"recursion"
] | false | false | true | false | false | let rec repeat_right_plus lo mi hi a f acc =
| if hi = mi then () else repeat_right_plus lo mi (hi - 1) a f acc | false |
Lib.LoopCombinators.fst | Lib.LoopCombinators.repeat_gen_all_ml | val repeat_gen_all_ml:
n:nat
-> a:(i:nat{i <= n} -> Type)
-> f:(i:nat{i < n} -> a i -> FStar.All.ML (a (i + 1)))
-> acc0:a 0
-> FStar.All.ML (a n) | val repeat_gen_all_ml:
n:nat
-> a:(i:nat{i <= n} -> Type)
-> f:(i:nat{i < n} -> a i -> FStar.All.ML (a (i + 1)))
-> acc0:a 0
-> FStar.All.ML (a n) | let repeat_gen_all_ml n a f acc0 =
repeat_right_all_ml 0 n a f acc0 | {
"file_name": "lib/Lib.LoopCombinators.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 34,
"end_line": 39,
"start_col": 0,
"start_line": 38
} | module Lib.LoopCombinators
let rec repeat_left lo hi a f acc =
if lo = hi then acc
else repeat_left (lo + 1) hi a f (f lo acc)
let rec repeat_left_all_ml lo hi a f acc =
if lo = hi then acc
else repeat_left_all_ml (lo + 1) hi a f (f lo acc)
let rec repeat_right lo hi a f acc =
if lo = hi then acc
else f (hi - 1) (repeat_right lo (hi - 1) a f acc)
let rec repeat_right_all_ml lo hi a f acc =
if lo = hi then acc
else f (hi - 1) (repeat_right_all_ml lo (hi - 1) a f acc)
let rec repeat_right_plus lo mi hi a f acc =
if hi = mi then ()
else repeat_right_plus lo mi (hi - 1) a f acc
let unfold_repeat_right lo hi a f acc0 i = ()
let eq_repeat_right lo hi a f acc0 = ()
let rec repeat_left_right lo hi a f acc =
if lo = hi then ()
else
begin
repeat_right_plus lo (lo + 1) hi a f acc;
repeat_left_right (lo + 1) hi a f (f lo acc)
end
let repeat_gen n a f acc0 =
repeat_right 0 n a f acc0 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.LoopCombinators.fst"
} | [
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"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": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
n: Prims.nat ->
a: (i: Prims.nat{i <= n} -> Type) ->
f: (i: Prims.nat{i < n} -> _: a i -> FStar.All.ML (a (i + 1))) ->
acc0: a 0
-> FStar.All.ML (a n) | FStar.All.ML | [
"ml"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.op_Addition",
"Lib.LoopCombinators.repeat_right_all_ml"
] | [] | false | true | false | false | false | let repeat_gen_all_ml n a f acc0 =
| repeat_right_all_ml 0 n a f acc0 | false |
Lib.LoopCombinators.fst | Lib.LoopCombinators.unfold_repeati | val unfold_repeati:
#a:Type
-> n:nat
-> f:(i:nat{i < n} -> a -> a)
-> acc0:a
-> i:nat{i < n}
-> Lemma (repeati #a (i + 1) f acc0 == f i (repeati #a i f acc0)) | val unfold_repeati:
#a:Type
-> n:nat
-> f:(i:nat{i < n} -> a -> a)
-> acc0:a
-> i:nat{i < n}
-> Lemma (repeati #a (i + 1) f acc0 == f i (repeati #a i f acc0)) | let unfold_repeati #a n f acc0 i =
unfold_repeat_gen n (fixed_a a) f acc0 i | {
"file_name": "lib/Lib.LoopCombinators.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 42,
"end_line": 60,
"start_col": 0,
"start_line": 59
} | module Lib.LoopCombinators
let rec repeat_left lo hi a f acc =
if lo = hi then acc
else repeat_left (lo + 1) hi a f (f lo acc)
let rec repeat_left_all_ml lo hi a f acc =
if lo = hi then acc
else repeat_left_all_ml (lo + 1) hi a f (f lo acc)
let rec repeat_right lo hi a f acc =
if lo = hi then acc
else f (hi - 1) (repeat_right lo (hi - 1) a f acc)
let rec repeat_right_all_ml lo hi a f acc =
if lo = hi then acc
else f (hi - 1) (repeat_right_all_ml lo (hi - 1) a f acc)
let rec repeat_right_plus lo mi hi a f acc =
if hi = mi then ()
else repeat_right_plus lo mi (hi - 1) a f acc
let unfold_repeat_right lo hi a f acc0 i = ()
let eq_repeat_right lo hi a f acc0 = ()
let rec repeat_left_right lo hi a f acc =
if lo = hi then ()
else
begin
repeat_right_plus lo (lo + 1) hi a f acc;
repeat_left_right (lo + 1) hi a f (f lo acc)
end
let repeat_gen n a f acc0 =
repeat_right 0 n a f acc0
let repeat_gen_all_ml n a f acc0 =
repeat_right_all_ml 0 n a f acc0
let unfold_repeat_gen n a f acc0 i = ()
(* // Proof when using [repeat_left]:
repeat_left_right 0 (i + 1) a f acc0;
repeat_left_right 0 i a f acc0
*)
let eq_repeat_gen0 n a f acc0 = ()
let repeat_gen_def n a f acc0 = ()
let repeati #a n f acc0 =
repeat_gen n (fixed_a a) f acc0
let repeati_all_ml #a n f acc0 =
repeat_gen_all_ml n (fixed_a a) f acc0
let eq_repeati0 #a n f acc0 = () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.LoopCombinators.fst"
} | [
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"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": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | n: Prims.nat -> f: (i: Prims.nat{i < n} -> _: a -> a) -> acc0: a -> i: Prims.nat{i < n}
-> FStar.Pervasives.Lemma
(ensures
Lib.LoopCombinators.repeati (i + 1) f acc0 == f i (Lib.LoopCombinators.repeati i f acc0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.LoopCombinators.unfold_repeat_gen",
"Lib.LoopCombinators.fixed_a",
"Prims.unit"
] | [] | true | false | true | false | false | let unfold_repeati #a n f acc0 i =
| unfold_repeat_gen n (fixed_a a) f acc0 i | false |
Lib.LoopCombinators.fst | Lib.LoopCombinators.repeat_left_right | val repeat_left_right:
lo:nat
-> hi:nat{lo <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> a (i + 1))
-> acc:a lo
-> Lemma (ensures repeat_right lo hi a f acc == repeat_left lo hi a f acc)
(decreases (hi - lo)) | val repeat_left_right:
lo:nat
-> hi:nat{lo <= hi}
-> a:(i:nat{lo <= i /\ i <= hi} -> Type)
-> f:(i:nat{lo <= i /\ i < hi} -> a i -> a (i + 1))
-> acc:a lo
-> Lemma (ensures repeat_right lo hi a f acc == repeat_left lo hi a f acc)
(decreases (hi - lo)) | let rec repeat_left_right lo hi a f acc =
if lo = hi then ()
else
begin
repeat_right_plus lo (lo + 1) hi a f acc;
repeat_left_right (lo + 1) hi a f (f lo acc)
end | {
"file_name": "lib/Lib.LoopCombinators.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 7,
"end_line": 33,
"start_col": 0,
"start_line": 27
} | module Lib.LoopCombinators
let rec repeat_left lo hi a f acc =
if lo = hi then acc
else repeat_left (lo + 1) hi a f (f lo acc)
let rec repeat_left_all_ml lo hi a f acc =
if lo = hi then acc
else repeat_left_all_ml (lo + 1) hi a f (f lo acc)
let rec repeat_right lo hi a f acc =
if lo = hi then acc
else f (hi - 1) (repeat_right lo (hi - 1) a f acc)
let rec repeat_right_all_ml lo hi a f acc =
if lo = hi then acc
else f (hi - 1) (repeat_right_all_ml lo (hi - 1) a f acc)
let rec repeat_right_plus lo mi hi a f acc =
if hi = mi then ()
else repeat_right_plus lo mi (hi - 1) a f acc
let unfold_repeat_right lo hi a f acc0 i = ()
let eq_repeat_right lo hi a f acc0 = () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.LoopCombinators.fst"
} | [
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"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": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
lo: Prims.nat ->
hi: Prims.nat{lo <= hi} ->
a: (i: Prims.nat{lo <= i /\ i <= hi} -> Type) ->
f: (i: Prims.nat{lo <= i /\ i < hi} -> _: a i -> a (i + 1)) ->
acc: a lo
-> FStar.Pervasives.Lemma
(ensures
Lib.LoopCombinators.repeat_right lo hi a f acc ==
Lib.LoopCombinators.repeat_left lo hi a f acc) (decreases hi - lo) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.l_and",
"Prims.op_LessThan",
"Prims.op_Addition",
"Prims.op_Equality",
"Prims.bool",
"Lib.LoopCombinators.repeat_left_right",
"Prims.unit",
"Lib.LoopCombinators.repeat_right_plus"
] | [
"recursion"
] | false | false | true | false | false | let rec repeat_left_right lo hi a f acc =
| if lo = hi
then ()
else
(repeat_right_plus lo (lo + 1) hi a f acc;
repeat_left_right (lo + 1) hi a f (f lo acc)) | false |
Lib.LoopCombinators.fst | Lib.LoopCombinators.a' | val a' : n: Prims.nat -> pred: (i: Prims.nat{i <= n} -> _: a -> Type) -> i: Prims.nat{i <= n} -> Type | let a' (#a:Type) (n:nat) (pred:(i:nat{i <= n} -> a -> Type)) = fun (i:nat{i<=n}) -> x:a{pred i x} | {
"file_name": "lib/Lib.LoopCombinators.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 97,
"end_line": 113,
"start_col": 0,
"start_line": 113
} | module Lib.LoopCombinators
let rec repeat_left lo hi a f acc =
if lo = hi then acc
else repeat_left (lo + 1) hi a f (f lo acc)
let rec repeat_left_all_ml lo hi a f acc =
if lo = hi then acc
else repeat_left_all_ml (lo + 1) hi a f (f lo acc)
let rec repeat_right lo hi a f acc =
if lo = hi then acc
else f (hi - 1) (repeat_right lo (hi - 1) a f acc)
let rec repeat_right_all_ml lo hi a f acc =
if lo = hi then acc
else f (hi - 1) (repeat_right_all_ml lo (hi - 1) a f acc)
let rec repeat_right_plus lo mi hi a f acc =
if hi = mi then ()
else repeat_right_plus lo mi (hi - 1) a f acc
let unfold_repeat_right lo hi a f acc0 i = ()
let eq_repeat_right lo hi a f acc0 = ()
let rec repeat_left_right lo hi a f acc =
if lo = hi then ()
else
begin
repeat_right_plus lo (lo + 1) hi a f acc;
repeat_left_right (lo + 1) hi a f (f lo acc)
end
let repeat_gen n a f acc0 =
repeat_right 0 n a f acc0
let repeat_gen_all_ml n a f acc0 =
repeat_right_all_ml 0 n a f acc0
let unfold_repeat_gen n a f acc0 i = ()
(* // Proof when using [repeat_left]:
repeat_left_right 0 (i + 1) a f acc0;
repeat_left_right 0 i a f acc0
*)
let eq_repeat_gen0 n a f acc0 = ()
let repeat_gen_def n a f acc0 = ()
let repeati #a n f acc0 =
repeat_gen n (fixed_a a) f acc0
let repeati_all_ml #a n f acc0 =
repeat_gen_all_ml n (fixed_a a) f acc0
let eq_repeati0 #a n f acc0 = ()
let unfold_repeati #a n f acc0 i =
unfold_repeat_gen n (fixed_a a) f acc0 i
let repeati_def #a n f acc0 = ()
let repeat #a n f acc0 =
repeati n (fixed_i f) acc0
let eq_repeat0 #a f acc0 = ()
let unfold_repeat #a n f acc0 i =
unfold_repeati #a n (fixed_i f) acc0 i
let repeat_range #a min max f x =
repeat_left min max (fun _ -> a) f x
let repeat_range_all_ml #a min max f x =
repeat_left_all_ml min max (fun _ -> a) f x
let repeat_range_inductive #a min max pred f x =
repeat_left min max (fun i -> x:a{pred i x}) f x
let repeati_inductive #a n pred f x0 =
repeat_range_inductive #a 0 n pred f x0
let unfold_repeat_right_once
(lo:nat)
(hi:nat{lo < hi})
(a:(i:nat{lo <= i /\ i <= hi} -> Type))
(f:(i:nat{lo <= i /\ i < hi} -> a i -> a (i + 1)))
(acc:a lo)
: Lemma (repeat_right lo hi a f acc ==
f (hi - 1) (repeat_right lo (hi - 1) a f acc))
= ()
module T = FStar.Tactics
let refine_eq (a:Type) (p q:a -> prop) (x:squash (forall (i:a). p i <==> q i))
: Lemma ((i:a{p i} == i:a{q i}))
= let pext (a:Type) (p q: a -> prop) (_:squash (forall (x:a). p x <==> q x)) (x:a) : Lemma (p x == q x)
= FStar.PropositionalExtensionality.apply (p x) (q x)
in
assert (i:a{p i} == i:a{q i})
by (T.l_to_r [quote (pext a p q x)]; T.trefl())
let nat_refine_equiv (n:nat)
: Lemma ((i:nat{i <= n}) == (i:nat{0<=i /\ i<=n}))
= let b2t_prop (b:bool)
: Lemma ((b2t b) `subtype_of` unit)
= assert_norm (b2t b == squash (equals b true))
in
refine_eq nat (fun (i:nat) -> b2t_prop (i <= n); b2t (i <= n)) (fun (i:nat) -> 0 <= i /\ i <= n) () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.LoopCombinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"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": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | n: Prims.nat -> pred: (i: Prims.nat{i <= n} -> _: a -> Type) -> i: Prims.nat{i <= n} -> Type | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual"
] | [] | false | false | false | false | true | let a' (#a: Type) (n: nat) (pred: (i: nat{i <= n} -> a -> Type)) =
| fun (i: nat{i <= n}) -> x: a{pred i x} | false |
|
Lib.LoopCombinators.fst | Lib.LoopCombinators.repeat_range | val repeat_range:
#a:Type
-> min:nat
-> max:nat{min <= max}
-> (s:nat{s >= min /\ s < max} -> a -> Tot a)
-> a
-> Tot a (decreases (max - min)) | val repeat_range:
#a:Type
-> min:nat
-> max:nat{min <= max}
-> (s:nat{s >= min /\ s < max} -> a -> Tot a)
-> a
-> Tot a (decreases (max - min)) | let repeat_range #a min max f x =
repeat_left min max (fun _ -> a) f x | {
"file_name": "lib/Lib.LoopCombinators.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 74,
"start_col": 0,
"start_line": 73
} | module Lib.LoopCombinators
let rec repeat_left lo hi a f acc =
if lo = hi then acc
else repeat_left (lo + 1) hi a f (f lo acc)
let rec repeat_left_all_ml lo hi a f acc =
if lo = hi then acc
else repeat_left_all_ml (lo + 1) hi a f (f lo acc)
let rec repeat_right lo hi a f acc =
if lo = hi then acc
else f (hi - 1) (repeat_right lo (hi - 1) a f acc)
let rec repeat_right_all_ml lo hi a f acc =
if lo = hi then acc
else f (hi - 1) (repeat_right_all_ml lo (hi - 1) a f acc)
let rec repeat_right_plus lo mi hi a f acc =
if hi = mi then ()
else repeat_right_plus lo mi (hi - 1) a f acc
let unfold_repeat_right lo hi a f acc0 i = ()
let eq_repeat_right lo hi a f acc0 = ()
let rec repeat_left_right lo hi a f acc =
if lo = hi then ()
else
begin
repeat_right_plus lo (lo + 1) hi a f acc;
repeat_left_right (lo + 1) hi a f (f lo acc)
end
let repeat_gen n a f acc0 =
repeat_right 0 n a f acc0
let repeat_gen_all_ml n a f acc0 =
repeat_right_all_ml 0 n a f acc0
let unfold_repeat_gen n a f acc0 i = ()
(* // Proof when using [repeat_left]:
repeat_left_right 0 (i + 1) a f acc0;
repeat_left_right 0 i a f acc0
*)
let eq_repeat_gen0 n a f acc0 = ()
let repeat_gen_def n a f acc0 = ()
let repeati #a n f acc0 =
repeat_gen n (fixed_a a) f acc0
let repeati_all_ml #a n f acc0 =
repeat_gen_all_ml n (fixed_a a) f acc0
let eq_repeati0 #a n f acc0 = ()
let unfold_repeati #a n f acc0 i =
unfold_repeat_gen n (fixed_a a) f acc0 i
let repeati_def #a n f acc0 = ()
let repeat #a n f acc0 =
repeati n (fixed_i f) acc0
let eq_repeat0 #a f acc0 = ()
let unfold_repeat #a n f acc0 i =
unfold_repeati #a n (fixed_i f) acc0 i | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.LoopCombinators.fst"
} | [
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"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": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
min: Prims.nat ->
max: Prims.nat{min <= max} ->
f: (s: Prims.nat{s >= min /\ s < max} -> _: a -> a) ->
x: a
-> Prims.Tot a | Prims.Tot | [
"total",
""
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.l_and",
"Prims.op_GreaterThanOrEqual",
"Prims.op_LessThan",
"Lib.LoopCombinators.repeat_left"
] | [] | false | false | false | false | false | let repeat_range #a min max f x =
| repeat_left min max (fun _ -> a) f x | false |
Lib.LoopCombinators.fst | Lib.LoopCombinators.repeati_inductive | val repeati_inductive:
#a:Type
-> n:nat
-> pred:(i:nat{i <= n} -> a -> Type)
-> f:repeatable #a #n pred
-> x0:a{pred 0 x0}
-> res:a{pred n res} | val repeati_inductive:
#a:Type
-> n:nat
-> pred:(i:nat{i <= n} -> a -> Type)
-> f:repeatable #a #n pred
-> x0:a{pred 0 x0}
-> res:a{pred n res} | let repeati_inductive #a n pred f x0 =
repeat_range_inductive #a 0 n pred f x0 | {
"file_name": "lib/Lib.LoopCombinators.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 41,
"end_line": 83,
"start_col": 0,
"start_line": 82
} | module Lib.LoopCombinators
let rec repeat_left lo hi a f acc =
if lo = hi then acc
else repeat_left (lo + 1) hi a f (f lo acc)
let rec repeat_left_all_ml lo hi a f acc =
if lo = hi then acc
else repeat_left_all_ml (lo + 1) hi a f (f lo acc)
let rec repeat_right lo hi a f acc =
if lo = hi then acc
else f (hi - 1) (repeat_right lo (hi - 1) a f acc)
let rec repeat_right_all_ml lo hi a f acc =
if lo = hi then acc
else f (hi - 1) (repeat_right_all_ml lo (hi - 1) a f acc)
let rec repeat_right_plus lo mi hi a f acc =
if hi = mi then ()
else repeat_right_plus lo mi (hi - 1) a f acc
let unfold_repeat_right lo hi a f acc0 i = ()
let eq_repeat_right lo hi a f acc0 = ()
let rec repeat_left_right lo hi a f acc =
if lo = hi then ()
else
begin
repeat_right_plus lo (lo + 1) hi a f acc;
repeat_left_right (lo + 1) hi a f (f lo acc)
end
let repeat_gen n a f acc0 =
repeat_right 0 n a f acc0
let repeat_gen_all_ml n a f acc0 =
repeat_right_all_ml 0 n a f acc0
let unfold_repeat_gen n a f acc0 i = ()
(* // Proof when using [repeat_left]:
repeat_left_right 0 (i + 1) a f acc0;
repeat_left_right 0 i a f acc0
*)
let eq_repeat_gen0 n a f acc0 = ()
let repeat_gen_def n a f acc0 = ()
let repeati #a n f acc0 =
repeat_gen n (fixed_a a) f acc0
let repeati_all_ml #a n f acc0 =
repeat_gen_all_ml n (fixed_a a) f acc0
let eq_repeati0 #a n f acc0 = ()
let unfold_repeati #a n f acc0 i =
unfold_repeat_gen n (fixed_a a) f acc0 i
let repeati_def #a n f acc0 = ()
let repeat #a n f acc0 =
repeati n (fixed_i f) acc0
let eq_repeat0 #a f acc0 = ()
let unfold_repeat #a n f acc0 i =
unfold_repeati #a n (fixed_i f) acc0 i
let repeat_range #a min max f x =
repeat_left min max (fun _ -> a) f x
let repeat_range_all_ml #a min max f x =
repeat_left_all_ml min max (fun _ -> a) f x
let repeat_range_inductive #a min max pred f x =
repeat_left min max (fun i -> x:a{pred i x}) f x | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.LoopCombinators.fst"
} | [
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"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": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
n: Prims.nat ->
pred: (i: Prims.nat{i <= n} -> _: a -> Type) ->
f: Lib.LoopCombinators.repeatable pred ->
x0: a{pred 0 x0}
-> res: a{pred n res} | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.LoopCombinators.repeatable",
"Lib.LoopCombinators.repeat_range_inductive"
] | [] | false | false | false | false | false | let repeati_inductive #a n pred f x0 =
| repeat_range_inductive #a 0 n pred f x0 | false |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.