effect stringclasses 48
values | original_source_type stringlengths 0 23k | opens_and_abbrevs listlengths 2 92 | isa_cross_project_example bool 1
class | source_definition stringlengths 9 57.9k | partial_definition stringlengths 7 23.3k | is_div bool 2
classes | is_type null | is_proof bool 2
classes | completed_definiton stringlengths 1 250k | dependencies dict | effect_flags listlengths 0 2 | ideal_premises listlengths 0 236 | mutual_with listlengths 0 11 | file_context stringlengths 0 407k | interleaved bool 1
class | is_simply_typed bool 2
classes | file_name stringlengths 5 48 | vconfig dict | is_simple_lemma null | source_type stringlengths 10 23k | proof_features listlengths 0 1 | name stringlengths 8 95 | source dict | verbose_type stringlengths 1 7.42k | source_range dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
FStar.Pervasives.Lemma | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_modul... | false | let expand_key_128_reveal = opaque_revealer (`%expand_key_128) expand_key_128 expand_key_128_def | let expand_key_128_reveal = | false | null | true | opaque_revealer (`%expand_key_128) expand_key_128 expand_key_128_def | {
"checked_file": "Vale.AES.AES_helpers_BE.fsti.checked",
"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.... | [
"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_128",
"Prims.l_True",
"Vale.AES.AES_helpers_BE.expand_key_128",
"Vale.AES.AES_helpers_BE.expand_key_128_def"
... | [] | module Vale.AES.AES_helpers_BE
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_BE_s
open FStar.Mul
open Vale.Arch.Types
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})... | false | false | Vale.AES.AES_helpers_BE.fsti | {
"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_el... | null | val expand_key_128_reveal : _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures Vale.AES.AES_helpers_BE.expand_key_128 == Vale.AES.AES_helpers_BE.expand_key_128_def) | [] | Vale.AES.AES_helpers_BE.expand_key_128_reveal | {
"file_name": "vale/code/crypto/aes/Vale.AES.AES_helpers_BE.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures Vale.AES.AES_helpers_BE.expand_key_128 == Vale.AES.AES_helpers_BE.expand_key_128_def) | {
"end_col": 108,
"end_line": 47,
"start_col": 40,
"start_line": 47
} | |
Prims.Tot | val quad32_shr32 (q: quad32) : quad32 | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_modul... | false | let quad32_shr32 (q:quad32) : quad32 =
let Mkfour v0 v1 v2 v3 = q in
Mkfour v1 v2 v3 0 | val quad32_shr32 (q: quad32) : quad32
let quad32_shr32 (q: quad32) : quad32 = | false | null | false | let Mkfour v0 v1 v2 v3 = q in
Mkfour v1 v2 v3 0 | {
"checked_file": "Vale.AES.AES_helpers_BE.fsti.checked",
"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.... | [
"total"
] | [
"Vale.Def.Types_s.quad32",
"Vale.Def.Types_s.nat32",
"Vale.Def.Words_s.Mkfour"
] | [] | module Vale.AES.AES_helpers_BE
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_BE_s
open FStar.Mul
open Vale.Arch.Types
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})... | false | true | Vale.AES.AES_helpers_BE.fsti | {
"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_el... | null | val quad32_shr32 (q: quad32) : quad32 | [] | Vale.AES.AES_helpers_BE.quad32_shr32 | {
"file_name": "vale/code/crypto/aes/Vale.AES.AES_helpers_BE.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | q: Vale.Def.Types_s.quad32 -> Vale.Def.Types_s.quad32 | {
"end_col": 19,
"end_line": 23,
"start_col": 38,
"start_line": 21
} |
Prims.Pure | val expand_key_128_def (key: seq nat32) (round: nat)
: Pure quad32 (requires is_aes_key_word AES_128 key) (ensures fun _ -> True) | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_modul... | false | let rec expand_key_128_def (key:seq nat32) (round:nat) : Pure quad32
(requires is_aes_key_word AES_128 key)
(ensures fun _ -> True)
=
if round = 0 then Mkfour key.[3] key.[2] key.[1] key.[0]
else round_key_128 (expand_key_128_def key (round - 1)) round | val expand_key_128_def (key: seq nat32) (round: nat)
: Pure quad32 (requires is_aes_key_word AES_128 key) (ensures fun _ -> True)
let rec expand_key_128_def (key: seq nat32) (round: nat)
: Pure quad32 (requires is_aes_key_word AES_128 key) (ensures fun _ -> True) = | false | null | false | if round = 0
then Mkfour key.[ 3 ] key.[ 2 ] key.[ 1 ] key.[ 0 ]
else round_key_128 (expand_key_128_def key (round - 1)) round | {
"checked_file": "Vale.AES.AES_helpers_BE.fsti.checked",
"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.... | [] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat32",
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"Vale.Def.Words_s.Mkfour",
"Vale.AES.AES_helpers_BE.op_String_Access",
"Prims.bool",
"Vale.AES.AES_helpers_BE.round_key_128",
"Vale.AES.AES_helpers_BE.expand_key_128_def",
"Prims.op_Subtraction",
"Va... | [] | module Vale.AES.AES_helpers_BE
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_BE_s
open FStar.Mul
open Vale.Arch.Types
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})... | false | false | Vale.AES.AES_helpers_BE.fsti | {
"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_el... | null | val expand_key_128_def (key: seq nat32) (round: nat)
: Pure quad32 (requires is_aes_key_word AES_128 key) (ensures fun _ -> True) | [
"recursion"
] | Vale.AES.AES_helpers_BE.expand_key_128_def | {
"file_name": "vale/code/crypto/aes/Vale.AES.AES_helpers_BE.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | key: FStar.Seq.Base.seq Vale.Def.Types_s.nat32 -> round: Prims.nat
-> Prims.Pure Vale.Def.Types_s.quad32 | {
"end_col": 63,
"end_line": 45,
"start_col": 2,
"start_line": 44
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasiv... | false | let prop0 = Type0 | let prop0 = | false | null | false | Type0 | {
"checked_file": "Vale.Def.Prop_s.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Def.Prop_s.fst"
} | [
"total"
] | [] | [] | module Vale.Def.Prop_s
open FStar.Mul
// Prims.logical (which is private to Prims) and prop0 are synonyms for Type0 in F*,
// but are not synonyms in Vale's type system:
// - importFStarTypes.exe interprets Prims.logical and prop0 as "prop"
// - importFStarTypes.exe interprets Type0 as "Type(0)" | false | true | Vale.Def.Prop_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val prop0 : Type | [] | Vale.Def.Prop_s.prop0 | {
"file_name": "vale/specs/defs/Vale.Def.Prop_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type | {
"end_col": 17,
"end_line": 9,
"start_col": 12,
"start_line": 9
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module"... | false | let bare_parser = tot_bare_parser | let bare_parser = | false | null | false | tot_bare_parser | {
"checked_file": "LowParse.Tot.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Tot.Base.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.tot_bare_parser"
] | [] | module LowParse.Tot.Base
include LowParse.Spec.Base | false | true | LowParse.Tot.Base.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bare_parser : t: Type -> Type | [] | LowParse.Tot.Base.bare_parser | {
"file_name": "src/lowparse/LowParse.Tot.Base.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | t: Type -> Type | {
"end_col": 33,
"end_line": 5,
"start_col": 18,
"start_line": 5
} | |
Prims.Pure | [
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module"... | false | let weaken = tot_weaken | let weaken = | false | null | false | tot_weaken | {
"checked_file": "LowParse.Tot.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Tot.Base.fst"
} | [] | [
"LowParse.Spec.Base.tot_weaken"
] | [] | module LowParse.Tot.Base
include LowParse.Spec.Base
inline_for_extraction
let bare_parser = tot_bare_parser
inline_for_extraction
let parser = tot_parser
inline_for_extraction
let serializer
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot Type
= serializer #k p | false | false | LowParse.Tot.Base.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val weaken : k1: LowParse.Spec.Base.parser_kind -> p2: LowParse.Spec.Base.tot_parser k2 t
-> Prims.Pure (LowParse.Spec.Base.tot_parser k1 t) | [] | LowParse.Tot.Base.weaken | {
"file_name": "src/lowparse/LowParse.Tot.Base.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | k1: LowParse.Spec.Base.parser_kind -> p2: LowParse.Spec.Base.tot_parser k2 t
-> Prims.Pure (LowParse.Spec.Base.tot_parser k1 t) | {
"end_col": 23,
"end_line": 19,
"start_col": 13,
"start_line": 19
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module"... | false | let parser = tot_parser | let parser = | false | null | false | tot_parser | {
"checked_file": "LowParse.Tot.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Tot.Base.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.tot_parser"
] | [] | module LowParse.Tot.Base
include LowParse.Spec.Base
inline_for_extraction
let bare_parser = tot_bare_parser | false | true | LowParse.Tot.Base.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val parser : k: LowParse.Spec.Base.parser_kind -> t: Type -> Type | [] | LowParse.Tot.Base.parser | {
"file_name": "src/lowparse/LowParse.Tot.Base.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | k: LowParse.Spec.Base.parser_kind -> t: Type -> Type | {
"end_col": 23,
"end_line": 8,
"start_col": 13,
"start_line": 8
} | |
Prims.Tot | val va_quick_AES128EncryptBlock
(input: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
: (va_quickCode unit (va_code_AES128EncryptBlock ())) | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
... | false | let va_quick_AES128EncryptBlock (input:quad32) (key:(seq nat32)) (round_keys:(seq quad32))
(keys_buffer:buffer128) : (va_quickCode unit (va_code_AES128EncryptBlock ())) =
(va_QProc (va_code_AES128EncryptBlock ()) ([va_Mod_flags; va_Mod_xmm 2; va_Mod_xmm 0])
(va_wp_AES128EncryptBlock input key round_keys keys_bu... | val va_quick_AES128EncryptBlock
(input: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
: (va_quickCode unit (va_code_AES128EncryptBlock ()))
let va_quick_AES128EncryptBlock
(input: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(... | false | null | false | (va_QProc (va_code_AES128EncryptBlock ())
([va_Mod_flags; va_Mod_xmm 2; va_Mod_xmm 0])
(va_wp_AES128EncryptBlock input key round_keys keys_buffer)
(va_wpProof_AES128EncryptBlock input key round_keys keys_buffer)) | {
"checked_file": "Vale.AES.X64.AES128.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsM... | [
"total"
] | [
"Vale.X64.Decls.quad32",
"FStar.Seq.Base.seq",
"Vale.X64.Memory.nat32",
"Vale.X64.Memory.buffer128",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.AES.X64.AES128.va_code_AES128EncryptBlock",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_... | [] | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.Q... | false | false | Vale.AES.X64.AES128.fsti | {
"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_el... | null | val va_quick_AES128EncryptBlock
(input: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
: (va_quickCode unit (va_code_AES128EncryptBlock ())) | [] | Vale.AES.X64.AES128.va_quick_AES128EncryptBlock | {
"file_name": "obj/Vale.AES.X64.AES128.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
input: Vale.X64.Decls.quad32 ->
key: FStar.Seq.Base.seq Vale.X64.Memory.nat32 ->
round_keys: FStar.Seq.Base.seq Vale.X64.Decls.quad32 ->
keys_buffer: Vale.X64.Memory.buffer128
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.AES.X64.AES128.va_code_AES128EncryptBlock ()) | {
"end_col": 38,
"end_line": 163,
"start_col": 2,
"start_line": 161
} |
Prims.Tot | val va_quick_KeyExpansion128Stdcall (win: bool) (input_key_b output_key_expansion_b: buffer128)
: (va_quickCode unit (va_code_KeyExpansion128Stdcall win)) | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
... | false | let va_quick_KeyExpansion128Stdcall (win:bool) (input_key_b:buffer128)
(output_key_expansion_b:buffer128) : (va_quickCode unit (va_code_KeyExpansion128Stdcall win)) =
(va_QProc (va_code_KeyExpansion128Stdcall win) ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2;
va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_reg64 rRdx;... | val va_quick_KeyExpansion128Stdcall (win: bool) (input_key_b output_key_expansion_b: buffer128)
: (va_quickCode unit (va_code_KeyExpansion128Stdcall win))
let va_quick_KeyExpansion128Stdcall (win: bool) (input_key_b output_key_expansion_b: buffer128)
: (va_quickCode unit (va_code_KeyExpansion128Stdcall win)) = | false | null | false | (va_QProc (va_code_KeyExpansion128Stdcall win)
([
va_Mod_flags;
va_Mod_xmm 3;
va_Mod_xmm 2;
va_Mod_xmm 1;
va_Mod_mem_heaplet 1;
va_Mod_reg64 rRdx;
va_Mod_mem
])
(va_wp_KeyExpansion128Stdcall win input_key_b output_key_expansion_b)
(va_wpProof_Key... | {
"checked_file": "Vale.AES.X64.AES128.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsM... | [
"total"
] | [
"Prims.bool",
"Vale.X64.Memory.buffer128",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.AES.X64.AES128.va_code_KeyExpansion128Stdcall",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_Mod_xmm",
"Vale.X64.QuickCode.va_Mod_mem_heaplet",
"Va... | [] | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.Q... | false | false | Vale.AES.X64.AES128.fsti | {
"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_el... | null | val va_quick_KeyExpansion128Stdcall (win: bool) (input_key_b output_key_expansion_b: buffer128)
: (va_quickCode unit (va_code_KeyExpansion128Stdcall win)) | [] | Vale.AES.X64.AES128.va_quick_KeyExpansion128Stdcall | {
"file_name": "obj/Vale.AES.X64.AES128.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
win: Prims.bool ->
input_key_b: Vale.X64.Memory.buffer128 ->
output_key_expansion_b: Vale.X64.Memory.buffer128
-> Vale.X64.QuickCode.va_quickCode Prims.unit
(Vale.AES.X64.AES128.va_code_KeyExpansion128Stdcall win) | {
"end_col": 79,
"end_line": 112,
"start_col": 2,
"start_line": 109
} |
Prims.Tot | val va_wp_AES128EncryptBlock
(input: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
... | false | let va_wp_AES128EncryptBlock (input:quad32) (key:(seq nat32)) (round_keys:(seq quad32))
(keys_buffer:buffer128) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (aesni_enabled /\ sse_enabled) /\ Vale.AES.AES_s.is_aes_key_LE AES_128 key /\
FStar.Seq.Base.length #quad32 round_keys... | val va_wp_AES128EncryptBlock
(input: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_AES128EncryptBlock
(input: quad32)
(key: (seq nat32))
(round_keys: (seq qu... | false | null | false | (va_get_ok va_s0 /\ (aesni_enabled /\ sse_enabled) /\ Vale.AES.AES_s.is_aes_key_LE AES_128 key /\
FStar.Seq.Base.length #quad32 round_keys == 11 /\
round_keys == Vale.AES.AES_s.key_to_round_keys_LE AES_128 key /\ va_get_xmm 0 va_s0 == input /\
va_get_reg64 rR8 va_s0 ==
Vale.X64.Memory.buffer_addr #Vale.X64.Memo... | {
"checked_file": "Vale.AES.X64.AES128.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsM... | [
"total"
] | [
"Vale.X64.Decls.quad32",
"FStar.Seq.Base.seq",
"Vale.X64.Memory.nat32",
"Vale.X64.Memory.buffer128",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.aesni_enabled",
"Vale.X64.CPU_Features_s.sse_enabled",
"Vale.AES.AES_s.... | [] | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.Q... | false | true | Vale.AES.X64.AES128.fsti | {
"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_el... | null | val va_wp_AES128EncryptBlock
(input: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.AES.X64.AES128.va_wp_AES128EncryptBlock | {
"file_name": "obj/Vale.AES.X64.AES128.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
input: Vale.X64.Decls.quad32 ->
key: FStar.Seq.Base.seq Vale.X64.Memory.nat32 ->
round_keys: FStar.Seq.Base.seq Vale.X64.Decls.quad32 ->
keys_buffer: Vale.X64.Memory.buffer128 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 73,
"end_line": 149,
"start_col": 2,
"start_line": 139
} |
Prims.Tot | val va_quick_AES128EncryptBlockStdcall
(win: bool)
(input: quad32)
(key: (seq nat32))
(input_buffer output_buffer keys_buffer: buffer128)
: (va_quickCode unit (va_code_AES128EncryptBlockStdcall win)) | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
... | false | let va_quick_AES128EncryptBlockStdcall (win:bool) (input:quad32) (key:(seq nat32))
(input_buffer:buffer128) (output_buffer:buffer128) (keys_buffer:buffer128) : (va_quickCode unit
(va_code_AES128EncryptBlockStdcall win)) =
(va_QProc (va_code_AES128EncryptBlockStdcall win) ([va_Mod_flags; va_Mod_xmm 2; va_Mod_xmm 0... | val va_quick_AES128EncryptBlockStdcall
(win: bool)
(input: quad32)
(key: (seq nat32))
(input_buffer output_buffer keys_buffer: buffer128)
: (va_quickCode unit (va_code_AES128EncryptBlockStdcall win))
let va_quick_AES128EncryptBlockStdcall
(win: bool)
(input: quad32)
(key: (... | false | null | false | (va_QProc (va_code_AES128EncryptBlockStdcall win)
([va_Mod_flags; va_Mod_xmm 2; va_Mod_xmm 0; va_Mod_mem_heaplet 1; va_Mod_reg64 rR8; va_Mod_mem])
(va_wp_AES128EncryptBlockStdcall win input key input_buffer output_buffer keys_buffer)
(va_wpProof_AES128EncryptBlockStdcall win input key input_buffer output_bu... | {
"checked_file": "Vale.AES.X64.AES128.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsM... | [
"total"
] | [
"Prims.bool",
"Vale.X64.Decls.quad32",
"FStar.Seq.Base.seq",
"Vale.X64.Memory.nat32",
"Vale.X64.Memory.buffer128",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.AES.X64.AES128.va_code_AES128EncryptBlockStdcall",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
... | [] | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.Q... | false | false | Vale.AES.X64.AES128.fsti | {
"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_el... | null | val va_quick_AES128EncryptBlockStdcall
(win: bool)
(input: quad32)
(key: (seq nat32))
(input_buffer output_buffer keys_buffer: buffer128)
: (va_quickCode unit (va_code_AES128EncryptBlockStdcall win)) | [] | Vale.AES.X64.AES128.va_quick_AES128EncryptBlockStdcall | {
"file_name": "obj/Vale.AES.X64.AES128.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
win: Prims.bool ->
input: Vale.X64.Decls.quad32 ->
key: FStar.Seq.Base.seq Vale.X64.Memory.nat32 ->
input_buffer: Vale.X64.Memory.buffer128 ->
output_buffer: Vale.X64.Memory.buffer128 ->
keys_buffer: Vale.X64.Memory.buffer128
-> Vale.X64.QuickCode.va_quickCode Prims.unit
(Vale.AES.X64.A... | {
"end_col": 44,
"end_line": 254,
"start_col": 2,
"start_line": 251
} |
Prims.Tot | val va_wp_KeyExpansion128Stdcall
(win: bool)
(input_key_b output_key_expansion_b: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
... | false | let va_wp_KeyExpansion128Stdcall (win:bool) (input_key_b:buffer128)
(output_key_expansion_b:buffer128) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (key_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi... | val va_wp_KeyExpansion128Stdcall
(win: bool)
(input_key_b output_key_expansion_b: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_KeyExpansion128Stdcall
(win: bool)
(input_key_b output_key_expansion_b: buffer128)
(va_s0: va_state)
(v... | false | null | false | (va_get_ok va_s0 /\
(let key_ptr:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0)
in
let key_expansion_ptr:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0)
... | {
"checked_file": "Vale.AES.X64.AES128.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsM... | [
"total"
] | [
"Prims.bool",
"Vale.X64.Memory.buffer128",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.aesni_enabled",
"Vale.X64.CPU_Features_s.avx_enabled",
"Vale.X64.CPU_Features_s.sse_enabled",
"Vale.X64.Decls.validSrcAddrs128",
... | [] | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.Q... | false | true | Vale.AES.X64.AES128.fsti | {
"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_el... | null | val va_wp_KeyExpansion128Stdcall
(win: bool)
(input_key_b output_key_expansion_b: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.AES.X64.AES128.va_wp_KeyExpansion128Stdcall | {
"file_name": "obj/Vale.AES.X64.AES128.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
win: Prims.bool ->
input_key_b: Vale.X64.Memory.buffer128 ->
output_key_expansion_b: Vale.X64.Memory.buffer128 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 29,
"end_line": 96,
"start_col": 2,
"start_line": 64
} |
Prims.Tot | val va_wp_AES128EncryptBlockStdcall
(win: bool)
(input: quad32)
(key: (seq nat32))
(input_buffer output_buffer keys_buffer: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
... | false | let va_wp_AES128EncryptBlockStdcall (win:bool) (input:quad32) (key:(seq nat32))
(input_buffer:buffer128) (output_buffer:buffer128) (keys_buffer:buffer128) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (output_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->... | val va_wp_AES128EncryptBlockStdcall
(win: bool)
(input: quad32)
(key: (seq nat32))
(input_buffer output_buffer keys_buffer: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_AES128EncryptBlockStdcall
(win: bool)
(input: quad32)
(... | false | null | false | (va_get_ok va_s0 /\
(let output_ptr:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0)
in
let input_ptr:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0)
i... | {
"checked_file": "Vale.AES.X64.AES128.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsM... | [
"total"
] | [
"Prims.bool",
"Vale.X64.Decls.quad32",
"FStar.Seq.Base.seq",
"Vale.X64.Memory.nat32",
"Vale.X64.Memory.buffer128",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.aesni_enabled",
"Vale.X64.CPU_Features_s.sse_enabled",
... | [] | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.Q... | false | true | Vale.AES.X64.AES128.fsti | {
"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_el... | null | val va_wp_AES128EncryptBlockStdcall
(win: bool)
(input: quad32)
(key: (seq nat32))
(input_buffer output_buffer keys_buffer: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.AES.X64.AES128.va_wp_AES128EncryptBlockStdcall | {
"file_name": "obj/Vale.AES.X64.AES128.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
win: Prims.bool ->
input: Vale.X64.Decls.quad32 ->
key: FStar.Seq.Base.seq Vale.X64.Memory.nat32 ->
input_buffer: Vale.X64.Memory.buffer128 ->
output_buffer: Vale.X64.Memory.buffer128 ->
keys_buffer: Vale.X64.Memory.buffer128 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls... | {
"end_col": 74,
"end_line": 236,
"start_col": 2,
"start_line": 208
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Lib",
"short_module": null
},
{
"abbrev": false,
... | false | let bn_lt_mask_t (t:limb_t) (len:size_nat) (i:nat{i <= len}) = limb t | let bn_lt_mask_t (t: limb_t) (len: size_nat) (i: nat{i <= len}) = | false | null | false | limb t | {
"checked_file": "Hacl.Spec.Bignum.Comparison.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Lib.fst.checked",
"Hacl.Spec.Bignum.Definit... | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Hacl.Spec.Bignum.Definitions.limb"
] | [] | module Hacl.Spec.Bignum.Comparison
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Lib
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Bignum comparison ... | false | false | Hacl.Spec.Bignum.Comparison.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bn_lt_mask_t : t: Hacl.Spec.Bignum.Definitions.limb_t -> len: Lib.IntTypes.size_nat -> i: Prims.nat{i <= len}
-> Type0 | [] | Hacl.Spec.Bignum.Comparison.bn_lt_mask_t | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Comparison.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | t: Hacl.Spec.Bignum.Definitions.limb_t -> len: Lib.IntTypes.size_nat -> i: Prims.nat{i <= len}
-> Type0 | {
"end_col": 69,
"end_line": 72,
"start_col": 63,
"start_line": 72
} | |
FStar.Pervasives.Lemma | val bn_lt_mask_lemma: #t:limb_t -> #len:size_nat -> a:lbignum t len -> b:lbignum t len ->
Lemma (mask_values (bn_lt_mask a b) /\
(if v (bn_lt_mask a b) = 0 then bn_v a >= bn_v b else bn_v a < bn_v b)) | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Lib",
"short_module": null
},
{
"abbrev": false,
... | false | let bn_lt_mask_lemma #t #len a b =
bn_lt_mask_lemma_loop a b len | val bn_lt_mask_lemma: #t:limb_t -> #len:size_nat -> a:lbignum t len -> b:lbignum t len ->
Lemma (mask_values (bn_lt_mask a b) /\
(if v (bn_lt_mask a b) = 0 then bn_v a >= bn_v b else bn_v a < bn_v b))
let bn_lt_mask_lemma #t #len a b = | false | null | true | bn_lt_mask_lemma_loop a b len | {
"checked_file": "Hacl.Spec.Bignum.Comparison.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Lib.fst.checked",
"Hacl.Spec.Bignum.Definit... | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Comparison.bn_lt_mask_lemma_loop",
"Prims.unit"
] | [] | module Hacl.Spec.Bignum.Comparison
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Lib
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Bignum comparison ... | false | false | Hacl.Spec.Bignum.Comparison.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bn_lt_mask_lemma: #t:limb_t -> #len:size_nat -> a:lbignum t len -> b:lbignum t len ->
Lemma (mask_values (bn_lt_mask a b) /\
(if v (bn_lt_mask a b) = 0 then bn_v a >= bn_v b else bn_v a < bn_v b)) | [] | Hacl.Spec.Bignum.Comparison.bn_lt_mask_lemma | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Comparison.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Hacl.Spec.Bignum.Definitions.lbignum t len -> b: Hacl.Spec.Bignum.Definitions.lbignum t len
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Base.mask_values (Hacl.Spec.Bignum.Comparison.bn_lt_mask a b) /\
(match Lib.IntTypes.v (Hacl.Spec.Bignum.Comparison.bn_lt_mask a b) = 0 with
| true... | {
"end_col": 31,
"end_line": 153,
"start_col": 2,
"start_line": 153
} |
Prims.Tot | val bn_eq_mask: #t:limb_t -> #len:size_nat -> a:lbignum t len -> b:lbignum t len -> limb t | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Lib",
"short_module": null
},
{
"abbrev": false,
... | false | let bn_eq_mask #t #len a b =
BSeq.seq_eq_mask a b len | val bn_eq_mask: #t:limb_t -> #len:size_nat -> a:lbignum t len -> b:lbignum t len -> limb t
let bn_eq_mask #t #len a b = | false | null | false | BSeq.seq_eq_mask a b len | {
"checked_file": "Hacl.Spec.Bignum.Comparison.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Lib.fst.checked",
"Hacl.Spec.Bignum.Definit... | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Lib.ByteSequence.seq_eq_mask",
"Hacl.Spec.Bignum.Definitions.limb"
] | [] | module Hacl.Spec.Bignum.Comparison
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Lib
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Bignum comparison ... | false | false | Hacl.Spec.Bignum.Comparison.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bn_eq_mask: #t:limb_t -> #len:size_nat -> a:lbignum t len -> b:lbignum t len -> limb t | [] | Hacl.Spec.Bignum.Comparison.bn_eq_mask | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Comparison.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Hacl.Spec.Bignum.Definitions.lbignum t len -> b: Hacl.Spec.Bignum.Definitions.lbignum t len
-> Hacl.Spec.Bignum.Definitions.limb t | {
"end_col": 26,
"end_line": 40,
"start_col": 2,
"start_line": 40
} |
Prims.Tot | val bn_lt_mask: #t:limb_t -> #len:size_nat -> a:lbignum t len -> b:lbignum t len -> limb t | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Lib",
"short_module": null
},
{
"abbrev": false,
... | false | let bn_lt_mask #t #len a b =
Loops.repeat_gen len (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0) | val bn_lt_mask: #t:limb_t -> #len:size_nat -> a:lbignum t len -> b:lbignum t len -> limb t
let bn_lt_mask #t #len a b = | false | null | false | Loops.repeat_gen len (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0) | {
"checked_file": "Hacl.Spec.Bignum.Comparison.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Lib.fst.checked",
"Hacl.Spec.Bignum.Definit... | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Lib.LoopCombinators.repeat_gen",
"Hacl.Spec.Bignum.Comparison.bn_lt_mask_t",
"Hacl.Spec.Bignum.Comparison.bn_lt_mask_f",
"Lib.IntTypes.uint",
"Lib.IntTypes.SEC",
"Hacl.Spec.Bignum.Definitions.lim... | [] | module Hacl.Spec.Bignum.Comparison
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Lib
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Bignum comparison ... | false | false | Hacl.Spec.Bignum.Comparison.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bn_lt_mask: #t:limb_t -> #len:size_nat -> a:lbignum t len -> b:lbignum t len -> limb t | [] | Hacl.Spec.Bignum.Comparison.bn_lt_mask | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Comparison.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Hacl.Spec.Bignum.Definitions.lbignum t len -> b: Hacl.Spec.Bignum.Definitions.lbignum t len
-> Hacl.Spec.Bignum.Definitions.limb t | {
"end_col": 74,
"end_line": 76,
"start_col": 2,
"start_line": 76
} |
Prims.Tot | val bn_lt_mask_f: #t:limb_t -> #len:size_nat -> a:lbignum t len -> b:lbignum t len -> i:nat{i < len} -> acc:limb t -> limb t | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Lib",
"short_module": null
},
{
"abbrev": false,
... | false | let bn_lt_mask_f #t #len a b i acc =
let beq = eq_mask a.[i] b.[i] in
let blt = lt_mask a.[i] b.[i] in
mask_select beq acc (mask_select blt (ones t SEC) (zeros t SEC)) | val bn_lt_mask_f: #t:limb_t -> #len:size_nat -> a:lbignum t len -> b:lbignum t len -> i:nat{i < len} -> acc:limb t -> limb t
let bn_lt_mask_f #t #len a b i acc = | false | null | false | let beq = eq_mask a.[ i ] b.[ i ] in
let blt = lt_mask a.[ i ] b.[ i ] in
mask_select beq acc (mask_select blt (ones t SEC) (zeros t SEC)) | {
"checked_file": "Hacl.Spec.Bignum.Comparison.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Lib.fst.checked",
"Hacl.Spec.Bignum.Definit... | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Base.mask_select",
"Lib.IntTypes.ones",
"Lib.IntTypes.SEC",
"Lib.IntTypes.zeros",
"Lib.I... | [] | module Hacl.Spec.Bignum.Comparison
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Lib
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Bignum comparison ... | false | false | Hacl.Spec.Bignum.Comparison.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bn_lt_mask_f: #t:limb_t -> #len:size_nat -> a:lbignum t len -> b:lbignum t len -> i:nat{i < len} -> acc:limb t -> limb t | [] | Hacl.Spec.Bignum.Comparison.bn_lt_mask_f | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Comparison.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Hacl.Spec.Bignum.Definitions.lbignum t len ->
b: Hacl.Spec.Bignum.Definitions.lbignum t len ->
i: Prims.nat{i < len} ->
acc: Hacl.Spec.Bignum.Definitions.limb t
-> Hacl.Spec.Bignum.Definitions.limb t | {
"end_col": 66,
"end_line": 70,
"start_col": 36,
"start_line": 67
} |
Prims.Tot | val bn_is_odd: #t:limb_t -> #len:size_pos -> a:lbignum t len -> limb t | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Lib",
"short_module": null
},
{
"abbrev": false,
... | false | let bn_is_odd #t #len b = b.[0] &. uint #t 1 | val bn_is_odd: #t:limb_t -> #len:size_pos -> a:lbignum t len -> limb t
let bn_is_odd #t #len b = | false | null | false | b.[ 0 ] &. uint #t 1 | {
"checked_file": "Hacl.Spec.Bignum.Comparison.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Lib.fst.checked",
"Hacl.Spec.Bignum.Definit... | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTypes.SEC",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Bignum.Definitions.limb",
"Lib.IntTypes.uint"
] | [] | module Hacl.Spec.Bignum.Comparison
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Lib
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Bignum comparison ... | false | false | Hacl.Spec.Bignum.Comparison.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bn_is_odd: #t:limb_t -> #len:size_pos -> a:lbignum t len -> limb t | [] | Hacl.Spec.Bignum.Comparison.bn_is_odd | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Comparison.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Hacl.Spec.Bignum.Definitions.lbignum t len -> Hacl.Spec.Bignum.Definitions.limb t | {
"end_col": 44,
"end_line": 22,
"start_col": 26,
"start_line": 22
} |
Prims.Tot | val bn_is_zero_mask: #t:limb_t -> #len:size_nat -> a:lbignum t len -> limb t | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Lib",
"short_module": null
},
{
"abbrev": false,
... | false | let bn_is_zero_mask #t #len b =
let bn_zero = create len (uint #t 0) in
bn_eq_mask b bn_zero | val bn_is_zero_mask: #t:limb_t -> #len:size_nat -> a:lbignum t len -> limb t
let bn_is_zero_mask #t #len b = | false | null | false | let bn_zero = create len (uint #t 0) in
bn_eq_mask b bn_zero | {
"checked_file": "Hacl.Spec.Bignum.Comparison.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Lib.fst.checked",
"Hacl.Spec.Bignum.Definit... | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Comparison.bn_eq_mask",
"Lib.Sequence.lseq",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.cre... | [] | module Hacl.Spec.Bignum.Comparison
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Lib
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Bignum comparison ... | false | false | Hacl.Spec.Bignum.Comparison.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bn_is_zero_mask: #t:limb_t -> #len:size_nat -> a:lbignum t len -> limb t | [] | Hacl.Spec.Bignum.Comparison.bn_is_zero_mask | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Comparison.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Hacl.Spec.Bignum.Definitions.lbignum t len -> Hacl.Spec.Bignum.Definitions.limb t | {
"end_col": 22,
"end_line": 55,
"start_col": 31,
"start_line": 53
} |
Prims.Tot | val bn_lt_pow2_mask: #t:limb_t -> #len:size_nat -> b:lbignum t len -> x:size_nat{x < bits t * len} -> limb t | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Lib",
"short_module": null
},
{
"abbrev": false,
... | false | let bn_lt_pow2_mask #t #len b x =
let b2 = create len (uint #t 0) in
let b2 = bn_set_ith_bit b2 x in
bn_lt_mask b b2 | val bn_lt_pow2_mask: #t:limb_t -> #len:size_nat -> b:lbignum t len -> x:size_nat{x < bits t * len} -> limb t
let bn_lt_pow2_mask #t #len b x = | false | null | false | let b2 = create len (uint #t 0) in
let b2 = bn_set_ith_bit b2 x in
bn_lt_mask b b2 | {
"checked_file": "Hacl.Spec.Bignum.Comparison.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Lib.fst.checked",
"Hacl.Spec.Bignum.Definit... | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Mul.op_Star",
"Lib.IntTypes.bits",
"Hacl.Spec.Bignum.Comparison.bn_lt_mask",
"Hacl.Spec.Bignum.Lib.bn_set_ith_bit",
"Lib.Sequence.lseq",
"Hacl.Spec.Big... | [] | module Hacl.Spec.Bignum.Comparison
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Lib
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Bignum comparison ... | false | false | Hacl.Spec.Bignum.Comparison.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bn_lt_pow2_mask: #t:limb_t -> #len:size_nat -> b:lbignum t len -> x:size_nat{x < bits t * len} -> limb t | [] | Hacl.Spec.Bignum.Comparison.bn_lt_pow2_mask | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Comparison.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
b: Hacl.Spec.Bignum.Definitions.lbignum t len ->
x: Lib.IntTypes.size_nat{x < Lib.IntTypes.bits t * len}
-> Hacl.Spec.Bignum.Definitions.limb t | {
"end_col": 17,
"end_line": 160,
"start_col": 33,
"start_line": 157
} |
FStar.Pervasives.Lemma | val bn_is_zero_mask_lemma: #t:limb_t -> #len:size_nat -> a:lbignum t len ->
Lemma (mask_values (bn_is_zero_mask a) /\
(if v (bn_is_zero_mask a) = 0 then bn_v a <> 0 else bn_v a = 0)) | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Lib",
"short_module": null
},
{
"abbrev": false,
... | false | let bn_is_zero_mask_lemma #t #len b =
let bn_zero = create len (uint #t 0) in
bn_eval_zeroes #t len len;
bn_eq_mask_lemma b bn_zero | val bn_is_zero_mask_lemma: #t:limb_t -> #len:size_nat -> a:lbignum t len ->
Lemma (mask_values (bn_is_zero_mask a) /\
(if v (bn_is_zero_mask a) = 0 then bn_v a <> 0 else bn_v a = 0))
let bn_is_zero_mask_lemma #t #len b = | false | null | true | let bn_zero = create len (uint #t 0) in
bn_eval_zeroes #t len len;
bn_eq_mask_lemma b bn_zero | {
"checked_file": "Hacl.Spec.Bignum.Comparison.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Lib.fst.checked",
"Hacl.Spec.Bignum.Definit... | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Comparison.bn_eq_mask_lemma",
"Prims.unit",
"Hacl.Spec.Bignum.Definitions.bn_eval_zeroes",
"Lib.Sequence.lseq",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.l_and",
"Prims.eq2",... | [] | module Hacl.Spec.Bignum.Comparison
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Lib
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Bignum comparison ... | false | false | Hacl.Spec.Bignum.Comparison.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bn_is_zero_mask_lemma: #t:limb_t -> #len:size_nat -> a:lbignum t len ->
Lemma (mask_values (bn_is_zero_mask a) /\
(if v (bn_is_zero_mask a) = 0 then bn_v a <> 0 else bn_v a = 0)) | [] | Hacl.Spec.Bignum.Comparison.bn_is_zero_mask_lemma | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Comparison.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Hacl.Spec.Bignum.Definitions.lbignum t len
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Base.mask_values (Hacl.Spec.Bignum.Comparison.bn_is_zero_mask a) /\
(match Lib.IntTypes.v (Hacl.Spec.Bignum.Comparison.bn_is_zero_mask a) = 0 with
| true -> Hacl.Spec.Bignum.Definitions.bn_v a <> ... | {
"end_col": 28,
"end_line": 63,
"start_col": 37,
"start_line": 60
} |
Prims.Tot | val bn_gt_pow2_mask: #t:limb_t -> #len:size_nat -> b:lbignum t len -> x:size_nat{x < bits t * len} -> limb t | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Lib",
"short_module": null
},
{
"abbrev": false,
... | false | let bn_gt_pow2_mask #t #len b x =
let b2 = create len (uint #t 0) in
let b2 = bn_set_ith_bit b2 x in
bn_lt_mask b2 b | val bn_gt_pow2_mask: #t:limb_t -> #len:size_nat -> b:lbignum t len -> x:size_nat{x < bits t * len} -> limb t
let bn_gt_pow2_mask #t #len b x = | false | null | false | let b2 = create len (uint #t 0) in
let b2 = bn_set_ith_bit b2 x in
bn_lt_mask b2 b | {
"checked_file": "Hacl.Spec.Bignum.Comparison.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Lib.fst.checked",
"Hacl.Spec.Bignum.Definit... | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Mul.op_Star",
"Lib.IntTypes.bits",
"Hacl.Spec.Bignum.Comparison.bn_lt_mask",
"Hacl.Spec.Bignum.Lib.bn_set_ith_bit",
"Lib.Sequence.lseq",
"Hacl.Spec.Big... | [] | module Hacl.Spec.Bignum.Comparison
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Lib
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Bignum comparison ... | false | false | Hacl.Spec.Bignum.Comparison.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bn_gt_pow2_mask: #t:limb_t -> #len:size_nat -> b:lbignum t len -> x:size_nat{x < bits t * len} -> limb t | [] | Hacl.Spec.Bignum.Comparison.bn_gt_pow2_mask | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Comparison.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
b: Hacl.Spec.Bignum.Definitions.lbignum t len ->
x: Lib.IntTypes.size_nat{x < Lib.IntTypes.bits t * len}
-> Hacl.Spec.Bignum.Definitions.limb t | {
"end_col": 17,
"end_line": 182,
"start_col": 33,
"start_line": 179
} |
FStar.Pervasives.Lemma | val bn_lt_pow2_mask_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> x:size_nat{x < bits t * len} ->
Lemma (mask_values (bn_lt_pow2_mask b x) /\
(if v (bn_lt_pow2_mask b x) = 0 then bn_v b >= pow2 x else bn_v b < pow2 x)) | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Lib",
"short_module": null
},
{
"abbrev": false,
... | false | let bn_lt_pow2_mask_lemma #t #len b x =
bn_eval_bound b len;
assert (bn_v b < pow2 (bits t * len));
let b2 = create len (uint #t 0) in
bn_eval_zeroes #t len len;
assert (bn_v b2 = 0);
//assert (bn_v b2 < pow2 x);
let b2' = bn_set_ith_bit b2 x in
bn_set_ith_bit_lemma b2 x;
assert (bn_v b2' == pow2 x);
... | val bn_lt_pow2_mask_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> x:size_nat{x < bits t * len} ->
Lemma (mask_values (bn_lt_pow2_mask b x) /\
(if v (bn_lt_pow2_mask b x) = 0 then bn_v b >= pow2 x else bn_v b < pow2 x))
let bn_lt_pow2_mask_lemma #t #len b x = | false | null | true | bn_eval_bound b len;
assert (bn_v b < pow2 (bits t * len));
let b2 = create len (uint #t 0) in
bn_eval_zeroes #t len len;
assert (bn_v b2 = 0);
let b2' = bn_set_ith_bit b2 x in
bn_set_ith_bit_lemma b2 x;
assert (bn_v b2' == pow2 x);
bn_lt_mask_lemma b b2' | {
"checked_file": "Hacl.Spec.Bignum.Comparison.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Lib.fst.checked",
"Hacl.Spec.Bignum.Definit... | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Mul.op_Star",
"Lib.IntTypes.bits",
"Hacl.Spec.Bignum.Comparison.bn_lt_mask_lemma",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.... | [] | module Hacl.Spec.Bignum.Comparison
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Lib
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Bignum comparison ... | false | false | Hacl.Spec.Bignum.Comparison.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bn_lt_pow2_mask_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> x:size_nat{x < bits t * len} ->
Lemma (mask_values (bn_lt_pow2_mask b x) /\
(if v (bn_lt_pow2_mask b x) = 0 then bn_v b >= pow2 x else bn_v b < pow2 x)) | [] | Hacl.Spec.Bignum.Comparison.bn_lt_pow2_mask_lemma | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Comparison.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
b: Hacl.Spec.Bignum.Definitions.lbignum t len ->
x: Lib.IntTypes.size_nat{x < Lib.IntTypes.bits t * len}
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Base.mask_values (Hacl.Spec.Bignum.Comparison.bn_lt_pow2_mask b x) /\
(match Lib.IntTypes.v (Hacl.Spec.Bignum.Comparison.bn_lt_pow2_mask... | {
"end_col": 24,
"end_line": 175,
"start_col": 2,
"start_line": 166
} |
FStar.Pervasives.Lemma | val bn_gt_pow2_mask_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> x:size_nat{x < bits t * len} ->
Lemma (mask_values (bn_gt_pow2_mask b x) /\
(if v (bn_gt_pow2_mask b x) = 0 then pow2 x >= bn_v b else pow2 x < bn_v b)) | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Lib",
"short_module": null
},
{
"abbrev": false,
... | false | let bn_gt_pow2_mask_lemma #t #len b x =
bn_eval_bound b len;
assert (bn_v b < pow2 (bits t * len));
let b2 = create len (uint #t 0) in
bn_eval_zeroes #t len len;
assert (bn_v b2 = 0);
//assert (bn_v b2 < pow2 x);
let b2' = bn_set_ith_bit b2 x in
bn_set_ith_bit_lemma b2 x;
assert (bn_v b2' == pow2 x);
... | val bn_gt_pow2_mask_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> x:size_nat{x < bits t * len} ->
Lemma (mask_values (bn_gt_pow2_mask b x) /\
(if v (bn_gt_pow2_mask b x) = 0 then pow2 x >= bn_v b else pow2 x < bn_v b))
let bn_gt_pow2_mask_lemma #t #len b x = | false | null | true | bn_eval_bound b len;
assert (bn_v b < pow2 (bits t * len));
let b2 = create len (uint #t 0) in
bn_eval_zeroes #t len len;
assert (bn_v b2 = 0);
let b2' = bn_set_ith_bit b2 x in
bn_set_ith_bit_lemma b2 x;
assert (bn_v b2' == pow2 x);
bn_lt_mask_lemma b2' b | {
"checked_file": "Hacl.Spec.Bignum.Comparison.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Lib.fst.checked",
"Hacl.Spec.Bignum.Definit... | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Mul.op_Star",
"Lib.IntTypes.bits",
"Hacl.Spec.Bignum.Comparison.bn_lt_mask_lemma",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.... | [] | module Hacl.Spec.Bignum.Comparison
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Lib
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Bignum comparison ... | false | false | Hacl.Spec.Bignum.Comparison.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bn_gt_pow2_mask_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> x:size_nat{x < bits t * len} ->
Lemma (mask_values (bn_gt_pow2_mask b x) /\
(if v (bn_gt_pow2_mask b x) = 0 then pow2 x >= bn_v b else pow2 x < bn_v b)) | [] | Hacl.Spec.Bignum.Comparison.bn_gt_pow2_mask_lemma | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Comparison.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
b: Hacl.Spec.Bignum.Definitions.lbignum t len ->
x: Lib.IntTypes.size_nat{x < Lib.IntTypes.bits t * len}
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Base.mask_values (Hacl.Spec.Bignum.Comparison.bn_gt_pow2_mask b x) /\
(match Lib.IntTypes.v (Hacl.Spec.Bignum.Comparison.bn_gt_pow2_mask... | {
"end_col": 24,
"end_line": 197,
"start_col": 2,
"start_line": 188
} |
FStar.Pervasives.Lemma | val bn_lt_mask_lemma_loop:
#t:limb_t
-> #len:size_nat
-> a:lbignum t len
-> b:lbignum t len
-> k:nat{k <= len} ->
Lemma (let mask = Loops.repeat_gen k (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0) in
mask_values mask /\ (if v mask = 0 then eval_ len a k >= eval_ len b k else eval_ len a k < eval_... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Lib",
"short_module": null
},
{
"abbrev": false,
... | false | let rec bn_lt_mask_lemma_loop #t #len a b k =
let mask = Loops.repeat_gen k (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0) in
if k = 0 then begin
Loops.eq_repeat_gen0 k (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0);
assert (v mask = 0);
bn_eval0 a;
bn_eval0 b end
else begin
let mask... | val bn_lt_mask_lemma_loop:
#t:limb_t
-> #len:size_nat
-> a:lbignum t len
-> b:lbignum t len
-> k:nat{k <= len} ->
Lemma (let mask = Loops.repeat_gen k (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0) in
mask_values mask /\ (if v mask = 0 then eval_ len a k >= eval_ len b k else eval_ len a k < eval_... | false | null | true | let mask = Loops.repeat_gen k (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0) in
if k = 0
then
(Loops.eq_repeat_gen0 k (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0);
assert (v mask = 0);
bn_eval0 a;
bn_eval0 b)
else
let mask0 = Loops.repeat_gen (k - 1) (bn_lt_mask_t t len) (bn_lt_mask_f a b) (... | {
"checked_file": "Hacl.Spec.Bignum.Comparison.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Lib.fst.checked",
"Hacl.Spec.Bignum.Definit... | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"Hacl.Spec.Bignum.Definitions.bn_eval0",
"Prims.unit",
"Prims._assert",
"Lib.IntTypes.v",
"Lib.IntTy... | [] | module Hacl.Spec.Bignum.Comparison
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Lib
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Bignum comparison ... | false | false | Hacl.Spec.Bignum.Comparison.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bn_lt_mask_lemma_loop:
#t:limb_t
-> #len:size_nat
-> a:lbignum t len
-> b:lbignum t len
-> k:nat{k <= len} ->
Lemma (let mask = Loops.repeat_gen k (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0) in
mask_values mask /\ (if v mask = 0 then eval_ len a k >= eval_ len b k else eval_ len a k < eval_... | [
"recursion"
] | Hacl.Spec.Bignum.Comparison.bn_lt_mask_lemma_loop | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Comparison.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Hacl.Spec.Bignum.Definitions.lbignum t len ->
b: Hacl.Spec.Bignum.Definitions.lbignum t len ->
k: Prims.nat{k <= len}
-> FStar.Pervasives.Lemma
(ensures
(let mask =
Lib.LoopCombinators.repeat_gen k
(Hacl.Spec.Bignum.Comparison.bn_lt_mask_t t len)
(Hacl.Spec.... | {
"end_col": 41,
"end_line": 146,
"start_col": 45,
"start_line": 135
} |
FStar.Pervasives.Lemma | val bn_is_odd_lemma: #t:limb_t -> #len:size_pos -> a:lbignum t len ->
Lemma (v (bn_is_odd a) == (bn_v a % 2)) | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Lib",
"short_module": null
},
{
"abbrev": false,
... | false | let bn_is_odd_lemma #t #len b =
let pbits = bits t in
bn_eval_split_i b 1;
bn_eval1 (slice b 0 1);
assert (bn_v b % 2 == (v b.[0] + pow2 pbits * bn_v (slice b 1 len)) % 2);
Math.Lemmas.pow2_plus 1 (pbits - 1);
Math.Lemmas.modulo_addition_lemma (v b.[0]) 2 (pow2 (pbits - 1) * bn_v (slice b 1 len));
assert ... | val bn_is_odd_lemma: #t:limb_t -> #len:size_pos -> a:lbignum t len ->
Lemma (v (bn_is_odd a) == (bn_v a % 2))
let bn_is_odd_lemma #t #len b = | false | null | true | let pbits = bits t in
bn_eval_split_i b 1;
bn_eval1 (slice b 0 1);
assert (bn_v b % 2 == (v b.[ 0 ] + pow2 pbits * bn_v (slice b 1 len)) % 2);
Math.Lemmas.pow2_plus 1 (pbits - 1);
Math.Lemmas.modulo_addition_lemma (v b.[ 0 ]) 2 (pow2 (pbits - 1) * bn_v (slice b 1 len));
assert (bn_v b % 2 == v b.[ 0 ] % 2);
mod_mask_le... | {
"checked_file": "Hacl.Spec.Bignum.Comparison.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Lib.fst.checked",
"Hacl.Spec.Bignum.Definit... | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims._assert",
"Prims.eq2",
"Lib.IntTypes.range_t",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Lib.IntTypes.mod_mask",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.uint",
"Prims.unit",
"Lib.Int... | [] | module Hacl.Spec.Bignum.Comparison
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Lib
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Bignum comparison ... | false | false | Hacl.Spec.Bignum.Comparison.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bn_is_odd_lemma: #t:limb_t -> #len:size_pos -> a:lbignum t len ->
Lemma (v (bn_is_odd a) == (bn_v a % 2)) | [] | Hacl.Spec.Bignum.Comparison.bn_is_odd_lemma | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Comparison.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Hacl.Spec.Bignum.Definitions.lbignum t len
-> FStar.Pervasives.Lemma
(ensures
Lib.IntTypes.v (Hacl.Spec.Bignum.Comparison.bn_is_odd a) ==
Hacl.Spec.Bignum.Definitions.bn_v a % 2) | {
"end_col": 57,
"end_line": 35,
"start_col": 31,
"start_line": 26
} |
FStar.Pervasives.Lemma | val bn_lt_mask_lemma_step:
#t:limb_t
-> #len:size_nat
-> a:lbignum t len
-> b:lbignum t len
-> k:pos{k <= len}
-> mask0:limb t -> Lemma
(requires
(if v mask0 = 0 then eval_ len a (k - 1) >= eval_ len b (k - 1) else eval_ len a (k - 1) < eval_ len b (k - 1)) /\
mask_values mask0)
(ensures (let ... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Lib",
"short_module": null
},
{
"abbrev": false,
... | false | let bn_lt_mask_lemma_step #t #len a b k mask0 =
let mask = bn_lt_mask_f a b (k - 1) mask0 in
let ai = a.[k - 1] in
let bi = b.[k - 1] in
let beq = eq_mask ai bi in
assert (if v ai = v bi then v beq == v (ones t SEC) else v beq == 0);
let blt = lt_mask ai bi in
assert (if v ai < v bi then v blt == v (ones ... | val bn_lt_mask_lemma_step:
#t:limb_t
-> #len:size_nat
-> a:lbignum t len
-> b:lbignum t len
-> k:pos{k <= len}
-> mask0:limb t -> Lemma
(requires
(if v mask0 = 0 then eval_ len a (k - 1) >= eval_ len b (k - 1) else eval_ len a (k - 1) < eval_ len b (k - 1)) /\
mask_values mask0)
(ensures (let ... | false | null | true | let mask = bn_lt_mask_f a b (k - 1) mask0 in
let ai = a.[ k - 1 ] in
let bi = b.[ k - 1 ] in
let beq = eq_mask ai bi in
assert (if v ai = v bi then v beq == v (ones t SEC) else v beq == 0);
let blt = lt_mask ai bi in
assert (if v ai < v bi then v blt == v (ones t SEC) else v blt == 0);
let res0 = mask_select blt (ones ... | {
"checked_file": "Hacl.Spec.Bignum.Comparison.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Lib.fst.checked",
"Hacl.Spec.Bignum.Definit... | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.op_Equality",
"Prims.int",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Prims.unit",
"Prims.op_L... | [] | module Hacl.Spec.Bignum.Comparison
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Lib
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Bignum comparison ... | false | false | Hacl.Spec.Bignum.Comparison.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bn_lt_mask_lemma_step:
#t:limb_t
-> #len:size_nat
-> a:lbignum t len
-> b:lbignum t len
-> k:pos{k <= len}
-> mask0:limb t -> Lemma
(requires
(if v mask0 = 0 then eval_ len a (k - 1) >= eval_ len b (k - 1) else eval_ len a (k - 1) < eval_ len b (k - 1)) /\
mask_values mask0)
(ensures (let ... | [] | Hacl.Spec.Bignum.Comparison.bn_lt_mask_lemma_step | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Comparison.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Hacl.Spec.Bignum.Definitions.lbignum t len ->
b: Hacl.Spec.Bignum.Definitions.lbignum t len ->
k: Prims.pos{k <= len} ->
mask0: Hacl.Spec.Bignum.Definitions.limb t
-> FStar.Pervasives.Lemma
(requires
(match Lib.IntTypes.v mask0 = 0 with
| true ->
Hacl.Spec.Bignu... | {
"end_col": 10,
"end_line": 123,
"start_col": 47,
"start_line": 93
} |
FStar.Pervasives.Lemma | val bn_eq_mask_lemma: #t:limb_t -> #len:size_nat -> a:lbignum t len -> b:lbignum t len ->
Lemma (mask_values (bn_eq_mask a b) /\
(if v (bn_eq_mask a b) = 0 then bn_v a <> bn_v b else bn_v a = bn_v b)) | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Lib",
"short_module": null
},
{
"abbrev": false,
... | false | let bn_eq_mask_lemma #t #len a b =
let mask = BSeq.seq_eq_mask a b len in
assert (a == b ==> v mask == v (ones t SEC));
assert (a =!= b ==> v mask == v (zeros t SEC));
Classical.move_requires_2 (bn_eval_inj len) a b | val bn_eq_mask_lemma: #t:limb_t -> #len:size_nat -> a:lbignum t len -> b:lbignum t len ->
Lemma (mask_values (bn_eq_mask a b) /\
(if v (bn_eq_mask a b) = 0 then bn_v a <> bn_v b else bn_v a = bn_v b))
let bn_eq_mask_lemma #t #len a b = | false | null | true | let mask = BSeq.seq_eq_mask a b len in
assert (a == b ==> v mask == v (ones t SEC));
assert (a =!= b ==> v mask == v (zeros t SEC));
Classical.move_requires_2 (bn_eval_inj len) a b | {
"checked_file": "Hacl.Spec.Bignum.Comparison.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Lib.fst.checked",
"Hacl.Spec.Bignum.Definit... | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"FStar.Classical.move_requires_2",
"Prims.eq2",
"Prims.nat",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Lib.Sequence.equal",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Definitions.bn_eval... | [] | module Hacl.Spec.Bignum.Comparison
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Lib
module BSeq = Lib.ByteSequence
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// Bignum comparison ... | false | false | Hacl.Spec.Bignum.Comparison.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bn_eq_mask_lemma: #t:limb_t -> #len:size_nat -> a:lbignum t len -> b:lbignum t len ->
Lemma (mask_values (bn_eq_mask a b) /\
(if v (bn_eq_mask a b) = 0 then bn_v a <> bn_v b else bn_v a = bn_v b)) | [] | Hacl.Spec.Bignum.Comparison.bn_eq_mask_lemma | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Comparison.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Hacl.Spec.Bignum.Definitions.lbignum t len -> b: Hacl.Spec.Bignum.Definitions.lbignum t len
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Base.mask_values (Hacl.Spec.Bignum.Comparison.bn_eq_mask a b) /\
(match Lib.IntTypes.v (Hacl.Spec.Bignum.Comparison.bn_eq_mask a b) = 0 with
| true... | {
"end_col": 49,
"end_line": 49,
"start_col": 34,
"start_line": 45
} |
FStar.HyperStack.ST.Stack | val x_mod_2:
x:felem ->
Stack uint64
(requires fun h -> live h x)
(ensures fun h0 z h1 -> h0 == h1 /\ v z < 2 /\
v z == F51.as_nat h0 x % 2
) | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"ful... | false | let x_mod_2 x =
(**) let h0 = ST.get() in
let x0 = x.(0ul) in
let z = x0 &. u64 1 in
mod_mask_lemma x0 1ul;
Lib.IntTypes.Compatibility.uintv_extensionality (u64 1) (mod_mask #U64 1ul);
z | val x_mod_2:
x:felem ->
Stack uint64
(requires fun h -> live h x)
(ensures fun h0 z h1 -> h0 == h1 /\ v z < 2 /\
v z == F51.as_nat h0 x % 2
)
let x_mod_2 x = | true | null | false | let h0 = ST.get () in
let x0 = x.(0ul) in
let z = x0 &. u64 1 in
mod_mask_lemma x0 1ul;
Lib.IntTypes.Compatibility.uintv_extensionality (u64 1) (mod_mask #U64 1ul);
z | {
"checked_file": "Hacl.Impl.Ed25519.PointCompress.fst.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.Compatibility.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.chec... | [] | [
"Hacl.Bignum25519.felem",
"Prims.unit",
"Lib.IntTypes.Compatibility.uintv_extensionality",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Lib.IntTypes.u64",
"Lib.IntTypes.mod_mask",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.mod_mask_lemma",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTy... | [] | module Hacl.Impl.Ed25519.PointCompress
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.ByteSequence
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
#set-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 0"
inline_for_extraction noextr... | false | false | Hacl.Impl.Ed25519.PointCompress.fst | {
"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_el... | null | val x_mod_2:
x:felem ->
Stack uint64
(requires fun h -> live h x)
(ensures fun h0 z h1 -> h0 == h1 /\ v z < 2 /\
v z == F51.as_nat h0 x % 2
) | [] | Hacl.Impl.Ed25519.PointCompress.x_mod_2 | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.PointCompress.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Hacl.Bignum25519.felem -> FStar.HyperStack.ST.Stack Lib.IntTypes.uint64 | {
"end_col": 3,
"end_line": 32,
"start_col": 15,
"start_line": 26
} |
FStar.HyperStack.ST.Stack | val point_compress_:
tmp:lbuffer uint64 15ul
-> p:point ->
Stack unit
(requires fun h -> live h tmp /\ live h p /\ disjoint tmp p /\ F51.point_inv_t h p)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\ (
let zinv = Spec.Curve25519.finv (F51.fevalh h0 (gsub p 10ul 5ul)) in
let x = Spec.C... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"short_module": null
},
{
"abbrev": false,
"ful... | false | let point_compress_ tmp p =
let zinv = sub tmp 0ul 5ul in
let x = sub tmp 5ul 5ul in
let out = sub tmp 10ul 5ul in
let px = getx p in
let py = gety p in
let pz = getz p in
inverse zinv pz;
fmul x px zinv;
reduce x;
fmul out py zinv;
reduce_513 out | val point_compress_:
tmp:lbuffer uint64 15ul
-> p:point ->
Stack unit
(requires fun h -> live h tmp /\ live h p /\ disjoint tmp p /\ F51.point_inv_t h p)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\ (
let zinv = Spec.Curve25519.finv (F51.fevalh h0 (gsub p 10ul 5ul)) in
let x = Spec.C... | true | null | false | let zinv = sub tmp 0ul 5ul in
let x = sub tmp 5ul 5ul in
let out = sub tmp 10ul 5ul in
let px = getx p in
let py = gety p in
let pz = getz p in
inverse zinv pz;
fmul x px zinv;
reduce x;
fmul out py zinv;
reduce_513 out | {
"checked_file": "Hacl.Impl.Ed25519.PointCompress.fst.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.Compatibility.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.chec... | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Hacl.Bignum25519.point",
"Hacl.Bignum25519.reduce_513",
"Prims.unit",
"Hacl.Bignum25519.fmul",
"Hacl.Bignum25519.reduce",
"Hacl.Bignum25519.inverse",
"Hacl.Bignum25519.felem",
"Hacl.Bignum25519.getz",
"Hacl.Bignum25519.g... | [] | module Hacl.Impl.Ed25519.PointCompress
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.ByteSequence
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
#set-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 0"
inline_for_extraction noextr... | false | false | Hacl.Impl.Ed25519.PointCompress.fst | {
"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_el... | null | val point_compress_:
tmp:lbuffer uint64 15ul
-> p:point ->
Stack unit
(requires fun h -> live h tmp /\ live h p /\ disjoint tmp p /\ F51.point_inv_t h p)
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\ (
let zinv = Spec.Curve25519.finv (F51.fevalh h0 (gsub p 10ul 5ul)) in
let x = Spec.C... | [] | Hacl.Impl.Ed25519.PointCompress.point_compress_ | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.PointCompress.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | tmp: Lib.Buffer.lbuffer Lib.IntTypes.uint64 15ul -> p: Hacl.Bignum25519.point
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 16,
"end_line": 157,
"start_col": 27,
"start_line": 145
} |
FStar.HyperStack.ST.Stack | val point_compress:
out:lbuffer uint8 32ul
-> p:point ->
Stack unit
(requires fun h -> live h out /\ live h p /\ F51.point_inv_t h p)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
as_seq h1 out == Spec.Ed25519.point_compress (F51.point_eval h0 p)
) | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"short_module": null
},
{
"abbrev": false,
"ful... | false | let point_compress z p =
push_frame();
let tmp = create 15ul (u64 0) in
let zinv = sub tmp 0ul 5ul in
let x = sub tmp 5ul 5ul in
let out = sub tmp 10ul 5ul in
point_compress_ tmp p;
let b = x_mod_2 x in
store_51 z out;
add_sign z b;
(**) let h3 = ST.get() in
(**) lemma_nat_from_to_bytes_l... | val point_compress:
out:lbuffer uint8 32ul
-> p:point ->
Stack unit
(requires fun h -> live h out /\ live h p /\ F51.point_inv_t h p)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
as_seq h1 out == Spec.Ed25519.point_compress (F51.point_eval h0 p)
)
let point_compress z p = | true | null | false | push_frame ();
let tmp = create 15ul (u64 0) in
let zinv = sub tmp 0ul 5ul in
let x = sub tmp 5ul 5ul in
let out = sub tmp 10ul 5ul in
point_compress_ tmp p;
let b = x_mod_2 x in
store_51 z out;
add_sign z b;
let h3 = ST.get () in
lemma_nat_from_to_bytes_le_preserves_value (as_seq h3 z) 32;
lemma_nat_to_from_bytes_le_p... | {
"checked_file": "Hacl.Impl.Ed25519.PointCompress.fst.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.Compatibility.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.chec... | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Hacl.Bignum25519.point",
"FStar.HyperStack.ST.pop_frame",
"Prims.unit",
"Lib.ByteSequence.lemma_nat_to_from_bytes_le_preserves_value",
"Lib.IntTypes.SEC",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Hacl.Impl.Ed25519.Field51.fe... | [] | module Hacl.Impl.Ed25519.PointCompress
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.ByteSequence
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
#set-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 0"
inline_for_extraction noextr... | false | false | Hacl.Impl.Ed25519.PointCompress.fst | {
"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_el... | null | val point_compress:
out:lbuffer uint8 32ul
-> p:point ->
Stack unit
(requires fun h -> live h out /\ live h p /\ F51.point_inv_t h p)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
as_seq h1 out == Spec.Ed25519.point_compress (F51.point_eval h0 p)
) | [] | Hacl.Impl.Ed25519.PointCompress.point_compress | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.PointCompress.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | out: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> p: Hacl.Bignum25519.point
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 13,
"end_line": 185,
"start_col": 2,
"start_line": 170
} |
FStar.Pervasives.Lemma | val lemma_fits_in_prime_last_byte (b: lbytes 32)
: Lemma (requires nat_from_bytes_le b < Spec.Curve25519.prime)
(ensures v (Seq.index b 31) < pow2 7) | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"short_module": null
},
{
"abbrev": false,
"ful... | false | let lemma_fits_in_prime_last_byte (b:lbytes 32) : Lemma
(requires nat_from_bytes_le b < Spec.Curve25519.prime)
(ensures v (Seq.index b 31) < pow2 7)
= calc (==) {
nat_from_bytes_le b <: nat;
(==) { nat_from_intseq_le_slice_lemma b 31 }
nat_from_intseq_le (Seq.slice b 0 31) +
pow2 (31 * 8) *... | val lemma_fits_in_prime_last_byte (b: lbytes 32)
: Lemma (requires nat_from_bytes_le b < Spec.Curve25519.prime)
(ensures v (Seq.index b 31) < pow2 7)
let lemma_fits_in_prime_last_byte (b: lbytes 32)
: Lemma (requires nat_from_bytes_le b < Spec.Curve25519.prime)
(ensures v (Seq.index b 31) < pow2 7) ... | false | null | true | calc ( == ) {
nat_from_bytes_le b <: nat;
( == ) { nat_from_intseq_le_slice_lemma b 31 }
nat_from_intseq_le (Seq.slice b 0 31) + pow2 (31 * 8) * nat_from_intseq_le (Seq.slice b 31 32);
( == ) { nat_from_intseq_le_lemma0 (Seq.slice b 31 32) }
nat_from_intseq_le (Seq.slice b 0 31) + pow2 (31 * 8) * v (Seq.index... | {
"checked_file": "Hacl.Impl.Ed25519.PointCompress.fst.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.Compatibility.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.chec... | [
"lemma"
] | [
"Lib.ByteSequence.lbytes",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"Prims.op_Subtraction",
"FStar.Mul.op_Star",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.op_Division",
"Prims.pow2",
"Lib.IntTypes.v",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"FStar.Seq.Base.index",
"L... | [] | module Hacl.Impl.Ed25519.PointCompress
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.ByteSequence
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
#set-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 0"
inline_for_extraction noextr... | false | false | Hacl.Impl.Ed25519.PointCompress.fst | {
"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_el... | null | val lemma_fits_in_prime_last_byte (b: lbytes 32)
: Lemma (requires nat_from_bytes_le b < Spec.Curve25519.prime)
(ensures v (Seq.index b 31) < pow2 7) | [] | Hacl.Impl.Ed25519.PointCompress.lemma_fits_in_prime_last_byte | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.PointCompress.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b: Lib.ByteSequence.lbytes 32
-> FStar.Pervasives.Lemma (requires Lib.ByteSequence.nat_from_bytes_le b < Spec.Curve25519.prime)
(ensures Lib.IntTypes.v (FStar.Seq.Base.index b 31) < Prims.pow2 7) | {
"end_col": 35,
"end_line": 65,
"start_col": 4,
"start_line": 39
} |
FStar.HyperStack.ST.Stack | val add_sign:
out:lbuffer uint8 32ul
-> x:uint64{v x < 2} ->
Stack unit
(requires fun h -> live h out /\ nat_from_bytes_le (as_seq h out) < Spec.Curve25519.prime)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
nat_from_bytes_le (as_seq h1 out) == nat_from_bytes_le (as_seq h0 out) + pow2 255 ... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"short_module": null
},
{
"abbrev": false,
"ful... | false | let add_sign out x =
(**) let h0 = ST.get() in
let xbyte = to_u8 x in
let o31 = out.(31ul) in
(**) FStar.Math.Lemmas.lemma_mult_le_left (pow2 7) (v x) 1;
(**) assert (pow2 7 * (v x) <= pow2 7);
(**) assert_norm (pow2 7 < pow2 8);
(**) assert (v (xbyte <<. 7ul) == pow2 7 * (v x));
out.(31ul) <- o31 +. (x... | val add_sign:
out:lbuffer uint8 32ul
-> x:uint64{v x < 2} ->
Stack unit
(requires fun h -> live h out /\ nat_from_bytes_le (as_seq h out) < Spec.Curve25519.prime)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
nat_from_bytes_le (as_seq h1 out) == nat_from_bytes_le (as_seq h0 out) + pow2 255 ... | true | null | false | let h0 = ST.get () in
let xbyte = to_u8 x in
let o31 = out.(31ul) in
FStar.Math.Lemmas.lemma_mult_le_left (pow2 7) (v x) 1;
assert (pow2 7 * (v x) <= pow2 7);
assert_norm (pow2 7 < pow2 8);
assert (v (xbyte <<. 7ul) == pow2 7 * (v x));
out.(31ul) <- o31 +. (xbyte <<. 7ul);
let h1 = ST.get () in
calc ( == ) {
nat_from... | {
"checked_file": "Hacl.Impl.Ed25519.PointCompress.fst.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.Compatibility.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.chec... | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.uint64",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.Calc.calc_finish",
"Prims.nat",
"Prims.eq2",
"Lib.ByteSequence.nat_from_intseq_le",
"Lib.IntType... | [] | module Hacl.Impl.Ed25519.PointCompress
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.ByteSequence
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
#set-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 0"
inline_for_extraction noextr... | false | false | Hacl.Impl.Ed25519.PointCompress.fst | {
"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_el... | null | val add_sign:
out:lbuffer uint8 32ul
-> x:uint64{v x < 2} ->
Stack unit
(requires fun h -> live h out /\ nat_from_bytes_le (as_seq h out) < Spec.Curve25519.prime)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
nat_from_bytes_le (as_seq h1 out) == nat_from_bytes_le (as_seq h0 out) + pow2 255 ... | [] | Hacl.Impl.Ed25519.PointCompress.add_sign | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.PointCompress.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | out: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> x: Lib.IntTypes.uint64{Lib.IntTypes.v x < 2}
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 8,
"end_line": 129,
"start_col": 20,
"start_line": 76
} |
Prims.Tot | val repeat_blocks_multi_vec_equiv_pre
(#a #b #b_vec: Type0)
(w: pos)
(blocksize: pos{w * blocksize <= max_size_t})
(f: (lseq a blocksize -> b -> b))
(f_v: (lseq a (w * blocksize) -> b_vec -> b_vec))
(normalize_v: (b_vec -> b))
(b_v: lseq a (w * blocksize))
(acc_v: b_vec)
... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.Sequence.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"fu... | false | let repeat_blocks_multi_vec_equiv_pre
(#a:Type0)
(#b:Type0)
(#b_vec:Type0)
(w:pos)
(blocksize:pos{w * blocksize <= max_size_t})
(f:(lseq a blocksize -> b -> b))
(f_v:(lseq a (w * blocksize) -> b_vec -> b_vec))
(normalize_v:(b_vec -> b))
(b_v:lseq a (w * blocksize))
(acc_v:b_vec)
: prop
=
Math.Le... | val repeat_blocks_multi_vec_equiv_pre
(#a #b #b_vec: Type0)
(w: pos)
(blocksize: pos{w * blocksize <= max_size_t})
(f: (lseq a blocksize -> b -> b))
(f_v: (lseq a (w * blocksize) -> b_vec -> b_vec))
(normalize_v: (b_vec -> b))
(b_v: lseq a (w * blocksize))
(acc_v: b_vec)
... | false | null | false | Math.Lemmas.cancel_mul_mod w blocksize;
normalize_v (f_v b_v acc_v) == repeat_blocks_multi blocksize b_v f (normalize_v acc_v) | {
"checked_file": "Lib.Vec.Lemmas.fsti.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.M... | [
"total"
] | [
"Prims.pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Prims.eq2",
"Lib.Sequence.repeat_blocks_multi",
"Prims.unit",
"FStar.Math.Lemmas.cancel_mul_mod",
"Prims.prop"
] | [] | module Lib.Vec.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.Sequence.Lemmas
module Loops = Lib.LoopCombinators
#push-options "--z3rlimit 30 --max_fuel 0 --max_ifuel 0 \
--using_facts_from '-* +Prims +FStar.Pervasives +FStar.Math.Lemmas +FStar.Seq -FStar.Seq.Properties.slice_slice \
+Lib.I... | false | false | Lib.Vec.Lemmas.fsti | {
"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_el... | null | val repeat_blocks_multi_vec_equiv_pre
(#a #b #b_vec: Type0)
(w: pos)
(blocksize: pos{w * blocksize <= max_size_t})
(f: (lseq a blocksize -> b -> b))
(f_v: (lseq a (w * blocksize) -> b_vec -> b_vec))
(normalize_v: (b_vec -> b))
(b_v: lseq a (w * blocksize))
(acc_v: b_vec)
... | [] | Lib.Vec.Lemmas.repeat_blocks_multi_vec_equiv_pre | {
"file_name": "lib/Lib.Vec.Lemmas.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
w: Prims.pos ->
blocksize: Prims.pos{w * blocksize <= Lib.IntTypes.max_size_t} ->
f: (_: Lib.Sequence.lseq a blocksize -> _: b -> b) ->
f_v: (_: Lib.Sequence.lseq a (w * blocksize) -> _: b_vec -> b_vec) ->
normalize_v: (_: b_vec -> b) ->
b_v: Lib.Sequence.lseq a (w * blocksize) ->
acc_v: b_... | {
"end_col": 88,
"end_line": 175,
"start_col": 2,
"start_line": 174
} |
Prims.Tot | val repeat_blocks_vec_equiv_pre
(#a #b #b_vec #c: Type0)
(w: pos)
(blocksize: pos{w * blocksize <= max_size_t})
(f: (lseq a blocksize -> b -> b))
(l: (len: nat{len < blocksize} -> lseq a len -> b -> c))
(l_v: (len: nat{len < w * blocksize} -> lseq a len -> b_vec -> c))
(normali... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.Sequence.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"fu... | false | let repeat_blocks_vec_equiv_pre
(#a:Type0)
(#b:Type0)
(#b_vec:Type0)
(#c:Type0)
(w:pos)
(blocksize:pos{w * blocksize <= max_size_t})
(f:(lseq a blocksize -> b -> b))
(l:(len:nat{len < blocksize} -> lseq a len -> b -> c))
(l_v:(len:nat{len < w * blocksize} -> lseq a len -> b_vec -> c))
(normalize_v:(... | val repeat_blocks_vec_equiv_pre
(#a #b #b_vec #c: Type0)
(w: pos)
(blocksize: pos{w * blocksize <= max_size_t})
(f: (lseq a blocksize -> b -> b))
(l: (len: nat{len < blocksize} -> lseq a len -> b -> c))
(l_v: (len: nat{len < w * blocksize} -> lseq a len -> b_vec -> c))
(normali... | false | null | false | l_v rem b_v acc_v == repeat_blocks blocksize b_v f l (normalize_v acc_v) | {
"checked_file": "Lib.Vec.Lemmas.fsti.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.M... | [
"total"
] | [
"Prims.pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Prims.nat",
"Prims.op_LessThan",
"Prims.eq2",
"Lib.Sequence.repeat_blocks",
"Prims.prop"
] | [] | module Lib.Vec.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.Sequence.Lemmas
module Loops = Lib.LoopCombinators
#push-options "--z3rlimit 30 --max_fuel 0 --max_ifuel 0 \
--using_facts_from '-* +Prims +FStar.Pervasives +FStar.Math.Lemmas +FStar.Seq -FStar.Seq.Properties.slice_slice \
+Lib.I... | false | false | Lib.Vec.Lemmas.fsti | {
"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_el... | null | val repeat_blocks_vec_equiv_pre
(#a #b #b_vec #c: Type0)
(w: pos)
(blocksize: pos{w * blocksize <= max_size_t})
(f: (lseq a blocksize -> b -> b))
(l: (len: nat{len < blocksize} -> lseq a len -> b -> c))
(l_v: (len: nat{len < w * blocksize} -> lseq a len -> b_vec -> c))
(normali... | [] | Lib.Vec.Lemmas.repeat_blocks_vec_equiv_pre | {
"file_name": "lib/Lib.Vec.Lemmas.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
w: Prims.pos ->
blocksize: Prims.pos{w * blocksize <= Lib.IntTypes.max_size_t} ->
f: (_: Lib.Sequence.lseq a blocksize -> _: b -> b) ->
l: (len: Prims.nat{len < blocksize} -> _: Lib.Sequence.lseq a len -> _: b -> c) ->
l_v: (len: Prims.nat{len < w * blocksize} -> _: Lib.Sequence.lseq a len -> _: b_... | {
"end_col": 53,
"end_line": 215,
"start_col": 2,
"start_line": 214
} |
Prims.Tot | val map_blocks_multi_vec_equiv_pre_k
(#a: Type)
(w: pos)
(blocksize: pos{w * blocksize <= max_size_t})
(n: nat)
(hi_f: nat{w * n <= hi_f})
(f: (i: nat{i < hi_f} -> lseq a blocksize -> lseq a blocksize))
(f_v: (i: nat{i < n} -> lseq a (w * blocksize) -> lseq a (w * blocksize)))
... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.Sequence.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"fu... | false | let map_blocks_multi_vec_equiv_pre_k
(#a:Type)
(w:pos)
(blocksize:pos{w * blocksize <= max_size_t})
(n:nat)
(hi_f:nat{w * n <= hi_f})
(f:(i:nat{i < hi_f} -> lseq a blocksize -> lseq a blocksize))
(f_v:(i:nat{i < n} -> lseq a (w * blocksize) -> lseq a (w * blocksize)))
(i:nat{i < n})
(b_v:lseq a (w * b... | val map_blocks_multi_vec_equiv_pre_k
(#a: Type)
(w: pos)
(blocksize: pos{w * blocksize <= max_size_t})
(n: nat)
(hi_f: nat{w * n <= hi_f})
(f: (i: nat{i < hi_f} -> lseq a blocksize -> lseq a blocksize))
(f_v: (i: nat{i < n} -> lseq a (w * blocksize) -> lseq a (w * blocksize)))
... | false | null | false | Math.Lemmas.cancel_mul_div w blocksize;
let block = get_block_s #a #(w * blocksize) blocksize b_v k in
lemma_f_map_ind w blocksize n i k;
Seq.index (f_v i b_v) k == Seq.index (f (w * i + k / blocksize) block) (k % blocksize) | {
"checked_file": "Lib.Vec.Lemmas.fsti.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.M... | [
"total"
] | [
"Prims.pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Prims.nat",
"Prims.op_LessThan",
"Lib.Sequence.lseq",
"Prims.eq2",
"FStar.Seq.Base.index",
"Prims.op_Addition",
"Prims.op_Division",
"Prims.op_Modulus",
"Prims.unit",
"Lib.Vec.Lemmas.le... | [] | module Lib.Vec.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.Sequence.Lemmas
module Loops = Lib.LoopCombinators
#push-options "--z3rlimit 30 --max_fuel 0 --max_ifuel 0 \
--using_facts_from '-* +Prims +FStar.Pervasives +FStar.Math.Lemmas +FStar.Seq -FStar.Seq.Properties.slice_slice \
+Lib.I... | false | false | Lib.Vec.Lemmas.fsti | {
"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_el... | null | val map_blocks_multi_vec_equiv_pre_k
(#a: Type)
(w: pos)
(blocksize: pos{w * blocksize <= max_size_t})
(n: nat)
(hi_f: nat{w * n <= hi_f})
(f: (i: nat{i < hi_f} -> lseq a blocksize -> lseq a blocksize))
(f_v: (i: nat{i < n} -> lseq a (w * blocksize) -> lseq a (w * blocksize)))
... | [] | Lib.Vec.Lemmas.map_blocks_multi_vec_equiv_pre_k | {
"file_name": "lib/Lib.Vec.Lemmas.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
w: Prims.pos ->
blocksize: Prims.pos{w * blocksize <= Lib.IntTypes.max_size_t} ->
n: Prims.nat ->
hi_f: Prims.nat{w * n <= hi_f} ->
f: (i: Prims.nat{i < hi_f} -> _: Lib.Sequence.lseq a blocksize -> Lib.Sequence.lseq a blocksize) ->
f_v:
(i: Prims.nat{i < n} -> _: Lib.Sequence.lseq a (w * ... | {
"end_col": 88,
"end_line": 267,
"start_col": 2,
"start_line": 264
} |
Prims.Tot | val repeat_gen_blocks_vec_equiv_pre
(#inp_t #c: Type0)
(w: pos)
(blocksize: pos{w * blocksize <= max_size_t})
(n: nat)
(a: (i: nat{i <= w * n + w} -> Type))
(a_vec: (i: nat{i <= n} -> Type))
(f: (i: nat{i < w * n + w} -> lseq inp_t blocksize -> a i -> a (i + 1)))
(l: (i: ... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.Sequence.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"fu... | false | let repeat_gen_blocks_vec_equiv_pre
(#inp_t:Type0)
(#c:Type0)
(w:pos)
(blocksize:pos{w * blocksize <= max_size_t})
(n:nat)
(a:(i:nat{i <= w * n + w} -> Type))
(a_vec:(i:nat{i <= n} -> Type))
(f:(i:nat{i < w * n + w} -> lseq inp_t blocksize -> a i -> a (i + 1)))
(l:(i:nat{i <= w * n + w} -> len:nat{len... | val repeat_gen_blocks_vec_equiv_pre
(#inp_t #c: Type0)
(w: pos)
(blocksize: pos{w * blocksize <= max_size_t})
(n: nat)
(a: (i: nat{i <= w * n + w} -> Type))
(a_vec: (i: nat{i <= n} -> Type))
(f: (i: nat{i < w * n + w} -> lseq inp_t blocksize -> a i -> a (i + 1)))
(l: (i: ... | false | null | false | l_v n rem b_v acc_v ==
repeat_gen_blocks #inp_t #c blocksize (w * n) (w * n + w) b_v a f l (normalize_v n acc_v) | {
"checked_file": "Lib.Vec.Lemmas.fsti.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.M... | [
"total"
] | [
"Prims.pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Prims.nat",
"Prims.op_Addition",
"Prims.op_LessThan",
"Lib.Sequence.lseq",
"Prims.eq2",
"Lib.Sequence.Lemmas.repeat_gen_blocks",
"Prims.prop"
] | [] | module Lib.Vec.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.Sequence.Lemmas
module Loops = Lib.LoopCombinators
#push-options "--z3rlimit 30 --max_fuel 0 --max_ifuel 0 \
--using_facts_from '-* +Prims +FStar.Pervasives +FStar.Math.Lemmas +FStar.Seq -FStar.Seq.Properties.slice_slice \
+Lib.I... | false | false | Lib.Vec.Lemmas.fsti | {
"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_el... | null | val repeat_gen_blocks_vec_equiv_pre
(#inp_t #c: Type0)
(w: pos)
(blocksize: pos{w * blocksize <= max_size_t})
(n: nat)
(a: (i: nat{i <= w * n + w} -> Type))
(a_vec: (i: nat{i <= n} -> Type))
(f: (i: nat{i < w * n + w} -> lseq inp_t blocksize -> a i -> a (i + 1)))
(l: (i: ... | [] | Lib.Vec.Lemmas.repeat_gen_blocks_vec_equiv_pre | {
"file_name": "lib/Lib.Vec.Lemmas.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
w: Prims.pos ->
blocksize: Prims.pos{w * blocksize <= Lib.IntTypes.max_size_t} ->
n: Prims.nat ->
a: (i: Prims.nat{i <= w * n + w} -> Type) ->
a_vec: (i: Prims.nat{i <= n} -> Type) ->
f: (i: Prims.nat{i < w * n + w} -> _: Lib.Sequence.lseq inp_t blocksize -> _: a i -> a (i + 1)) ->
l:
... | {
"end_col": 91,
"end_line": 127,
"start_col": 2,
"start_line": 126
} |
Prims.Tot | val repeat_gen_blocks_multi_vec_equiv_pre
(#inp_t: Type0)
(w: pos)
(blocksize: pos{w * blocksize <= max_size_t})
(n: nat)
(hi_f: nat{w * n <= hi_f})
(a: (i: nat{i <= hi_f} -> Type))
(a_vec: (i: nat{i <= n} -> Type))
(f: (i: nat{i < hi_f} -> lseq inp_t blocksize -> a i -> ... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.Sequence.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"fu... | false | let repeat_gen_blocks_multi_vec_equiv_pre
(#inp_t:Type0)
(w:pos)
(blocksize:pos{w * blocksize <= max_size_t})
(n:nat)
(hi_f:nat{w * n <= hi_f})
(a:(i:nat{i <= hi_f} -> Type))
(a_vec:(i:nat{i <= n} -> Type))
(f:(i:nat{i < hi_f} -> lseq inp_t blocksize -> a i -> a (i + 1)))
(f_v:(i:nat{i < n} -> lseq in... | val repeat_gen_blocks_multi_vec_equiv_pre
(#inp_t: Type0)
(w: pos)
(blocksize: pos{w * blocksize <= max_size_t})
(n: nat)
(hi_f: nat{w * n <= hi_f})
(a: (i: nat{i <= hi_f} -> Type))
(a_vec: (i: nat{i <= n} -> Type))
(f: (i: nat{i < hi_f} -> lseq inp_t blocksize -> a i -> ... | false | null | false | Math.Lemmas.lemma_mult_le_right w (i + 1) n;
normalize_v (i + 1) (f_v i b_v acc_v) ==
repeat_gen_blocks_multi blocksize (w * i) hi_f w b_v a f (normalize_v i acc_v) | {
"checked_file": "Lib.Vec.Lemmas.fsti.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.M... | [
"total"
] | [
"Prims.pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Prims.nat",
"Prims.op_LessThan",
"Lib.Sequence.lseq",
"Prims.op_Addition",
"Prims.eq2",
"Lib.Sequence.Lemmas.repeat_gen_blocks_multi",
"Prims.unit",
"FStar.Math.Lemmas.lemma_mult_le_right",... | [] | module Lib.Vec.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.Sequence.Lemmas
module Loops = Lib.LoopCombinators
#push-options "--z3rlimit 30 --max_fuel 0 --max_ifuel 0 \
--using_facts_from '-* +Prims +FStar.Pervasives +FStar.Math.Lemmas +FStar.Seq -FStar.Seq.Properties.slice_slice \
+Lib.I... | false | false | Lib.Vec.Lemmas.fsti | {
"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_el... | null | val repeat_gen_blocks_multi_vec_equiv_pre
(#inp_t: Type0)
(w: pos)
(blocksize: pos{w * blocksize <= max_size_t})
(n: nat)
(hi_f: nat{w * n <= hi_f})
(a: (i: nat{i <= hi_f} -> Type))
(a_vec: (i: nat{i <= n} -> Type))
(f: (i: nat{i < hi_f} -> lseq inp_t blocksize -> a i -> ... | [] | Lib.Vec.Lemmas.repeat_gen_blocks_multi_vec_equiv_pre | {
"file_name": "lib/Lib.Vec.Lemmas.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
w: Prims.pos ->
blocksize: Prims.pos{w * blocksize <= Lib.IntTypes.max_size_t} ->
n: Prims.nat ->
hi_f: Prims.nat{w * n <= hi_f} ->
a: (i: Prims.nat{i <= hi_f} -> Type) ->
a_vec: (i: Prims.nat{i <= n} -> Type) ->
f: (i: Prims.nat{i < hi_f} -> _: Lib.Sequence.lseq inp_t blocksize -> _: a i -... | {
"end_col": 80,
"end_line": 83,
"start_col": 2,
"start_line": 80
} |
Prims.Tot | val map_blocks_vec_equiv_pre_k
(#a: Type)
(w: pos)
(blocksize: pos{w * blocksize <= max_size_t})
(n: nat)
(f: (i: nat{i < w * n + w} -> lseq a blocksize -> lseq a blocksize))
(l: (i: nat{i <= w * n + w} -> rem: nat{rem < blocksize} -> lseq a rem -> lseq a rem))
(l_v: (i: nat{i ... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.Sequence.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"fu... | false | let map_blocks_vec_equiv_pre_k
(#a:Type)
(w:pos)
(blocksize:pos{w * blocksize <= max_size_t})
(n:nat)
(f:(i:nat{i < w * n + w} -> lseq a blocksize -> lseq a blocksize))
(l:(i:nat{i <= w * n + w} -> rem:nat{rem < blocksize} -> lseq a rem -> lseq a rem))
(l_v:(i:nat{i <= n} -> rem:nat{rem < w * blocksize} -... | val map_blocks_vec_equiv_pre_k
(#a: Type)
(w: pos)
(blocksize: pos{w * blocksize <= max_size_t})
(n: nat)
(f: (i: nat{i < w * n + w} -> lseq a blocksize -> lseq a blocksize))
(l: (i: nat{i <= w * n + w} -> rem: nat{rem < blocksize} -> lseq a rem -> lseq a rem))
(l_v: (i: nat{i ... | false | null | false | let j = w * n + k / blocksize in
div_mul_lt blocksize k w;
if k < (rem / blocksize) * blocksize
then
let block = get_block_s #a #rem blocksize b_v k in
Seq.index (l_v n rem b_v) k == Seq.index (f j block) (k % blocksize)
else
let block_l = get_last_s blocksize b_v in
mod_div_lt blocksize k rem;
assert (k % bl... | {
"checked_file": "Lib.Vec.Lemmas.fsti.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.Lemmas.fsti.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.M... | [
"total"
] | [
"Prims.pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Prims.nat",
"Prims.op_LessThan",
"Prims.op_Addition",
"Lib.Sequence.lseq",
"Prims.op_Division",
"Prims.eq2",
"FStar.Seq.Base.index",
"Prims.op_Modulus",
"Lib.Sequence.Lemmas.get_block_s",... | [] | module Lib.Vec.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.Sequence.Lemmas
module Loops = Lib.LoopCombinators
#push-options "--z3rlimit 30 --max_fuel 0 --max_ifuel 0 \
--using_facts_from '-* +Prims +FStar.Pervasives +FStar.Math.Lemmas +FStar.Seq -FStar.Seq.Properties.slice_slice \
+Lib.I... | false | false | Lib.Vec.Lemmas.fsti | {
"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_el... | null | val map_blocks_vec_equiv_pre_k
(#a: Type)
(w: pos)
(blocksize: pos{w * blocksize <= max_size_t})
(n: nat)
(f: (i: nat{i < w * n + w} -> lseq a blocksize -> lseq a blocksize))
(l: (i: nat{i <= w * n + w} -> rem: nat{rem < blocksize} -> lseq a rem -> lseq a rem))
(l_v: (i: nat{i ... | [] | Lib.Vec.Lemmas.map_blocks_vec_equiv_pre_k | {
"file_name": "lib/Lib.Vec.Lemmas.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
w: Prims.pos ->
blocksize: Prims.pos{w * blocksize <= Lib.IntTypes.max_size_t} ->
n: Prims.nat ->
f:
(i: Prims.nat{i < w * n + w} -> _: Lib.Sequence.lseq a blocksize
-> Lib.Sequence.lseq a blocksize) ->
l:
(i: Prims.nat{i <= w * n + w} -> rem: Prims.nat{rem < blocksize} -> _: ... | {
"end_col": 96,
"end_line": 311,
"start_col": 2,
"start_line": 300
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Hacl.Impl.Exponentiation.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation.Definition",
"short_module": "S"
},... | false | let lprecomp_get_st
(a_t:inttype_a)
(len:size_t{v len > 0})
(ctx_len:size_t)
(k:concrete_ops a_t len ctx_len) =
a:Ghost.erased (LSeq.lseq (uint_t a_t SEC) (v len))
-> table_len:size_t{1 < v table_len /\ v table_len * v len <= max_size_t}
-> table:clbuffer (uint_t a_t SEC) (table_len *! len)
-> bits_l:... | let lprecomp_get_st
(a_t: inttype_a)
(len: size_t{v len > 0})
(ctx_len: size_t)
(k: concrete_ops a_t len ctx_len)
= | false | null | false |
a: Ghost.erased (LSeq.lseq (uint_t a_t SEC) (v len)) ->
table_len: size_t{1 < v table_len /\ v table_len * v len <= max_size_t} ->
table: clbuffer (uint_t a_t SEC) (table_len *! len) ->
bits_l: uint_t a_t SEC {v bits_l < v table_len} ->
tmp: lbuffer (uint_t a_t SEC) len
-> Stack unit
(requi... | {
"checked_file": "Hacl.Impl.PrecompTable.fsti.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.Definition.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Exponentiation.Definitions.fst.checked",
"Hacl.Big... | [
"total"
] | [
"Hacl.Impl.Exponentiation.Definitions.inttype_a",
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_GreaterThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Impl.Exponentiation.Definitions.concrete_ops",
"FStar.Ghost.erased",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint_t",
"Lib.In... | [] | module Hacl.Impl.PrecompTable
open FStar.Mul
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Lib.Exponentiation.Definition
module BD = Hacl.Bignum.Definitions
include Hacl.Impl.Exponentiation.Defi... | false | false | Hacl.Impl.PrecompTable.fsti | {
"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_el... | null | val lprecomp_get_st : a_t: Hacl.Impl.Exponentiation.Definitions.inttype_a ->
len: Lib.IntTypes.size_t{Lib.IntTypes.v len > 0} ->
ctx_len: Lib.IntTypes.size_t ->
k: Hacl.Impl.Exponentiation.Definitions.concrete_ops a_t len ctx_len
-> Type0 | [] | Hacl.Impl.PrecompTable.lprecomp_get_st | {
"file_name": "code/bignum/Hacl.Impl.PrecompTable.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a_t: Hacl.Impl.Exponentiation.Definitions.inttype_a ->
len: Lib.IntTypes.size_t{Lib.IntTypes.v len > 0} ->
ctx_len: Lib.IntTypes.size_t ->
k: Hacl.Impl.Exponentiation.Definitions.concrete_ops a_t len ctx_len
-> Type0 | {
"end_col": 81,
"end_line": 111,
"start_col": 4,
"start_line": 98
} | |
Prims.Tot | val precomp_table_inv
(#a_t: inttype_a)
(len: size_t{v len > 0})
(ctx_len: size_t)
(k: concrete_ops a_t len ctx_len)
(a: LSeq.lseq (uint_t a_t SEC) (v len))
(table_len: size_t{v table_len * v len <= max_size_t})
(table: LSeq.lseq (uint_t a_t SEC) (v table_len * v len))
(j... | [
{
"abbrev": false,
"full_module": "Hacl.Impl.Exponentiation.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation.Definition",
"short_module": "S"
},... | false | let precomp_table_inv
(#a_t:inttype_a)
(len:size_t{v len > 0})
(ctx_len:size_t)
(k:concrete_ops a_t len ctx_len)
(a:LSeq.lseq (uint_t a_t SEC) (v len))
(table_len:size_t{v table_len * v len <= max_size_t})
(table:LSeq.lseq (uint_t a_t SEC) (v table_len * v len))
(j:nat{j < v table_len}) : Type0
=
let... | val precomp_table_inv
(#a_t: inttype_a)
(len: size_t{v len > 0})
(ctx_len: size_t)
(k: concrete_ops a_t len ctx_len)
(a: LSeq.lseq (uint_t a_t SEC) (v len))
(table_len: size_t{v table_len * v len <= max_size_t})
(table: LSeq.lseq (uint_t a_t SEC) (v table_len * v len))
(j... | false | null | false | let bj = spec_table_sub_len (v len) (v table_len) table j in
k.to.linv bj /\ k.to.linv a /\ k.to.refl bj == S.pow k.to.comm_monoid (k.to.refl a) j | {
"checked_file": "Hacl.Impl.PrecompTable.fsti.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.Definition.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Exponentiation.Definitions.fst.checked",
"Hacl.Big... | [
"total"
] | [
"Hacl.Impl.Exponentiation.Definitions.inttype_a",
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_GreaterThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Impl.Exponentiation.Definitions.concrete_ops",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.SEC",
"Prims.op... | [] | module Hacl.Impl.PrecompTable
open FStar.Mul
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Lib.Exponentiation.Definition
module BD = Hacl.Bignum.Definitions
include Hacl.Impl.Exponentiation.Defi... | false | false | Hacl.Impl.PrecompTable.fsti | {
"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_el... | null | val precomp_table_inv
(#a_t: inttype_a)
(len: size_t{v len > 0})
(ctx_len: size_t)
(k: concrete_ops a_t len ctx_len)
(a: LSeq.lseq (uint_t a_t SEC) (v len))
(table_len: size_t{v table_len * v len <= max_size_t})
(table: LSeq.lseq (uint_t a_t SEC) (v table_len * v len))
(j... | [] | Hacl.Impl.PrecompTable.precomp_table_inv | {
"file_name": "code/bignum/Hacl.Impl.PrecompTable.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
len: Lib.IntTypes.size_t{Lib.IntTypes.v len > 0} ->
ctx_len: Lib.IntTypes.size_t ->
k: Hacl.Impl.Exponentiation.Definitions.concrete_ops a_t len ctx_len ->
a: Lib.Sequence.lseq (Lib.IntTypes.uint_t a_t Lib.IntTypes.SEC) (Lib.IntTypes.v len) ->
table_len:
Lib.IntTypes.size_t{Lib.IntTypes.v tab... | {
"end_col": 56,
"end_line": 68,
"start_col": 2,
"start_line": 65
} |
Prims.Tot | val spec_table_sub_len
(#t: BD.limb_t)
(len: pos)
(table_len: size_nat{table_len * len <= max_size_t})
(table: LSeq.lseq (uint_t t SEC) (table_len * len))
(i: nat{i < table_len})
: LSeq.lseq (uint_t t SEC) len | [
{
"abbrev": false,
"full_module": "Hacl.Impl.Exponentiation.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation.Definition",
"short_module": "S"
},... | false | let spec_table_sub_len
(#t:BD.limb_t)
(len:pos)
(table_len:size_nat{table_len * len <= max_size_t})
(table:LSeq.lseq (uint_t t SEC) (table_len * len))
(i:nat{i < table_len}) : LSeq.lseq (uint_t t SEC) len =
lemma_table_sub_len len table_len i;
LSeq.sub table (i * len) len | val spec_table_sub_len
(#t: BD.limb_t)
(len: pos)
(table_len: size_nat{table_len * len <= max_size_t})
(table: LSeq.lseq (uint_t t SEC) (table_len * len))
(i: nat{i < table_len})
: LSeq.lseq (uint_t t SEC) len
let spec_table_sub_len
(#t: BD.limb_t)
(len: pos)
(table_l... | false | null | false | lemma_table_sub_len len table_len i;
LSeq.sub table (i * len) len | {
"checked_file": "Hacl.Impl.PrecompTable.fsti.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.Definition.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Exponentiation.Definitions.fst.checked",
"Hacl.Big... | [
"total"
] | [
"Hacl.Bignum.Definitions.limb_t",
"Prims.pos",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.SEC",
"Prims.nat",
"Prims.op_LessThan",
"Lib.Sequence.sub",
"Prims.unit... | [] | module Hacl.Impl.PrecompTable
open FStar.Mul
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Lib.Exponentiation.Definition
module BD = Hacl.Bignum.Definitions
include Hacl.Impl.Exponentiation.Defi... | false | false | Hacl.Impl.PrecompTable.fsti | {
"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_el... | null | val spec_table_sub_len
(#t: BD.limb_t)
(len: pos)
(table_len: size_nat{table_len * len <= max_size_t})
(table: LSeq.lseq (uint_t t SEC) (table_len * len))
(i: nat{i < table_len})
: LSeq.lseq (uint_t t SEC) len | [] | Hacl.Impl.PrecompTable.spec_table_sub_len | {
"file_name": "code/bignum/Hacl.Impl.PrecompTable.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
len: Prims.pos ->
table_len: Lib.IntTypes.size_nat{table_len * len <= Lib.IntTypes.max_size_t} ->
table: Lib.Sequence.lseq (Lib.IntTypes.uint_t t Lib.IntTypes.SEC) (table_len * len) ->
i: Prims.nat{i < table_len}
-> Lib.Sequence.lseq (Lib.IntTypes.uint_t t Lib.IntTypes.SEC) len | {
"end_col": 30,
"end_line": 34,
"start_col": 2,
"start_line": 33
} |
Prims.Tot | val seqTo128_app (s: Seq.seq nat64) (i: int) : nat128 | [
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let seqTo128_app (s:Seq.seq nat64) (i:int) : nat128 = seqTo128 s i | val seqTo128_app (s: Seq.seq nat64) (i: int) : nat128
let seqTo128_app (s: Seq.seq nat64) (i: int) : nat128 = | false | null | false | seqTo128 s i | {
"checked_file": "Vale.Poly1305.Util.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Poly1305.Spec_s.fst.checked",
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Prop_s.f... | [
"total"
] | [
"FStar.Seq.Base.seq",
"Vale.X64.Memory.nat64",
"Prims.int",
"Vale.Poly1305.Util.seqTo128",
"Vale.X64.Machine_s.nat128"
] | [] | module Vale.Poly1305.Util
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Poly1305.Spec_s
open Vale.X64.Machine_s
open Vale.Poly1305.Math
open Vale.X64.State
open Vale.X64.Decls
open Vale.Def.Opaque_s
open Vale.X64.Memory
let rec poly1305_heap_blocks'
(h:int) (pad:int) (r:int) (s:Seq.seq nat6... | false | true | Vale.Poly1305.Util.fsti | {
"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_el... | null | val seqTo128_app (s: Seq.seq nat64) (i: int) : nat128 | [] | Vale.Poly1305.Util.seqTo128_app | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Util.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: FStar.Seq.Base.seq Vale.X64.Memory.nat64 -> i: Prims.int -> Vale.X64.Machine_s.nat128 | {
"end_col": 66,
"end_line": 37,
"start_col": 54,
"start_line": 37
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let readable_words (len:nat) =
((len + 15) / 16) * 2 | let readable_words (len: nat) = | false | null | false | ((len + 15) / 16) * 2 | {
"checked_file": "Vale.Poly1305.Util.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Poly1305.Spec_s.fst.checked",
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Prop_s.f... | [
"total"
] | [
"Prims.nat",
"FStar.Mul.op_Star",
"Prims.op_Division",
"Prims.op_Addition",
"Prims.int"
] | [] | module Vale.Poly1305.Util
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Poly1305.Spec_s
open Vale.X64.Machine_s
open Vale.Poly1305.Math
open Vale.X64.State
open Vale.X64.Decls
open Vale.Def.Opaque_s
open Vale.X64.Memory
let rec poly1305_heap_blocks'
(h:int) (pad:int) (r:int) (s:Seq.seq nat6... | false | true | Vale.Poly1305.Util.fsti | {
"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_el... | null | val readable_words : len: Prims.nat -> Prims.int | [] | Vale.Poly1305.Util.readable_words | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Util.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Prims.nat -> Prims.int | {
"end_col": 23,
"end_line": 54,
"start_col": 2,
"start_line": 54
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let modifies_buffer (b:buffer64) (h1 h2:vale_heap) = modifies_mem (loc_buffer b) h1 h2 | let modifies_buffer (b: buffer64) (h1 h2: vale_heap) = | false | null | false | modifies_mem (loc_buffer b) h1 h2 | {
"checked_file": "Vale.Poly1305.Util.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Poly1305.Spec_s.fst.checked",
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Prop_s.f... | [
"total"
] | [
"Vale.X64.Memory.buffer64",
"Vale.X64.Memory.vale_heap",
"Vale.X64.Decls.modifies_mem",
"Vale.X64.Memory.loc_buffer",
"Vale.X64.Memory.vuint64",
"Vale.Def.Prop_s.prop0"
] | [] | module Vale.Poly1305.Util
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Poly1305.Spec_s
open Vale.X64.Machine_s
open Vale.Poly1305.Math
open Vale.X64.State
open Vale.X64.Decls
open Vale.Def.Opaque_s
open Vale.X64.Memory
let rec poly1305_heap_blocks'
(h:int) (pad:int) (r:int) (s:Seq.seq nat6... | false | true | Vale.Poly1305.Util.fsti | {
"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_el... | null | val modifies_buffer : b: Vale.X64.Memory.buffer64 -> h1: Vale.X64.Memory.vale_heap -> h2: Vale.X64.Memory.vale_heap
-> Vale.Def.Prop_s.prop0 | [] | Vale.Poly1305.Util.modifies_buffer | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Util.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b: Vale.X64.Memory.buffer64 -> h1: Vale.X64.Memory.vale_heap -> h2: Vale.X64.Memory.vale_heap
-> Vale.Def.Prop_s.prop0 | {
"end_col": 93,
"end_line": 51,
"start_col": 60,
"start_line": 51
} | |
Prims.Tot | val seqTo128 (s: Seq.seq nat64) : t_seqTo128 | [
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let seqTo128 (s:Seq.seq nat64) : t_seqTo128 =
let f (i:int) : nat128 =
if 0 <= i && i < Seq.length s / 2 then
(Seq.index s (2 * i)) + 0x10000000000000000 * (Seq.index s (2 * i + 1))
else
42
in f | val seqTo128 (s: Seq.seq nat64) : t_seqTo128
let seqTo128 (s: Seq.seq nat64) : t_seqTo128 = | false | null | false | let f (i: int) : nat128 =
if 0 <= i && i < Seq.length s / 2
then (Seq.index s (2 * i)) + 0x10000000000000000 * (Seq.index s (2 * i + 1))
else 42
in
f | {
"checked_file": "Vale.Poly1305.Util.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Poly1305.Spec_s.fst.checked",
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Prop_s.f... | [
"total"
] | [
"FStar.Seq.Base.seq",
"Vale.X64.Memory.nat64",
"Prims.int",
"Vale.Def.Words_s.nat128",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.op_Division",
"FStar.Seq.Base.length",
"Prims.op_Addition",
"FStar.Seq.Base.index",
"FStar.Mul.op_Star",
"Prims.bool",
"Vale.X64... | [] | module Vale.Poly1305.Util
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Poly1305.Spec_s
open Vale.X64.Machine_s
open Vale.Poly1305.Math
open Vale.X64.State
open Vale.X64.Decls
open Vale.Def.Opaque_s
open Vale.X64.Memory
let rec poly1305_heap_blocks'
(h:int) (pad:int) (r:int) (s:Seq.seq nat6... | false | true | Vale.Poly1305.Util.fsti | {
"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_el... | null | val seqTo128 (s: Seq.seq nat64) : t_seqTo128 | [] | Vale.Poly1305.Util.seqTo128 | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Util.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: FStar.Seq.Base.seq Vale.X64.Memory.nat64 -> Vale.Poly1305.Util.t_seqTo128 | {
"end_col": 6,
"end_line": 36,
"start_col": 45,
"start_line": 30
} |
Prims.Tot | val poly1305_heap_blocks'
(h pad r: int)
(s: Seq.seq nat64)
(k: int{0 <= k /\ k <= Seq.length s /\ k % 2 == 0})
: Tot int (decreases k) | [
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let rec poly1305_heap_blocks'
(h:int) (pad:int) (r:int) (s:Seq.seq nat64) (k:int{0 <= k /\ k <= Seq.length s /\ k % 2 == 0})
: Tot int (decreases k) =
if k = 0 then h
else
let kk = k - 2 in
let hh = poly1305_heap_blocks' h pad r s kk in
modp ((hh + pad + pow2_64 * Seq.index s (kk + 1) + Seq.index ... | val poly1305_heap_blocks'
(h pad r: int)
(s: Seq.seq nat64)
(k: int{0 <= k /\ k <= Seq.length s /\ k % 2 == 0})
: Tot int (decreases k)
let rec poly1305_heap_blocks'
(h pad r: int)
(s: Seq.seq nat64)
(k: int{0 <= k /\ k <= Seq.length s /\ k % 2 == 0})
: Tot int (decreases k) ... | false | null | false | if k = 0
then h
else
let kk = k - 2 in
let hh = poly1305_heap_blocks' h pad r s kk in
modp ((hh + pad + pow2_64 * Seq.index s (kk + 1) + Seq.index s kk) * r) | {
"checked_file": "Vale.Poly1305.Util.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Poly1305.Spec_s.fst.checked",
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Prop_s.f... | [
"total",
""
] | [
"Prims.int",
"FStar.Seq.Base.seq",
"Vale.X64.Memory.nat64",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"Prims.eq2",
"Prims.op_Modulus",
"Prims.op_Equality",
"Prims.bool",
"Vale.Poly1305.Spec_s.modp",
"FStar.Mul.op_Star",
"Prims.op_Addition",
"Vale.X6... | [] | module Vale.Poly1305.Util
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Poly1305.Spec_s
open Vale.X64.Machine_s
open Vale.Poly1305.Math
open Vale.X64.State
open Vale.X64.Decls
open Vale.Def.Opaque_s
open Vale.X64.Memory
let rec poly1305_heap_blocks'
(h:int) (pad:int) (r:int) (s:Seq.seq nat6... | false | false | Vale.Poly1305.Util.fsti | {
"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_el... | null | val poly1305_heap_blocks'
(h pad r: int)
(s: Seq.seq nat64)
(k: int{0 <= k /\ k <= Seq.length s /\ k % 2 == 0})
: Tot int (decreases k) | [
"recursion"
] | Vale.Poly1305.Util.poly1305_heap_blocks' | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Util.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
h: Prims.int ->
pad: Prims.int ->
r: Prims.int ->
s: FStar.Seq.Base.seq Vale.X64.Memory.nat64 ->
k: Prims.int{0 <= k /\ k <= FStar.Seq.Base.length s /\ k % 2 == 0}
-> Prims.Tot Prims.int | {
"end_col": 75,
"end_line": 21,
"start_col": 2,
"start_line": 17
} |
Prims.GTot | val buffers_readable (h: vale_heap) (l: list buffer64) : GTot Type0 (decreases l) | [
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let rec buffers_readable (h:vale_heap) (l:list buffer64) : GTot Type0 (decreases l) =
match l with
| [] -> True
| b :: l' -> buffer_readable h b /\ buffers_readable h l' | val buffers_readable (h: vale_heap) (l: list buffer64) : GTot Type0 (decreases l)
let rec buffers_readable (h: vale_heap) (l: list buffer64) : GTot Type0 (decreases l) = | false | null | false | match l with
| [] -> True
| b :: l' -> buffer_readable h b /\ buffers_readable h l' | {
"checked_file": "Vale.Poly1305.Util.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Poly1305.Spec_s.fst.checked",
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Prop_s.f... | [
"sometrivial",
""
] | [
"Vale.X64.Memory.vale_heap",
"Prims.list",
"Vale.X64.Memory.buffer64",
"Prims.l_True",
"Prims.l_and",
"Vale.X64.Memory.buffer_readable",
"Vale.X64.Memory.vuint64",
"Vale.Poly1305.Util.buffers_readable"
] | [] | module Vale.Poly1305.Util
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Poly1305.Spec_s
open Vale.X64.Machine_s
open Vale.Poly1305.Math
open Vale.X64.State
open Vale.X64.Decls
open Vale.Def.Opaque_s
open Vale.X64.Memory
let rec poly1305_heap_blocks'
(h:int) (pad:int) (r:int) (s:Seq.seq nat6... | false | false | Vale.Poly1305.Util.fsti | {
"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_el... | null | val buffers_readable (h: vale_heap) (l: list buffer64) : GTot Type0 (decreases l) | [
"recursion"
] | Vale.Poly1305.Util.buffers_readable | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Util.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: Vale.X64.Memory.vale_heap -> l: Prims.list Vale.X64.Memory.buffer64 -> Prims.GTot Type0 | {
"end_col": 60,
"end_line": 49,
"start_col": 2,
"start_line": 47
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abb... | false | let mod_inv_limb_t (t:limb_t) (i:nat{i <= bits t}) = tuple2 (limb t) (limb t) | let mod_inv_limb_t (t: limb_t) (i: nat{i <= bits t}) = | false | null | false | tuple2 (limb t) (limb t) | {
"checked_file": "Hacl.Spec.Bignum.ModInvLimb.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.... | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.bits",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Definitions.limb"
] | [] | module Hacl.Spec.Bignum.ModInvLimb
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
module M = Hacl.Spec.Montgomery.Lemmas
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
the modular inverse function was taken from
https://github.com/google/boringssl/blob/master/cry... | false | false | Hacl.Spec.Bignum.ModInvLimb.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val mod_inv_limb_t : t: Hacl.Spec.Bignum.Definitions.limb_t -> i: Prims.nat{i <= Lib.IntTypes.bits t} -> Type0 | [] | Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb_t | {
"file_name": "code/bignum/Hacl.Spec.Bignum.ModInvLimb.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | t: Hacl.Spec.Bignum.Definitions.limb_t -> i: Prims.nat{i <= Lib.IntTypes.bits t} -> Type0 | {
"end_col": 77,
"end_line": 34,
"start_col": 53,
"start_line": 34
} | |
Prims.Tot | val mod_inv_limb: #t:limb_t -> n0:limb t -> limb t | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abb... | false | let mod_inv_limb #t n0 =
let alpha = uint #t 1 <<. size (bits t - 1) in
let beta = n0 in
let (u, v) = repeat_gen (bits t) (mod_inv_limb_t t) (mod_inv_limb_f alpha beta) (uint #t 1, uint #t 0) in
v | val mod_inv_limb: #t:limb_t -> n0:limb t -> limb t
let mod_inv_limb #t n0 = | false | null | false | let alpha = uint #t 1 <<. size (bits t - 1) in
let beta = n0 in
let u, v =
repeat_gen (bits t) (mod_inv_limb_t t) (mod_inv_limb_f alpha beta) (uint #t 1, uint #t 0)
in
v | {
"checked_file": "Hacl.Spec.Bignum.ModInvLimb.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.... | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb_t",
"Lib.IntTypes.bits",
"Lib.LoopCombinators.repeat_gen",
"Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb_f",
"FStar.Pervasives.Native.Mktuple2",
"Lib.IntTypes.uint",
"Lib.IntTypes.SEC",
... | [] | module Hacl.Spec.Bignum.ModInvLimb
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
module M = Hacl.Spec.Montgomery.Lemmas
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
the modular inverse function was taken from
https://github.com/google/boringssl/blob/master/cry... | false | false | Hacl.Spec.Bignum.ModInvLimb.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val mod_inv_limb: #t:limb_t -> n0:limb t -> limb t | [] | Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb | {
"file_name": "code/bignum/Hacl.Spec.Bignum.ModInvLimb.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | n0: Hacl.Spec.Bignum.Definitions.limb t -> Hacl.Spec.Bignum.Definitions.limb t | {
"end_col": 3,
"end_line": 40,
"start_col": 24,
"start_line": 36
} |
Prims.Tot | val mod_inv_limb_f:
#t:limb_t
-> alpha:limb t
-> beta:limb t
-> i:nat{i < bits t}
-> tuple2 (limb t) (limb t) ->
tuple2 (limb t) (limb t) | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abb... | false | let mod_inv_limb_f #t alpha beta i (ub, vb) =
let u_is_odd = uint #t 0 -. (ub &. uint #t 1) in
let beta_if_u_is_odd = beta &. u_is_odd in
let u = ((ub ^. beta_if_u_is_odd) >>. 1ul) +. (ub &. beta_if_u_is_odd) in
let alpha_if_u_is_odd = alpha &. u_is_odd in
let v = (vb >>. 1ul) +. alpha_if_u_is_odd in
(u, v... | val mod_inv_limb_f:
#t:limb_t
-> alpha:limb t
-> beta:limb t
-> i:nat{i < bits t}
-> tuple2 (limb t) (limb t) ->
tuple2 (limb t) (limb t)
let mod_inv_limb_f #t alpha beta i (ub, vb) = | false | null | false | let u_is_odd = uint #t 0 -. (ub &. uint #t 1) in
let beta_if_u_is_odd = beta &. u_is_odd in
let u = ((ub ^. beta_if_u_is_odd) >>. 1ul) +. (ub &. beta_if_u_is_odd) in
let alpha_if_u_is_odd = alpha &. u_is_odd in
let v = (vb >>. 1ul) +. alpha_if_u_is_odd in
(u, v) | {
"checked_file": "Hacl.Spec.Bignum.ModInvLimb.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.... | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.bits",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"Lib.IntTypes.int_t",
"Lib.IntTypes.SEC",
"Lib.IntTypes.op_Plus_Dot",
"Lib.IntTy... | [] | module Hacl.Spec.Bignum.ModInvLimb
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
module M = Hacl.Spec.Montgomery.Lemmas
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
the modular inverse function was taken from
https://github.com/google/boringssl/blob/master/cry... | false | false | Hacl.Spec.Bignum.ModInvLimb.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val mod_inv_limb_f:
#t:limb_t
-> alpha:limb t
-> beta:limb t
-> i:nat{i < bits t}
-> tuple2 (limb t) (limb t) ->
tuple2 (limb t) (limb t) | [] | Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb_f | {
"file_name": "code/bignum/Hacl.Spec.Bignum.ModInvLimb.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
alpha: Hacl.Spec.Bignum.Definitions.limb t ->
beta: Hacl.Spec.Bignum.Definitions.limb t ->
i: Prims.nat{i < Lib.IntTypes.bits t} ->
_: (Hacl.Spec.Bignum.Definitions.limb t * Hacl.Spec.Bignum.Definitions.limb t)
-> Hacl.Spec.Bignum.Definitions.limb t * Hacl.Spec.Bignum.Definitions.limb t | {
"end_col": 8,
"end_line": 32,
"start_col": 45,
"start_line": 25
} |
FStar.Pervasives.Lemma | val x_if_u_is_odd: #t:limb_t -> x:limb t -> u:limb t ->
Lemma (let u_is_odd = uint #t 0 -. (u &. uint #t 1) in
v (x &. u_is_odd) == (if v u % 2 = 0 then 0 else v x)) | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abb... | false | let x_if_u_is_odd #t x u =
let u_is_odd = uint #t 0 -. (u &. uint #t 1) in
logand_mask u (uint #t 1) 1;
assert (v (u &. uint #t 1) == v u % 2);
assert (v u_is_odd == (- v u % 2) % pow2 (bits t));
assert (v u_is_odd == (if v u % 2 = 0 then 0 else pow2 (bits t) - 1));
if v u % 2 = 0 then
logand_zeros x
... | val x_if_u_is_odd: #t:limb_t -> x:limb t -> u:limb t ->
Lemma (let u_is_odd = uint #t 0 -. (u &. uint #t 1) in
v (x &. u_is_odd) == (if v u % 2 = 0 then 0 else v x))
let x_if_u_is_odd #t x u = | false | null | true | let u_is_odd = uint #t 0 -. (u &. uint #t 1) in
logand_mask u (uint #t 1) 1;
assert (v (u &. uint #t 1) == v u % 2);
assert (v u_is_odd == (- v u % 2) % pow2 (bits t));
assert (v u_is_odd == (if v u % 2 = 0 then 0 else pow2 (bits t) - 1));
if v u % 2 = 0 then logand_zeros x else logand_ones x | {
"checked_file": "Hacl.Spec.Bignum.ModInvLimb.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.... | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Lib.IntTypes.logand_zeros",
"Prims.bool",
"Lib.IntTypes.logand_ones",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.... | [] | module Hacl.Spec.Bignum.ModInvLimb
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
module M = Hacl.Spec.Montgomery.Lemmas
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
the modular inverse function was taken from
https://github.com/google/boringssl/blob/master/cry... | false | false | Hacl.Spec.Bignum.ModInvLimb.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val x_if_u_is_odd: #t:limb_t -> x:limb t -> u:limb t ->
Lemma (let u_is_odd = uint #t 0 -. (u &. uint #t 1) in
v (x &. u_is_odd) == (if v u % 2 = 0 then 0 else v x)) | [] | Hacl.Spec.Bignum.ModInvLimb.x_if_u_is_odd | {
"file_name": "code/bignum/Hacl.Spec.Bignum.ModInvLimb.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Hacl.Spec.Bignum.Definitions.limb t -> u17: Hacl.Spec.Bignum.Definitions.limb t
-> FStar.Pervasives.Lemma
(ensures
(let u_is_odd = Lib.IntTypes.uint 0 -. (u17 &. Lib.IntTypes.uint 1) in
Lib.IntTypes.v (x &. u_is_odd) ==
(match Lib.IntTypes.v u17 % 2 = 0 with
| true -> 0
... | {
"end_col": 17,
"end_line": 62,
"start_col": 26,
"start_line": 53
} |
FStar.Pervasives.Lemma | val bn_mod_inv_limb_lemma: #t:limb_t -> #nLen:size_pos -> n:lbignum t nLen -> Lemma
(requires 1 < bn_v n /\ bn_v n % 2 = 1)
(ensures (let mu = mod_inv_limb (Lib.Sequence.index n 0) in
(1 + bn_v n * v mu) % pow2 (bits t) == 0)) | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abb... | false | let bn_mod_inv_limb_lemma #t #nLen n =
let n0 = Lib.Sequence.index n 0 in
let mu = mod_inv_limb n0 in
bn_eval_index n 0;
assert (bn_v n % pow2 (bits t) == v n0);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v n) 2 (bits t);
assert (v n0 % 2 = 1); // since bn_v n % 2 = 1
mod_inv_limb_lemma n0;
assert ((1 +... | val bn_mod_inv_limb_lemma: #t:limb_t -> #nLen:size_pos -> n:lbignum t nLen -> Lemma
(requires 1 < bn_v n /\ bn_v n % 2 = 1)
(ensures (let mu = mod_inv_limb (Lib.Sequence.index n 0) in
(1 + bn_v n * v mu) % pow2 (bits t) == 0))
let bn_mod_inv_limb_lemma #t #nLen n = | false | null | true | let n0 = Lib.Sequence.index n 0 in
let mu = mod_inv_limb n0 in
bn_eval_index n 0;
assert (bn_v n % pow2 (bits t) == v n0);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v n) 2 (bits t);
assert (v n0 % 2 = 1);
mod_inv_limb_lemma n0;
assert ((1 + (bn_v n % pow2 (bits t)) * v mu) % pow2 (bits t) == 0);
M.mont_preconditions_n... | {
"checked_file": "Hacl.Spec.Bignum.ModInvLimb.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.... | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Montgomery.Lemmas.mont_preconditions_n0",
"Lib.IntTypes.bits",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Prims.unit",
"Prims._assert",
"Prims.eq2",... | [] | module Hacl.Spec.Bignum.ModInvLimb
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
module M = Hacl.Spec.Montgomery.Lemmas
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
the modular inverse function was taken from
https://github.com/google/boringssl/blob/master/cry... | false | false | Hacl.Spec.Bignum.ModInvLimb.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bn_mod_inv_limb_lemma: #t:limb_t -> #nLen:size_pos -> n:lbignum t nLen -> Lemma
(requires 1 < bn_v n /\ bn_v n % 2 = 1)
(ensures (let mu = mod_inv_limb (Lib.Sequence.index n 0) in
(1 + bn_v n * v mu) % pow2 (bits t) == 0)) | [] | Hacl.Spec.Bignum.ModInvLimb.bn_mod_inv_limb_lemma | {
"file_name": "code/bignum/Hacl.Spec.Bignum.ModInvLimb.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | n: Hacl.Spec.Bignum.Definitions.lbignum t nLen
-> FStar.Pervasives.Lemma
(requires
1 < Hacl.Spec.Bignum.Definitions.bn_v n /\ Hacl.Spec.Bignum.Definitions.bn_v n % 2 = 1)
(ensures
(let mu = Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb (Lib.Sequence.index n 0) in
(1 + Hacl.Spec.Bignum... | {
"end_col": 50,
"end_line": 275,
"start_col": 38,
"start_line": 266
} |
FStar.Pervasives.Lemma | val mod_inv_limb_inv_step:
#t:limb_t -> n0:limb t
-> i:pos{i <= bits t} -> ub0:limb t -> vb0:limb t -> Lemma
(requires
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
v n0 % 2 = 1 /\ pow2 (bits t - i + 1) == v ub0 * 2 * v alpha - v vb0 * v beta))
(ensures
(let alpha = uint #t #... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abb... | false | let mod_inv_limb_inv_step #t n0 i ub0 vb0 =
let pbits = bits t in
let alpha = uint #t #SEC 1 <<. size (bits t - 1) in
let beta = n0 in
let u_is_odd = uint #t 0 -. (ub0 &. uint #t 1) in
let beta_if_u_is_odd = beta &. u_is_odd in
let ub = ((ub0 ^. beta_if_u_is_odd) >>. 1ul) +. (ub0 &. beta_if_u_is_odd) in
... | val mod_inv_limb_inv_step:
#t:limb_t -> n0:limb t
-> i:pos{i <= bits t} -> ub0:limb t -> vb0:limb t -> Lemma
(requires
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
v n0 % 2 = 1 /\ pow2 (bits t - i + 1) == v ub0 * 2 * v alpha - v vb0 * v beta))
(ensures
(let alpha = uint #t #... | false | null | true | let pbits = bits t in
let alpha = uint #t #SEC 1 <<. size (bits t - 1) in
let beta = n0 in
let u_is_odd = uint #t 0 -. (ub0 &. uint #t 1) in
let beta_if_u_is_odd = beta &. u_is_odd in
let ub = ((ub0 ^. beta_if_u_is_odd) >>. 1ul) +. (ub0 &. beta_if_u_is_odd) in
let alpha_if_u_is_odd = alpha &. u_is_odd in
let vb = (vb0 ... | {
"checked_file": "Hacl.Spec.Bignum.ModInvLimb.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.... | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.bits",
"FStar.Math.Lemmas.pow2_minus",
"Prims.op_Addition",
"Prims.op_Subtraction",
"Prims.unit",
"FStar.Math.Lemmas.cancel_mul_div",
"FStar.Mul.op_St... | [] | module Hacl.Spec.Bignum.ModInvLimb
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
module M = Hacl.Spec.Montgomery.Lemmas
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
the modular inverse function was taken from
https://github.com/google/boringssl/blob/master/cry... | false | false | Hacl.Spec.Bignum.ModInvLimb.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val mod_inv_limb_inv_step:
#t:limb_t -> n0:limb t
-> i:pos{i <= bits t} -> ub0:limb t -> vb0:limb t -> Lemma
(requires
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
v n0 % 2 = 1 /\ pow2 (bits t - i + 1) == v ub0 * 2 * v alpha - v vb0 * v beta))
(ensures
(let alpha = uint #t #... | [] | Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb_inv_step | {
"file_name": "code/bignum/Hacl.Spec.Bignum.ModInvLimb.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
n0: Hacl.Spec.Bignum.Definitions.limb t ->
i: Prims.pos{i <= Lib.IntTypes.bits t} ->
ub0: Hacl.Spec.Bignum.Definitions.limb t ->
vb0: Hacl.Spec.Bignum.Definitions.limb t
-> FStar.Pervasives.Lemma
(requires
(let alpha = Lib.IntTypes.uint 1 <<. Lib.IntTypes.size (Lib.IntTypes.bits t - 1) ... | {
"end_col": 42,
"end_line": 221,
"start_col": 43,
"start_line": 192
} |
FStar.Pervasives.Lemma | val mod_inv_limb_inv: #t:limb_t -> n0:limb t -> i:nat{i <= bits t} -> Lemma
(requires v n0 % 2 = 1)
(ensures
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in
let beta = n0 in
let (ub, vb) = repeat_gen i (mod_inv_limb_t t) (mod_inv_limb_f alpha beta) (uint #t 1, uint #t 0) in
pow2 (bits t - i) == ... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abb... | false | let rec mod_inv_limb_inv #t n0 i =
let alpha = uint #t #SEC 1 <<. size (bits t - 1) in
let beta = n0 in
let (ub, vb) = repeat_gen i (mod_inv_limb_t t) (mod_inv_limb_f alpha beta) (uint #t 1, uint #t 0) in
if i = 0 then
eq_repeat_gen0 i (mod_inv_limb_t t) (mod_inv_limb_f alpha beta) (uint #t 1, uint #t 0)
... | val mod_inv_limb_inv: #t:limb_t -> n0:limb t -> i:nat{i <= bits t} -> Lemma
(requires v n0 % 2 = 1)
(ensures
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in
let beta = n0 in
let (ub, vb) = repeat_gen i (mod_inv_limb_t t) (mod_inv_limb_f alpha beta) (uint #t 1, uint #t 0) in
pow2 (bits t - i) == ... | false | null | true | let alpha = uint #t #SEC 1 <<. size (bits t - 1) in
let beta = n0 in
let ub, vb = repeat_gen i (mod_inv_limb_t t) (mod_inv_limb_f alpha beta) (uint #t 1, uint #t 0) in
if i = 0
then eq_repeat_gen0 i (mod_inv_limb_t t) (mod_inv_limb_f alpha beta) (uint #t 1, uint #t 0)
else
let ub0, vb0 =
repeat_gen (i - 1) (mod_i... | {
"checked_file": "Hacl.Spec.Bignum.ModInvLimb.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.... | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.bits",
"Prims.op_Equality",
"Prims.int",
"Lib.LoopCombinators.eq_repeat_gen0",
"Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb_t",
"Hacl.Spec.Bignum.ModInvLim... | [] | module Hacl.Spec.Bignum.ModInvLimb
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
module M = Hacl.Spec.Montgomery.Lemmas
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
the modular inverse function was taken from
https://github.com/google/boringssl/blob/master/cry... | false | false | Hacl.Spec.Bignum.ModInvLimb.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val mod_inv_limb_inv: #t:limb_t -> n0:limb t -> i:nat{i <= bits t} -> Lemma
(requires v n0 % 2 = 1)
(ensures
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in
let beta = n0 in
let (ub, vb) = repeat_gen i (mod_inv_limb_t t) (mod_inv_limb_f alpha beta) (uint #t 1, uint #t 0) in
pow2 (bits t - i) == ... | [
"recursion"
] | Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb_inv | {
"file_name": "code/bignum/Hacl.Spec.Bignum.ModInvLimb.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | n0: Hacl.Spec.Bignum.Definitions.limb t -> i: Prims.nat{i <= Lib.IntTypes.bits t}
-> FStar.Pervasives.Lemma (requires Lib.IntTypes.v n0 % 2 = 1)
(ensures
(let alpha = Lib.IntTypes.uint 1 <<. Lib.IntTypes.size (Lib.IntTypes.bits t - 1) in
let beta = n0 in
let _ =
Lib.LoopC... | {
"end_col": 10,
"end_line": 245,
"start_col": 34,
"start_line": 232
} |
FStar.Pervasives.Lemma | val mod_inv_limb_inv_step_even:
#t:limb_t -> n0:limb t
-> i:pos{i <= bits t} -> ub0:limb t -> vb0:limb t -> Lemma
(requires
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
v n0 % 2 = 1 /\ v ub0 % 2 = 0 /\
pow2 (bits t - i + 1) == v ub0 * 2 * v alpha - v vb0 * v beta))
(ensures... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abb... | false | let mod_inv_limb_inv_step_even #t n0 i ub0 vb0 =
let pbits = bits t in
let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
let ub = v ub0 / 2 % pow2 pbits in
let vb = v vb0 / 2 % pow2 pbits in
Math.Lemmas.small_mod (v ub0 / 2) (pow2 pbits);
Math.Lemmas.small_mod (v vb0 / 2) (pow2 pbits);
... | val mod_inv_limb_inv_step_even:
#t:limb_t -> n0:limb t
-> i:pos{i <= bits t} -> ub0:limb t -> vb0:limb t -> Lemma
(requires
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
v n0 % 2 = 1 /\ v ub0 % 2 = 0 /\
pow2 (bits t - i + 1) == v ub0 * 2 * v alpha - v vb0 * v beta))
(ensures... | false | null | true | let pbits = bits t in
let alpha = uint #t #SEC 1 <<. size (bits t - 1) in
let beta = n0 in
let ub = v ub0 / 2 % pow2 pbits in
let vb = v vb0 / 2 % pow2 pbits in
Math.Lemmas.small_mod (v ub0 / 2) (pow2 pbits);
Math.Lemmas.small_mod (v vb0 / 2) (pow2 pbits);
assert ((ub * 2) * v alpha - vb * v beta == ((v ub0 / 2) * 2) *... | {
"checked_file": "Hacl.Spec.Bignum.ModInvLimb.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.... | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.bits",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"FStar.Mul.op_Star",
"Prims.op_Subtraction",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Prims.pow2",... | [] | module Hacl.Spec.Bignum.ModInvLimb
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
module M = Hacl.Spec.Montgomery.Lemmas
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
the modular inverse function was taken from
https://github.com/google/boringssl/blob/master/cry... | false | false | Hacl.Spec.Bignum.ModInvLimb.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val mod_inv_limb_inv_step_even:
#t:limb_t -> n0:limb t
-> i:pos{i <= bits t} -> ub0:limb t -> vb0:limb t -> Lemma
(requires
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
v n0 % 2 = 1 /\ v ub0 % 2 = 0 /\
pow2 (bits t - i + 1) == v ub0 * 2 * v alpha - v vb0 * v beta))
(ensures... | [] | Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb_inv_step_even | {
"file_name": "code/bignum/Hacl.Spec.Bignum.ModInvLimb.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
n0: Hacl.Spec.Bignum.Definitions.limb t ->
i: Prims.pos{i <= Lib.IntTypes.bits t} ->
ub0: Hacl.Spec.Bignum.Definitions.limb t ->
vb0: Hacl.Spec.Bignum.Definitions.limb t
-> FStar.Pervasives.Lemma
(requires
(let alpha = Lib.IntTypes.uint 1 <<. Lib.IntTypes.size (Lib.IntTypes.bits t - 1) ... | {
"end_col": 71,
"end_line": 125,
"start_col": 48,
"start_line": 103
} |
FStar.Pervasives.Lemma | val mod_inv_limb_inv_vb_is_even:
#t:limb_t -> n0:limb t
-> i:pos{i <= bits t} -> ub0:limb t -> vb0:limb t -> Lemma
(requires
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
v n0 % 2 = 1 /\ pow2 (bits t - i + 1) == v ub0 * 2 * v alpha - v vb0 * v beta))
(ensures v vb0 % 2 = 0) | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abb... | false | let mod_inv_limb_inv_vb_is_even #t n0 i ub0 vb0 =
let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
Math.Lemmas.pow2_multiplication_modulo_lemma_1 1 1 (bits t - i + 1);
assert (pow2 (bits t - i + 1) % 2 == 0);
calc (==) {
pow2 (bits t - i + 1) % 2;
(==) { }
(v ub0 * 2 * v alpha - ... | val mod_inv_limb_inv_vb_is_even:
#t:limb_t -> n0:limb t
-> i:pos{i <= bits t} -> ub0:limb t -> vb0:limb t -> Lemma
(requires
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
v n0 % 2 = 1 /\ pow2 (bits t - i + 1) == v ub0 * 2 * v alpha - v vb0 * v beta))
(ensures v vb0 % 2 = 0)
let ... | false | null | true | let alpha = uint #t #SEC 1 <<. size (bits t - 1) in
let beta = n0 in
Math.Lemmas.pow2_multiplication_modulo_lemma_1 1 1 (bits t - i + 1);
assert (pow2 (bits t - i + 1) % 2 == 0);
calc ( == ) {
pow2 (bits t - i + 1) % 2;
( == ) { () }
((v ub0 * 2) * v alpha - v vb0 * v beta) % 2;
( == ) { Math.Lemmas.lemma_mod_p... | {
"checked_file": "Hacl.Spec.Bignum.ModInvLimb.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.... | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.bits",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Modulus",
"Prims.pow2",
"Prims.op_Addition",
"Prims.op_Subtraction",
"Lib.Int... | [] | module Hacl.Spec.Bignum.ModInvLimb
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
module M = Hacl.Spec.Montgomery.Lemmas
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
the modular inverse function was taken from
https://github.com/google/boringssl/blob/master/cry... | false | false | Hacl.Spec.Bignum.ModInvLimb.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val mod_inv_limb_inv_vb_is_even:
#t:limb_t -> n0:limb t
-> i:pos{i <= bits t} -> ub0:limb t -> vb0:limb t -> Lemma
(requires
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
v n0 % 2 = 1 /\ pow2 (bits t - i + 1) == v ub0 * 2 * v alpha - v vb0 * v beta))
(ensures v vb0 % 2 = 0) | [] | Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb_inv_vb_is_even | {
"file_name": "code/bignum/Hacl.Spec.Bignum.ModInvLimb.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
n0: Hacl.Spec.Bignum.Definitions.limb t ->
i: Prims.pos{i <= Lib.IntTypes.bits t} ->
ub0: Hacl.Spec.Bignum.Definitions.limb t ->
vb0: Hacl.Spec.Bignum.Definitions.limb t
-> FStar.Pervasives.Lemma
(requires
(let alpha = Lib.IntTypes.uint 1 <<. Lib.IntTypes.size (Lib.IntTypes.bits t - 1) ... | {
"end_col": 5,
"end_line": 87,
"start_col": 49,
"start_line": 73
} |
FStar.Pervasives.Lemma | val mod_inv_limb_lemma: #t:limb_t -> n0:limb t -> Lemma
(requires v n0 % 2 == 1)
(ensures (1 + v n0 * v (mod_inv_limb n0)) % pow2 (bits t) == 0) | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abb... | false | let mod_inv_limb_lemma #t n0 =
let pbits = bits t in
let alpha = uint #t #SEC 1 <<. size (bits t - 1) in
let beta = n0 in
let (ub, vb) = repeat_gen pbits (mod_inv_limb_t t) (mod_inv_limb_f alpha beta) (uint #t 1, uint #t 0) in
mod_inv_limb_inv n0 pbits;
calc (==) {
(1 + v vb * v n0) % pow2 pbits;
(=... | val mod_inv_limb_lemma: #t:limb_t -> n0:limb t -> Lemma
(requires v n0 % 2 == 1)
(ensures (1 + v n0 * v (mod_inv_limb n0)) % pow2 (bits t) == 0)
let mod_inv_limb_lemma #t n0 = | false | null | true | let pbits = bits t in
let alpha = uint #t #SEC 1 <<. size (bits t - 1) in
let beta = n0 in
let ub, vb =
repeat_gen pbits (mod_inv_limb_t t) (mod_inv_limb_f alpha beta) (uint #t 1, uint #t 0)
in
mod_inv_limb_inv n0 pbits;
calc ( == ) {
(1 + v vb * v n0) % pow2 pbits;
( == ) { () }
((v ub * 2) * v alpha) % pow2 p... | {
"checked_file": "Hacl.Spec.Bignum.ModInvLimb.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.... | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Prims.pow2",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.Cons",
"... | [] | module Hacl.Spec.Bignum.ModInvLimb
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
module M = Hacl.Spec.Montgomery.Lemmas
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
the modular inverse function was taken from
https://github.com/google/boringssl/blob/master/cry... | false | false | Hacl.Spec.Bignum.ModInvLimb.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val mod_inv_limb_lemma: #t:limb_t -> n0:limb t -> Lemma
(requires v n0 % 2 == 1)
(ensures (1 + v n0 * v (mod_inv_limb n0)) % pow2 (bits t) == 0) | [] | Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb_lemma | {
"file_name": "code/bignum/Hacl.Spec.Bignum.ModInvLimb.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | n0: Hacl.Spec.Bignum.Definitions.limb t
-> FStar.Pervasives.Lemma (requires Lib.IntTypes.v n0 % 2 == 1)
(ensures
(1 + Lib.IntTypes.v n0 * Lib.IntTypes.v (Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb n0)) %
Prims.pow2 (Lib.IntTypes.bits t) ==
0) | {
"end_col": 46,
"end_line": 263,
"start_col": 30,
"start_line": 248
} |
FStar.Pervasives.Lemma | val mod_inv_limb_inv_step_odd:
#t:limb_t -> n0:limb t
-> i:pos{i <= bits t} -> ub0:limb t -> vb0:limb t -> Lemma
(requires
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
v n0 % 2 = 1 /\ v ub0 % 2 = 1 /\
pow2 (bits t - i + 1) == v ub0 * 2 * v alpha - v vb0 * v beta))
(ensures
... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abb... | false | let mod_inv_limb_inv_step_odd #t n0 i ub0 vb0 =
let pbits = bits t in
let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
let ub = (v ub0 + v beta) / 2 % pow2 pbits in
let vb = (v vb0 / 2 + v alpha) % pow2 pbits in
calc (==) {
2 * (ub * 2 * v alpha - vb * v beta);
(==) { Math.Lemmas.... | val mod_inv_limb_inv_step_odd:
#t:limb_t -> n0:limb t
-> i:pos{i <= bits t} -> ub0:limb t -> vb0:limb t -> Lemma
(requires
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
v n0 % 2 = 1 /\ v ub0 % 2 = 1 /\
pow2 (bits t - i + 1) == v ub0 * 2 * v alpha - v vb0 * v beta))
(ensures
... | false | null | true | let pbits = bits t in
let alpha = uint #t #SEC 1 <<. size (bits t - 1) in
let beta = n0 in
let ub = (v ub0 + v beta) / 2 % pow2 pbits in
let vb = (v vb0 / 2 + v alpha) % pow2 pbits in
calc ( == ) {
2 * ((ub * 2) * v alpha - vb * v beta);
( == ) { Math.Lemmas.small_mod ((v ub0 + v beta) / 2) (pow2 pbits) }
2 * (((... | {
"checked_file": "Hacl.Spec.Bignum.ModInvLimb.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.... | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.bits",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"FStar.Mul.op_Star",
"Prims.op_Subtraction",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Prims.pow2",... | [] | module Hacl.Spec.Bignum.ModInvLimb
open FStar.Mul
open Lib.IntTypes
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
module M = Hacl.Spec.Montgomery.Lemmas
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
the modular inverse function was taken from
https://github.com/google/boringssl/blob/master/cry... | false | false | Hacl.Spec.Bignum.ModInvLimb.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val mod_inv_limb_inv_step_odd:
#t:limb_t -> n0:limb t
-> i:pos{i <= bits t} -> ub0:limb t -> vb0:limb t -> Lemma
(requires
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
v n0 % 2 = 1 /\ v ub0 % 2 = 1 /\
pow2 (bits t - i + 1) == v ub0 * 2 * v alpha - v vb0 * v beta))
(ensures
... | [] | Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb_inv_step_odd | {
"file_name": "code/bignum/Hacl.Spec.Bignum.ModInvLimb.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
n0: Hacl.Spec.Bignum.Definitions.limb t ->
i: Prims.pos{i <= Lib.IntTypes.bits t} ->
ub0: Hacl.Spec.Bignum.Definitions.limb t ->
vb0: Hacl.Spec.Bignum.Definitions.limb t
-> FStar.Pervasives.Lemma
(requires
(let alpha = Lib.IntTypes.uint 1 <<. Lib.IntTypes.size (Lib.IntTypes.bits t - 1) ... | {
"end_col": 71,
"end_line": 177,
"start_col": 47,
"start_line": 142
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.Chacha20",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let state = lbuffer uint32 16ul | let state = | false | null | false | lbuffer uint32 16ul | {
"checked_file": "Hacl.Impl.Chacha20.Core32.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"FStar.U... | [
"total"
] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint32",
"FStar.UInt32.__uint_to_t"
] | [] | module Hacl.Impl.Chacha20.Core32
open FStar.HyperStack
open FStar.HyperStack.All
open Lib.IntTypes
open Lib.Sequence
open Lib.Buffer
open Lib.ByteBuffer
module ST = FStar.HyperStack.ST
module Spec = Spec.Chacha20 | false | true | Hacl.Impl.Chacha20.Core32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val state : Type0 | [] | Hacl.Impl.Chacha20.Core32.state | {
"file_name": "code/chacha20/Hacl.Impl.Chacha20.Core32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 31,
"end_line": 15,
"start_col": 12,
"start_line": 15
} | |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.Chacha20",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let index = i:size_t{size_v i < 16} | let index = | false | null | false | i: size_t{size_v i < 16} | {
"checked_file": "Hacl.Impl.Chacha20.Core32.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"FStar.U... | [
"total"
] | [
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.size_v"
] | [] | module Hacl.Impl.Chacha20.Core32
open FStar.HyperStack
open FStar.HyperStack.All
open Lib.IntTypes
open Lib.Sequence
open Lib.Buffer
open Lib.ByteBuffer
module ST = FStar.HyperStack.ST
module Spec = Spec.Chacha20 | false | true | Hacl.Impl.Chacha20.Core32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val index : Type0 | [] | Hacl.Impl.Chacha20.Core32.index | {
"file_name": "code/chacha20/Hacl.Impl.Chacha20.Core32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 35,
"end_line": 16,
"start_col": 12,
"start_line": 16
} | |
FStar.HyperStack.ST.Stack | val incr_counter:
st:state ->
Stack unit
(requires fun h -> live h st)
(ensures fun h0 _ h1 -> modifies (loc st) h0 h1) | [
{
"abbrev": true,
"full_module": "Spec.Chacha20",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let incr_counter st =
let c = st.(size 12) in
st.(size 12) <- c +. u32 1 | val incr_counter:
st:state ->
Stack unit
(requires fun h -> live h st)
(ensures fun h0 _ h1 -> modifies (loc st) h0 h1)
let incr_counter st = | true | null | false | let c = st.(size 12) in
st.(size 12) <- c +. u32 1 | {
"checked_file": "Hacl.Impl.Chacha20.Core32.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"FStar.U... | [] | [
"Hacl.Impl.Chacha20.Core32.state",
"Lib.Buffer.op_Array_Assignment",
"Lib.IntTypes.uint32",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.size",
"Lib.IntTypes.op_Plus_Dot",
"Lib.IntTypes.U32",
"Lib.IntTypes.SEC",
"Lib.IntTypes.u32",
"Prims.unit",
"Lib.IntTypes.int_t",
"Lib.Buffer.op_Array_Access",... | [] | module Hacl.Impl.Chacha20.Core32
open FStar.HyperStack
open FStar.HyperStack.All
open Lib.IntTypes
open Lib.Sequence
open Lib.Buffer
open Lib.ByteBuffer
module ST = FStar.HyperStack.ST
module Spec = Spec.Chacha20
let state = lbuffer uint32 16ul
let index = i:size_t{size_v i < 16}
inline_for_extraction
val create... | false | false | Hacl.Impl.Chacha20.Core32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val incr_counter:
st:state ->
Stack unit
(requires fun h -> live h st)
(ensures fun h0 _ h1 -> modifies (loc st) h0 h1) | [] | Hacl.Impl.Chacha20.Core32.incr_counter | {
"file_name": "code/chacha20/Hacl.Impl.Chacha20.Core32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | st: Hacl.Impl.Chacha20.Core32.state -> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 28,
"end_line": 78,
"start_col": 21,
"start_line": 76
} |
FStar.HyperStack.ST.Stack | val copy_state:
st:state
-> ost:state ->
Stack unit
(requires fun h -> live h st /\ live h ost /\ disjoint st ost)
(ensures fun h0 _ h1 -> modifies (loc st) h0 h1 /\
as_seq h1 st == as_seq h0 ost) | [
{
"abbrev": true,
"full_module": "Spec.Chacha20",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let copy_state st ost = copy #MUT #uint32 #(size 16) st ost | val copy_state:
st:state
-> ost:state ->
Stack unit
(requires fun h -> live h st /\ live h ost /\ disjoint st ost)
(ensures fun h0 _ h1 -> modifies (loc st) h0 h1 /\
as_seq h1 st == as_seq h0 ost)
let copy_state st ost = | true | null | false | copy #MUT #uint32 #(size 16) st ost | {
"checked_file": "Hacl.Impl.Chacha20.Core32.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"FStar.U... | [] | [
"Hacl.Impl.Chacha20.Core32.state",
"Lib.Buffer.copy",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint32",
"Lib.IntTypes.size",
"Prims.unit"
] | [] | module Hacl.Impl.Chacha20.Core32
open FStar.HyperStack
open FStar.HyperStack.All
open Lib.IntTypes
open Lib.Sequence
open Lib.Buffer
open Lib.ByteBuffer
module ST = FStar.HyperStack.ST
module Spec = Spec.Chacha20
let state = lbuffer uint32 16ul
let index = i:size_t{size_v i < 16}
inline_for_extraction
val create... | false | false | Hacl.Impl.Chacha20.Core32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val copy_state:
st:state
-> ost:state ->
Stack unit
(requires fun h -> live h st /\ live h ost /\ disjoint st ost)
(ensures fun h0 _ h1 -> modifies (loc st) h0 h1 /\
as_seq h1 st == as_seq h0 ost) | [] | Hacl.Impl.Chacha20.Core32.copy_state | {
"file_name": "code/chacha20/Hacl.Impl.Chacha20.Core32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | st: Hacl.Impl.Chacha20.Core32.state -> ost: Hacl.Impl.Chacha20.Core32.state
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 59,
"end_line": 90,
"start_col": 24,
"start_line": 90
} |
FStar.HyperStack.ST.Stack | val sum_state:
st:state
-> ost:state ->
Stack unit
(requires fun h -> live h st /\ live h ost /\ eq_or_disjoint st ost)
(ensures fun h0 _ h1 -> modifies (loc st) h0 h1 /\
as_seq h1 st == Spec.sum_state (as_seq h0 st) (as_seq h0 ost)) | [
{
"abbrev": true,
"full_module": "Spec.Chacha20",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let sum_state st ost = map2T #MUT #MUT #uint32 #uint32 #uint32 (size 16) st ( +. ) st ost | val sum_state:
st:state
-> ost:state ->
Stack unit
(requires fun h -> live h st /\ live h ost /\ eq_or_disjoint st ost)
(ensures fun h0 _ h1 -> modifies (loc st) h0 h1 /\
as_seq h1 st == Spec.sum_state (as_seq h0 st) (as_seq h0 ost))
let sum_state st ost = | true | null | false | map2T #MUT #MUT #uint32 #uint32 #uint32 (size 16) st ( +. ) st ost | {
"checked_file": "Hacl.Impl.Chacha20.Core32.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"FStar.U... | [] | [
"Hacl.Impl.Chacha20.Core32.state",
"Lib.Buffer.map2T",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint32",
"Lib.IntTypes.size",
"Lib.IntTypes.op_Plus_Dot",
"Lib.IntTypes.U32",
"Lib.IntTypes.SEC",
"Prims.unit"
] | [] | module Hacl.Impl.Chacha20.Core32
open FStar.HyperStack
open FStar.HyperStack.All
open Lib.IntTypes
open Lib.Sequence
open Lib.Buffer
open Lib.ByteBuffer
module ST = FStar.HyperStack.ST
module Spec = Spec.Chacha20
let state = lbuffer uint32 16ul
let index = i:size_t{size_v i < 16}
inline_for_extraction
val create... | false | false | Hacl.Impl.Chacha20.Core32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val sum_state:
st:state
-> ost:state ->
Stack unit
(requires fun h -> live h st /\ live h ost /\ eq_or_disjoint st ost)
(ensures fun h0 _ h1 -> modifies (loc st) h0 h1 /\
as_seq h1 st == Spec.sum_state (as_seq h0 st) (as_seq h0 ost)) | [] | Hacl.Impl.Chacha20.Core32.sum_state | {
"file_name": "code/chacha20/Hacl.Impl.Chacha20.Core32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | st: Hacl.Impl.Chacha20.Core32.state -> ost: Hacl.Impl.Chacha20.Core32.state
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 90,
"end_line": 102,
"start_col": 24,
"start_line": 102
} |
FStar.HyperStack.ST.StackInline | val create_state: unit ->
StackInline state
(requires fun h -> True)
(ensures fun h0 r h1 -> live h1 r /\
as_seq h1 r == Seq.create 16 (u32 0) /\
stack_allocated r h0 h1 (Seq.create 16 (u32 0))) | [
{
"abbrev": true,
"full_module": "Spec.Chacha20",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let create_state () = create (size 16) (u32 0) | val create_state: unit ->
StackInline state
(requires fun h -> True)
(ensures fun h0 r h1 -> live h1 r /\
as_seq h1 r == Seq.create 16 (u32 0) /\
stack_allocated r h0 h1 (Seq.create 16 (u32 0)))
let create_state () = | true | null | false | create (size 16) (u32 0) | {
"checked_file": "Hacl.Impl.Chacha20.Core32.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"FStar.U... | [] | [
"Prims.unit",
"Lib.Buffer.create",
"Lib.IntTypes.uint32",
"Lib.IntTypes.size",
"Lib.IntTypes.u32",
"Lib.Buffer.lbuffer",
"Hacl.Impl.Chacha20.Core32.state"
] | [] | module Hacl.Impl.Chacha20.Core32
open FStar.HyperStack
open FStar.HyperStack.All
open Lib.IntTypes
open Lib.Sequence
open Lib.Buffer
open Lib.ByteBuffer
module ST = FStar.HyperStack.ST
module Spec = Spec.Chacha20
let state = lbuffer uint32 16ul
let index = i:size_t{size_v i < 16}
inline_for_extraction
val create... | false | false | Hacl.Impl.Chacha20.Core32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val create_state: unit ->
StackInline state
(requires fun h -> True)
(ensures fun h0 r h1 -> live h1 r /\
as_seq h1 r == Seq.create 16 (u32 0) /\
stack_allocated r h0 h1 (Seq.create 16 (u32 0))) | [] | Hacl.Impl.Chacha20.Core32.create_state | {
"file_name": "code/chacha20/Hacl.Impl.Chacha20.Core32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.unit -> FStar.HyperStack.ST.StackInline Hacl.Impl.Chacha20.Core32.state | {
"end_col": 46,
"end_line": 27,
"start_col": 22,
"start_line": 27
} |
FStar.HyperStack.ST.Stack | val line:
st:state
-> a:index
-> b:index
-> d:index
-> r:rotval U32 ->
Stack unit
(requires fun h -> live h st /\ v a <> v d)
(ensures fun h0 _ h1 -> modifies (loc st) h0 h1 /\
as_seq h1 st == Spec.line (v a) (v b) (v d) r (as_seq h0 st)) | [
{
"abbrev": true,
"full_module": "Spec.Chacha20",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let line st a b d r =
let sta = st.(a) in
let stb = st.(b) in
let std = st.(d) in
let sta = sta +. stb in
let std = std ^. sta in
let std = rotate_left std r in
st.(a) <- sta;
st.(d) <- std | val line:
st:state
-> a:index
-> b:index
-> d:index
-> r:rotval U32 ->
Stack unit
(requires fun h -> live h st /\ v a <> v d)
(ensures fun h0 _ h1 -> modifies (loc st) h0 h1 /\
as_seq h1 st == Spec.line (v a) (v b) (v d) r (as_seq h0 st))
let line st a b d r = | true | null | false | let sta = st.(a) in
let stb = st.(b) in
let std = st.(d) in
let sta = sta +. stb in
let std = std ^. sta in
let std = rotate_left std r in
st.(a) <- sta;
st.(d) <- std | {
"checked_file": "Hacl.Impl.Chacha20.Core32.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"FStar.U... | [] | [
"Hacl.Impl.Chacha20.Core32.state",
"Hacl.Impl.Chacha20.Core32.index",
"Lib.IntTypes.rotval",
"Lib.IntTypes.U32",
"Lib.Buffer.op_Array_Assignment",
"Lib.IntTypes.uint32",
"FStar.UInt32.__uint_to_t",
"Prims.unit",
"Lib.IntTypes.int_t",
"Lib.IntTypes.SEC",
"Lib.IntTypes.rotate_left",
"Lib.IntType... | [] | module Hacl.Impl.Chacha20.Core32
open FStar.HyperStack
open FStar.HyperStack.All
open Lib.IntTypes
open Lib.Sequence
open Lib.Buffer
open Lib.ByteBuffer
module ST = FStar.HyperStack.ST
module Spec = Spec.Chacha20
let state = lbuffer uint32 16ul
let index = i:size_t{size_v i < 16}
inline_for_extraction
val create... | false | false | Hacl.Impl.Chacha20.Core32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val line:
st:state
-> a:index
-> b:index
-> d:index
-> r:rotval U32 ->
Stack unit
(requires fun h -> live h st /\ v a <> v d)
(ensures fun h0 _ h1 -> modifies (loc st) h0 h1 /\
as_seq h1 st == Spec.line (v a) (v b) (v d) r (as_seq h0 st)) | [] | Hacl.Impl.Chacha20.Core32.line | {
"file_name": "code/chacha20/Hacl.Impl.Chacha20.Core32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
st: Hacl.Impl.Chacha20.Core32.state ->
a: Hacl.Impl.Chacha20.Core32.index ->
b: Hacl.Impl.Chacha20.Core32.index ->
d: Hacl.Impl.Chacha20.Core32.index ->
r: Lib.IntTypes.rotval Lib.IntTypes.U32
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 15,
"end_line": 144,
"start_col": 21,
"start_line": 136
} |
FStar.HyperStack.ST.Stack | val load_state:
st:state
-> b:lbuffer uint8 64ul ->
Stack unit
(requires fun h -> live h st /\ live h b /\ disjoint st b)
(ensures fun h0 _ h1 -> modifies (loc st) h0 h1 /\
as_seq h1 st == Lib.ByteSequence.uints_from_bytes_le (as_seq h0 b)) | [
{
"abbrev": true,
"full_module": "Spec.Chacha20",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let load_state st b =
uints_from_bytes_le st b | val load_state:
st:state
-> b:lbuffer uint8 64ul ->
Stack unit
(requires fun h -> live h st /\ live h b /\ disjoint st b)
(ensures fun h0 _ h1 -> modifies (loc st) h0 h1 /\
as_seq h1 st == Lib.ByteSequence.uints_from_bytes_le (as_seq h0 b))
let load_state st b = | true | null | false | uints_from_bytes_le st b | {
"checked_file": "Hacl.Impl.Chacha20.Core32.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"FStar.U... | [] | [
"Hacl.Impl.Chacha20.Core32.state",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Lib.ByteBuffer.uints_from_bytes_le",
"Lib.IntTypes.U32",
"Lib.IntTypes.SEC",
"Prims.unit"
] | [] | module Hacl.Impl.Chacha20.Core32
open FStar.HyperStack
open FStar.HyperStack.All
open Lib.IntTypes
open Lib.Sequence
open Lib.Buffer
open Lib.ByteBuffer
module ST = FStar.HyperStack.ST
module Spec = Spec.Chacha20
let state = lbuffer uint32 16ul
let index = i:size_t{size_v i < 16}
inline_for_extraction
val create... | false | false | Hacl.Impl.Chacha20.Core32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val load_state:
st:state
-> b:lbuffer uint8 64ul ->
Stack unit
(requires fun h -> live h st /\ live h b /\ disjoint st b)
(ensures fun h0 _ h1 -> modifies (loc st) h0 h1 /\
as_seq h1 st == Lib.ByteSequence.uints_from_bytes_le (as_seq h0 b)) | [] | Hacl.Impl.Chacha20.Core32.load_state | {
"file_name": "code/chacha20/Hacl.Impl.Chacha20.Core32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | st: Hacl.Impl.Chacha20.Core32.state -> b: Lib.Buffer.lbuffer Lib.IntTypes.uint8 64ul
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 26,
"end_line": 40,
"start_col": 2,
"start_line": 40
} |
FStar.HyperStack.ST.Stack | val store_state:
b:lbuffer uint8 64ul
-> st:state ->
Stack unit
(requires fun h -> live h st /\ live h b /\ disjoint st b)
(ensures fun h0 _ h1 -> modifies (loc b) h0 h1 /\
as_seq h1 b == Lib.ByteSequence.uints_to_bytes_le (as_seq h0 st)) | [
{
"abbrev": true,
"full_module": "Spec.Chacha20",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let store_state st b =
uints_to_bytes_le 16ul st b | val store_state:
b:lbuffer uint8 64ul
-> st:state ->
Stack unit
(requires fun h -> live h st /\ live h b /\ disjoint st b)
(ensures fun h0 _ h1 -> modifies (loc b) h0 h1 /\
as_seq h1 b == Lib.ByteSequence.uints_to_bytes_le (as_seq h0 st))
let store_state st b = | true | null | false | uints_to_bytes_le 16ul st b | {
"checked_file": "Hacl.Impl.Chacha20.Core32.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"FStar.U... | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.Chacha20.Core32.state",
"Lib.ByteBuffer.uints_to_bytes_le",
"Lib.IntTypes.U32",
"Lib.IntTypes.SEC",
"Prims.unit"
] | [] | module Hacl.Impl.Chacha20.Core32
open FStar.HyperStack
open FStar.HyperStack.All
open Lib.IntTypes
open Lib.Sequence
open Lib.Buffer
open Lib.ByteBuffer
module ST = FStar.HyperStack.ST
module Spec = Spec.Chacha20
let state = lbuffer uint32 16ul
let index = i:size_t{size_v i < 16}
inline_for_extraction
val create... | false | false | Hacl.Impl.Chacha20.Core32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val store_state:
b:lbuffer uint8 64ul
-> st:state ->
Stack unit
(requires fun h -> live h st /\ live h b /\ disjoint st b)
(ensures fun h0 _ h1 -> modifies (loc b) h0 h1 /\
as_seq h1 b == Lib.ByteSequence.uints_to_bytes_le (as_seq h0 st)) | [] | Hacl.Impl.Chacha20.Core32.store_state | {
"file_name": "code/chacha20/Hacl.Impl.Chacha20.Core32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b: Lib.Buffer.lbuffer Lib.IntTypes.uint8 64ul -> st: Hacl.Impl.Chacha20.Core32.state
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 29,
"end_line": 53,
"start_col": 2,
"start_line": 53
} |
FStar.HyperStack.ST.Stack | val set_counter:
st:state
-> c:size_t ->
Stack unit
(requires fun h -> live h st)
(ensures fun h0 _ h1 -> modifies (loc st) h0 h1 /\
as_seq h1 st == Seq.upd (as_seq h0 st) 12 (size_to_uint32 c)) | [
{
"abbrev": true,
"full_module": "Spec.Chacha20",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let set_counter st c =
st.(size 12) <- size_to_uint32 c | val set_counter:
st:state
-> c:size_t ->
Stack unit
(requires fun h -> live h st)
(ensures fun h0 _ h1 -> modifies (loc st) h0 h1 /\
as_seq h1 st == Seq.upd (as_seq h0 st) 12 (size_to_uint32 c))
let set_counter st c = | true | null | false | st.(size 12) <- size_to_uint32 c | {
"checked_file": "Hacl.Impl.Chacha20.Core32.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"FStar.U... | [] | [
"Hacl.Impl.Chacha20.Core32.state",
"Lib.IntTypes.size_t",
"Lib.Buffer.op_Array_Assignment",
"Lib.IntTypes.uint32",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.size",
"Lib.IntTypes.size_to_uint32",
"Prims.unit"
] | [] | module Hacl.Impl.Chacha20.Core32
open FStar.HyperStack
open FStar.HyperStack.All
open Lib.IntTypes
open Lib.Sequence
open Lib.Buffer
open Lib.ByteBuffer
module ST = FStar.HyperStack.ST
module Spec = Spec.Chacha20
let state = lbuffer uint32 16ul
let index = i:size_t{size_v i < 16}
inline_for_extraction
val create... | false | false | Hacl.Impl.Chacha20.Core32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val set_counter:
st:state
-> c:size_t ->
Stack unit
(requires fun h -> live h st)
(ensures fun h0 _ h1 -> modifies (loc st) h0 h1 /\
as_seq h1 st == Seq.upd (as_seq h0 st) 12 (size_to_uint32 c)) | [] | Hacl.Impl.Chacha20.Core32.set_counter | {
"file_name": "code/chacha20/Hacl.Impl.Chacha20.Core32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | st: Hacl.Impl.Chacha20.Core32.state -> c: Lib.IntTypes.size_t
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 34,
"end_line": 66,
"start_col": 2,
"start_line": 66
} |
FStar.HyperStack.ST.Stack | val quarter_round:
st:state
-> a:index
-> b:index
-> c:index
-> d:index ->
Stack unit
(requires fun h -> live h st /\ v a <> v d /\ v c <> v b)
(ensures fun h0 _ h1 -> modifies (loc st) h0 h1 /\
as_seq h1 st == Spec.quarter_round (v a) (v b) (v c) (v d) (as_seq h0 st)) | [
{
"abbrev": true,
"full_module": "Spec.Chacha20",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let quarter_round st a b c d =
line st a b d (size 16);
line st c d b (size 12);
line st a b d (size 8);
line st c d b (size 7) | val quarter_round:
st:state
-> a:index
-> b:index
-> c:index
-> d:index ->
Stack unit
(requires fun h -> live h st /\ v a <> v d /\ v c <> v b)
(ensures fun h0 _ h1 -> modifies (loc st) h0 h1 /\
as_seq h1 st == Spec.quarter_round (v a) (v b) (v c) (v d) (as_seq h0 st))
let quarter_round st a b c ... | true | null | false | line st a b d (size 16);
line st c d b (size 12);
line st a b d (size 8);
line st c d b (size 7) | {
"checked_file": "Hacl.Impl.Chacha20.Core32.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"FStar.U... | [] | [
"Hacl.Impl.Chacha20.Core32.state",
"Hacl.Impl.Chacha20.Core32.index",
"Hacl.Impl.Chacha20.Core32.line",
"Lib.IntTypes.size",
"Prims.unit"
] | [] | module Hacl.Impl.Chacha20.Core32
open FStar.HyperStack
open FStar.HyperStack.All
open Lib.IntTypes
open Lib.Sequence
open Lib.Buffer
open Lib.ByteBuffer
module ST = FStar.HyperStack.ST
module Spec = Spec.Chacha20
let state = lbuffer uint32 16ul
let index = i:size_t{size_v i < 16}
inline_for_extraction
val create... | false | false | Hacl.Impl.Chacha20.Core32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val quarter_round:
st:state
-> a:index
-> b:index
-> c:index
-> d:index ->
Stack unit
(requires fun h -> live h st /\ v a <> v d /\ v c <> v b)
(ensures fun h0 _ h1 -> modifies (loc st) h0 h1 /\
as_seq h1 st == Spec.quarter_round (v a) (v b) (v c) (v d) (as_seq h0 st)) | [] | Hacl.Impl.Chacha20.Core32.quarter_round | {
"file_name": "code/chacha20/Hacl.Impl.Chacha20.Core32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
st: Hacl.Impl.Chacha20.Core32.state ->
a: Hacl.Impl.Chacha20.Core32.index ->
b: Hacl.Impl.Chacha20.Core32.index ->
c: Hacl.Impl.Chacha20.Core32.index ->
d: Hacl.Impl.Chacha20.Core32.index
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 24,
"end_line": 163,
"start_col": 2,
"start_line": 160
} |
FStar.HyperStack.ST.Stack | val xor_block:
o:lbuffer uint8 64ul
-> st:state
-> b:lbuffer uint8 64ul ->
Stack unit
(requires fun h -> live h o /\ live h st /\ live h b)
(ensures fun h0 _ h1 -> modifies (loc o) h0 h1 /\
as_seq h1 o == Spec.xor_block (as_seq h0 st) (as_seq h0 b)) | [
{
"abbrev": true,
"full_module": "Spec.Chacha20",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let xor_block o st b =
push_frame();
let bl = create_state() in
load_state bl b;
map2T (size 16) bl ( ^. ) bl st;
store_state o bl;
pop_frame() | val xor_block:
o:lbuffer uint8 64ul
-> st:state
-> b:lbuffer uint8 64ul ->
Stack unit
(requires fun h -> live h o /\ live h st /\ live h b)
(ensures fun h0 _ h1 -> modifies (loc o) h0 h1 /\
as_seq h1 o == Spec.xor_block (as_seq h0 st) (as_seq h0 b))
let xor_block o st b = | true | null | false | push_frame ();
let bl = create_state () in
load_state bl b;
map2T (size 16) bl ( ^. ) bl st;
store_state o bl;
pop_frame () | {
"checked_file": "Hacl.Impl.Chacha20.Core32.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"FStar.U... | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.Chacha20.Core32.state",
"FStar.HyperStack.ST.pop_frame",
"Prims.unit",
"Hacl.Impl.Chacha20.Core32.store_state",
"Lib.Buffer.map2T",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint32",
"Lib.IntTypes.size",
"Lib.IntTypes.op_... | [] | module Hacl.Impl.Chacha20.Core32
open FStar.HyperStack
open FStar.HyperStack.All
open Lib.IntTypes
open Lib.Sequence
open Lib.Buffer
open Lib.ByteBuffer
module ST = FStar.HyperStack.ST
module Spec = Spec.Chacha20
let state = lbuffer uint32 16ul
let index = i:size_t{size_v i < 16}
inline_for_extraction
val create... | false | false | Hacl.Impl.Chacha20.Core32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val xor_block:
o:lbuffer uint8 64ul
-> st:state
-> b:lbuffer uint8 64ul ->
Stack unit
(requires fun h -> live h o /\ live h st /\ live h b)
(ensures fun h0 _ h1 -> modifies (loc o) h0 h1 /\
as_seq h1 o == Spec.xor_block (as_seq h0 st) (as_seq h0 b)) | [] | Hacl.Impl.Chacha20.Core32.xor_block | {
"file_name": "code/chacha20/Hacl.Impl.Chacha20.Core32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
o: Lib.Buffer.lbuffer Lib.IntTypes.uint8 64ul ->
st: Hacl.Impl.Chacha20.Core32.state ->
b: Lib.Buffer.lbuffer Lib.IntTypes.uint8 64ul
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 13,
"end_line": 121,
"start_col": 2,
"start_line": 116
} |
FStar.HyperStack.ST.Stack | val double_round:
st:state ->
Stack unit
(requires fun h -> live h st)
(ensures fun h0 _ h1 -> modifies (loc st) h0 h1 /\
as_seq h1 st == Spec.double_round (as_seq h0 st)) | [
{
"abbrev": true,
"full_module": "Spec.Chacha20",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let double_round st =
quarter_round st (size 0) (size 4) (size 8) (size 12);
quarter_round st (size 1) (size 5) (size 9) (size 13);
quarter_round st (size 2) (size 6) (size 10) (size 14);
quarter_round st (size 3) (size 7) (size 11) (size 15);
quarter_round st (size 0) (size 5) (size 10) (size 15);
quarter... | val double_round:
st:state ->
Stack unit
(requires fun h -> live h st)
(ensures fun h0 _ h1 -> modifies (loc st) h0 h1 /\
as_seq h1 st == Spec.double_round (as_seq h0 st))
let double_round st = | true | null | false | quarter_round st (size 0) (size 4) (size 8) (size 12);
quarter_round st (size 1) (size 5) (size 9) (size 13);
quarter_round st (size 2) (size 6) (size 10) (size 14);
quarter_round st (size 3) (size 7) (size 11) (size 15);
quarter_round st (size 0) (size 5) (size 10) (size 15);
quarter_round st (size 1) (size 6) (size 1... | {
"checked_file": "Hacl.Impl.Chacha20.Core32.fst.checked",
"dependencies": [
"Spec.Chacha20.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"FStar.U... | [] | [
"Hacl.Impl.Chacha20.Core32.state",
"Hacl.Impl.Chacha20.Core32.quarter_round",
"Lib.IntTypes.size",
"Prims.unit"
] | [] | module Hacl.Impl.Chacha20.Core32
open FStar.HyperStack
open FStar.HyperStack.All
open Lib.IntTypes
open Lib.Sequence
open Lib.Buffer
open Lib.ByteBuffer
module ST = FStar.HyperStack.ST
module Spec = Spec.Chacha20
let state = lbuffer uint32 16ul
let index = i:size_t{size_v i < 16}
inline_for_extraction
val create... | false | false | Hacl.Impl.Chacha20.Core32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val double_round:
st:state ->
Stack unit
(requires fun h -> live h st)
(ensures fun h0 _ h1 -> modifies (loc st) h0 h1 /\
as_seq h1 st == Spec.double_round (as_seq h0 st)) | [] | Hacl.Impl.Chacha20.Core32.double_round | {
"file_name": "code/chacha20/Hacl.Impl.Chacha20.Core32.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | st: Hacl.Impl.Chacha20.Core32.state -> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 55,
"end_line": 185,
"start_col": 2,
"start_line": 177
} |
Prims.Tot | val va_quick_AES256EncryptBlock
(input: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
: (va_quickCode unit (va_code_AES256EncryptBlock ())) | [
{
"abbrev": false,
"full_module": "Vale.AES.AES256_helpers_BE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCodes",
"short_module": null
},
{
"abbrev": fa... | false | let va_quick_AES256EncryptBlock (input:quad32) (key:(seq nat32)) (round_keys:(seq quad32))
(keys_buffer:buffer128) : (va_quickCode unit (va_code_AES256EncryptBlock ())) =
(va_QProc (va_code_AES256EncryptBlock ()) ([va_Mod_vec 2; va_Mod_vec 0; va_Mod_reg 10])
(va_wp_AES256EncryptBlock input key round_keys keys_b... | val va_quick_AES256EncryptBlock
(input: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
: (va_quickCode unit (va_code_AES256EncryptBlock ()))
let va_quick_AES256EncryptBlock
(input: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(... | false | null | false | (va_QProc (va_code_AES256EncryptBlock ())
([va_Mod_vec 2; va_Mod_vec 0; va_Mod_reg 10])
(va_wp_AES256EncryptBlock input key round_keys keys_buffer)
(va_wpProof_AES256EncryptBlock input key round_keys keys_buffer)) | {
"checked_file": "Vale.AES.PPC64LE.AES256.fsti.checked",
"dependencies": [
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCodes.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsVector.fsti.... | [
"total"
] | [
"Vale.PPC64LE.Memory.quad32",
"FStar.Seq.Base.seq",
"Vale.PPC64LE.Memory.nat32",
"Vale.PPC64LE.Memory.buffer128",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.AES.PPC64LE.AES256.va_code_AES256EncryptBlock",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_Mod_vec"... | [] | module Vale.AES.PPC64LE.AES256
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_BE_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.Memory
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.InsVector
open Vale.PPC64LE.QuickCo... | false | false | Vale.AES.PPC64LE.AES256.fsti | {
"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_el... | null | val va_quick_AES256EncryptBlock
(input: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
: (va_quickCode unit (va_code_AES256EncryptBlock ())) | [] | Vale.AES.PPC64LE.AES256.va_quick_AES256EncryptBlock | {
"file_name": "obj/Vale.AES.PPC64LE.AES256.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
input: Vale.PPC64LE.Memory.quad32 ->
key: FStar.Seq.Base.seq Vale.PPC64LE.Memory.nat32 ->
round_keys: FStar.Seq.Base.seq Vale.PPC64LE.Memory.quad32 ->
keys_buffer: Vale.PPC64LE.Memory.buffer128
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.AES.PPC64LE.AES256.va_code_AES256EncryptBlock... | {
"end_col": 38,
"end_line": 158,
"start_col": 2,
"start_line": 156
} |
Prims.Tot | val va_wp_AES256EncryptBlock
(input: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"abbrev": false,
"full_module": "Vale.AES.AES256_helpers_BE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCodes",
"short_module": null
},
{
"abbrev": fa... | false | let va_wp_AES256EncryptBlock (input:quad32) (key:(seq nat32)) (round_keys:(seq quad32))
(keys_buffer:buffer128) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.AES.AES_BE_s.is_aes_key_word AES_256 key /\ FStar.Seq.Base.length
#quad32 round_keys == 15 /\ round_keys == Vale.... | val va_wp_AES256EncryptBlock
(input: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_AES256EncryptBlock
(input: quad32)
(key: (seq nat32))
(round_keys: (seq qu... | false | null | false | (va_get_ok va_s0 /\ Vale.AES.AES_BE_s.is_aes_key_word AES_256 key /\
FStar.Seq.Base.length #quad32 round_keys == 15 /\
round_keys == Vale.AES.AES_BE_s.key_to_round_keys_word AES_256 key /\ va_get_vec 0 va_s0 == input /\
va_get_reg 4 va_s0 ==
Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
keys... | {
"checked_file": "Vale.AES.PPC64LE.AES256.fsti.checked",
"dependencies": [
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCodes.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsVector.fsti.... | [
"total"
] | [
"Vale.PPC64LE.Memory.quad32",
"FStar.Seq.Base.seq",
"Vale.PPC64LE.Memory.nat32",
"Vale.PPC64LE.Memory.buffer128",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Vale.AES.AES_BE_s.is_aes_key_word",
"Vale.AES.AES_common_s.AES_256",
"Prim... | [] | module Vale.AES.PPC64LE.AES256
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_BE_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.Memory
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.InsVector
open Vale.PPC64LE.QuickCo... | false | true | Vale.AES.PPC64LE.AES256.fsti | {
"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_el... | null | val va_wp_AES256EncryptBlock
(input: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.AES.PPC64LE.AES256.va_wp_AES256EncryptBlock | {
"file_name": "obj/Vale.AES.PPC64LE.AES256.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
input: Vale.PPC64LE.Memory.quad32 ->
key: FStar.Seq.Base.seq Vale.PPC64LE.Memory.nat32 ->
round_keys: FStar.Seq.Base.seq Vale.PPC64LE.Memory.quad32 ->
keys_buffer: Vale.PPC64LE.Memory.buffer128 ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Ty... | {
"end_col": 81,
"end_line": 144,
"start_col": 2,
"start_line": 134
} |
Prims.Tot | val va_quick_KeyExpansion256Stdcall (input_key_b output_key_expansion_b: buffer128)
: (va_quickCode unit (va_code_KeyExpansion256Stdcall ())) | [
{
"abbrev": false,
"full_module": "Vale.AES.AES256_helpers_BE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCodes",
"short_module": null
},
{
"abbrev": fa... | false | let va_quick_KeyExpansion256Stdcall (input_key_b:buffer128) (output_key_expansion_b:buffer128) :
(va_quickCode unit (va_code_KeyExpansion256Stdcall ())) =
(va_QProc (va_code_KeyExpansion256Stdcall ()) ([va_Mod_vec 5; va_Mod_vec 4; va_Mod_vec 3;
va_Mod_vec 2; va_Mod_vec 1; va_Mod_vec 0; va_Mod_reg 10; va_Mod_mem... | val va_quick_KeyExpansion256Stdcall (input_key_b output_key_expansion_b: buffer128)
: (va_quickCode unit (va_code_KeyExpansion256Stdcall ()))
let va_quick_KeyExpansion256Stdcall (input_key_b output_key_expansion_b: buffer128)
: (va_quickCode unit (va_code_KeyExpansion256Stdcall ())) = | false | null | false | (va_QProc (va_code_KeyExpansion256Stdcall ())
([
va_Mod_vec 5;
va_Mod_vec 4;
va_Mod_vec 3;
va_Mod_vec 2;
va_Mod_vec 1;
va_Mod_vec 0;
va_Mod_reg 10;
va_Mod_mem_heaplet 1;
va_Mod_mem
])
(va_wp_KeyExpansion256Stdcall input_key_b output_k... | {
"checked_file": "Vale.AES.PPC64LE.AES256.fsti.checked",
"dependencies": [
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCodes.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsVector.fsti.... | [
"total"
] | [
"Vale.PPC64LE.Memory.buffer128",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.AES.PPC64LE.AES256.va_code_KeyExpansion256Stdcall",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_Mod_vec",
"Vale.PPC64LE.QuickCode.va_Mod_reg",
"Vale.PPC64LE.QuickCode.va_Mod_mem_heapl... | [] | module Vale.AES.PPC64LE.AES256
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_BE_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.Memory
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.InsVector
open Vale.PPC64LE.QuickCo... | false | false | Vale.AES.PPC64LE.AES256.fsti | {
"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_el... | null | val va_quick_KeyExpansion256Stdcall (input_key_b output_key_expansion_b: buffer128)
: (va_quickCode unit (va_code_KeyExpansion256Stdcall ())) | [] | Vale.AES.PPC64LE.AES256.va_quick_KeyExpansion256Stdcall | {
"file_name": "obj/Vale.AES.PPC64LE.AES256.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | input_key_b: Vale.PPC64LE.Memory.buffer128 -> output_key_expansion_b: Vale.PPC64LE.Memory.buffer128
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.AES.PPC64LE.AES256.va_code_KeyExpansion256Stdcall ()) | {
"end_col": 75,
"end_line": 107,
"start_col": 2,
"start_line": 104
} |
Prims.Tot | val va_wp_KeyExpansion256Stdcall
(input_key_b output_key_expansion_b: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"abbrev": false,
"full_module": "Vale.AES.AES256_helpers_BE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCodes",
"short_module": null
},
{
"abbrev": fa... | false | let va_wp_KeyExpansion256Stdcall (input_key_b:buffer128) (output_key_expansion_b:buffer128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) =
Vale.AES.AES256_helpers_BE.make_AES256_key (Vale.Def.Types_s.reverse_bytes_quad32... | val va_wp_KeyExpansion256Stdcall
(input_key_b output_key_expansion_b: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_KeyExpansion256Stdcall
(input_key_b output_key_expansion_b: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
... | false | null | false | (va_get_ok va_s0 /\
(let key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32) =
Vale.AES.AES256_helpers_BE.make_AES256_key (Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read
input_key_b
0
(va_get_mem_heaplet 0 va_s0)))
(Vale.Def.Types_s.r... | {
"checked_file": "Vale.AES.PPC64LE.AES256.fsti.checked",
"dependencies": [
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCodes.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsVector.fsti.... | [
"total"
] | [
"Vale.PPC64LE.Memory.buffer128",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Vale.PPC64LE.Decls.validSrcAddrs128",
"Vale.PPC64LE.Decls.va_get_mem_heaplet",
"Vale.PPC64LE.Decls.va_get_reg",
"Vale.PPC64LE.Decls.va_get_mem_layout",
"Vale... | [] | module Vale.AES.PPC64LE.AES256
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_BE_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.Memory
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.InsVector
open Vale.PPC64LE.QuickCo... | false | true | Vale.AES.PPC64LE.AES256.fsti | {
"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_el... | null | val va_wp_KeyExpansion256Stdcall
(input_key_b output_key_expansion_b: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.AES.PPC64LE.AES256.va_wp_KeyExpansion256Stdcall | {
"file_name": "obj/Vale.AES.PPC64LE.AES256.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
input_key_b: Vale.PPC64LE.Memory.buffer128 ->
output_key_expansion_b: Vale.PPC64LE.Memory.buffer128 ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 16,
"end_line": 91,
"start_col": 2,
"start_line": 61
} |
Prims.Tot | val va_quick_AES256EncryptBlock_6way
(in1 in2 in3 in4 in5 in6: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
: (va_quickCode unit (va_code_AES256EncryptBlock_6way ())) | [
{
"abbrev": false,
"full_module": "Vale.AES.AES256_helpers_BE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCodes",
"short_module": null
},
{
"abbrev": fa... | false | let va_quick_AES256EncryptBlock_6way (in1:quad32) (in2:quad32) (in3:quad32) (in4:quad32)
(in5:quad32) (in6:quad32) (key:(seq nat32)) (round_keys:(seq quad32)) (keys_buffer:buffer128) :
(va_quickCode unit (va_code_AES256EncryptBlock_6way ())) =
(va_QProc (va_code_AES256EncryptBlock_6way ()) ([va_Mod_vec 6; va_Mod_... | val va_quick_AES256EncryptBlock_6way
(in1 in2 in3 in4 in5 in6: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
: (va_quickCode unit (va_code_AES256EncryptBlock_6way ()))
let va_quick_AES256EncryptBlock_6way
(in1 in2 in3 in4 in5 in6: quad32)
(key: (s... | false | null | false | (va_QProc (va_code_AES256EncryptBlock_6way ())
([
va_Mod_vec 6;
va_Mod_vec 5;
va_Mod_vec 4;
va_Mod_vec 3;
va_Mod_vec 2;
va_Mod_vec 1;
va_Mod_vec 0;
va_Mod_reg 10
])
(va_wp_AES256EncryptBlock_6way in1 in2 in3 in4 in5 in6 key round_keys keys_bu... | {
"checked_file": "Vale.AES.PPC64LE.AES256.fsti.checked",
"dependencies": [
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCodes.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsVector.fsti.... | [
"total"
] | [
"Vale.PPC64LE.Memory.quad32",
"FStar.Seq.Base.seq",
"Vale.PPC64LE.Memory.nat32",
"Vale.PPC64LE.Memory.buffer128",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.AES.PPC64LE.AES256.va_code_AES256EncryptBlock_6way",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_Mod... | [] | module Vale.AES.PPC64LE.AES256
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_BE_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.Memory
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.InsVector
open Vale.PPC64LE.QuickCo... | false | false | Vale.AES.PPC64LE.AES256.fsti | {
"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_el... | null | val va_quick_AES256EncryptBlock_6way
(in1 in2 in3 in4 in5 in6: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
: (va_quickCode unit (va_code_AES256EncryptBlock_6way ())) | [] | Vale.AES.PPC64LE.AES256.va_quick_AES256EncryptBlock_6way | {
"file_name": "obj/Vale.AES.PPC64LE.AES256.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
in1: Vale.PPC64LE.Memory.quad32 ->
in2: Vale.PPC64LE.Memory.quad32 ->
in3: Vale.PPC64LE.Memory.quad32 ->
in4: Vale.PPC64LE.Memory.quad32 ->
in5: Vale.PPC64LE.Memory.quad32 ->
in6: Vale.PPC64LE.Memory.quad32 ->
key: FStar.Seq.Base.seq Vale.PPC64LE.Memory.nat32 ->
round_keys: FStar.Seq.Ba... | {
"end_col": 92,
"end_line": 230,
"start_col": 2,
"start_line": 227
} |
Prims.Tot | val va_wp_AES256EncryptBlock_6way
(in1 in2 in3 in4 in5 in6: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"abbrev": false,
"full_module": "Vale.AES.AES256_helpers_BE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCodes",
"short_module": null
},
{
"abbrev": fa... | false | let va_wp_AES256EncryptBlock_6way (in1:quad32) (in2:quad32) (in3:quad32) (in4:quad32) (in5:quad32)
(in6:quad32) (key:(seq nat32)) (round_keys:(seq quad32)) (keys_buffer:buffer128) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.AES.AES_BE_s.is_aes_key_word AES_256 key /\ FSt... | val va_wp_AES256EncryptBlock_6way
(in1 in2 in3 in4 in5 in6: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_AES256EncryptBlock_6way
(in1 in2 in3 in4 in5 in6: quad32)
... | false | null | false | (va_get_ok va_s0 /\ Vale.AES.AES_BE_s.is_aes_key_word AES_256 key /\
FStar.Seq.Base.length #quad32 round_keys == 15 /\
round_keys == Vale.AES.AES_BE_s.key_to_round_keys_word AES_256 key /\ va_get_vec 0 va_s0 == in1 /\
va_get_vec 1 va_s0 == in2 /\ va_get_vec 2 va_s0 == in3 /\ va_get_vec 3 va_s0 == in4 /\
va_get_... | {
"checked_file": "Vale.AES.PPC64LE.AES256.fsti.checked",
"dependencies": [
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCodes.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsVector.fsti.... | [
"total"
] | [
"Vale.PPC64LE.Memory.quad32",
"FStar.Seq.Base.seq",
"Vale.PPC64LE.Memory.nat32",
"Vale.PPC64LE.Memory.buffer128",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Vale.AES.AES_BE_s.is_aes_key_word",
"Vale.AES.AES_common_s.AES_256",
"Prim... | [] | module Vale.AES.PPC64LE.AES256
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_BE_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.Memory
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.InsVector
open Vale.PPC64LE.QuickCo... | false | true | Vale.AES.PPC64LE.AES256.fsti | {
"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_el... | null | val va_wp_AES256EncryptBlock_6way
(in1 in2 in3 in4 in5 in6: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.AES.PPC64LE.AES256.va_wp_AES256EncryptBlock_6way | {
"file_name": "obj/Vale.AES.PPC64LE.AES256.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
in1: Vale.PPC64LE.Memory.quad32 ->
in2: Vale.PPC64LE.Memory.quad32 ->
in3: Vale.PPC64LE.Memory.quad32 ->
in4: Vale.PPC64LE.Memory.quad32 ->
in5: Vale.PPC64LE.Memory.quad32 ->
in6: Vale.PPC64LE.Memory.quad32 ->
key: FStar.Seq.Base.seq Vale.PPC64LE.Memory.nat32 ->
round_keys: FStar.Seq.Ba... | {
"end_col": 76,
"end_line": 212,
"start_col": 2,
"start_line": 194
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.SpinLock",
"short_module": "L"
},
{
"abbrev": false,
"f... | false | let maybe_p (p:vprop) (v:bool) = if v then p else emp | let maybe_p (p: vprop) (v: bool) = | false | null | false | if v then p else emp | {
"checked_file": "Steel.Primitive.ForkJoin.fst.checked",
"dependencies": [
"Steel.SpinLock.fsti.checked",
"Steel.Reference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.ch... | [
"total"
] | [
"Steel.Effect.Common.vprop",
"Prims.bool",
"Steel.Effect.Common.emp"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | true | Steel.Primitive.ForkJoin.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val maybe_p : p: Steel.Effect.Common.vprop -> v: Prims.bool -> Steel.Effect.Common.vprop | [] | Steel.Primitive.ForkJoin.maybe_p | {
"file_name": "lib/steel/Steel.Primitive.ForkJoin.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p: Steel.Effect.Common.vprop -> v: Prims.bool -> Steel.Effect.Common.vprop | {
"end_col": 53,
"end_line": 28,
"start_col": 33,
"start_line": 28
} | |
Prims.Tot | val lock_inv_pred (r: ref bool) (p: vprop) (v: bool) : vprop | [
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.SpinLock",
"short_module": "L"
},
{
"abbrev": false,
"f... | false | let lock_inv_pred (r:ref bool) (p:vprop) (v:bool) : vprop =
pts_to r full_perm v `star` maybe_p p v | val lock_inv_pred (r: ref bool) (p: vprop) (v: bool) : vprop
let lock_inv_pred (r: ref bool) (p: vprop) (v: bool) : vprop = | false | null | false | (pts_to r full_perm v) `star` (maybe_p p v) | {
"checked_file": "Steel.Primitive.ForkJoin.fst.checked",
"dependencies": [
"Steel.SpinLock.fsti.checked",
"Steel.Reference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.ch... | [
"total"
] | [
"Steel.Reference.ref",
"Prims.bool",
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.star",
"Steel.Reference.pts_to",
"Steel.FractionalPermission.full_perm",
"Steel.Primitive.ForkJoin.maybe_p"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | true | Steel.Primitive.ForkJoin.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lock_inv_pred (r: ref bool) (p: vprop) (v: bool) : vprop | [] | Steel.Primitive.ForkJoin.lock_inv_pred | {
"file_name": "lib/steel/Steel.Primitive.ForkJoin.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.Reference.ref Prims.bool -> p: Steel.Effect.Common.vprop -> v: Prims.bool
-> Steel.Effect.Common.vprop | {
"end_col": 41,
"end_line": 32,
"start_col": 2,
"start_line": 32
} |
Prims.Tot | val lock_inv (r: ref bool) (p: vprop) : vprop | [
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.SpinLock",
"short_module": "L"
},
{
"abbrev": false,
"f... | false | let lock_inv (r:ref bool) (p:vprop)
: vprop
= h_exists (lock_inv_pred r p) | val lock_inv (r: ref bool) (p: vprop) : vprop
let lock_inv (r: ref bool) (p: vprop) : vprop = | false | null | false | h_exists (lock_inv_pred r p) | {
"checked_file": "Steel.Primitive.ForkJoin.fst.checked",
"dependencies": [
"Steel.SpinLock.fsti.checked",
"Steel.Reference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.ch... | [
"total"
] | [
"Steel.Reference.ref",
"Prims.bool",
"Steel.Effect.Common.vprop",
"Steel.Effect.Atomic.h_exists",
"Steel.Primitive.ForkJoin.lock_inv_pred"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | true | Steel.Primitive.ForkJoin.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lock_inv (r: ref bool) (p: vprop) : vprop | [] | Steel.Primitive.ForkJoin.lock_inv | {
"file_name": "lib/steel/Steel.Primitive.ForkJoin.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.Reference.ref Prims.bool -> p: Steel.Effect.Common.vprop -> Steel.Effect.Common.vprop | {
"end_col": 32,
"end_line": 36,
"start_col": 4,
"start_line": 36
} |
Steel.Effect.SteelT | val intro_maybe_p_false (p: vprop) : SteelT unit emp (fun _ -> maybe_p p false) | [
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.SpinLock",
"short_module": "L"
},
{
"abbrev": false,
"f... | false | let intro_maybe_p_false (p:vprop)
: SteelT unit emp (fun _ -> maybe_p p false)
= rewrite_slprop emp (maybe_p p false) (fun _ -> ()) | val intro_maybe_p_false (p: vprop) : SteelT unit emp (fun _ -> maybe_p p false)
let intro_maybe_p_false (p: vprop) : SteelT unit emp (fun _ -> maybe_p p false) = | true | null | false | rewrite_slprop emp (maybe_p p false) (fun _ -> ()) | {
"checked_file": "Steel.Primitive.ForkJoin.fst.checked",
"dependencies": [
"Steel.SpinLock.fsti.checked",
"Steel.Reference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.ch... | [] | [
"Steel.Effect.Common.vprop",
"Steel.Effect.Atomic.rewrite_slprop",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.Effect.Common.emp",
"Steel.Primitive.ForkJoin.maybe_p",
"Steel.Memory.mem",
"Prims.unit"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | false | Steel.Primitive.ForkJoin.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val intro_maybe_p_false (p: vprop) : SteelT unit emp (fun _ -> maybe_p p false) | [] | Steel.Primitive.ForkJoin.intro_maybe_p_false | {
"file_name": "lib/steel/Steel.Primitive.ForkJoin.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p: Steel.Effect.Common.vprop -> Steel.Effect.SteelT Prims.unit | {
"end_col": 54,
"end_line": 46,
"start_col": 4,
"start_line": 46
} |
Steel.Effect.SteelT | val intro_maybe_p_true (p: vprop) : SteelT unit p (fun _ -> maybe_p p true) | [
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.SpinLock",
"short_module": "L"
},
{
"abbrev": false,
"f... | false | let intro_maybe_p_true (p:vprop)
: SteelT unit p (fun _ -> maybe_p p true)
= rewrite_slprop p (maybe_p p true) (fun _ -> ()) | val intro_maybe_p_true (p: vprop) : SteelT unit p (fun _ -> maybe_p p true)
let intro_maybe_p_true (p: vprop) : SteelT unit p (fun _ -> maybe_p p true) = | true | null | false | rewrite_slprop p (maybe_p p true) (fun _ -> ()) | {
"checked_file": "Steel.Primitive.ForkJoin.fst.checked",
"dependencies": [
"Steel.SpinLock.fsti.checked",
"Steel.Reference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.ch... | [] | [
"Steel.Effect.Common.vprop",
"Steel.Effect.Atomic.rewrite_slprop",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.Primitive.ForkJoin.maybe_p",
"Steel.Memory.mem",
"Prims.unit"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | false | Steel.Primitive.ForkJoin.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val intro_maybe_p_true (p: vprop) : SteelT unit p (fun _ -> maybe_p p true) | [] | Steel.Primitive.ForkJoin.intro_maybe_p_true | {
"file_name": "lib/steel/Steel.Primitive.ForkJoin.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p: Steel.Effect.Common.vprop -> Steel.Effect.SteelT Prims.unit | {
"end_col": 51,
"end_line": 50,
"start_col": 4,
"start_line": 50
} |
Steel.Effect.SteelT | val spawn: #p: vprop -> #q: vprop -> $f: (unit -> SteelT unit p (fun _ -> q)) -> t: thread q -> unit
-> SteelT unit p (fun _ -> emp) | [
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.SpinLock",
"short_module": "L"
},
{
"abbrev": false,
"f... | false | let spawn (#p #q:vprop)
($f: (unit -> SteelT unit p (fun _ -> q)))
(t:thread q)
(_:unit)
: SteelT unit p (fun _ -> emp)
= let b = acquire t in
f ();
finish t b | val spawn: #p: vprop -> #q: vprop -> $f: (unit -> SteelT unit p (fun _ -> q)) -> t: thread q -> unit
-> SteelT unit p (fun _ -> emp)
let spawn (#p: vprop) (#q: vprop) ($f: (unit -> SteelT unit p (fun _ -> q))) (t: thread q) (_: unit)
: SteelT unit p (fun _ -> emp) = | true | null | false | let b = acquire t in
f ();
finish t b | {
"checked_file": "Steel.Primitive.ForkJoin.fst.checked",
"dependencies": [
"Steel.SpinLock.fsti.checked",
"Steel.Reference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.ch... | [] | [
"Steel.Effect.Common.vprop",
"Prims.unit",
"Steel.Primitive.ForkJoin.thread",
"Steel.Primitive.ForkJoin.finish",
"Prims.bool",
"Steel.Primitive.ForkJoin.acquire",
"Steel.Effect.Common.emp"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | false | Steel.Primitive.ForkJoin.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val spawn: #p: vprop -> #q: vprop -> $f: (unit -> SteelT unit p (fun _ -> q)) -> t: thread q -> unit
-> SteelT unit p (fun _ -> emp) | [] | Steel.Primitive.ForkJoin.spawn | {
"file_name": "lib/steel/Steel.Primitive.ForkJoin.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
$f: (_: Prims.unit -> Steel.Effect.SteelT Prims.unit) ->
t: Steel.Primitive.ForkJoin.thread q ->
_: Prims.unit
-> Steel.Effect.SteelT Prims.unit | {
"end_col": 14,
"end_line": 83,
"start_col": 3,
"start_line": 81
} |
Steel.Effect.SteelT | val fork (#p #q #r #s:vprop)
(f: (unit -> SteelT unit p (fun _ -> q)))
(g: (thread q -> unit -> SteelT unit r (fun _ -> s)))
: SteelT unit (p `star` r) (fun _ -> s) | [
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.SpinLock",
"short_module": "L"
},
{
"abbrev": false,
"f... | false | let fork (#p #q #r #s:vprop)
(f: (unit -> SteelT unit p (fun _ -> q)))
(g: (thread q -> unit -> SteelT unit r (fun _ -> s)))
: SteelT unit (p `star` r) (fun _ -> s)
= let t : thread q = new_thread q in
let _ = par (spawn f t) (g t) in
() | val fork (#p #q #r #s:vprop)
(f: (unit -> SteelT unit p (fun _ -> q)))
(g: (thread q -> unit -> SteelT unit r (fun _ -> s)))
: SteelT unit (p `star` r) (fun _ -> s)
let fork
(#p #q #r #s: vprop)
(f: (unit -> SteelT unit p (fun _ -> q)))
(g: (thread q -> unit -> SteelT unit r (fun _... | true | null | false | let t:thread q = new_thread q in
let _ = par (spawn f t) (g t) in
() | {
"checked_file": "Steel.Primitive.ForkJoin.fst.checked",
"dependencies": [
"Steel.SpinLock.fsti.checked",
"Steel.Reference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.ch... | [] | [
"Steel.Effect.Common.vprop",
"Prims.unit",
"Steel.Primitive.ForkJoin.thread",
"FStar.Pervasives.Native.tuple2",
"Steel.Effect.par",
"Steel.Effect.Common.emp",
"Steel.Primitive.ForkJoin.spawn",
"Steel.Primitive.ForkJoin.new_thread",
"Steel.Effect.Common.star"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | false | Steel.Primitive.ForkJoin.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val fork (#p #q #r #s:vprop)
(f: (unit -> SteelT unit p (fun _ -> q)))
(g: (thread q -> unit -> SteelT unit r (fun _ -> s)))
: SteelT unit (p `star` r) (fun _ -> s) | [] | Steel.Primitive.ForkJoin.fork | {
"file_name": "lib/steel/Steel.Primitive.ForkJoin.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
f: (_: Prims.unit -> Steel.Effect.SteelT Prims.unit) ->
g: (_: Steel.Primitive.ForkJoin.thread q -> _: Prims.unit -> Steel.Effect.SteelT Prims.unit)
-> Steel.Effect.SteelT Prims.unit | {
"end_col": 6,
"end_line": 91,
"start_col": 3,
"start_line": 89
} |
Steel.Effect.SteelT | val finish (#p: vprop) (t: thread p) (v: bool)
: SteelT unit ((pts_to t.r full_perm v) `star` p) (fun _ -> emp) | [
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.SpinLock",
"short_module": "L"
},
{
"abbrev": false,
"f... | false | let finish (#p:vprop) (t:thread p) (v:bool)
: SteelT unit (pts_to t.r full_perm v `star` p) (fun _ -> emp)
= write_pt t.r true;
intro_maybe_p_true p;
intro_exists true (lock_inv_pred t.r p);
L.release t.l | val finish (#p: vprop) (t: thread p) (v: bool)
: SteelT unit ((pts_to t.r full_perm v) `star` p) (fun _ -> emp)
let finish (#p: vprop) (t: thread p) (v: bool)
: SteelT unit ((pts_to t.r full_perm v) `star` p) (fun _ -> emp) = | true | null | false | write_pt t.r true;
intro_maybe_p_true p;
intro_exists true (lock_inv_pred t.r p);
L.release t.l | {
"checked_file": "Steel.Primitive.ForkJoin.fst.checked",
"dependencies": [
"Steel.SpinLock.fsti.checked",
"Steel.Reference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.ch... | [] | [
"Steel.Effect.Common.vprop",
"Steel.Primitive.ForkJoin.thread",
"Prims.bool",
"Steel.SpinLock.release",
"Steel.Primitive.ForkJoin.lock_inv",
"Steel.Primitive.ForkJoin.__proj__Mkthread__item__r",
"Steel.Primitive.ForkJoin.__proj__Mkthread__item__l",
"Prims.unit",
"Steel.Effect.Atomic.intro_exists",
... | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | false | Steel.Primitive.ForkJoin.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val finish (#p: vprop) (t: thread p) (v: bool)
: SteelT unit ((pts_to t.r full_perm v) `star` p) (fun _ -> emp) | [] | Steel.Primitive.ForkJoin.finish | {
"file_name": "lib/steel/Steel.Primitive.ForkJoin.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | t: Steel.Primitive.ForkJoin.thread p -> v: Prims.bool -> Steel.Effect.SteelT Prims.unit | {
"end_col": 17,
"end_line": 66,
"start_col": 4,
"start_line": 63
} |
Steel.Effect.SteelT | val acquire (#p: vprop) (t: thread p) : SteelT bool emp (fun b -> pts_to t.r full_perm b) | [
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.SpinLock",
"short_module": "L"
},
{
"abbrev": false,
"f... | false | let acquire (#p:vprop) (t:thread p)
: SteelT bool emp (fun b -> pts_to t.r full_perm b)
= L.acquire t.l;
let b = read_refine_pt #_ #full_perm (maybe_p p) t.r in
drop (maybe_p p b);
return b | val acquire (#p: vprop) (t: thread p) : SteelT bool emp (fun b -> pts_to t.r full_perm b)
let acquire (#p: vprop) (t: thread p) : SteelT bool emp (fun b -> pts_to t.r full_perm b) = | true | null | false | L.acquire t.l;
let b = read_refine_pt #_ #full_perm (maybe_p p) t.r in
drop (maybe_p p b);
return b | {
"checked_file": "Steel.Primitive.ForkJoin.fst.checked",
"dependencies": [
"Steel.SpinLock.fsti.checked",
"Steel.Reference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.ch... | [] | [
"Steel.Effect.Common.vprop",
"Steel.Primitive.ForkJoin.thread",
"Steel.Effect.Atomic.return",
"Prims.bool",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.Reference.pts_to",
"Steel.Primitive.ForkJoin.__proj__Mkthread__item__r",
"Steel.FractionalPermission.fu... | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | false | Steel.Primitive.ForkJoin.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val acquire (#p: vprop) (t: thread p) : SteelT bool emp (fun b -> pts_to t.r full_perm b) | [] | Steel.Primitive.ForkJoin.acquire | {
"file_name": "lib/steel/Steel.Primitive.ForkJoin.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | t: Steel.Primitive.ForkJoin.thread p -> Steel.Effect.SteelT Prims.bool | {
"end_col": 12,
"end_line": 74,
"start_col": 4,
"start_line": 71
} |
Steel.Effect.SteelT | val new_thread (p: vprop) : SteelT (thread p) emp (fun _ -> emp) | [
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.SpinLock",
"short_module": "L"
},
{
"abbrev": false,
"f... | false | let new_thread (p:vprop)
: SteelT (thread p) emp (fun _ -> emp)
= let r = alloc_pt false in
intro_maybe_p_false p;
intro_exists false (lock_inv_pred r p);
let l = L.new_lock (lock_inv r p) in
let t = {r = r; l = l} in
t | val new_thread (p: vprop) : SteelT (thread p) emp (fun _ -> emp)
let new_thread (p: vprop) : SteelT (thread p) emp (fun _ -> emp) = | true | null | false | let r = alloc_pt false in
intro_maybe_p_false p;
intro_exists false (lock_inv_pred r p);
let l = L.new_lock (lock_inv r p) in
let t = { r = r; l = l } in
t | {
"checked_file": "Steel.Primitive.ForkJoin.fst.checked",
"dependencies": [
"Steel.SpinLock.fsti.checked",
"Steel.Reference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.ch... | [] | [
"Steel.Effect.Common.vprop",
"Steel.Primitive.ForkJoin.thread",
"Steel.Primitive.ForkJoin.Mkthread",
"Steel.SpinLock.lock",
"Steel.Primitive.ForkJoin.lock_inv",
"Steel.SpinLock.new_lock",
"Prims.unit",
"Steel.Effect.Atomic.intro_exists",
"Prims.bool",
"FStar.Ghost.hide",
"FStar.Set.set",
"Stee... | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | false | Steel.Primitive.ForkJoin.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val new_thread (p: vprop) : SteelT (thread p) emp (fun _ -> emp) | [] | Steel.Primitive.ForkJoin.new_thread | {
"file_name": "lib/steel/Steel.Primitive.ForkJoin.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p: Steel.Effect.Common.vprop -> Steel.Effect.SteelT (Steel.Primitive.ForkJoin.thread p) | {
"end_col": 5,
"end_line": 59,
"start_col": 3,
"start_line": 54
} |
Steel.Effect.SteelT | val join (#p:vprop) (t:thread p)
: SteelT unit emp (fun _ -> p) | [
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.SpinLock",
"short_module": "L"
},
{
"abbrev": false,
"f... | false | let rec join (#p:vprop) (t:thread p)
: SteelT unit emp (fun _ -> p)
= let _ = L.acquire t.l in
let b = read_refine_pt (maybe_p p) t.r in
if b then
(rewrite_slprop (lock_inv_pred t.r p b) p (fun _ -> ()); noop ())
else
(rewrite_slprop (lock_inv_pred t.r p b) (lock_inv_pred t.r p false) (fun _... | val join (#p:vprop) (t:thread p)
: SteelT unit emp (fun _ -> p)
let rec join (#p: vprop) (t: thread p) : SteelT unit emp (fun _ -> p) = | true | null | false | let _ = L.acquire t.l in
let b = read_refine_pt (maybe_p p) t.r in
if b
then
(rewrite_slprop (lock_inv_pred t.r p b) p (fun _ -> ());
noop ())
else
(rewrite_slprop (lock_inv_pred t.r p b) (lock_inv_pred t.r p false) (fun _ -> ());
intro_exists false (lock_inv_pred t.r p);
L.release t.l;
join t) | {
"checked_file": "Steel.Primitive.ForkJoin.fst.checked",
"dependencies": [
"Steel.SpinLock.fsti.checked",
"Steel.Reference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.ch... | [] | [
"Steel.Effect.Common.vprop",
"Steel.Primitive.ForkJoin.thread",
"Steel.Effect.Atomic.noop",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Prims.unit",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.Primitive.ForkJoin.lock_inv_pred",
"Steel.Primitive.ForkJoin.__proj... | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | false | false | Steel.Primitive.ForkJoin.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val join (#p:vprop) (t:thread p)
: SteelT unit emp (fun _ -> p) | [
"recursion"
] | Steel.Primitive.ForkJoin.join | {
"file_name": "lib/steel/Steel.Primitive.ForkJoin.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | t: Steel.Primitive.ForkJoin.thread p -> Steel.Effect.SteelT Prims.unit | {
"end_col": 13,
"end_line": 103,
"start_col": 3,
"start_line": 95
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.Sample",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full... | false | let frodo_sample_st (a:FP.frodo_alg) =
r:uint16
-> Stack uint16
(requires fun h -> True)
(ensures fun h0 res h1 -> modifies0 h0 h1 /\
res == S.frodo_sample a r) | let frodo_sample_st (a: FP.frodo_alg) = | false | null | false | r: uint16
-> Stack uint16
(requires fun h -> True)
(ensures fun h0 res h1 -> modifies0 h0 h1 /\ res == S.frodo_sample a r) | {
"checked_file": "Hacl.Impl.Frodo.Sample.fst.checked",
"dependencies": [
"Spec.Frodo.Sample.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.Lemmas.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.Loops.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
... | [
"total"
] | [
"Spec.Frodo.Params.frodo_alg",
"Lib.IntTypes.uint16",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_True",
"Prims.l_and",
"Lib.Buffer.modifies0",
"Prims.eq2",
"Spec.Frodo.Sample.frodo_sample"
] | [] | module Hacl.Impl.Frodo.Sample
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Hacl.Impl.Matrix
open Hacl.Impl.Frodo.Params
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module Loops = Lib.LoopCombinators
module Lemmas = Spec.Frod... | false | true | Hacl.Impl.Frodo.Sample.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val frodo_sample_st : a: Spec.Frodo.Params.frodo_alg -> Type0 | [] | Hacl.Impl.Frodo.Sample.frodo_sample_st | {
"file_name": "code/frodo/Hacl.Impl.Frodo.Sample.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Spec.Frodo.Params.frodo_alg -> Type0 | {
"end_col": 32,
"end_line": 60,
"start_col": 4,
"start_line": 56
} | |
Prims.Tot | val frodo_sample_matrix1344:frodo_sample_matrix_st FP.Frodo1344 | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.Sample",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full... | false | let frodo_sample_matrix1344 : frodo_sample_matrix_st FP.Frodo1344=
frodo_sample_matrix_ FP.Frodo1344 (frodo_sample FP.Frodo1344) | val frodo_sample_matrix1344:frodo_sample_matrix_st FP.Frodo1344
let frodo_sample_matrix1344:frodo_sample_matrix_st FP.Frodo1344 = | false | null | false | frodo_sample_matrix_ FP.Frodo1344 (frodo_sample FP.Frodo1344) | {
"checked_file": "Hacl.Impl.Frodo.Sample.fst.checked",
"dependencies": [
"Spec.Frodo.Sample.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.Lemmas.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.Loops.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
... | [
"total"
] | [
"Hacl.Impl.Frodo.Sample.frodo_sample_matrix_",
"Spec.Frodo.Params.Frodo1344",
"Hacl.Impl.Frodo.Sample.frodo_sample"
] | [] | module Hacl.Impl.Frodo.Sample
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Hacl.Impl.Matrix
open Hacl.Impl.Frodo.Params
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module Loops = Lib.LoopCombinators
module Lemmas = Spec.Frod... | false | true | Hacl.Impl.Frodo.Sample.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val frodo_sample_matrix1344:frodo_sample_matrix_st FP.Frodo1344 | [] | Hacl.Impl.Frodo.Sample.frodo_sample_matrix1344 | {
"file_name": "code/frodo/Hacl.Impl.Frodo.Sample.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.Frodo.Sample.frodo_sample_matrix_st Spec.Frodo.Params.Frodo1344 | {
"end_col": 63,
"end_line": 170,
"start_col": 2,
"start_line": 170
} |
Prims.Tot | val frodo_sample_matrix640:frodo_sample_matrix_st FP.Frodo640 | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.Sample",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full... | false | let frodo_sample_matrix640 : frodo_sample_matrix_st FP.Frodo640 =
frodo_sample_matrix_ FP.Frodo640 (frodo_sample FP.Frodo640) | val frodo_sample_matrix640:frodo_sample_matrix_st FP.Frodo640
let frodo_sample_matrix640:frodo_sample_matrix_st FP.Frodo640 = | false | null | false | frodo_sample_matrix_ FP.Frodo640 (frodo_sample FP.Frodo640) | {
"checked_file": "Hacl.Impl.Frodo.Sample.fst.checked",
"dependencies": [
"Spec.Frodo.Sample.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.Lemmas.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.Loops.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
... | [
"total"
] | [
"Hacl.Impl.Frodo.Sample.frodo_sample_matrix_",
"Spec.Frodo.Params.Frodo640",
"Hacl.Impl.Frodo.Sample.frodo_sample"
] | [] | module Hacl.Impl.Frodo.Sample
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Hacl.Impl.Matrix
open Hacl.Impl.Frodo.Params
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module Loops = Lib.LoopCombinators
module Lemmas = Spec.Frod... | false | true | Hacl.Impl.Frodo.Sample.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val frodo_sample_matrix640:frodo_sample_matrix_st FP.Frodo640 | [] | Hacl.Impl.Frodo.Sample.frodo_sample_matrix640 | {
"file_name": "code/frodo/Hacl.Impl.Frodo.Sample.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.Frodo.Sample.frodo_sample_matrix_st Spec.Frodo.Params.Frodo640 | {
"end_col": 61,
"end_line": 164,
"start_col": 2,
"start_line": 164
} |
Prims.Tot | val frodo_sample_matrix976:frodo_sample_matrix_st FP.Frodo976 | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.Sample",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full... | false | let frodo_sample_matrix976 : frodo_sample_matrix_st FP.Frodo976 =
frodo_sample_matrix_ FP.Frodo976 (frodo_sample FP.Frodo976) | val frodo_sample_matrix976:frodo_sample_matrix_st FP.Frodo976
let frodo_sample_matrix976:frodo_sample_matrix_st FP.Frodo976 = | false | null | false | frodo_sample_matrix_ FP.Frodo976 (frodo_sample FP.Frodo976) | {
"checked_file": "Hacl.Impl.Frodo.Sample.fst.checked",
"dependencies": [
"Spec.Frodo.Sample.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.Lemmas.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.Loops.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
... | [
"total"
] | [
"Hacl.Impl.Frodo.Sample.frodo_sample_matrix_",
"Spec.Frodo.Params.Frodo976",
"Hacl.Impl.Frodo.Sample.frodo_sample"
] | [] | module Hacl.Impl.Frodo.Sample
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Hacl.Impl.Matrix
open Hacl.Impl.Frodo.Params
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module Loops = Lib.LoopCombinators
module Lemmas = Spec.Frod... | false | true | Hacl.Impl.Frodo.Sample.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val frodo_sample_matrix976:frodo_sample_matrix_st FP.Frodo976 | [] | Hacl.Impl.Frodo.Sample.frodo_sample_matrix976 | {
"file_name": "code/frodo/Hacl.Impl.Frodo.Sample.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.Frodo.Sample.frodo_sample_matrix_st Spec.Frodo.Params.Frodo976 | {
"end_col": 61,
"end_line": 167,
"start_col": 2,
"start_line": 167
} |
Prims.Tot | val frodo_sample_matrix64:frodo_sample_matrix_st FP.Frodo64 | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.Sample",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full... | false | let frodo_sample_matrix64 : frodo_sample_matrix_st FP.Frodo64 =
frodo_sample_matrix_ FP.Frodo64 (frodo_sample FP.Frodo64) | val frodo_sample_matrix64:frodo_sample_matrix_st FP.Frodo64
let frodo_sample_matrix64:frodo_sample_matrix_st FP.Frodo64 = | false | null | false | frodo_sample_matrix_ FP.Frodo64 (frodo_sample FP.Frodo64) | {
"checked_file": "Hacl.Impl.Frodo.Sample.fst.checked",
"dependencies": [
"Spec.Frodo.Sample.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.Lemmas.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.Loops.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
... | [
"total"
] | [
"Hacl.Impl.Frodo.Sample.frodo_sample_matrix_",
"Spec.Frodo.Params.Frodo64",
"Hacl.Impl.Frodo.Sample.frodo_sample"
] | [] | module Hacl.Impl.Frodo.Sample
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Hacl.Impl.Matrix
open Hacl.Impl.Frodo.Params
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module Loops = Lib.LoopCombinators
module Lemmas = Spec.Frod... | false | true | Hacl.Impl.Frodo.Sample.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val frodo_sample_matrix64:frodo_sample_matrix_st FP.Frodo64 | [] | Hacl.Impl.Frodo.Sample.frodo_sample_matrix64 | {
"file_name": "code/frodo/Hacl.Impl.Frodo.Sample.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.Frodo.Sample.frodo_sample_matrix_st Spec.Frodo.Params.Frodo64 | {
"end_col": 59,
"end_line": 161,
"start_col": 2,
"start_line": 161
} |
Prims.Tot | val frodo_sample_matrix (a: FP.frodo_alg) : frodo_sample_matrix_st a | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.Sample",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full... | false | let frodo_sample_matrix (a:FP.frodo_alg) : frodo_sample_matrix_st a =
match a with
| FP.Frodo64 -> frodo_sample_matrix64
| FP.Frodo640 -> frodo_sample_matrix640
| FP.Frodo976 -> frodo_sample_matrix976
| FP.Frodo1344 -> frodo_sample_matrix1344 | val frodo_sample_matrix (a: FP.frodo_alg) : frodo_sample_matrix_st a
let frodo_sample_matrix (a: FP.frodo_alg) : frodo_sample_matrix_st a = | false | null | false | match a with
| FP.Frodo64 -> frodo_sample_matrix64
| FP.Frodo640 -> frodo_sample_matrix640
| FP.Frodo976 -> frodo_sample_matrix976
| FP.Frodo1344 -> frodo_sample_matrix1344 | {
"checked_file": "Hacl.Impl.Frodo.Sample.fst.checked",
"dependencies": [
"Spec.Frodo.Sample.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.Lemmas.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.Loops.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
... | [
"total"
] | [
"Spec.Frodo.Params.frodo_alg",
"Hacl.Impl.Frodo.Sample.frodo_sample_matrix64",
"Hacl.Impl.Frodo.Sample.frodo_sample_matrix640",
"Hacl.Impl.Frodo.Sample.frodo_sample_matrix976",
"Hacl.Impl.Frodo.Sample.frodo_sample_matrix1344",
"Hacl.Impl.Frodo.Sample.frodo_sample_matrix_st"
] | [] | module Hacl.Impl.Frodo.Sample
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Hacl.Impl.Matrix
open Hacl.Impl.Frodo.Params
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module Loops = Lib.LoopCombinators
module Lemmas = Spec.Frod... | false | false | Hacl.Impl.Frodo.Sample.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val frodo_sample_matrix (a: FP.frodo_alg) : frodo_sample_matrix_st a | [] | Hacl.Impl.Frodo.Sample.frodo_sample_matrix | {
"file_name": "code/frodo/Hacl.Impl.Frodo.Sample.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Spec.Frodo.Params.frodo_alg -> Hacl.Impl.Frodo.Sample.frodo_sample_matrix_st a | {
"end_col": 43,
"end_line": 178,
"start_col": 2,
"start_line": 174
} |
Prims.Tot | val frodo_sample_res:
a:FP.frodo_alg
-> sign:uint16{v sign <= 1}
-> sample:uint16{v sample < v (cdf_table_len a)}
-> res:uint16{res == S.frodo_sample_res a sign (v sample)} | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.Sample",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full... | false | let frodo_sample_res a sign sample =
Lemmas.lemma_frodo_sample2 sign sample;
((lognot sign +. u16 1) ^. sample) +. sign | val frodo_sample_res:
a:FP.frodo_alg
-> sign:uint16{v sign <= 1}
-> sample:uint16{v sample < v (cdf_table_len a)}
-> res:uint16{res == S.frodo_sample_res a sign (v sample)}
let frodo_sample_res a sign sample = | false | null | false | Lemmas.lemma_frodo_sample2 sign sample;
((lognot sign +. u16 1) ^. sample) +. sign | {
"checked_file": "Hacl.Impl.Frodo.Sample.fst.checked",
"dependencies": [
"Spec.Frodo.Sample.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.Lemmas.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.Loops.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
... | [
"total"
] | [
"Spec.Frodo.Params.frodo_alg",
"Lib.IntTypes.uint16",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.v",
"Lib.IntTypes.U16",
"Lib.IntTypes.SEC",
"Prims.op_LessThan",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Impl.Frodo.Params.cdf_table_len",
"Lib.IntTypes.op_Plus_Dot",
"Lib.IntTy... | [] | module Hacl.Impl.Frodo.Sample
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Hacl.Impl.Matrix
open Hacl.Impl.Frodo.Params
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module Loops = Lib.LoopCombinators
module Lemmas = Spec.Frod... | false | false | Hacl.Impl.Frodo.Sample.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val frodo_sample_res:
a:FP.frodo_alg
-> sign:uint16{v sign <= 1}
-> sample:uint16{v sample < v (cdf_table_len a)}
-> res:uint16{res == S.frodo_sample_res a sign (v sample)} | [] | Hacl.Impl.Frodo.Sample.frodo_sample_res | {
"file_name": "code/frodo/Hacl.Impl.Frodo.Sample.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Spec.Frodo.Params.frodo_alg ->
sign: Lib.IntTypes.uint16{Lib.IntTypes.v sign <= 1} ->
sample:
Lib.IntTypes.uint16
{Lib.IntTypes.v sample < Lib.IntTypes.v (Hacl.Impl.Frodo.Params.cdf_table_len a)}
-> res:
Lib.IntTypes.uint16{res == Spec.Frodo.Sample.frodo_sample_res a sign (Lib.IntTyp... | {
"end_col": 44,
"end_line": 51,
"start_col": 2,
"start_line": 50
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.Sample",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full... | false | let frodo_sample_matrix_st (a:FP.frodo_alg) =
n1:size_t
-> n2:size_t{0 < 2 * v n1 * v n2 /\ 2 * v n1 * v n2 <= max_size_t}
-> r:lbytes (2ul *! n1 *! n2)
-> res:matrix_t n1 n2
-> Stack unit
(requires fun h ->
live h r /\ live h res /\ disjoint r res)
(ensures fun h0 r_ h1 -> modifies1 res h0 h... | let frodo_sample_matrix_st (a: FP.frodo_alg) = | false | null | false |
n1: size_t ->
n2: size_t{0 < (2 * v n1) * v n2 /\ (2 * v n1) * v n2 <= max_size_t} ->
r: lbytes (2ul *! n1 *! n2) ->
res: matrix_t n1 n2
-> Stack unit
(requires fun h -> live h r /\ live h res /\ disjoint r res)
(ensures
fun h0 r_ h1 ->
modifies1 res h0 h1 /\
a... | {
"checked_file": "Hacl.Impl.Frodo.Sample.fst.checked",
"dependencies": [
"Spec.Frodo.Sample.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.Lemmas.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.Loops.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
... | [
"total"
] | [
"Spec.Frodo.Params.frodo_alg",
"Lib.IntTypes.size_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.max_size_t",
"Hacl.Impl.Matrix.lbytes",
"Lib.IntTypes.op_Star_Bang",... | [] | module Hacl.Impl.Frodo.Sample
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Hacl.Impl.Matrix
open Hacl.Impl.Frodo.Params
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module Loops = Lib.LoopCombinators
module Lemmas = Spec.Frod... | false | true | Hacl.Impl.Frodo.Sample.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val frodo_sample_matrix_st : a: Spec.Frodo.Params.frodo_alg -> Type0 | [] | Hacl.Impl.Frodo.Sample.frodo_sample_matrix_st | {
"file_name": "code/frodo/Hacl.Impl.Frodo.Sample.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Spec.Frodo.Params.frodo_alg -> Type0 | {
"end_col": 78,
"end_line": 136,
"start_col": 4,
"start_line": 128
} | |
FStar.HyperStack.ST.Stack | val frodo_sample_f:
a:FP.frodo_alg
-> t:uint16{uint_v t < pow2 15}
-> i:size_t{v i < v (cdf_table_len a)}
-> Stack uint16
(requires fun h -> True)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
v r == S.frodo_sample_f a t (v i)) | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.Sample",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full... | false | let frodo_sample_f a t i =
recall_contents (cdf_table a) (FP.cdf_table a);
let ti = index (cdf_table a) i in
FP.lemma_cdf_list a (v i);
Lemmas.lemma_frodo_sample t ti;
to_u16 (to_u32 (ti -. t)) >>. 15ul | val frodo_sample_f:
a:FP.frodo_alg
-> t:uint16{uint_v t < pow2 15}
-> i:size_t{v i < v (cdf_table_len a)}
-> Stack uint16
(requires fun h -> True)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
v r == S.frodo_sample_f a t (v i))
let frodo_sample_f a t i = | true | null | false | recall_contents (cdf_table a) (FP.cdf_table a);
let ti = index (cdf_table a) i in
FP.lemma_cdf_list a (v i);
Lemmas.lemma_frodo_sample t ti;
to_u16 (to_u32 (ti -. t)) >>. 15ul | {
"checked_file": "Hacl.Impl.Frodo.Sample.fst.checked",
"dependencies": [
"Spec.Frodo.Sample.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.Lemmas.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.Loops.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
... | [] | [
"Spec.Frodo.Params.frodo_alg",
"Lib.IntTypes.uint16",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.uint_v",
"Lib.IntTypes.U16",
"Lib.IntTypes.SEC",
"Prims.pow2",
"Lib.IntTypes.size_t",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Impl.Frodo.Params.cdf_table_len",
"Lib... | [] | module Hacl.Impl.Frodo.Sample
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Hacl.Impl.Matrix
open Hacl.Impl.Frodo.Params
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module Loops = Lib.LoopCombinators
module Lemmas = Spec.Frod... | false | false | Hacl.Impl.Frodo.Sample.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val frodo_sample_f:
a:FP.frodo_alg
-> t:uint16{uint_v t < pow2 15}
-> i:size_t{v i < v (cdf_table_len a)}
-> Stack uint16
(requires fun h -> True)
(ensures fun h0 r h1 -> modifies0 h0 h1 /\
v r == S.frodo_sample_f a t (v i)) | [] | Hacl.Impl.Frodo.Sample.frodo_sample_f | {
"file_name": "code/frodo/Hacl.Impl.Frodo.Sample.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Spec.Frodo.Params.frodo_alg ->
t: Lib.IntTypes.uint16{Lib.IntTypes.uint_v t < Prims.pow2 15} ->
i:
Lib.IntTypes.size_t
{Lib.IntTypes.v i < Lib.IntTypes.v (Hacl.Impl.Frodo.Params.cdf_table_len a)}
-> FStar.HyperStack.ST.Stack Lib.IntTypes.uint16 | {
"end_col": 36,
"end_line": 39,
"start_col": 2,
"start_line": 35
} |
Prims.Tot | val frodo_sample_matrix_:
a:FP.frodo_alg
-> frodo_sample:frodo_sample_st a
-> frodo_sample_matrix_st a | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.Sample",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.Lemmas",
"short_module": "Lemmas"
},
{
"abbrev": true,
"full... | false | let frodo_sample_matrix_ a frodo_sample n1 n2 r res =
memset res (u16 0) (n1 *! n2);
let h0 = ST.get () in
LSeq.eq_intro (LSeq.sub (as_seq h0 res) 0 (v n1 * v n2)) (as_seq h0 res);
[@ inline_let]
let spec h0 = S.frodo_sample_matrix1 a (v n1) (v n2) (as_seq h0 r) in
loop1 h0 n1 res spec
(fun i ->
Loop... | val frodo_sample_matrix_:
a:FP.frodo_alg
-> frodo_sample:frodo_sample_st a
-> frodo_sample_matrix_st a
let frodo_sample_matrix_ a frodo_sample n1 n2 r res = | false | null | false | memset res (u16 0) (n1 *! n2);
let h0 = ST.get () in
LSeq.eq_intro (LSeq.sub (as_seq h0 res) 0 (v n1 * v n2)) (as_seq h0 res);
[@@ inline_let ]let spec h0 = S.frodo_sample_matrix1 a (v n1) (v n2) (as_seq h0 r) in
loop1 h0
n1
res
spec
(fun i ->
Loops.unfold_repeati (v n1) (spec h0) (as_seq h0 res) (v i);
... | {
"checked_file": "Hacl.Impl.Frodo.Sample.fst.checked",
"dependencies": [
"Spec.Frodo.Sample.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.Lemmas.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.Loops.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
... | [
"total"
] | [
"Spec.Frodo.Params.frodo_alg",
"Hacl.Impl.Frodo.Sample.frodo_sample_st",
"Lib.IntTypes.size_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.max_size_t",
"Hacl.Impl.Ma... | [] | module Hacl.Impl.Frodo.Sample
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Hacl.Impl.Matrix
open Hacl.Impl.Frodo.Params
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module Loops = Lib.LoopCombinators
module Lemmas = Spec.Frod... | false | false | Hacl.Impl.Frodo.Sample.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val frodo_sample_matrix_:
a:FP.frodo_alg
-> frodo_sample:frodo_sample_st a
-> frodo_sample_matrix_st a | [] | Hacl.Impl.Frodo.Sample.frodo_sample_matrix_ | {
"file_name": "code/frodo/Hacl.Impl.Frodo.Sample.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Spec.Frodo.Params.frodo_alg -> frodo_sample: Hacl.Impl.Frodo.Sample.frodo_sample_st a
-> Hacl.Impl.Frodo.Sample.frodo_sample_matrix_st a | {
"end_col": 3,
"end_line": 156,
"start_col": 2,
"start_line": 146
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.