effect
stringclasses 48
values | original_source_type
stringlengths 0
23k
| opens_and_abbrevs
listlengths 2
92
| isa_cross_project_example
bool 1
class | source_definition
stringlengths 9
57.9k
| partial_definition
stringlengths 7
23.3k
| is_div
bool 2
classes | is_type
null | is_proof
bool 2
classes | completed_definiton
stringlengths 1
250k
| dependencies
dict | effect_flags
sequencelengths 0
2
| ideal_premises
sequencelengths 0
236
| mutual_with
sequencelengths 0
11
| file_context
stringlengths 0
407k
| interleaved
bool 1
class | is_simply_typed
bool 2
classes | file_name
stringlengths 5
48
| vconfig
dict | is_simple_lemma
null | source_type
stringlengths 10
23k
| proof_features
sequencelengths 0
1
| name
stringlengths 8
95
| source
dict | verbose_type
stringlengths 1
7.42k
| source_range
dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
FStar.Pervasives.Lemma | [
{
"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_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.AES_helpers_BE.fsti"
} | [
"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}) : Tot a = index s i
unfold let (.[]<-) = Seq.upd
unfold let ( *^ ) = nat32_xor
unfold let ( *^^ ) = quad32_xor
unfold let be_quad32_to_seq (q:quad32) : seq nat32 = four_to_seq_BE q
let quad32_shr32 (q:quad32) : quad32 =
let Mkfour v0 v1 v2 v3 = q in
Mkfour v1 v2 v3 0
// Redefine key expansion in terms of quad32 values rather than nat32 values,
// then prove both definitions are equivalent.
let round_key_128_rcon (prev:quad32) (rcon:nat32) : quad32 =
let Mkfour v0 v1 v2 v3 = prev in
let w3 = v3 *^ (sub_word (rot_word v0) *^ rcon) in
let w2 = v2 *^ w3 in
let w1 = v1 *^ w2 in
let w0 = v0 *^ w1 in
Mkfour w0 w1 w2 w3
let round_key_128 (prev:quad32) (round:nat) : quad32 =
round_key_128_rcon prev (aes_rcon (round - 1))
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 | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.AES_helpers_BE.fsti"
} | [
"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}) : Tot a = index s i
unfold let (.[]<-) = Seq.upd
unfold let ( *^ ) = nat32_xor
unfold let ( *^^ ) = quad32_xor
unfold let be_quad32_to_seq (q:quad32) : seq nat32 = four_to_seq_BE q | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.AES_helpers_BE.fsti"
} | [] | [
"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",
"Vale.Def.Types_s.quad32",
"Vale.AES.AES_BE_s.is_aes_key_word",
"Vale.AES.AES_common_s.AES_128",
"Prims.l_True"
] | [] | 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}) : Tot a = index s i
unfold let (.[]<-) = Seq.upd
unfold let ( *^ ) = nat32_xor
unfold let ( *^^ ) = quad32_xor
unfold let be_quad32_to_seq (q:quad32) : seq nat32 = four_to_seq_BE q
let quad32_shr32 (q:quad32) : quad32 =
let Mkfour v0 v1 v2 v3 = q in
Mkfour v1 v2 v3 0
// Redefine key expansion in terms of quad32 values rather than nat32 values,
// then prove both definitions are equivalent.
let round_key_128_rcon (prev:quad32) (rcon:nat32) : quad32 =
let Mkfour v0 v1 v2 v3 = prev in
let w3 = v3 *^ (sub_word (rot_word v0) *^ rcon) in
let w2 = v2 *^ w3 in
let w1 = v1 *^ w2 in
let w0 = v0 *^ w1 in
Mkfour w0 w1 w2 w3
let round_key_128 (prev:quad32) (round:nat) : quad32 =
round_key_128_rcon prev (aes_rcon (round - 1))
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 | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val bare_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": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"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,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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_buffer) (va_wpProof_AES128EncryptBlock
input key round_keys keys_buffer)) | 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))
(keys_buffer: buffer128)
: (va_quickCode unit (va_code_AES128EncryptBlock ())) = | 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.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.InsAes.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"Vale.AES.AES_helpers.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.X64.AES128.fsti"
} | [
"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_Mod_xmm",
"Prims.Nil",
"Vale.AES.X64.AES128.va_wp_AES128EncryptBlock",
"Vale.AES.X64.AES128.va_wpProof_AES128EncryptBlock",
"Vale.X64.QuickCode.va_quickCode"
] | [] | 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.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers
open Vale.X64.CPU_Features_s
#reset-options "--z3rlimit 20"
//-- KeyExpansion128Stdcall
val va_code_KeyExpansion128Stdcall : win:bool -> Tot va_code
val va_codegen_success_KeyExpansion128Stdcall : win:bool -> Tot va_pbool
val va_lemma_KeyExpansion128Stdcall : va_b0:va_code -> va_s0:va_state -> win:bool ->
input_key_b:buffer128 -> output_key_expansion_b:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansion128Stdcall win) va_s0 /\ va_get_ok va_s0
/\ (let (key_ptr:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0
else va_get_reg64 rRdi va_s0) in let (key_expansion_ptr:(va_int_range 0 18446744073709551615))
= (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let
(key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq
(Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in aesni_enabled /\
avx_enabled /\ sse_enabled /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
key_ptr input_key_b 1 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_s0) key_expansion_ptr output_key_expansion_b 11 (va_get_mem_layout
va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (key_ptr:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0
else va_get_reg64 rRdi va_s0) in let (key_expansion_ptr:(va_int_range 0 18446744073709551615))
= (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let
(key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq
(Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in aesni_enabled /\
avx_enabled /\ sse_enabled /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM)
key_ptr input_key_b 1 (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_sM) key_expansion_ptr output_key_expansion_b 11 (va_get_mem_layout
va_sM) Secret) /\ (let (key_ptr:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (key_expansion_ptr:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq
(Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in
Vale.X64.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) /\ (forall j . {:pattern(buffer128_read output_key_expansion_b j
(va_get_mem_heaplet 1 va_sM))}0 <= j /\ j <= 10 ==> Vale.X64.Decls.buffer128_read
output_key_expansion_b j (va_get_mem_heaplet 1 va_sM) == FStar.Seq.Base.index
#Vale.Def.Types_s.quad32 (Vale.AES.AES_s.key_to_round_keys_LE AES_128 key) j)) /\ va_state_eq
va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1
va_sM (va_update_mem_heaplet 1 va_sM (va_update_reg64 rRdx va_sM (va_update_ok va_sM
(va_update_mem va_sM va_s0))))))))))
[@ va_qattr]
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 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) in let (key:(FStar.Seq.Base.seq
Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read
input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in aesni_enabled /\ avx_enabled /\ sse_enabled /\
Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) key_ptr input_key_b 1
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_s0) key_expansion_ptr output_key_expansion_b 11 (va_get_mem_layout va_s0) Secret) /\ (forall
(va_x_mem:vale_heap) (va_x_rdx:nat64) (va_x_heap1:vale_heap) (va_x_xmm1:quad32)
(va_x_xmm2:quad32) (va_x_xmm3:quad32) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_xmm 3 va_x_xmm3 (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1
(va_upd_mem_heaplet 1 va_x_heap1 (va_upd_reg64 rRdx va_x_rdx (va_upd_mem va_x_mem va_s0))))))
in va_get_ok va_sM /\ (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) in let (key:(FStar.Seq.Base.seq
Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read
input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in aesni_enabled /\ avx_enabled /\ sse_enabled /\
Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM) key_ptr input_key_b 1
(va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_sM) key_expansion_ptr output_key_expansion_b 11 (va_get_mem_layout va_sM) Secret) /\ (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) in let (key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) =
Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet
0 va_s0)) in Vale.X64.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1
va_s0) (va_get_mem_heaplet 1 va_sM) /\ (forall j . {:pattern(buffer128_read
output_key_expansion_b j (va_get_mem_heaplet 1 va_sM))}0 <= j /\ j <= 10 ==>
Vale.X64.Decls.buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1 va_sM) ==
FStar.Seq.Base.index #Vale.Def.Types_s.quad32 (Vale.AES.AES_s.key_to_round_keys_LE AES_128 key)
j)) ==> va_k va_sM (())))
val va_wpProof_KeyExpansion128Stdcall : win:bool -> input_key_b:buffer128 ->
output_key_expansion_b:buffer128 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansion128Stdcall win input_key_b
output_key_expansion_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (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_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
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; va_Mod_mem])
(va_wp_KeyExpansion128Stdcall win input_key_b output_key_expansion_b)
(va_wpProof_KeyExpansion128Stdcall win input_key_b output_key_expansion_b))
//--
//-- AES128EncryptBlock
val va_code_AES128EncryptBlock : va_dummy:unit -> Tot va_code
val va_codegen_success_AES128EncryptBlock : va_dummy:unit -> Tot va_pbool
val va_lemma_AES128EncryptBlock : va_b0:va_code -> va_s0:va_state -> input:quad32 -> key:(seq
nat32) -> round_keys:(seq quad32) -> keys_buffer:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_AES128EncryptBlock ()) va_s0 /\ 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.Memory.vuint128 keys_buffer
(va_get_mem_heaplet 0 va_s0) /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
(va_get_reg64 rR8 va_s0) keys_buffer 11 (va_get_mem_layout va_s0) Secret /\ (forall (i:nat) . i
< 11 ==> Vale.X64.Decls.buffer128_read keys_buffer i (va_get_mem_heaplet 0 va_s0) ==
FStar.Seq.Base.index #quad32 round_keys i)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_get_xmm 0 va_sM == Vale.AES.AES_s.aes_encrypt_LE AES_128 key input /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_xmm 2 va_sM (va_update_xmm 0 va_sM (va_update_ok va_sM
va_s0))))))
[@ va_qattr]
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 == 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.Memory.vuint128 keys_buffer
(va_get_mem_heaplet 0 va_s0) /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
(va_get_reg64 rR8 va_s0) keys_buffer 11 (va_get_mem_layout va_s0) Secret /\ (forall (i:nat) . i
< 11 ==> Vale.X64.Decls.buffer128_read keys_buffer i (va_get_mem_heaplet 0 va_s0) ==
FStar.Seq.Base.index #quad32 round_keys i) /\ (forall (va_x_xmm0:quad32) (va_x_xmm2:quad32)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm 2 va_x_xmm2
(va_upd_xmm 0 va_x_xmm0 va_s0)) in va_get_ok va_sM /\ va_get_xmm 0 va_sM ==
Vale.AES.AES_s.aes_encrypt_LE AES_128 key input ==> va_k va_sM (())))
val va_wpProof_AES128EncryptBlock : input:quad32 -> key:(seq nat32) -> round_keys:(seq quad32) ->
keys_buffer:buffer128 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_AES128EncryptBlock input key round_keys keys_buffer va_s0
va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_AES128EncryptBlock ()) ([va_Mod_flags;
va_Mod_xmm 2; va_Mod_xmm 0]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_AES128EncryptBlock (input:quad32) (key:(seq nat32)) (round_keys:(seq quad32)) | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"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,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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; va_Mod_mem])
(va_wp_KeyExpansion128Stdcall win input_key_b output_key_expansion_b)
(va_wpProof_KeyExpansion128Stdcall win input_key_b output_key_expansion_b)) | 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_KeyExpansion128Stdcall win input_key_b output_key_expansion_b)) | {
"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.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.InsAes.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"Vale.AES.AES_helpers.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.X64.AES128.fsti"
} | [
"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",
"Vale.X64.QuickCode.va_Mod_reg64",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.QuickCode.va_Mod_mem",
"Prims.Nil",
"Vale.AES.X64.AES128.va_wp_KeyExpansion128Stdcall",
"Vale.AES.X64.AES128.va_wpProof_KeyExpansion128Stdcall",
"Vale.X64.QuickCode.va_quickCode"
] | [] | 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.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers
open Vale.X64.CPU_Features_s
#reset-options "--z3rlimit 20"
//-- KeyExpansion128Stdcall
val va_code_KeyExpansion128Stdcall : win:bool -> Tot va_code
val va_codegen_success_KeyExpansion128Stdcall : win:bool -> Tot va_pbool
val va_lemma_KeyExpansion128Stdcall : va_b0:va_code -> va_s0:va_state -> win:bool ->
input_key_b:buffer128 -> output_key_expansion_b:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansion128Stdcall win) va_s0 /\ va_get_ok va_s0
/\ (let (key_ptr:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0
else va_get_reg64 rRdi va_s0) in let (key_expansion_ptr:(va_int_range 0 18446744073709551615))
= (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let
(key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq
(Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in aesni_enabled /\
avx_enabled /\ sse_enabled /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
key_ptr input_key_b 1 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_s0) key_expansion_ptr output_key_expansion_b 11 (va_get_mem_layout
va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (key_ptr:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0
else va_get_reg64 rRdi va_s0) in let (key_expansion_ptr:(va_int_range 0 18446744073709551615))
= (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let
(key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq
(Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in aesni_enabled /\
avx_enabled /\ sse_enabled /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM)
key_ptr input_key_b 1 (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_sM) key_expansion_ptr output_key_expansion_b 11 (va_get_mem_layout
va_sM) Secret) /\ (let (key_ptr:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (key_expansion_ptr:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq
(Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in
Vale.X64.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) /\ (forall j . {:pattern(buffer128_read output_key_expansion_b j
(va_get_mem_heaplet 1 va_sM))}0 <= j /\ j <= 10 ==> Vale.X64.Decls.buffer128_read
output_key_expansion_b j (va_get_mem_heaplet 1 va_sM) == FStar.Seq.Base.index
#Vale.Def.Types_s.quad32 (Vale.AES.AES_s.key_to_round_keys_LE AES_128 key) j)) /\ va_state_eq
va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1
va_sM (va_update_mem_heaplet 1 va_sM (va_update_reg64 rRdx va_sM (va_update_ok va_sM
(va_update_mem va_sM va_s0))))))))))
[@ va_qattr]
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 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) in let (key:(FStar.Seq.Base.seq
Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read
input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in aesni_enabled /\ avx_enabled /\ sse_enabled /\
Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) key_ptr input_key_b 1
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_s0) key_expansion_ptr output_key_expansion_b 11 (va_get_mem_layout va_s0) Secret) /\ (forall
(va_x_mem:vale_heap) (va_x_rdx:nat64) (va_x_heap1:vale_heap) (va_x_xmm1:quad32)
(va_x_xmm2:quad32) (va_x_xmm3:quad32) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_xmm 3 va_x_xmm3 (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1
(va_upd_mem_heaplet 1 va_x_heap1 (va_upd_reg64 rRdx va_x_rdx (va_upd_mem va_x_mem va_s0))))))
in va_get_ok va_sM /\ (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) in let (key:(FStar.Seq.Base.seq
Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read
input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in aesni_enabled /\ avx_enabled /\ sse_enabled /\
Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM) key_ptr input_key_b 1
(va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_sM) key_expansion_ptr output_key_expansion_b 11 (va_get_mem_layout va_sM) Secret) /\ (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) in let (key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) =
Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet
0 va_s0)) in Vale.X64.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1
va_s0) (va_get_mem_heaplet 1 va_sM) /\ (forall j . {:pattern(buffer128_read
output_key_expansion_b j (va_get_mem_heaplet 1 va_sM))}0 <= j /\ j <= 10 ==>
Vale.X64.Decls.buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1 va_sM) ==
FStar.Seq.Base.index #Vale.Def.Types_s.quad32 (Vale.AES.AES_s.key_to_round_keys_LE AES_128 key)
j)) ==> va_k va_sM (())))
val va_wpProof_KeyExpansion128Stdcall : win:bool -> input_key_b:buffer128 ->
output_key_expansion_b:buffer128 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansion128Stdcall win input_key_b
output_key_expansion_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (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_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_KeyExpansion128Stdcall (win:bool) (input_key_b:buffer128) | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"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,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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 == 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.Memory.vuint128 keys_buffer
(va_get_mem_heaplet 0 va_s0) /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
(va_get_reg64 rR8 va_s0) keys_buffer 11 (va_get_mem_layout va_s0) Secret /\ (forall (i:nat) . i
< 11 ==> Vale.X64.Decls.buffer128_read keys_buffer i (va_get_mem_heaplet 0 va_s0) ==
FStar.Seq.Base.index #quad32 round_keys i) /\ (forall (va_x_xmm0:quad32) (va_x_xmm2:quad32)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm 2 va_x_xmm2
(va_upd_xmm 0 va_x_xmm0 va_s0)) in va_get_ok va_sM /\ va_get_xmm 0 va_sM ==
Vale.AES.AES_s.aes_encrypt_LE AES_128 key input ==> va_k va_sM (()))) | 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 quad32))
(keys_buffer: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | 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.Memory.vuint128 keys_buffer (va_get_mem_heaplet 0 va_s0) /\
Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
(va_get_reg64 rR8 va_s0)
keys_buffer
11
(va_get_mem_layout va_s0)
Secret /\
(forall (i: nat).
i < 11 ==>
Vale.X64.Decls.buffer128_read keys_buffer i (va_get_mem_heaplet 0 va_s0) ==
FStar.Seq.Base.index #quad32 round_keys i) /\
(forall (va_x_xmm0: quad32) (va_x_xmm2: quad32) (va_x_efl: Vale.X64.Flags.t).
let va_sM = va_upd_flags va_x_efl (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 0 va_x_xmm0 va_s0)) in
va_get_ok va_sM /\ va_get_xmm 0 va_sM == Vale.AES.AES_s.aes_encrypt_LE AES_128 key input ==>
va_k va_sM (()))) | {
"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.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.InsAes.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"Vale.AES.AES_helpers.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.X64.AES128.fsti"
} | [
"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.is_aes_key_LE",
"Vale.AES.AES_common_s.AES_128",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"Vale.AES.AES_s.key_to_round_keys_LE",
"Vale.X64.Decls.va_get_xmm",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Memory.buffer_addr",
"Vale.X64.Memory.vuint128",
"Vale.X64.Decls.va_get_mem_heaplet",
"Vale.X64.Decls.validSrcAddrs128",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.Arch.HeapTypes_s.Secret",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.op_LessThan",
"Vale.X64.Decls.buffer128_read",
"FStar.Seq.Base.index",
"Vale.X64.Flags.t",
"Vale.Def.Types_s.quad32",
"Vale.AES.AES_s.aes_encrypt_LE",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_xmm"
] | [] | 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.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers
open Vale.X64.CPU_Features_s
#reset-options "--z3rlimit 20"
//-- KeyExpansion128Stdcall
val va_code_KeyExpansion128Stdcall : win:bool -> Tot va_code
val va_codegen_success_KeyExpansion128Stdcall : win:bool -> Tot va_pbool
val va_lemma_KeyExpansion128Stdcall : va_b0:va_code -> va_s0:va_state -> win:bool ->
input_key_b:buffer128 -> output_key_expansion_b:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansion128Stdcall win) va_s0 /\ va_get_ok va_s0
/\ (let (key_ptr:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0
else va_get_reg64 rRdi va_s0) in let (key_expansion_ptr:(va_int_range 0 18446744073709551615))
= (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let
(key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq
(Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in aesni_enabled /\
avx_enabled /\ sse_enabled /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
key_ptr input_key_b 1 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_s0) key_expansion_ptr output_key_expansion_b 11 (va_get_mem_layout
va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (key_ptr:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0
else va_get_reg64 rRdi va_s0) in let (key_expansion_ptr:(va_int_range 0 18446744073709551615))
= (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let
(key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq
(Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in aesni_enabled /\
avx_enabled /\ sse_enabled /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM)
key_ptr input_key_b 1 (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_sM) key_expansion_ptr output_key_expansion_b 11 (va_get_mem_layout
va_sM) Secret) /\ (let (key_ptr:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (key_expansion_ptr:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq
(Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in
Vale.X64.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) /\ (forall j . {:pattern(buffer128_read output_key_expansion_b j
(va_get_mem_heaplet 1 va_sM))}0 <= j /\ j <= 10 ==> Vale.X64.Decls.buffer128_read
output_key_expansion_b j (va_get_mem_heaplet 1 va_sM) == FStar.Seq.Base.index
#Vale.Def.Types_s.quad32 (Vale.AES.AES_s.key_to_round_keys_LE AES_128 key) j)) /\ va_state_eq
va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1
va_sM (va_update_mem_heaplet 1 va_sM (va_update_reg64 rRdx va_sM (va_update_ok va_sM
(va_update_mem va_sM va_s0))))))))))
[@ va_qattr]
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 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) in let (key:(FStar.Seq.Base.seq
Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read
input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in aesni_enabled /\ avx_enabled /\ sse_enabled /\
Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) key_ptr input_key_b 1
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_s0) key_expansion_ptr output_key_expansion_b 11 (va_get_mem_layout va_s0) Secret) /\ (forall
(va_x_mem:vale_heap) (va_x_rdx:nat64) (va_x_heap1:vale_heap) (va_x_xmm1:quad32)
(va_x_xmm2:quad32) (va_x_xmm3:quad32) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_xmm 3 va_x_xmm3 (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1
(va_upd_mem_heaplet 1 va_x_heap1 (va_upd_reg64 rRdx va_x_rdx (va_upd_mem va_x_mem va_s0))))))
in va_get_ok va_sM /\ (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) in let (key:(FStar.Seq.Base.seq
Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read
input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in aesni_enabled /\ avx_enabled /\ sse_enabled /\
Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM) key_ptr input_key_b 1
(va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_sM) key_expansion_ptr output_key_expansion_b 11 (va_get_mem_layout va_sM) Secret) /\ (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) in let (key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) =
Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet
0 va_s0)) in Vale.X64.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1
va_s0) (va_get_mem_heaplet 1 va_sM) /\ (forall j . {:pattern(buffer128_read
output_key_expansion_b j (va_get_mem_heaplet 1 va_sM))}0 <= j /\ j <= 10 ==>
Vale.X64.Decls.buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1 va_sM) ==
FStar.Seq.Base.index #Vale.Def.Types_s.quad32 (Vale.AES.AES_s.key_to_round_keys_LE AES_128 key)
j)) ==> va_k va_sM (())))
val va_wpProof_KeyExpansion128Stdcall : win:bool -> input_key_b:buffer128 ->
output_key_expansion_b:buffer128 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansion128Stdcall win input_key_b
output_key_expansion_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (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_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
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; va_Mod_mem])
(va_wp_KeyExpansion128Stdcall win input_key_b output_key_expansion_b)
(va_wpProof_KeyExpansion128Stdcall win input_key_b output_key_expansion_b))
//--
//-- AES128EncryptBlock
val va_code_AES128EncryptBlock : va_dummy:unit -> Tot va_code
val va_codegen_success_AES128EncryptBlock : va_dummy:unit -> Tot va_pbool
val va_lemma_AES128EncryptBlock : va_b0:va_code -> va_s0:va_state -> input:quad32 -> key:(seq
nat32) -> round_keys:(seq quad32) -> keys_buffer:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_AES128EncryptBlock ()) va_s0 /\ 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.Memory.vuint128 keys_buffer
(va_get_mem_heaplet 0 va_s0) /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
(va_get_reg64 rR8 va_s0) keys_buffer 11 (va_get_mem_layout va_s0) Secret /\ (forall (i:nat) . i
< 11 ==> Vale.X64.Decls.buffer128_read keys_buffer i (va_get_mem_heaplet 0 va_s0) ==
FStar.Seq.Base.index #quad32 round_keys i)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_get_xmm 0 va_sM == Vale.AES.AES_s.aes_encrypt_LE AES_128 key input /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_xmm 2 va_sM (va_update_xmm 0 va_sM (va_update_ok va_sM
va_s0))))))
[@ va_qattr]
let va_wp_AES128EncryptBlock (input:quad32) (key:(seq nat32)) (round_keys:(seq quad32)) | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"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,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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;
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_buffer keys_buffer)) | 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: (seq nat32))
(input_buffer output_buffer keys_buffer: buffer128)
: (va_quickCode unit (va_code_AES128EncryptBlockStdcall win)) = | 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_buffer 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.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.InsAes.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"Vale.AES.AES_helpers.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.X64.AES128.fsti"
} | [
"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",
"Vale.X64.QuickCode.va_Mod_xmm",
"Vale.X64.QuickCode.va_Mod_mem_heaplet",
"Vale.X64.QuickCode.va_Mod_reg64",
"Vale.X64.Machine_s.rR8",
"Vale.X64.QuickCode.va_Mod_mem",
"Prims.Nil",
"Vale.AES.X64.AES128.va_wp_AES128EncryptBlockStdcall",
"Vale.AES.X64.AES128.va_wpProof_AES128EncryptBlockStdcall",
"Vale.X64.QuickCode.va_quickCode"
] | [] | 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.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers
open Vale.X64.CPU_Features_s
#reset-options "--z3rlimit 20"
//-- KeyExpansion128Stdcall
val va_code_KeyExpansion128Stdcall : win:bool -> Tot va_code
val va_codegen_success_KeyExpansion128Stdcall : win:bool -> Tot va_pbool
val va_lemma_KeyExpansion128Stdcall : va_b0:va_code -> va_s0:va_state -> win:bool ->
input_key_b:buffer128 -> output_key_expansion_b:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansion128Stdcall win) va_s0 /\ va_get_ok va_s0
/\ (let (key_ptr:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0
else va_get_reg64 rRdi va_s0) in let (key_expansion_ptr:(va_int_range 0 18446744073709551615))
= (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let
(key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq
(Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in aesni_enabled /\
avx_enabled /\ sse_enabled /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
key_ptr input_key_b 1 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_s0) key_expansion_ptr output_key_expansion_b 11 (va_get_mem_layout
va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (key_ptr:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0
else va_get_reg64 rRdi va_s0) in let (key_expansion_ptr:(va_int_range 0 18446744073709551615))
= (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let
(key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq
(Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in aesni_enabled /\
avx_enabled /\ sse_enabled /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM)
key_ptr input_key_b 1 (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_sM) key_expansion_ptr output_key_expansion_b 11 (va_get_mem_layout
va_sM) Secret) /\ (let (key_ptr:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (key_expansion_ptr:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq
(Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in
Vale.X64.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) /\ (forall j . {:pattern(buffer128_read output_key_expansion_b j
(va_get_mem_heaplet 1 va_sM))}0 <= j /\ j <= 10 ==> Vale.X64.Decls.buffer128_read
output_key_expansion_b j (va_get_mem_heaplet 1 va_sM) == FStar.Seq.Base.index
#Vale.Def.Types_s.quad32 (Vale.AES.AES_s.key_to_round_keys_LE AES_128 key) j)) /\ va_state_eq
va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1
va_sM (va_update_mem_heaplet 1 va_sM (va_update_reg64 rRdx va_sM (va_update_ok va_sM
(va_update_mem va_sM va_s0))))))))))
[@ va_qattr]
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 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) in let (key:(FStar.Seq.Base.seq
Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read
input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in aesni_enabled /\ avx_enabled /\ sse_enabled /\
Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) key_ptr input_key_b 1
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_s0) key_expansion_ptr output_key_expansion_b 11 (va_get_mem_layout va_s0) Secret) /\ (forall
(va_x_mem:vale_heap) (va_x_rdx:nat64) (va_x_heap1:vale_heap) (va_x_xmm1:quad32)
(va_x_xmm2:quad32) (va_x_xmm3:quad32) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_xmm 3 va_x_xmm3 (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1
(va_upd_mem_heaplet 1 va_x_heap1 (va_upd_reg64 rRdx va_x_rdx (va_upd_mem va_x_mem va_s0))))))
in va_get_ok va_sM /\ (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) in let (key:(FStar.Seq.Base.seq
Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read
input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in aesni_enabled /\ avx_enabled /\ sse_enabled /\
Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM) key_ptr input_key_b 1
(va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_sM) key_expansion_ptr output_key_expansion_b 11 (va_get_mem_layout va_sM) Secret) /\ (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) in let (key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) =
Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet
0 va_s0)) in Vale.X64.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1
va_s0) (va_get_mem_heaplet 1 va_sM) /\ (forall j . {:pattern(buffer128_read
output_key_expansion_b j (va_get_mem_heaplet 1 va_sM))}0 <= j /\ j <= 10 ==>
Vale.X64.Decls.buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1 va_sM) ==
FStar.Seq.Base.index #Vale.Def.Types_s.quad32 (Vale.AES.AES_s.key_to_round_keys_LE AES_128 key)
j)) ==> va_k va_sM (())))
val va_wpProof_KeyExpansion128Stdcall : win:bool -> input_key_b:buffer128 ->
output_key_expansion_b:buffer128 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansion128Stdcall win input_key_b
output_key_expansion_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (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_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
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; va_Mod_mem])
(va_wp_KeyExpansion128Stdcall win input_key_b output_key_expansion_b)
(va_wpProof_KeyExpansion128Stdcall win input_key_b output_key_expansion_b))
//--
//-- AES128EncryptBlock
val va_code_AES128EncryptBlock : va_dummy:unit -> Tot va_code
val va_codegen_success_AES128EncryptBlock : va_dummy:unit -> Tot va_pbool
val va_lemma_AES128EncryptBlock : va_b0:va_code -> va_s0:va_state -> input:quad32 -> key:(seq
nat32) -> round_keys:(seq quad32) -> keys_buffer:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_AES128EncryptBlock ()) va_s0 /\ 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.Memory.vuint128 keys_buffer
(va_get_mem_heaplet 0 va_s0) /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
(va_get_reg64 rR8 va_s0) keys_buffer 11 (va_get_mem_layout va_s0) Secret /\ (forall (i:nat) . i
< 11 ==> Vale.X64.Decls.buffer128_read keys_buffer i (va_get_mem_heaplet 0 va_s0) ==
FStar.Seq.Base.index #quad32 round_keys i)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_get_xmm 0 va_sM == Vale.AES.AES_s.aes_encrypt_LE AES_128 key input /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_xmm 2 va_sM (va_update_xmm 0 va_sM (va_update_ok va_sM
va_s0))))))
[@ va_qattr]
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 == 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.Memory.vuint128 keys_buffer
(va_get_mem_heaplet 0 va_s0) /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
(va_get_reg64 rR8 va_s0) keys_buffer 11 (va_get_mem_layout va_s0) Secret /\ (forall (i:nat) . i
< 11 ==> Vale.X64.Decls.buffer128_read keys_buffer i (va_get_mem_heaplet 0 va_s0) ==
FStar.Seq.Base.index #quad32 round_keys i) /\ (forall (va_x_xmm0:quad32) (va_x_xmm2:quad32)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm 2 va_x_xmm2
(va_upd_xmm 0 va_x_xmm0 va_s0)) in va_get_ok va_sM /\ va_get_xmm 0 va_sM ==
Vale.AES.AES_s.aes_encrypt_LE AES_128 key input ==> va_k va_sM (())))
val va_wpProof_AES128EncryptBlock : input:quad32 -> key:(seq nat32) -> round_keys:(seq quad32) ->
keys_buffer:buffer128 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_AES128EncryptBlock input key round_keys keys_buffer va_s0
va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_AES128EncryptBlock ()) ([va_Mod_flags;
va_Mod_xmm 2; va_Mod_xmm 0]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
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_buffer) (va_wpProof_AES128EncryptBlock
input key round_keys keys_buffer))
//--
//-- AES128EncryptBlockStdcall
val va_code_AES128EncryptBlockStdcall : win:bool -> Tot va_code
val va_codegen_success_AES128EncryptBlockStdcall : win:bool -> Tot va_pbool
val va_lemma_AES128EncryptBlockStdcall : va_b0:va_code -> va_s0:va_state -> win:bool ->
input:quad32 -> key:(seq nat32) -> input_buffer:buffer128 -> output_buffer:buffer128 ->
keys_buffer:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_AES128EncryptBlockStdcall win) va_s0 /\ va_get_ok
va_s0 /\ (let (output_ptr:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64
rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (input_ptr:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (expanded_key_ptr:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8
va_s0 else va_get_reg64 rRdx va_s0) in aesni_enabled /\ sse_enabled /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ Vale.X64.Decls.buffer128_read input_buffer 0
(va_get_mem_heaplet 0 va_s0) == input /\ expanded_key_ptr == Vale.X64.Memory.buffer_addr
#Vale.X64.Memory.vuint128 keys_buffer (va_get_mem_heaplet 0 va_s0) /\
Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) input_ptr input_buffer 1
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_s0) output_ptr output_buffer 1 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) expanded_key_ptr keys_buffer 11
(va_get_mem_layout va_s0) Secret /\ (forall (i:nat) . i < 11 ==> Vale.X64.Decls.buffer128_read
keys_buffer i (va_get_mem_heaplet 0 va_s0) == FStar.Seq.Base.index #Vale.Def.Types_s.quad32
(Vale.AES.AES_s.key_to_round_keys_LE AES_128 key) i))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (output_ptr:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0
else va_get_reg64 rRdi va_s0) in let (input_ptr:(va_int_range 0 18446744073709551615)) = (if
win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let
(expanded_key_ptr:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0
else va_get_reg64 rRdx va_s0) in Vale.X64.Decls.modifies_mem (Vale.X64.Decls.loc_buffer
#Vale.X64.Memory.vuint128 output_buffer) (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet 1
va_sM) /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 1 va_sM) output_ptr output_buffer
1 (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.buffer128_read output_buffer 0
(va_get_mem_heaplet 1 va_sM) == Vale.AES.AES_s.aes_encrypt_LE AES_128 key input) /\ va_state_eq
va_sM (va_update_flags va_sM (va_update_xmm 2 va_sM (va_update_xmm 0 va_sM
(va_update_mem_heaplet 1 va_sM (va_update_reg64 rR8 va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))
[@ va_qattr]
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 _ ->
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) in let (expanded_key_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _
-> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in aesni_enabled /\ sse_enabled
/\ Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ Vale.X64.Decls.buffer128_read input_buffer 0
(va_get_mem_heaplet 0 va_s0) == input /\ expanded_key_ptr == Vale.X64.Memory.buffer_addr
#Vale.X64.Memory.vuint128 keys_buffer (va_get_mem_heaplet 0 va_s0) /\
Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) input_ptr input_buffer 1
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_s0) output_ptr output_buffer 1 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) expanded_key_ptr keys_buffer 11
(va_get_mem_layout va_s0) Secret /\ (forall (i:nat) . i < 11 ==> Vale.X64.Decls.buffer128_read
keys_buffer i (va_get_mem_heaplet 0 va_s0) == FStar.Seq.Base.index #Vale.Def.Types_s.quad32
(Vale.AES.AES_s.key_to_round_keys_LE AES_128 key) i)) /\ (forall (va_x_mem:vale_heap)
(va_x_r8:nat64) (va_x_heap1:vale_heap) (va_x_xmm0:quad32) (va_x_xmm2:quad32)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm 2 va_x_xmm2
(va_upd_xmm 0 va_x_xmm0 (va_upd_mem_heaplet 1 va_x_heap1 (va_upd_reg64 rR8 va_x_r8 (va_upd_mem
va_x_mem va_s0))))) in va_get_ok va_sM /\ (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) in let
(expanded_key_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8
va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in Vale.X64.Decls.modifies_mem
(Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint128 output_buffer) (va_get_mem_heaplet 1
va_s0) (va_get_mem_heaplet 1 va_sM) /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 1
va_sM) output_ptr output_buffer 1 (va_get_mem_layout va_sM) Secret /\
Vale.X64.Decls.buffer128_read output_buffer 0 (va_get_mem_heaplet 1 va_sM) ==
Vale.AES.AES_s.aes_encrypt_LE AES_128 key input) ==> va_k va_sM (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_AES128EncryptBlockStdcall win input key input_buffer
output_buffer keys_buffer va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (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_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_AES128EncryptBlockStdcall (win:bool) (input:quad32) (key:(seq nat32))
(input_buffer:buffer128) (output_buffer:buffer128) (keys_buffer:buffer128) : (va_quickCode unit | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.AES128.va_code_AES128EncryptBlockStdcall win) | {
"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,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"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,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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 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) in let (key:(FStar.Seq.Base.seq
Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read
input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in aesni_enabled /\ avx_enabled /\ sse_enabled /\
Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) key_ptr input_key_b 1
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_s0) key_expansion_ptr output_key_expansion_b 11 (va_get_mem_layout va_s0) Secret) /\ (forall
(va_x_mem:vale_heap) (va_x_rdx:nat64) (va_x_heap1:vale_heap) (va_x_xmm1:quad32)
(va_x_xmm2:quad32) (va_x_xmm3:quad32) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_xmm 3 va_x_xmm3 (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1
(va_upd_mem_heaplet 1 va_x_heap1 (va_upd_reg64 rRdx va_x_rdx (va_upd_mem va_x_mem va_s0))))))
in va_get_ok va_sM /\ (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) in let (key:(FStar.Seq.Base.seq
Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read
input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in aesni_enabled /\ avx_enabled /\ sse_enabled /\
Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM) key_ptr input_key_b 1
(va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_sM) key_expansion_ptr output_key_expansion_b 11 (va_get_mem_layout va_sM) Secret) /\ (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) in let (key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) =
Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet
0 va_s0)) in Vale.X64.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1
va_s0) (va_get_mem_heaplet 1 va_sM) /\ (forall j . {:pattern(buffer128_read
output_key_expansion_b j (va_get_mem_heaplet 1 va_sM))}0 <= j /\ j <= 10 ==>
Vale.X64.Decls.buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1 va_sM) ==
FStar.Seq.Base.index #Vale.Def.Types_s.quad32 (Vale.AES.AES_s.key_to_round_keys_LE AES_128 key)
j)) ==> va_k va_sM (()))) | 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)
(va_k: (va_state -> unit -> Type0))
: Type0 = | 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)
in
let key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32) =
Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read input_key_b
0
(va_get_mem_heaplet 0 va_s0))
in
aesni_enabled /\ avx_enabled /\ sse_enabled /\
Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
key_ptr
input_key_b
1
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0)
key_expansion_ptr
output_key_expansion_b
11
(va_get_mem_layout va_s0)
Secret) /\
(forall (va_x_mem: vale_heap)
(va_x_rdx: nat64)
(va_x_heap1: vale_heap)
(va_x_xmm1: quad32)
(va_x_xmm2: quad32)
(va_x_xmm3: quad32)
(va_x_efl: Vale.X64.Flags.t).
let va_sM =
va_upd_flags va_x_efl
(va_upd_xmm 3
va_x_xmm3
(va_upd_xmm 2
va_x_xmm2
(va_upd_xmm 1
va_x_xmm1
(va_upd_mem_heaplet 1
va_x_heap1
(va_upd_reg64 rRdx va_x_rdx (va_upd_mem va_x_mem va_s0))))))
in
va_get_ok va_sM /\
(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)
in
let key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32) =
Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read input_key_b
0
(va_get_mem_heaplet 0 va_s0))
in
aesni_enabled /\ avx_enabled /\ sse_enabled /\
Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM)
key_ptr
input_key_b
1
(va_get_mem_layout va_sM)
Secret /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM)
key_expansion_ptr
output_key_expansion_b
11
(va_get_mem_layout va_sM)
Secret) /\
(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)
in
let key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32) =
Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read input_key_b
0
(va_get_mem_heaplet 0 va_s0))
in
Vale.X64.Decls.modifies_buffer128 output_key_expansion_b
(va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) /\
(forall j. {:pattern (buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1 va_sM))}
0 <= j /\ j <= 10 ==>
Vale.X64.Decls.buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1 va_sM) ==
FStar.Seq.Base.index #Vale.Def.Types_s.quad32
(Vale.AES.AES_s.key_to_round_keys_LE AES_128 key)
j)) ==>
va_k va_sM (()))) | {
"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.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.InsAes.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"Vale.AES.AES_helpers.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.X64.AES128.fsti"
} | [
"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",
"Vale.X64.Decls.va_get_mem_heaplet",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.validDstAddrs128",
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.nat32",
"Vale.Arch.Types.quad32_to_seq",
"Vale.X64.Decls.buffer128_read",
"Vale.X64.Decls.va_int_range",
"Vale.X64.Decls.va_if",
"Vale.Def.Types_s.nat64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRdx",
"Prims.l_not",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRdi",
"Prims.l_Forall",
"Vale.X64.InsBasic.vale_heap",
"Vale.X64.Memory.nat64",
"Vale.X64.Decls.quad32",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Vale.X64.Decls.modifies_buffer128",
"Prims.int",
"Prims.op_GreaterThanOrEqual",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Vale.Def.Types_s.quad32",
"Vale.AES.AES_s.key_to_round_keys_LE",
"Vale.AES.AES_common_s.AES_128",
"Prims.op_LessThanOrEqual",
"Prims.eq2",
"FStar.Seq.Base.index",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_xmm",
"Vale.X64.Decls.va_upd_mem_heaplet",
"Vale.X64.Decls.va_upd_reg64",
"Vale.X64.Decls.va_upd_mem"
] | [] | 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.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers
open Vale.X64.CPU_Features_s
#reset-options "--z3rlimit 20"
//-- KeyExpansion128Stdcall
val va_code_KeyExpansion128Stdcall : win:bool -> Tot va_code
val va_codegen_success_KeyExpansion128Stdcall : win:bool -> Tot va_pbool
val va_lemma_KeyExpansion128Stdcall : va_b0:va_code -> va_s0:va_state -> win:bool ->
input_key_b:buffer128 -> output_key_expansion_b:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansion128Stdcall win) va_s0 /\ va_get_ok va_s0
/\ (let (key_ptr:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0
else va_get_reg64 rRdi va_s0) in let (key_expansion_ptr:(va_int_range 0 18446744073709551615))
= (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let
(key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq
(Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in aesni_enabled /\
avx_enabled /\ sse_enabled /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
key_ptr input_key_b 1 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_s0) key_expansion_ptr output_key_expansion_b 11 (va_get_mem_layout
va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (key_ptr:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0
else va_get_reg64 rRdi va_s0) in let (key_expansion_ptr:(va_int_range 0 18446744073709551615))
= (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let
(key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq
(Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in aesni_enabled /\
avx_enabled /\ sse_enabled /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM)
key_ptr input_key_b 1 (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_sM) key_expansion_ptr output_key_expansion_b 11 (va_get_mem_layout
va_sM) Secret) /\ (let (key_ptr:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (key_expansion_ptr:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq
(Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in
Vale.X64.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) /\ (forall j . {:pattern(buffer128_read output_key_expansion_b j
(va_get_mem_heaplet 1 va_sM))}0 <= j /\ j <= 10 ==> Vale.X64.Decls.buffer128_read
output_key_expansion_b j (va_get_mem_heaplet 1 va_sM) == FStar.Seq.Base.index
#Vale.Def.Types_s.quad32 (Vale.AES.AES_s.key_to_round_keys_LE AES_128 key) j)) /\ va_state_eq
va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1
va_sM (va_update_mem_heaplet 1 va_sM (va_update_reg64 rRdx va_sM (va_update_ok va_sM
(va_update_mem va_sM va_s0))))))))))
[@ va_qattr]
let va_wp_KeyExpansion128Stdcall (win:bool) (input_key_b:buffer128) | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"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,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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 _ ->
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) in let (expanded_key_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _
-> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in aesni_enabled /\ sse_enabled
/\ Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ Vale.X64.Decls.buffer128_read input_buffer 0
(va_get_mem_heaplet 0 va_s0) == input /\ expanded_key_ptr == Vale.X64.Memory.buffer_addr
#Vale.X64.Memory.vuint128 keys_buffer (va_get_mem_heaplet 0 va_s0) /\
Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) input_ptr input_buffer 1
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_s0) output_ptr output_buffer 1 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) expanded_key_ptr keys_buffer 11
(va_get_mem_layout va_s0) Secret /\ (forall (i:nat) . i < 11 ==> Vale.X64.Decls.buffer128_read
keys_buffer i (va_get_mem_heaplet 0 va_s0) == FStar.Seq.Base.index #Vale.Def.Types_s.quad32
(Vale.AES.AES_s.key_to_round_keys_LE AES_128 key) i)) /\ (forall (va_x_mem:vale_heap)
(va_x_r8:nat64) (va_x_heap1:vale_heap) (va_x_xmm0:quad32) (va_x_xmm2:quad32)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm 2 va_x_xmm2
(va_upd_xmm 0 va_x_xmm0 (va_upd_mem_heaplet 1 va_x_heap1 (va_upd_reg64 rR8 va_x_r8 (va_upd_mem
va_x_mem va_s0))))) in va_get_ok va_sM /\ (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) in let
(expanded_key_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rR8
va_s0) (fun _ -> va_get_reg64 rRdx va_s0) in Vale.X64.Decls.modifies_mem
(Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint128 output_buffer) (va_get_mem_heaplet 1
va_s0) (va_get_mem_heaplet 1 va_sM) /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 1
va_sM) output_ptr output_buffer 1 (va_get_mem_layout va_sM) Secret /\
Vale.X64.Decls.buffer128_read output_buffer 0 (va_get_mem_heaplet 1 va_sM) ==
Vale.AES.AES_s.aes_encrypt_LE AES_128 key input) ==> va_k va_sM (()))) | 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)
(key: (seq nat32))
(input_buffer output_buffer keys_buffer: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | 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)
in
let expanded_key_ptr:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0)
in
aesni_enabled /\ sse_enabled /\ Vale.AES.AES_s.is_aes_key_LE AES_128 key /\
Vale.X64.Decls.buffer128_read input_buffer 0 (va_get_mem_heaplet 0 va_s0) == input /\
expanded_key_ptr ==
Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 keys_buffer (va_get_mem_heaplet 0 va_s0) /\
Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
input_ptr
input_buffer
1
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0)
output_ptr
output_buffer
1
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
expanded_key_ptr
keys_buffer
11
(va_get_mem_layout va_s0)
Secret /\
(forall (i: nat).
i < 11 ==>
Vale.X64.Decls.buffer128_read keys_buffer i (va_get_mem_heaplet 0 va_s0) ==
FStar.Seq.Base.index #Vale.Def.Types_s.quad32
(Vale.AES.AES_s.key_to_round_keys_LE AES_128 key)
i)) /\
(forall (va_x_mem: vale_heap)
(va_x_r8: nat64)
(va_x_heap1: vale_heap)
(va_x_xmm0: quad32)
(va_x_xmm2: quad32)
(va_x_efl: Vale.X64.Flags.t).
let va_sM =
va_upd_flags va_x_efl
(va_upd_xmm 2
va_x_xmm2
(va_upd_xmm 0
va_x_xmm0
(va_upd_mem_heaplet 1
va_x_heap1
(va_upd_reg64 rR8 va_x_r8 (va_upd_mem va_x_mem va_s0)))))
in
va_get_ok va_sM /\
(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)
in
let expanded_key_ptr:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rR8 va_s0) (fun _ -> va_get_reg64 rRdx va_s0)
in
Vale.X64.Decls.modifies_mem (Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint128
output_buffer)
(va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) /\
Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 1 va_sM)
output_ptr
output_buffer
1
(va_get_mem_layout va_sM)
Secret /\
Vale.X64.Decls.buffer128_read output_buffer 0 (va_get_mem_heaplet 1 va_sM) ==
Vale.AES.AES_s.aes_encrypt_LE AES_128 key input) ==>
va_k va_sM (()))) | {
"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.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.InsAes.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"Vale.AES.AES_helpers.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.X64.AES128.fsti"
} | [
"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",
"Vale.AES.AES_s.is_aes_key_LE",
"Vale.AES.AES_common_s.AES_128",
"Prims.eq2",
"Vale.X64.Decls.buffer128_read",
"Vale.X64.Decls.va_get_mem_heaplet",
"Prims.int",
"Vale.X64.Memory.buffer_addr",
"Vale.X64.Memory.vuint128",
"Vale.X64.Decls.validSrcAddrs128",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.validDstAddrs128",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.op_LessThan",
"Vale.Def.Types_s.quad32",
"FStar.Seq.Base.index",
"Vale.AES.AES_s.key_to_round_keys_LE",
"Vale.X64.Decls.va_int_range",
"Vale.X64.Decls.va_if",
"Vale.Def.Types_s.nat64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rR8",
"Prims.l_not",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRdi",
"Vale.X64.InsBasic.vale_heap",
"Vale.X64.Memory.nat64",
"Vale.X64.Flags.t",
"Vale.X64.Decls.modifies_mem",
"Vale.X64.Decls.loc_buffer",
"Vale.AES.AES_s.aes_encrypt_LE",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_xmm",
"Vale.X64.Decls.va_upd_mem_heaplet",
"Vale.X64.Decls.va_upd_reg64",
"Vale.X64.Decls.va_upd_mem"
] | [] | 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.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers
open Vale.X64.CPU_Features_s
#reset-options "--z3rlimit 20"
//-- KeyExpansion128Stdcall
val va_code_KeyExpansion128Stdcall : win:bool -> Tot va_code
val va_codegen_success_KeyExpansion128Stdcall : win:bool -> Tot va_pbool
val va_lemma_KeyExpansion128Stdcall : va_b0:va_code -> va_s0:va_state -> win:bool ->
input_key_b:buffer128 -> output_key_expansion_b:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansion128Stdcall win) va_s0 /\ va_get_ok va_s0
/\ (let (key_ptr:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0
else va_get_reg64 rRdi va_s0) in let (key_expansion_ptr:(va_int_range 0 18446744073709551615))
= (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let
(key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq
(Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in aesni_enabled /\
avx_enabled /\ sse_enabled /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
key_ptr input_key_b 1 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_s0) key_expansion_ptr output_key_expansion_b 11 (va_get_mem_layout
va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (key_ptr:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0
else va_get_reg64 rRdi va_s0) in let (key_expansion_ptr:(va_int_range 0 18446744073709551615))
= (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let
(key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq
(Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in aesni_enabled /\
avx_enabled /\ sse_enabled /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM)
key_ptr input_key_b 1 (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_sM) key_expansion_ptr output_key_expansion_b 11 (va_get_mem_layout
va_sM) Secret) /\ (let (key_ptr:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (key_expansion_ptr:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq
(Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in
Vale.X64.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) /\ (forall j . {:pattern(buffer128_read output_key_expansion_b j
(va_get_mem_heaplet 1 va_sM))}0 <= j /\ j <= 10 ==> Vale.X64.Decls.buffer128_read
output_key_expansion_b j (va_get_mem_heaplet 1 va_sM) == FStar.Seq.Base.index
#Vale.Def.Types_s.quad32 (Vale.AES.AES_s.key_to_round_keys_LE AES_128 key) j)) /\ va_state_eq
va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1
va_sM (va_update_mem_heaplet 1 va_sM (va_update_reg64 rRdx va_sM (va_update_ok va_sM
(va_update_mem va_sM va_s0))))))))))
[@ va_qattr]
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 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) in let (key:(FStar.Seq.Base.seq
Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read
input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in aesni_enabled /\ avx_enabled /\ sse_enabled /\
Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) key_ptr input_key_b 1
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_s0) key_expansion_ptr output_key_expansion_b 11 (va_get_mem_layout va_s0) Secret) /\ (forall
(va_x_mem:vale_heap) (va_x_rdx:nat64) (va_x_heap1:vale_heap) (va_x_xmm1:quad32)
(va_x_xmm2:quad32) (va_x_xmm3:quad32) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_xmm 3 va_x_xmm3 (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1
(va_upd_mem_heaplet 1 va_x_heap1 (va_upd_reg64 rRdx va_x_rdx (va_upd_mem va_x_mem va_s0))))))
in va_get_ok va_sM /\ (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) in let (key:(FStar.Seq.Base.seq
Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read
input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in aesni_enabled /\ avx_enabled /\ sse_enabled /\
Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM) key_ptr input_key_b 1
(va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_sM) key_expansion_ptr output_key_expansion_b 11 (va_get_mem_layout va_sM) Secret) /\ (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) in let (key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) =
Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet
0 va_s0)) in Vale.X64.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1
va_s0) (va_get_mem_heaplet 1 va_sM) /\ (forall j . {:pattern(buffer128_read
output_key_expansion_b j (va_get_mem_heaplet 1 va_sM))}0 <= j /\ j <= 10 ==>
Vale.X64.Decls.buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1 va_sM) ==
FStar.Seq.Base.index #Vale.Def.Types_s.quad32 (Vale.AES.AES_s.key_to_round_keys_LE AES_128 key)
j)) ==> va_k va_sM (())))
val va_wpProof_KeyExpansion128Stdcall : win:bool -> input_key_b:buffer128 ->
output_key_expansion_b:buffer128 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansion128Stdcall win input_key_b
output_key_expansion_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (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_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
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; va_Mod_mem])
(va_wp_KeyExpansion128Stdcall win input_key_b output_key_expansion_b)
(va_wpProof_KeyExpansion128Stdcall win input_key_b output_key_expansion_b))
//--
//-- AES128EncryptBlock
val va_code_AES128EncryptBlock : va_dummy:unit -> Tot va_code
val va_codegen_success_AES128EncryptBlock : va_dummy:unit -> Tot va_pbool
val va_lemma_AES128EncryptBlock : va_b0:va_code -> va_s0:va_state -> input:quad32 -> key:(seq
nat32) -> round_keys:(seq quad32) -> keys_buffer:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_AES128EncryptBlock ()) va_s0 /\ 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.Memory.vuint128 keys_buffer
(va_get_mem_heaplet 0 va_s0) /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
(va_get_reg64 rR8 va_s0) keys_buffer 11 (va_get_mem_layout va_s0) Secret /\ (forall (i:nat) . i
< 11 ==> Vale.X64.Decls.buffer128_read keys_buffer i (va_get_mem_heaplet 0 va_s0) ==
FStar.Seq.Base.index #quad32 round_keys i)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_get_xmm 0 va_sM == Vale.AES.AES_s.aes_encrypt_LE AES_128 key input /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_xmm 2 va_sM (va_update_xmm 0 va_sM (va_update_ok va_sM
va_s0))))))
[@ va_qattr]
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 == 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.Memory.vuint128 keys_buffer
(va_get_mem_heaplet 0 va_s0) /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
(va_get_reg64 rR8 va_s0) keys_buffer 11 (va_get_mem_layout va_s0) Secret /\ (forall (i:nat) . i
< 11 ==> Vale.X64.Decls.buffer128_read keys_buffer i (va_get_mem_heaplet 0 va_s0) ==
FStar.Seq.Base.index #quad32 round_keys i) /\ (forall (va_x_xmm0:quad32) (va_x_xmm2:quad32)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm 2 va_x_xmm2
(va_upd_xmm 0 va_x_xmm0 va_s0)) in va_get_ok va_sM /\ va_get_xmm 0 va_sM ==
Vale.AES.AES_s.aes_encrypt_LE AES_128 key input ==> va_k va_sM (())))
val va_wpProof_AES128EncryptBlock : input:quad32 -> key:(seq nat32) -> round_keys:(seq quad32) ->
keys_buffer:buffer128 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_AES128EncryptBlock input key round_keys keys_buffer va_s0
va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_AES128EncryptBlock ()) ([va_Mod_flags;
va_Mod_xmm 2; va_Mod_xmm 0]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
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_buffer) (va_wpProof_AES128EncryptBlock
input key round_keys keys_buffer))
//--
//-- AES128EncryptBlockStdcall
val va_code_AES128EncryptBlockStdcall : win:bool -> Tot va_code
val va_codegen_success_AES128EncryptBlockStdcall : win:bool -> Tot va_pbool
val va_lemma_AES128EncryptBlockStdcall : va_b0:va_code -> va_s0:va_state -> win:bool ->
input:quad32 -> key:(seq nat32) -> input_buffer:buffer128 -> output_buffer:buffer128 ->
keys_buffer:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_AES128EncryptBlockStdcall win) va_s0 /\ va_get_ok
va_s0 /\ (let (output_ptr:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64
rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (input_ptr:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
let (expanded_key_ptr:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8
va_s0 else va_get_reg64 rRdx va_s0) in aesni_enabled /\ sse_enabled /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ Vale.X64.Decls.buffer128_read input_buffer 0
(va_get_mem_heaplet 0 va_s0) == input /\ expanded_key_ptr == Vale.X64.Memory.buffer_addr
#Vale.X64.Memory.vuint128 keys_buffer (va_get_mem_heaplet 0 va_s0) /\
Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) input_ptr input_buffer 1
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_s0) output_ptr output_buffer 1 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) expanded_key_ptr keys_buffer 11
(va_get_mem_layout va_s0) Secret /\ (forall (i:nat) . i < 11 ==> Vale.X64.Decls.buffer128_read
keys_buffer i (va_get_mem_heaplet 0 va_s0) == FStar.Seq.Base.index #Vale.Def.Types_s.quad32
(Vale.AES.AES_s.key_to_round_keys_LE AES_128 key) i))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (output_ptr:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0
else va_get_reg64 rRdi va_s0) in let (input_ptr:(va_int_range 0 18446744073709551615)) = (if
win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let
(expanded_key_ptr:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rR8 va_s0
else va_get_reg64 rRdx va_s0) in Vale.X64.Decls.modifies_mem (Vale.X64.Decls.loc_buffer
#Vale.X64.Memory.vuint128 output_buffer) (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet 1
va_sM) /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 1 va_sM) output_ptr output_buffer
1 (va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.buffer128_read output_buffer 0
(va_get_mem_heaplet 1 va_sM) == Vale.AES.AES_s.aes_encrypt_LE AES_128 key input) /\ va_state_eq
va_sM (va_update_flags va_sM (va_update_xmm 2 va_sM (va_update_xmm 0 va_sM
(va_update_mem_heaplet 1 va_sM (va_update_reg64 rR8 va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))
[@ va_qattr]
let va_wp_AES128EncryptBlockStdcall (win:bool) (input:quad32) (key:(seq nat32))
(input_buffer:buffer128) (output_buffer:buffer128) (keys_buffer:buffer128) (va_s0:va_state) | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"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,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Comparison.fst"
} | [
"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 and test functions
///
val bn_is_odd: #t:limb_t -> #len:size_pos -> a:lbignum t len -> limb t
let bn_is_odd #t #len b = b.[0] &. uint #t 1
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 =
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_lemma b.[0] 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1))
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 =
BSeq.seq_eq_mask a b len
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 =
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_is_zero_mask: #t:limb_t -> #len:size_nat -> a:lbignum t len -> limb t
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_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 =
let bn_zero = create len (uint #t 0) in
bn_eval_zeroes #t len len;
bn_eq_mask_lemma b bn_zero
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 =
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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Comparison.fst"
} | [
"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 and test functions
///
val bn_is_odd: #t:limb_t -> #len:size_pos -> a:lbignum t len -> limb t
let bn_is_odd #t #len b = b.[0] &. uint #t 1
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 =
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_lemma b.[0] 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1))
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 =
BSeq.seq_eq_mask a b len
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 =
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_is_zero_mask: #t:limb_t -> #len:size_nat -> a:lbignum t len -> limb t
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_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 =
let bn_zero = create len (uint #t 0) in
bn_eval_zeroes #t len len;
bn_eq_mask_lemma b bn_zero
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 =
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))
let bn_lt_mask_t (t:limb_t) (len:size_nat) (i:nat{i <= len}) = limb t
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 =
Loops.repeat_gen len (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0)
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 mask = bn_lt_mask_f a b (k - 1) mask0 in
(if v mask = 0 then eval_ len a k >= eval_ len b k else eval_ len a k < eval_ len b k) /\
mask_values mask))
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 t SEC) else v blt == 0);
let res0 = mask_select blt (ones t SEC) (zeros t SEC) in
let mask = mask_select beq mask0 res0 in
//assert (mask == bn_lt_mask_f #len a b (k - 1) mask0);
mask_select_lemma blt (ones t SEC) (zeros t SEC);
mask_select_lemma beq mask0 res0;
if v beq = 0 then begin
assert (v mask = v res0);
mask_select_lemma blt (ones t SEC) (zeros t SEC);
//assert (v res0 == (if v blt = 0 then 0 else v (ones t SEC)));
assert (if v mask = 0 then v ai > v bi else v ai < v bi);
if v a.[k - 1] < v b.[k - 1] then bn_eval_lt len a b k else bn_eval_lt len b a k;
() end
else begin
assert (v mask = v mask0);
//assert (v beq == v (ones t SEC));
//assert (if v mask = v mask0 then v ai = v bi else v ai <> v bi);
assert (v ai == v bi);
bn_eval_unfold_i a k;
bn_eval_unfold_i b k;
() end
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_ len b k))
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 mask0 = Loops.repeat_gen (k - 1) (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0) in
Loops.unfold_repeat_gen k (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0) (k - 1);
bn_lt_mask_lemma_loop a b (k - 1);
bn_lt_mask_lemma_step a b k mask0 end
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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 -> Hacl.Spec.Bignum.Definitions.bn_v a >= Hacl.Spec.Bignum.Definitions.bn_v b
| _ -> Hacl.Spec.Bignum.Definitions.bn_v a < Hacl.Spec.Bignum.Definitions.bn_v b)) | {
"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,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Comparison.fst"
} | [
"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 and test functions
///
val bn_is_odd: #t:limb_t -> #len:size_pos -> a:lbignum t len -> limb t
let bn_is_odd #t #len b = b.[0] &. uint #t 1
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 =
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_lemma b.[0] 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1))
val bn_eq_mask: #t:limb_t -> #len:size_nat -> a:lbignum t len -> b:lbignum t len -> limb t | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Comparison.fst"
} | [
"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.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 and test functions
///
val bn_is_odd: #t:limb_t -> #len:size_pos -> a:lbignum t len -> limb t
let bn_is_odd #t #len b = b.[0] &. uint #t 1
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 =
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_lemma b.[0] 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1))
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 =
BSeq.seq_eq_mask a b len
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 =
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_is_zero_mask: #t:limb_t -> #len:size_nat -> a:lbignum t len -> limb t
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_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 =
let bn_zero = create len (uint #t 0) in
bn_eval_zeroes #t len len;
bn_eq_mask_lemma b bn_zero
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 =
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))
let bn_lt_mask_t (t:limb_t) (len:size_nat) (i:nat{i <= len}) = limb t
val bn_lt_mask: #t:limb_t -> #len:size_nat -> a:lbignum t len -> b:lbignum t len -> limb t | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Comparison.fst"
} | [
"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.IntTypes.int_t",
"Lib.IntTypes.lt_mask",
"Lib.Sequence.op_String_Access",
"Lib.IntTypes.eq_mask"
] | [] | 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 and test functions
///
val bn_is_odd: #t:limb_t -> #len:size_pos -> a:lbignum t len -> limb t
let bn_is_odd #t #len b = b.[0] &. uint #t 1
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 =
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_lemma b.[0] 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1))
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 =
BSeq.seq_eq_mask a b len
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 =
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_is_zero_mask: #t:limb_t -> #len:size_nat -> a:lbignum t len -> limb t
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_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 =
let bn_zero = create len (uint #t 0) in
bn_eval_zeroes #t len len;
bn_eq_mask_lemma b bn_zero | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Comparison.fst"
} | [
"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 and test functions
/// | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Comparison.fst"
} | [
"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.create",
"Lib.IntTypes.mk_int",
"Lib.IntTypes.SEC",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.Sequence.index",
"Lib.Sequence.create",
"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 and test functions
///
val bn_is_odd: #t:limb_t -> #len:size_pos -> a:lbignum t len -> limb t
let bn_is_odd #t #len b = b.[0] &. uint #t 1
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 =
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_lemma b.[0] 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1))
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 =
BSeq.seq_eq_mask a b len
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 =
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 | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Comparison.fst"
} | [
"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.Bignum.Definitions.limb",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Lib.IntTypes.SEC",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Lib.Sequence.index",
"Lib.Sequence.create",
"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 and test functions
///
val bn_is_odd: #t:limb_t -> #len:size_pos -> a:lbignum t len -> limb t
let bn_is_odd #t #len b = b.[0] &. uint #t 1
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 =
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_lemma b.[0] 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1))
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 =
BSeq.seq_eq_mask a b len
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 =
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_is_zero_mask: #t:limb_t -> #len:size_nat -> a:lbignum t len -> limb t
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_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 =
let bn_zero = create len (uint #t 0) in
bn_eval_zeroes #t len len;
bn_eq_mask_lemma b bn_zero
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 =
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))
let bn_lt_mask_t (t:limb_t) (len:size_nat) (i:nat{i <= len}) = limb t
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 =
Loops.repeat_gen len (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0)
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 mask = bn_lt_mask_f a b (k - 1) mask0 in
(if v mask = 0 then eval_ len a k >= eval_ len b k else eval_ len a k < eval_ len b k) /\
mask_values mask))
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 t SEC) else v blt == 0);
let res0 = mask_select blt (ones t SEC) (zeros t SEC) in
let mask = mask_select beq mask0 res0 in
//assert (mask == bn_lt_mask_f #len a b (k - 1) mask0);
mask_select_lemma blt (ones t SEC) (zeros t SEC);
mask_select_lemma beq mask0 res0;
if v beq = 0 then begin
assert (v mask = v res0);
mask_select_lemma blt (ones t SEC) (zeros t SEC);
//assert (v res0 == (if v blt = 0 then 0 else v (ones t SEC)));
assert (if v mask = 0 then v ai > v bi else v ai < v bi);
if v a.[k - 1] < v b.[k - 1] then bn_eval_lt len a b k else bn_eval_lt len b a k;
() end
else begin
assert (v mask = v mask0);
//assert (v beq == v (ones t SEC));
//assert (if v mask = v mask0 then v ai = v bi else v ai <> v bi);
assert (v ai == v bi);
bn_eval_unfold_i a k;
bn_eval_unfold_i b k;
() end
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_ len b k))
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 mask0 = Loops.repeat_gen (k - 1) (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0) in
Loops.unfold_repeat_gen k (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0) (k - 1);
bn_lt_mask_lemma_loop a b (k - 1);
bn_lt_mask_lemma_step a b k mask0 end
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 =
bn_lt_mask_lemma_loop a b len | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Comparison.fst"
} | [
"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",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Lib.IntTypes.SEC",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.Sequence.index",
"Lib.Sequence.create",
"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 and test functions
///
val bn_is_odd: #t:limb_t -> #len:size_pos -> a:lbignum t len -> limb t
let bn_is_odd #t #len b = b.[0] &. uint #t 1
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 =
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_lemma b.[0] 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1))
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 =
BSeq.seq_eq_mask a b len
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 =
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_is_zero_mask: #t:limb_t -> #len:size_nat -> a:lbignum t len -> limb t
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_lemma: #t:limb_t -> #len:size_nat -> a:lbignum t len ->
Lemma (mask_values (bn_is_zero_mask a) /\ | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 <> 0
| _ -> Hacl.Spec.Bignum.Definitions.bn_v a = 0)) | {
"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,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Comparison.fst"
} | [
"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.Bignum.Definitions.limb",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Lib.IntTypes.SEC",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Lib.Sequence.index",
"Lib.Sequence.create",
"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 and test functions
///
val bn_is_odd: #t:limb_t -> #len:size_pos -> a:lbignum t len -> limb t
let bn_is_odd #t #len b = b.[0] &. uint #t 1
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 =
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_lemma b.[0] 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1))
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 =
BSeq.seq_eq_mask a b len
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 =
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_is_zero_mask: #t:limb_t -> #len:size_nat -> a:lbignum t len -> limb t
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_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 =
let bn_zero = create len (uint #t 0) in
bn_eval_zeroes #t len len;
bn_eq_mask_lemma b bn_zero
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 =
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))
let bn_lt_mask_t (t:limb_t) (len:size_nat) (i:nat{i <= len}) = limb t
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 =
Loops.repeat_gen len (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0)
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 mask = bn_lt_mask_f a b (k - 1) mask0 in
(if v mask = 0 then eval_ len a k >= eval_ len b k else eval_ len a k < eval_ len b k) /\
mask_values mask))
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 t SEC) else v blt == 0);
let res0 = mask_select blt (ones t SEC) (zeros t SEC) in
let mask = mask_select beq mask0 res0 in
//assert (mask == bn_lt_mask_f #len a b (k - 1) mask0);
mask_select_lemma blt (ones t SEC) (zeros t SEC);
mask_select_lemma beq mask0 res0;
if v beq = 0 then begin
assert (v mask = v res0);
mask_select_lemma blt (ones t SEC) (zeros t SEC);
//assert (v res0 == (if v blt = 0 then 0 else v (ones t SEC)));
assert (if v mask = 0 then v ai > v bi else v ai < v bi);
if v a.[k - 1] < v b.[k - 1] then bn_eval_lt len a b k else bn_eval_lt len b a k;
() end
else begin
assert (v mask = v mask0);
//assert (v beq == v (ones t SEC));
//assert (if v mask = v mask0 then v ai = v bi else v ai <> v bi);
assert (v ai == v bi);
bn_eval_unfold_i a k;
bn_eval_unfold_i b k;
() end
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_ len b k))
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 mask0 = Loops.repeat_gen (k - 1) (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0) in
Loops.unfold_repeat_gen k (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0) (k - 1);
bn_lt_mask_lemma_loop a b (k - 1);
bn_lt_mask_lemma_step a b k mask0 end
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 =
bn_lt_mask_lemma_loop a b len
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 =
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_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 =
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);
bn_lt_mask_lemma b b2' | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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);
bn_lt_mask_lemma b b2' | 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.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Comparison.fst"
} | [
"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.l_or",
"Prims.op_GreaterThan",
"Prims.op_GreaterThanOrEqual",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.pow2",
"Hacl.Spec.Bignum.Lib.bn_set_ith_bit_lemma",
"Hacl.Spec.Bignum.Lib.bn_set_ith_bit",
"Prims.op_Equality",
"Hacl.Spec.Bignum.Definitions.bn_eval_zeroes",
"Lib.Sequence.lseq",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.l_and",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Lib.IntTypes.SEC",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Lib.Sequence.index",
"Lib.Sequence.create",
"Lib.IntTypes.uint",
"Hacl.Spec.Bignum.Definitions.bn_eval_bound"
] | [] | 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 and test functions
///
val bn_is_odd: #t:limb_t -> #len:size_pos -> a:lbignum t len -> limb t
let bn_is_odd #t #len b = b.[0] &. uint #t 1
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 =
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_lemma b.[0] 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1))
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 =
BSeq.seq_eq_mask a b len
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 =
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_is_zero_mask: #t:limb_t -> #len:size_nat -> a:lbignum t len -> limb t
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_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 =
let bn_zero = create len (uint #t 0) in
bn_eval_zeroes #t len len;
bn_eq_mask_lemma b bn_zero
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 =
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))
let bn_lt_mask_t (t:limb_t) (len:size_nat) (i:nat{i <= len}) = limb t
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 =
Loops.repeat_gen len (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0)
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 mask = bn_lt_mask_f a b (k - 1) mask0 in
(if v mask = 0 then eval_ len a k >= eval_ len b k else eval_ len a k < eval_ len b k) /\
mask_values mask))
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 t SEC) else v blt == 0);
let res0 = mask_select blt (ones t SEC) (zeros t SEC) in
let mask = mask_select beq mask0 res0 in
//assert (mask == bn_lt_mask_f #len a b (k - 1) mask0);
mask_select_lemma blt (ones t SEC) (zeros t SEC);
mask_select_lemma beq mask0 res0;
if v beq = 0 then begin
assert (v mask = v res0);
mask_select_lemma blt (ones t SEC) (zeros t SEC);
//assert (v res0 == (if v blt = 0 then 0 else v (ones t SEC)));
assert (if v mask = 0 then v ai > v bi else v ai < v bi);
if v a.[k - 1] < v b.[k - 1] then bn_eval_lt len a b k else bn_eval_lt len b a k;
() end
else begin
assert (v mask = v mask0);
//assert (v beq == v (ones t SEC));
//assert (if v mask = v mask0 then v ai = v bi else v ai <> v bi);
assert (v ai == v bi);
bn_eval_unfold_i a k;
bn_eval_unfold_i b k;
() end
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_ len b k))
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 mask0 = Loops.repeat_gen (k - 1) (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0) in
Loops.unfold_repeat_gen k (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0) (k - 1);
bn_lt_mask_lemma_loop a b (k - 1);
bn_lt_mask_lemma_step a b k mask0 end
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 =
bn_lt_mask_lemma_loop a b len
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 =
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_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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 b x) = 0 with
| true -> Hacl.Spec.Bignum.Definitions.bn_v b >= Prims.pow2 x
| _ -> Hacl.Spec.Bignum.Definitions.bn_v b < Prims.pow2 x)) | {
"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,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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);
bn_lt_mask_lemma b2' b | 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.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Comparison.fst"
} | [
"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.l_or",
"Prims.op_GreaterThan",
"Prims.op_GreaterThanOrEqual",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.pow2",
"Hacl.Spec.Bignum.Lib.bn_set_ith_bit_lemma",
"Hacl.Spec.Bignum.Lib.bn_set_ith_bit",
"Prims.op_Equality",
"Hacl.Spec.Bignum.Definitions.bn_eval_zeroes",
"Lib.Sequence.lseq",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.l_and",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Lib.IntTypes.SEC",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Lib.Sequence.index",
"Lib.Sequence.create",
"Lib.IntTypes.uint",
"Hacl.Spec.Bignum.Definitions.bn_eval_bound"
] | [] | 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 and test functions
///
val bn_is_odd: #t:limb_t -> #len:size_pos -> a:lbignum t len -> limb t
let bn_is_odd #t #len b = b.[0] &. uint #t 1
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 =
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_lemma b.[0] 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1))
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 =
BSeq.seq_eq_mask a b len
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 =
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_is_zero_mask: #t:limb_t -> #len:size_nat -> a:lbignum t len -> limb t
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_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 =
let bn_zero = create len (uint #t 0) in
bn_eval_zeroes #t len len;
bn_eq_mask_lemma b bn_zero
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 =
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))
let bn_lt_mask_t (t:limb_t) (len:size_nat) (i:nat{i <= len}) = limb t
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 =
Loops.repeat_gen len (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0)
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 mask = bn_lt_mask_f a b (k - 1) mask0 in
(if v mask = 0 then eval_ len a k >= eval_ len b k else eval_ len a k < eval_ len b k) /\
mask_values mask))
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 t SEC) else v blt == 0);
let res0 = mask_select blt (ones t SEC) (zeros t SEC) in
let mask = mask_select beq mask0 res0 in
//assert (mask == bn_lt_mask_f #len a b (k - 1) mask0);
mask_select_lemma blt (ones t SEC) (zeros t SEC);
mask_select_lemma beq mask0 res0;
if v beq = 0 then begin
assert (v mask = v res0);
mask_select_lemma blt (ones t SEC) (zeros t SEC);
//assert (v res0 == (if v blt = 0 then 0 else v (ones t SEC)));
assert (if v mask = 0 then v ai > v bi else v ai < v bi);
if v a.[k - 1] < v b.[k - 1] then bn_eval_lt len a b k else bn_eval_lt len b a k;
() end
else begin
assert (v mask = v mask0);
//assert (v beq == v (ones t SEC));
//assert (if v mask = v mask0 then v ai = v bi else v ai <> v bi);
assert (v ai == v bi);
bn_eval_unfold_i a k;
bn_eval_unfold_i b k;
() end
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_ len b k))
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 mask0 = Loops.repeat_gen (k - 1) (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0) in
Loops.unfold_repeat_gen k (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0) (k - 1);
bn_lt_mask_lemma_loop a b (k - 1);
bn_lt_mask_lemma_step a b k mask0 end
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 =
bn_lt_mask_lemma_loop a b len
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 =
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_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 =
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);
bn_lt_mask_lemma b b2'
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 =
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_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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 b x) = 0 with
| true -> Prims.pow2 x >= Hacl.Spec.Bignum.Definitions.bn_v b
| _ -> Prims.pow2 x < Hacl.Spec.Bignum.Definitions.bn_v b)) | {
"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_ len b k)) | [
{
"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,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 mask0 = Loops.repeat_gen (k - 1) (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0) in
Loops.unfold_repeat_gen k (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0) (k - 1);
bn_lt_mask_lemma_loop a b (k - 1);
bn_lt_mask_lemma_step a b k mask0 end | 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_ len b k))
let rec bn_lt_mask_lemma_loop #t #len a b k = | 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) (uint #t 0) in
Loops.unfold_repeat_gen k (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0) (k - 1);
bn_lt_mask_lemma_loop a b (k - 1);
bn_lt_mask_lemma_step a b k mask0 | {
"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.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Comparison.fst"
} | [
"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.IntTypes.SEC",
"Lib.LoopCombinators.eq_repeat_gen0",
"Hacl.Spec.Bignum.Comparison.bn_lt_mask_t",
"Hacl.Spec.Bignum.Comparison.bn_lt_mask_f",
"Lib.IntTypes.uint",
"Prims.bool",
"Hacl.Spec.Bignum.Comparison.bn_lt_mask_lemma_step",
"Hacl.Spec.Bignum.Comparison.bn_lt_mask_lemma_loop",
"Prims.op_Subtraction",
"Lib.LoopCombinators.unfold_repeat_gen",
"Lib.LoopCombinators.repeat_gen"
] | [] | 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 and test functions
///
val bn_is_odd: #t:limb_t -> #len:size_pos -> a:lbignum t len -> limb t
let bn_is_odd #t #len b = b.[0] &. uint #t 1
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 =
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_lemma b.[0] 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1))
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 =
BSeq.seq_eq_mask a b len
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 =
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_is_zero_mask: #t:limb_t -> #len:size_nat -> a:lbignum t len -> limb t
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_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 =
let bn_zero = create len (uint #t 0) in
bn_eval_zeroes #t len len;
bn_eq_mask_lemma b bn_zero
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 =
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))
let bn_lt_mask_t (t:limb_t) (len:size_nat) (i:nat{i <= len}) = limb t
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 =
Loops.repeat_gen len (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0)
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 mask = bn_lt_mask_f a b (k - 1) mask0 in
(if v mask = 0 then eval_ len a k >= eval_ len b k else eval_ len a k < eval_ len b k) /\
mask_values mask))
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 t SEC) else v blt == 0);
let res0 = mask_select blt (ones t SEC) (zeros t SEC) in
let mask = mask_select beq mask0 res0 in
//assert (mask == bn_lt_mask_f #len a b (k - 1) mask0);
mask_select_lemma blt (ones t SEC) (zeros t SEC);
mask_select_lemma beq mask0 res0;
if v beq = 0 then begin
assert (v mask = v res0);
mask_select_lemma blt (ones t SEC) (zeros t SEC);
//assert (v res0 == (if v blt = 0 then 0 else v (ones t SEC)));
assert (if v mask = 0 then v ai > v bi else v ai < v bi);
if v a.[k - 1] < v b.[k - 1] then bn_eval_lt len a b k else bn_eval_lt len b a k;
() end
else begin
assert (v mask = v mask0);
//assert (v beq == v (ones t SEC));
//assert (if v mask = v mask0 then v ai = v bi else v ai <> v bi);
assert (v ai == v bi);
bn_eval_unfold_i a k;
bn_eval_unfold_i b k;
() end
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_ len b k)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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_ len b k)) | [
"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.Bignum.Comparison.bn_lt_mask_f a b)
(Lib.IntTypes.uint 0)
in
Hacl.Spec.Bignum.Base.mask_values mask /\
(match Lib.IntTypes.v mask = 0 with
| true ->
Hacl.Spec.Bignum.Definitions.eval_ len a k >= Hacl.Spec.Bignum.Definitions.eval_ len b k
| _ ->
Hacl.Spec.Bignum.Definitions.eval_ len a k < Hacl.Spec.Bignum.Definitions.eval_ len b k)
)) | {
"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,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 (bn_v b % 2 == v b.[0] % 2);
mod_mask_lemma b.[0] 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1)) | 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_lemma b.[ 0 ] 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 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.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Comparison.fst"
} | [
"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.IntTypes.mod_mask_lemma",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.int",
"Prims.op_Modulus",
"Hacl.Spec.Bignum.Definitions.bn_v",
"FStar.Math.Lemmas.modulo_addition_lemma",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.op_Subtraction",
"Lib.Sequence.slice",
"FStar.Math.Lemmas.pow2_plus",
"Prims.op_Addition",
"Hacl.Spec.Bignum.Definitions.bn_eval1",
"Hacl.Spec.Bignum.Definitions.bn_eval_split_i",
"Lib.IntTypes.bits"
] | [] | 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 and test functions
///
val bn_is_odd: #t:limb_t -> #len:size_pos -> a:lbignum t len -> limb t
let bn_is_odd #t #len b = b.[0] &. uint #t 1
val bn_is_odd_lemma: #t:limb_t -> #len:size_pos -> a:lbignum t len -> | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 mask = bn_lt_mask_f a b (k - 1) mask0 in
(if v mask = 0 then eval_ len a k >= eval_ len b k else eval_ len a k < eval_ len b k) /\
mask_values mask)) | [
{
"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,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 t SEC) else v blt == 0);
let res0 = mask_select blt (ones t SEC) (zeros t SEC) in
let mask = mask_select beq mask0 res0 in
//assert (mask == bn_lt_mask_f #len a b (k - 1) mask0);
mask_select_lemma blt (ones t SEC) (zeros t SEC);
mask_select_lemma beq mask0 res0;
if v beq = 0 then begin
assert (v mask = v res0);
mask_select_lemma blt (ones t SEC) (zeros t SEC);
//assert (v res0 == (if v blt = 0 then 0 else v (ones t SEC)));
assert (if v mask = 0 then v ai > v bi else v ai < v bi);
if v a.[k - 1] < v b.[k - 1] then bn_eval_lt len a b k else bn_eval_lt len b a k;
() end
else begin
assert (v mask = v mask0);
//assert (v beq == v (ones t SEC));
//assert (if v mask = v mask0 then v ai = v bi else v ai <> v bi);
assert (v ai == v bi);
bn_eval_unfold_i a k;
bn_eval_unfold_i b k;
() end | 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 mask = bn_lt_mask_f a b (k - 1) mask0 in
(if v mask = 0 then eval_ len a k >= eval_ len b k else eval_ len a k < eval_ len b k) /\
mask_values mask))
let bn_lt_mask_lemma_step #t #len a b k mask0 = | 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 t SEC) (zeros t SEC) in
let mask = mask_select beq mask0 res0 in
mask_select_lemma blt (ones t SEC) (zeros t SEC);
mask_select_lemma beq mask0 res0;
if v beq = 0
then
(assert (v mask = v res0);
mask_select_lemma blt (ones t SEC) (zeros t SEC);
assert (if v mask = 0 then v ai > v bi else v ai < v bi);
if v a.[ k - 1 ] < v b.[ k - 1 ] then bn_eval_lt len a b k else bn_eval_lt len b a k;
())
else
(assert (v mask = v mask0);
assert (v ai == v bi);
bn_eval_unfold_i a k;
bn_eval_unfold_i b k;
()) | {
"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.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Comparison.fst"
} | [
"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_LessThan",
"Lib.Sequence.op_String_Access",
"Prims.op_Subtraction",
"Hacl.Spec.Bignum.Definitions.bn_eval_lt",
"Prims.bool",
"Prims._assert",
"Prims.op_GreaterThan",
"Hacl.Spec.Bignum.Base.mask_select_lemma",
"Lib.IntTypes.ones",
"Lib.IntTypes.zeros",
"Lib.IntTypes.range_t",
"Hacl.Spec.Bignum.Definitions.bn_eval_unfold_i",
"Prims.eq2",
"Hacl.Spec.Bignum.Base.mask_select",
"Lib.IntTypes.int_t",
"Lib.IntTypes.lt_mask",
"Lib.IntTypes.eq_mask",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Hacl.Spec.Bignum.Comparison.bn_lt_mask_f"
] | [] | 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 and test functions
///
val bn_is_odd: #t:limb_t -> #len:size_pos -> a:lbignum t len -> limb t
let bn_is_odd #t #len b = b.[0] &. uint #t 1
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 =
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_lemma b.[0] 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1))
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 =
BSeq.seq_eq_mask a b len
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 =
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_is_zero_mask: #t:limb_t -> #len:size_nat -> a:lbignum t len -> limb t
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_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 =
let bn_zero = create len (uint #t 0) in
bn_eval_zeroes #t len len;
bn_eq_mask_lemma b bn_zero
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 =
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))
let bn_lt_mask_t (t:limb_t) (len:size_nat) (i:nat{i <= len}) = limb t
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 =
Loops.repeat_gen len (bn_lt_mask_t t len) (bn_lt_mask_f a b) (uint #t 0)
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 mask = bn_lt_mask_f a b (k - 1) mask0 in
(if v mask = 0 then eval_ len a k >= eval_ len b k else eval_ len a k < eval_ len b k) /\
mask_values mask)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 mask = bn_lt_mask_f a b (k - 1) mask0 in
(if v mask = 0 then eval_ len a k >= eval_ len b k else eval_ len a k < eval_ len b k) /\
mask_values mask)) | [] | 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.Bignum.Definitions.eval_ len a (k - 1) >=
Hacl.Spec.Bignum.Definitions.eval_ len b (k - 1)
| _ ->
Hacl.Spec.Bignum.Definitions.eval_ len a (k - 1) <
Hacl.Spec.Bignum.Definitions.eval_ len b (k - 1)) /\
Hacl.Spec.Bignum.Base.mask_values mask0)
(ensures
(let mask = Hacl.Spec.Bignum.Comparison.bn_lt_mask_f a b (k - 1) mask0 in
(match Lib.IntTypes.v mask = 0 with
| true ->
Hacl.Spec.Bignum.Definitions.eval_ len a k >=
Hacl.Spec.Bignum.Definitions.eval_ len b k
| _ ->
Hacl.Spec.Bignum.Definitions.eval_ len a k <
Hacl.Spec.Bignum.Definitions.eval_ len b k) /\ Hacl.Spec.Bignum.Base.mask_values mask)
) | {
"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,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Comparison.fst"
} | [
"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_inj",
"Prims.unit",
"Prims._assert",
"Prims.l_imp",
"Prims.l_not",
"Lib.IntTypes.range_t",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Lib.IntTypes.zeros",
"Lib.IntTypes.ones",
"Lib.IntTypes.int_t",
"Prims.l_and",
"Lib.Sequence.lseq",
"Prims.l_or",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"Prims.l_Forall",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Lib.Sequence.sub",
"Prims.int",
"Lib.IntTypes.range",
"Lib.ByteSequence.seq_eq_mask"
] | [] | 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 and test functions
///
val bn_is_odd: #t:limb_t -> #len:size_pos -> a:lbignum t len -> limb t
let bn_is_odd #t #len b = b.[0] &. uint #t 1
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 =
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_lemma b.[0] 1ul;
assert (v (mod_mask #t #SEC 1ul) == v (uint #t #SEC 1))
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 =
BSeq.seq_eq_mask a b len
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) /\ | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 -> Hacl.Spec.Bignum.Definitions.bn_v a <> Hacl.Spec.Bignum.Definitions.bn_v b
| _ -> Hacl.Spec.Bignum.Definitions.bn_v a = Hacl.Spec.Bignum.Definitions.bn_v b)) | {
"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,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Bignum25519.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.PointCompress.fst"
} | [] | [
"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.IntTypes.uint64",
"Lib.Buffer.op_Array_Access",
"Lib.Buffer.MUT",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get"
] | [] | 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 noextract
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 | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.Curve25519.fmul (F51.fevalh h0 (gsub p 0ul 5ul)) zinv in
let y = Spec.Curve25519.fmul (F51.fevalh h0 (gsub p 5ul 5ul)) zinv in
F51.mul_inv_t h1 (gsub tmp 10ul 5ul) /\
F51.fevalh h1 (gsub tmp 10ul 5ul) == y /\
F51.as_nat h1 (gsub tmp 5ul 5ul) == x)
) | [
{
"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,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Curve25519.fmul (F51.fevalh h0 (gsub p 0ul 5ul)) zinv in
let y = Spec.Curve25519.fmul (F51.fevalh h0 (gsub p 5ul 5ul)) zinv in
F51.mul_inv_t h1 (gsub tmp 10ul 5ul) /\
F51.fevalh h1 (gsub tmp 10ul 5ul) == y /\
F51.as_nat h1 (gsub tmp 5ul 5ul) == x)
)
let point_compress_ tmp p = | 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.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Bignum25519.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.PointCompress.fst"
} | [] | [
"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.gety",
"Hacl.Bignum25519.getx",
"Lib.Buffer.lbuffer_t",
"Lib.Buffer.MUT",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.sub"
] | [] | 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 noextract
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 =
(**) 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
open FStar.Calc
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) * 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 b 31);
};
assert (nat_from_intseq_le (Seq.slice b 0 31) < pow2 (31 * 8));
calc (<) {
pow2 (31*8) * v (Seq.index b 31);
(<) { }
Spec.Curve25519.prime - nat_from_intseq_le (Seq.slice b 0 31);
(<=) { }
Spec.Curve25519.prime;
(<) { }
pow2 255;
};
FStar.Math.Lemmas.lemma_div_lt_nat (pow2 (31*8) * v (Seq.index b 31)) 255 (31*8);
calc (==) {
(pow2 (31 *8) * v (Seq.index b 31))/ (pow2 (31*8));
(==) { FStar.Math.Lemmas.swap_mul (pow2 (31*8)) (v (Seq.index b 31)) }
(v (Seq.index b 31) * pow2 (31 *8)) / (pow2 (31*8));
(==) { FStar.Math.Lemmas.cancel_mul_div (v (Seq.index b 31)) (pow2 (31*8)) }
v (Seq.index b 31);
};
assert_norm (255 - 31 * 8 == 7)
inline_for_extraction noextract
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 * (v x)
)
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 +. (xbyte <<. 7ul);
(**) let h1 = ST.get() in
(**) calc (==) {
(**) nat_from_intseq_le (as_seq h1 out) <: nat;
(**) (==) { nat_from_intseq_le_slice_lemma (as_seq h1 out) 31 }
(**) nat_from_intseq_le (Seq.slice (as_seq h1 out) 0 31) +
(**) pow2 (31 * 8) * nat_from_intseq_le (Seq.slice (as_seq h1 out) 31 32);
(**) (==) {
(**) calc (==) {
(**) pow2 (31 * 8) * nat_from_intseq_le (Seq.slice (as_seq h1 out) 31 32);
(**) (==) { calc (==) {
(**) nat_from_intseq_le (Seq.slice (as_seq h1 out) 31 32) <: nat;
(**) (==) { nat_from_intseq_le_lemma0 (Seq.slice (as_seq h1 out) 31 32) }
(**) v (o31 +. (xbyte <<. 7ul));
(**) (==) { calc (==) {
(**) v (o31 +. (xbyte <<. 7ul)) <: nat;
(**) (==) { }
(**) (v o31 + v (xbyte <<. 7ul)) % pow2 8;
(**) (==) { 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);
(**) lemma_fits_in_prime_last_byte (as_seq h0 out);
(**) assert_norm (pow2 7 + pow2 7 == pow2 8);
(**) FStar.Math.Lemmas.modulo_lemma (v o31 + pow2 7 * (v x)) (pow2 8)
(**) }
(**) v o31 + pow2 7 * (v x);
(**) }; nat_from_intseq_le_lemma0 (Seq.slice (as_seq h0 out) 31 32)
(**) }
(**) nat_from_intseq_le (Seq.slice (as_seq h0 out) 31 32) + pow2 7 * (v x);
(**) } }
(**) pow2 (31 * 8) * (nat_from_intseq_le (Seq.slice (as_seq h0 out) 31 32) + pow2 7 * (v x));
(**) (==) { FStar.Math.Lemmas.distributivity_add_right (pow2 (31 * 8))
(**) (nat_from_intseq_le (Seq.slice (as_seq h0 out) 31 32)) (pow2 7 * (v x)) }
(**) pow2 (31 * 8) * nat_from_intseq_le (Seq.slice (as_seq h0 out) 31 32) +
(**) pow2 (31 * 8) * pow2 7 * (v x);
(**) (==) { assert_norm (pow2 (31*8) * pow2 7 == pow2 255) }
(**) pow2 (31 * 8) * nat_from_intseq_le (Seq.slice (as_seq h0 out) 31 32) +
(**) pow2 255 * (v x);
(**) }
(**) }
(**) nat_from_intseq_le (Seq.slice (as_seq h1 out) 0 31) +
(**) pow2 (31 * 8) * nat_from_intseq_le (Seq.slice (as_seq h0 out) 31 32) +
(**) pow2 255 * (v x);
(**) (==) { nat_from_intseq_le_slice_lemma (as_seq h0 out) 31 }
(**) nat_from_bytes_le (as_seq h0 out) + pow2 255 * (v x);
(**) }
inline_for_extraction noextract
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.Curve25519.fmul (F51.fevalh h0 (gsub p 0ul 5ul)) zinv in
let y = Spec.Curve25519.fmul (F51.fevalh h0 (gsub p 5ul 5ul)) zinv in
F51.mul_inv_t h1 (gsub tmp 10ul 5ul) /\
F51.fevalh h1 (gsub tmp 10ul 5ul) == y /\
F51.as_nat h1 (gsub tmp 5ul 5ul) == x) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.Curve25519.fmul (F51.fevalh h0 (gsub p 0ul 5ul)) zinv in
let y = Spec.Curve25519.fmul (F51.fevalh h0 (gsub p 5ul 5ul)) zinv in
F51.mul_inv_t h1 (gsub tmp 10ul 5ul) /\
F51.fevalh h1 (gsub tmp 10ul 5ul) == y /\
F51.as_nat h1 (gsub tmp 5ul 5ul) == x)
) | [] | 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,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_le_preserves_value (as_seq h3 z) 32;
(**) lemma_nat_to_from_bytes_le_preserves_value (as_seq h3 z) 32 (F51.fevalh h3 out);
pop_frame() | 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_preserves_value (as_seq h3 z) 32 (F51.fevalh h3 out);
pop_frame () | {
"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.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Bignum25519.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.PointCompress.fst"
} | [] | [
"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.fevalh",
"Lib.ByteSequence.lemma_nat_from_to_bytes_le_preserves_value",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Hacl.Impl.Ed25519.PointCompress.add_sign",
"Hacl.Bignum25519.store_51",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Hacl.Impl.Ed25519.PointCompress.x_mod_2",
"Lib.IntTypes.uint64",
"Hacl.Impl.Ed25519.PointCompress.point_compress_",
"Lib.Buffer.lbuffer_t",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.sub",
"Lib.Buffer.create",
"Lib.IntTypes.u64",
"FStar.HyperStack.ST.push_frame"
] | [] | 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 noextract
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 =
(**) 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
open FStar.Calc
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) * 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 b 31);
};
assert (nat_from_intseq_le (Seq.slice b 0 31) < pow2 (31 * 8));
calc (<) {
pow2 (31*8) * v (Seq.index b 31);
(<) { }
Spec.Curve25519.prime - nat_from_intseq_le (Seq.slice b 0 31);
(<=) { }
Spec.Curve25519.prime;
(<) { }
pow2 255;
};
FStar.Math.Lemmas.lemma_div_lt_nat (pow2 (31*8) * v (Seq.index b 31)) 255 (31*8);
calc (==) {
(pow2 (31 *8) * v (Seq.index b 31))/ (pow2 (31*8));
(==) { FStar.Math.Lemmas.swap_mul (pow2 (31*8)) (v (Seq.index b 31)) }
(v (Seq.index b 31) * pow2 (31 *8)) / (pow2 (31*8));
(==) { FStar.Math.Lemmas.cancel_mul_div (v (Seq.index b 31)) (pow2 (31*8)) }
v (Seq.index b 31);
};
assert_norm (255 - 31 * 8 == 7)
inline_for_extraction noextract
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 * (v x)
)
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 +. (xbyte <<. 7ul);
(**) let h1 = ST.get() in
(**) calc (==) {
(**) nat_from_intseq_le (as_seq h1 out) <: nat;
(**) (==) { nat_from_intseq_le_slice_lemma (as_seq h1 out) 31 }
(**) nat_from_intseq_le (Seq.slice (as_seq h1 out) 0 31) +
(**) pow2 (31 * 8) * nat_from_intseq_le (Seq.slice (as_seq h1 out) 31 32);
(**) (==) {
(**) calc (==) {
(**) pow2 (31 * 8) * nat_from_intseq_le (Seq.slice (as_seq h1 out) 31 32);
(**) (==) { calc (==) {
(**) nat_from_intseq_le (Seq.slice (as_seq h1 out) 31 32) <: nat;
(**) (==) { nat_from_intseq_le_lemma0 (Seq.slice (as_seq h1 out) 31 32) }
(**) v (o31 +. (xbyte <<. 7ul));
(**) (==) { calc (==) {
(**) v (o31 +. (xbyte <<. 7ul)) <: nat;
(**) (==) { }
(**) (v o31 + v (xbyte <<. 7ul)) % pow2 8;
(**) (==) { 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);
(**) lemma_fits_in_prime_last_byte (as_seq h0 out);
(**) assert_norm (pow2 7 + pow2 7 == pow2 8);
(**) FStar.Math.Lemmas.modulo_lemma (v o31 + pow2 7 * (v x)) (pow2 8)
(**) }
(**) v o31 + pow2 7 * (v x);
(**) }; nat_from_intseq_le_lemma0 (Seq.slice (as_seq h0 out) 31 32)
(**) }
(**) nat_from_intseq_le (Seq.slice (as_seq h0 out) 31 32) + pow2 7 * (v x);
(**) } }
(**) pow2 (31 * 8) * (nat_from_intseq_le (Seq.slice (as_seq h0 out) 31 32) + pow2 7 * (v x));
(**) (==) { FStar.Math.Lemmas.distributivity_add_right (pow2 (31 * 8))
(**) (nat_from_intseq_le (Seq.slice (as_seq h0 out) 31 32)) (pow2 7 * (v x)) }
(**) pow2 (31 * 8) * nat_from_intseq_le (Seq.slice (as_seq h0 out) 31 32) +
(**) pow2 (31 * 8) * pow2 7 * (v x);
(**) (==) { assert_norm (pow2 (31*8) * pow2 7 == pow2 255) }
(**) pow2 (31 * 8) * nat_from_intseq_le (Seq.slice (as_seq h0 out) 31 32) +
(**) pow2 255 * (v x);
(**) }
(**) }
(**) nat_from_intseq_le (Seq.slice (as_seq h1 out) 0 31) +
(**) pow2 (31 * 8) * nat_from_intseq_le (Seq.slice (as_seq h0 out) 31 32) +
(**) pow2 255 * (v x);
(**) (==) { nat_from_intseq_le_slice_lemma (as_seq h0 out) 31 }
(**) nat_from_bytes_le (as_seq h0 out) + pow2 255 * (v x);
(**) }
inline_for_extraction noextract
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.Curve25519.fmul (F51.fevalh h0 (gsub p 0ul 5ul)) zinv in
let y = Spec.Curve25519.fmul (F51.fevalh h0 (gsub p 5ul 5ul)) zinv in
F51.mul_inv_t h1 (gsub tmp 10ul 5ul) /\
F51.fevalh h1 (gsub tmp 10ul 5ul) == y /\
F51.as_nat h1 (gsub tmp 5ul 5ul) == x)
)
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:
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)
) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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) * 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 b 31);
};
assert (nat_from_intseq_le (Seq.slice b 0 31) < pow2 (31 * 8));
calc (<) {
pow2 (31*8) * v (Seq.index b 31);
(<) { }
Spec.Curve25519.prime - nat_from_intseq_le (Seq.slice b 0 31);
(<=) { }
Spec.Curve25519.prime;
(<) { }
pow2 255;
};
FStar.Math.Lemmas.lemma_div_lt_nat (pow2 (31*8) * v (Seq.index b 31)) 255 (31*8);
calc (==) {
(pow2 (31 *8) * v (Seq.index b 31))/ (pow2 (31*8));
(==) { FStar.Math.Lemmas.swap_mul (pow2 (31*8)) (v (Seq.index b 31)) }
(v (Seq.index b 31) * pow2 (31 *8)) / (pow2 (31*8));
(==) { FStar.Math.Lemmas.cancel_mul_div (v (Seq.index b 31)) (pow2 (31*8)) }
v (Seq.index b 31);
};
assert_norm (255 - 31 * 8 == 7) | 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 b 31);
};
assert (nat_from_intseq_le (Seq.slice b 0 31) < pow2 (31 * 8));
calc ( < ) {
pow2 (31 * 8) * v (Seq.index b 31);
( < ) { () }
Spec.Curve25519.prime - nat_from_intseq_le (Seq.slice b 0 31);
( <= ) { () }
Spec.Curve25519.prime;
( < ) { () }
pow2 255;
};
FStar.Math.Lemmas.lemma_div_lt_nat (pow2 (31 * 8) * v (Seq.index b 31)) 255 (31 * 8);
calc ( == ) {
(pow2 (31 * 8) * v (Seq.index b 31)) / (pow2 (31 * 8));
( == ) { FStar.Math.Lemmas.swap_mul (pow2 (31 * 8)) (v (Seq.index b 31)) }
(v (Seq.index b 31) * pow2 (31 * 8)) / (pow2 (31 * 8));
( == ) { FStar.Math.Lemmas.cancel_mul_div (v (Seq.index b 31)) (pow2 (31 * 8)) }
v (Seq.index b 31);
};
assert_norm (255 - 31 * 8 == 7) | {
"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.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Bignum25519.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.PointCompress.fst"
} | [
"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",
"Lib.IntTypes.uint_t",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.swap_mul",
"Prims.squash",
"FStar.Math.Lemmas.cancel_mul_div",
"FStar.Math.Lemmas.lemma_div_lt_nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"Spec.Curve25519.prime",
"Lib.ByteSequence.nat_from_intseq_le",
"FStar.Seq.Base.slice",
"Prims._assert",
"Prims.nat",
"Lib.ByteSequence.nat_from_bytes_le",
"Prims.op_Addition",
"Lib.ByteSequence.nat_from_intseq_le_slice_lemma",
"Lib.ByteSequence.nat_from_intseq_le_lemma0",
"FStar.Pervasives.pattern"
] | [] | 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 noextract
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 =
(**) 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
open FStar.Calc
let lemma_fits_in_prime_last_byte (b:lbytes 32) : Lemma
(requires nat_from_bytes_le b < Spec.Curve25519.prime) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 * (v x)
) | [
{
"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,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 +. (xbyte <<. 7ul);
(**) let h1 = ST.get() in
(**) calc (==) {
(**) nat_from_intseq_le (as_seq h1 out) <: nat;
(**) (==) { nat_from_intseq_le_slice_lemma (as_seq h1 out) 31 }
(**) nat_from_intseq_le (Seq.slice (as_seq h1 out) 0 31) +
(**) pow2 (31 * 8) * nat_from_intseq_le (Seq.slice (as_seq h1 out) 31 32);
(**) (==) {
(**) calc (==) {
(**) pow2 (31 * 8) * nat_from_intseq_le (Seq.slice (as_seq h1 out) 31 32);
(**) (==) { calc (==) {
(**) nat_from_intseq_le (Seq.slice (as_seq h1 out) 31 32) <: nat;
(**) (==) { nat_from_intseq_le_lemma0 (Seq.slice (as_seq h1 out) 31 32) }
(**) v (o31 +. (xbyte <<. 7ul));
(**) (==) { calc (==) {
(**) v (o31 +. (xbyte <<. 7ul)) <: nat;
(**) (==) { }
(**) (v o31 + v (xbyte <<. 7ul)) % pow2 8;
(**) (==) { 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);
(**) lemma_fits_in_prime_last_byte (as_seq h0 out);
(**) assert_norm (pow2 7 + pow2 7 == pow2 8);
(**) FStar.Math.Lemmas.modulo_lemma (v o31 + pow2 7 * (v x)) (pow2 8)
(**) }
(**) v o31 + pow2 7 * (v x);
(**) }; nat_from_intseq_le_lemma0 (Seq.slice (as_seq h0 out) 31 32)
(**) }
(**) nat_from_intseq_le (Seq.slice (as_seq h0 out) 31 32) + pow2 7 * (v x);
(**) } }
(**) pow2 (31 * 8) * (nat_from_intseq_le (Seq.slice (as_seq h0 out) 31 32) + pow2 7 * (v x));
(**) (==) { FStar.Math.Lemmas.distributivity_add_right (pow2 (31 * 8))
(**) (nat_from_intseq_le (Seq.slice (as_seq h0 out) 31 32)) (pow2 7 * (v x)) }
(**) pow2 (31 * 8) * nat_from_intseq_le (Seq.slice (as_seq h0 out) 31 32) +
(**) pow2 (31 * 8) * pow2 7 * (v x);
(**) (==) { assert_norm (pow2 (31*8) * pow2 7 == pow2 255) }
(**) pow2 (31 * 8) * nat_from_intseq_le (Seq.slice (as_seq h0 out) 31 32) +
(**) pow2 255 * (v x);
(**) }
(**) }
(**) nat_from_intseq_le (Seq.slice (as_seq h1 out) 0 31) +
(**) pow2 (31 * 8) * nat_from_intseq_le (Seq.slice (as_seq h0 out) 31 32) +
(**) pow2 255 * (v x);
(**) (==) { nat_from_intseq_le_slice_lemma (as_seq h0 out) 31 }
(**) nat_from_bytes_le (as_seq h0 out) + pow2 255 * (v 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 * (v x)
)
let add_sign out x = | 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_intseq_le (as_seq h1 out) <: nat;
( == ) { nat_from_intseq_le_slice_lemma (as_seq h1 out) 31 }
nat_from_intseq_le (Seq.slice (as_seq h1 out) 0 31) +
pow2 (31 * 8) * nat_from_intseq_le (Seq.slice (as_seq h1 out) 31 32);
( == ) { calc ( == ) {
pow2 (31 * 8) * nat_from_intseq_le (Seq.slice (as_seq h1 out) 31 32);
( == ) { calc ( == ) {
nat_from_intseq_le (Seq.slice (as_seq h1 out) 31 32) <: nat;
( == ) { nat_from_intseq_le_lemma0 (Seq.slice (as_seq h1 out) 31 32) }
v (o31 +. (xbyte <<. 7ul));
( == ) { (calc ( == ) {
v (o31 +. (xbyte <<. 7ul)) <: nat;
( == ) { () }
(v o31 + v (xbyte <<. 7ul)) % pow2 8;
( == ) { (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);
lemma_fits_in_prime_last_byte (as_seq h0 out);
assert_norm (pow2 7 + pow2 7 == pow2 8);
FStar.Math.Lemmas.modulo_lemma (v o31 + pow2 7 * (v x)) (pow2 8)) }
v o31 + pow2 7 * (v x);
};
nat_from_intseq_le_lemma0 (Seq.slice (as_seq h0 out) 31 32)) }
nat_from_intseq_le (Seq.slice (as_seq h0 out) 31 32) + pow2 7 * (v x);
} }
pow2 (31 * 8) * (nat_from_intseq_le (Seq.slice (as_seq h0 out) 31 32) + pow2 7 * (v x));
( == ) { FStar.Math.Lemmas.distributivity_add_right (pow2 (31 * 8))
(nat_from_intseq_le (Seq.slice (as_seq h0 out) 31 32))
(pow2 7 * (v x)) }
pow2 (31 * 8) * nat_from_intseq_le (Seq.slice (as_seq h0 out) 31 32) +
(pow2 (31 * 8) * pow2 7) * (v x);
( == ) { assert_norm (pow2 (31 * 8) * pow2 7 == pow2 255) }
pow2 (31 * 8) * nat_from_intseq_le (Seq.slice (as_seq h0 out) 31 32) + pow2 255 * (v x);
} }
nat_from_intseq_le (Seq.slice (as_seq h1 out) 0 31) +
pow2 (31 * 8) * nat_from_intseq_le (Seq.slice (as_seq h0 out) 31 32) +
pow2 255 * (v x);
( == ) { nat_from_intseq_le_slice_lemma (as_seq h0 out) 31 }
nat_from_bytes_le (as_seq h0 out) + pow2 255 * (v x);
} | {
"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.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Bignum25519.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.PointCompress.fst"
} | [] | [
"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.IntTypes.U8",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Prims.op_Addition",
"Lib.ByteSequence.nat_from_bytes_le",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Seq.Base.slice",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Lib.ByteSequence.nat_from_intseq_le_slice_lemma",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.squash",
"Prims.int",
"Lib.IntTypes.op_Plus_Dot",
"Lib.IntTypes.op_Less_Less_Dot",
"Lib.ByteSequence.nat_from_intseq_le_lemma0",
"Prims.op_Modulus",
"FStar.Math.Lemmas.modulo_lemma",
"FStar.Pervasives.assert_norm",
"Hacl.Impl.Ed25519.PointCompress.lemma_fits_in_prime_last_byte",
"Prims._assert",
"Prims.op_LessThanOrEqual",
"FStar.Math.Lemmas.lemma_mult_le_left",
"FStar.Math.Lemmas.distributivity_add_right",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Lib.Buffer.op_Array_Assignment",
"Lib.IntTypes.int_t",
"Lib.Buffer.op_Array_Access",
"Lib.IntTypes.to_u8"
] | [] | 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 noextract
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 =
(**) 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
open FStar.Calc
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) * 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 b 31);
};
assert (nat_from_intseq_le (Seq.slice b 0 31) < pow2 (31 * 8));
calc (<) {
pow2 (31*8) * v (Seq.index b 31);
(<) { }
Spec.Curve25519.prime - nat_from_intseq_le (Seq.slice b 0 31);
(<=) { }
Spec.Curve25519.prime;
(<) { }
pow2 255;
};
FStar.Math.Lemmas.lemma_div_lt_nat (pow2 (31*8) * v (Seq.index b 31)) 255 (31*8);
calc (==) {
(pow2 (31 *8) * v (Seq.index b 31))/ (pow2 (31*8));
(==) { FStar.Math.Lemmas.swap_mul (pow2 (31*8)) (v (Seq.index b 31)) }
(v (Seq.index b 31) * pow2 (31 *8)) / (pow2 (31*8));
(==) { FStar.Math.Lemmas.cancel_mul_div (v (Seq.index b 31)) (pow2 (31*8)) }
v (Seq.index b 31);
};
assert_norm (255 - 31 * 8 == 7)
inline_for_extraction noextract
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 * (v x) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 * (v x)
) | [] | 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)
: prop | [
{
"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,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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.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) | 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)
: prop
let 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)
: prop = | 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.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Lib.Vec.Lemmas.fsti"
} | [
"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.IntTypes +Lib.Sequence +Lib.Sequence.Lemmas +Lib.LoopCombinators +Lib.Vec.Lemmas'"
val lemma_repeat_gen_vec:
w:pos
-> n:nat
-> a:(i:nat{i <= w * n} -> Type)
-> a_vec:(i:nat{i <= n} -> Type)
-> normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i))
-> f:(i:nat{i < w * n} -> a i -> a (i + 1))
-> f_v:(i:nat{i < n} -> a_vec i -> a_vec (i + 1))
-> acc_v0:a_vec 0 ->
Lemma
(requires (forall (i:nat{i < n}) (acc_v:a_vec i).
(assert (w * (i + 1) <= w * n);
normalize_v (i + 1) (f_v i acc_v) ==
Loops.repeat_right (w * i) (w * (i + 1)) a f (normalize_v i acc_v))))
(ensures
normalize_v n (Loops.repeat_right 0 n a_vec f_v acc_v0) ==
Loops.repeat_right 0 (w * n) a f (normalize_v 0 acc_v0))
val lemma_repeati_vec:
#a:Type0
-> #a_vec:Type0
-> w:pos
-> n:nat
-> normalize_v:(a_vec -> a)
-> f:(i:nat{i < w * n} -> a -> a)
-> f_v:(i:nat{i < n} -> a_vec -> a_vec)
-> acc_v0:a_vec ->
Lemma
(requires (forall (i:nat{i < n}) (acc_v:a_vec).
(assert (w * (i + 1) <= w * n);
normalize_v (f_v i acc_v) ==
Loops.repeat_right (w * i) (w * (i + 1)) (Loops.fixed_a a) f (normalize_v acc_v))))
(ensures
normalize_v (Loops.repeati n f_v acc_v0) ==
Loops.repeati (w * n) f (normalize_v acc_v0))
///
/// Lemma
/// (repeat_gen_blocks (w * blocksize) 0 n inp a_vec f_v l_v acc_v0 ==
/// repeat_gen_blocks blocksize 0 (w * n + w) inp a f l (normalize_v 0 acc_v0))
///
val len_is_w_n_blocksize: w:pos -> blocksize:pos -> n:nat -> Lemma
(let len = w * n * blocksize in
len / blocksize = w * n /\ len / (w * blocksize) = n /\
len % blocksize = 0 /\ len % (w * blocksize) = 0)
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 inp_t (w * blocksize) -> a_vec i -> a_vec (i + 1)))
(normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i)))
(i:nat{i < n})
(b_v:lseq inp_t (w * blocksize))
(acc_v:a_vec i)
: prop
=
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)
val lemma_repeat_gen_blocks_multi_vec:
#inp_t:Type0
-> w:pos
-> blocksize:pos{w * blocksize <= max_size_t}
-> n:nat
-> hi_f:nat{w * n <= hi_f}
-> inp:seq inp_t{length inp = w * n * blocksize}
-> 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 inp_t (w * blocksize) -> a_vec i -> a_vec (i + 1))
-> normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i))
-> acc_v0:a_vec 0 ->
Lemma
(requires
(forall (i:nat{i < n}) (b_v:lseq inp_t (w * blocksize)) (acc_v:a_vec i).
repeat_gen_blocks_multi_vec_equiv_pre w blocksize n hi_f a a_vec f f_v normalize_v i b_v acc_v))
(ensures
(len_is_w_n_blocksize w blocksize n;
normalize_v n (repeat_gen_blocks_multi (w * blocksize) 0 n n inp a_vec f_v acc_v0) ==
repeat_gen_blocks_multi blocksize 0 hi_f (w * n) inp a f (normalize_v 0 acc_v0)))
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 < blocksize} -> lseq inp_t len -> a i -> c))
(l_v:(i:nat{i <= n} -> len:nat{len < w * blocksize} -> lseq inp_t len -> a_vec i -> c))
(normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i)))
(rem:nat{rem < w * blocksize})
(b_v:lseq inp_t rem)
(acc_v:a_vec n)
: prop
=
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)
val lemma_repeat_gen_blocks_vec:
#inp_t:Type0
-> #c:Type0
-> w:pos
-> blocksize:pos{w * blocksize <= max_size_t}
-> inp:seq inp_t
-> n:nat{n = length inp / (w * blocksize)}
-> 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 < blocksize} -> lseq inp_t len -> a i -> c)
-> f_v:(i:nat{i < n} -> lseq inp_t (w * blocksize) -> a_vec i -> a_vec (i + 1))
-> l_v:(i:nat{i <= n} -> len:nat{len < w * blocksize} -> lseq inp_t len -> a_vec i -> c)
-> normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i))
-> acc_v0:a_vec 0 ->
Lemma
(requires
(forall (i:nat{i < n}) (b_v:lseq inp_t (w * blocksize)) (acc_v:a_vec i).
repeat_gen_blocks_multi_vec_equiv_pre w blocksize n (w * n + w) a a_vec f f_v normalize_v i b_v acc_v) /\
(forall (rem:nat{rem < w * blocksize}) (b_v:lseq inp_t rem) (acc_v:a_vec n).
repeat_gen_blocks_vec_equiv_pre w blocksize n a a_vec f l l_v normalize_v rem b_v acc_v))
(ensures
repeat_gen_blocks (w * blocksize) 0 n inp a_vec f_v l_v acc_v0 ==
repeat_gen_blocks blocksize 0 (w * n + w) inp a f l (normalize_v 0 acc_v0))
///
/// Lemma
/// (repeat_blocks (w * blocksize) inp f_v l_v acc_v0 ==
/// repeat_blocks blocksize inp f l (normalize_v acc_v0))
///
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 | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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)
: prop | [] | 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_vec
-> Prims.prop | {
"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))
(normalize_v: (b_vec -> b))
(rem: nat{rem < w * blocksize})
(b_v: lseq a rem)
(acc_v: b_vec)
: prop | [
{
"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,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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:(b_vec -> b))
(rem:nat{rem < w * blocksize})
(b_v:lseq a rem)
(acc_v:b_vec)
: prop
=
l_v rem b_v acc_v ==
repeat_blocks blocksize b_v f l (normalize_v acc_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))
(normalize_v: (b_vec -> b))
(rem: nat{rem < w * blocksize})
(b_v: lseq a rem)
(acc_v: b_vec)
: prop
let 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))
(normalize_v: (b_vec -> b))
(rem: nat{rem < w * blocksize})
(b_v: lseq a rem)
(acc_v: b_vec)
: prop = | 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.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Lib.Vec.Lemmas.fsti"
} | [
"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.IntTypes +Lib.Sequence +Lib.Sequence.Lemmas +Lib.LoopCombinators +Lib.Vec.Lemmas'"
val lemma_repeat_gen_vec:
w:pos
-> n:nat
-> a:(i:nat{i <= w * n} -> Type)
-> a_vec:(i:nat{i <= n} -> Type)
-> normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i))
-> f:(i:nat{i < w * n} -> a i -> a (i + 1))
-> f_v:(i:nat{i < n} -> a_vec i -> a_vec (i + 1))
-> acc_v0:a_vec 0 ->
Lemma
(requires (forall (i:nat{i < n}) (acc_v:a_vec i).
(assert (w * (i + 1) <= w * n);
normalize_v (i + 1) (f_v i acc_v) ==
Loops.repeat_right (w * i) (w * (i + 1)) a f (normalize_v i acc_v))))
(ensures
normalize_v n (Loops.repeat_right 0 n a_vec f_v acc_v0) ==
Loops.repeat_right 0 (w * n) a f (normalize_v 0 acc_v0))
val lemma_repeati_vec:
#a:Type0
-> #a_vec:Type0
-> w:pos
-> n:nat
-> normalize_v:(a_vec -> a)
-> f:(i:nat{i < w * n} -> a -> a)
-> f_v:(i:nat{i < n} -> a_vec -> a_vec)
-> acc_v0:a_vec ->
Lemma
(requires (forall (i:nat{i < n}) (acc_v:a_vec).
(assert (w * (i + 1) <= w * n);
normalize_v (f_v i acc_v) ==
Loops.repeat_right (w * i) (w * (i + 1)) (Loops.fixed_a a) f (normalize_v acc_v))))
(ensures
normalize_v (Loops.repeati n f_v acc_v0) ==
Loops.repeati (w * n) f (normalize_v acc_v0))
///
/// Lemma
/// (repeat_gen_blocks (w * blocksize) 0 n inp a_vec f_v l_v acc_v0 ==
/// repeat_gen_blocks blocksize 0 (w * n + w) inp a f l (normalize_v 0 acc_v0))
///
val len_is_w_n_blocksize: w:pos -> blocksize:pos -> n:nat -> Lemma
(let len = w * n * blocksize in
len / blocksize = w * n /\ len / (w * blocksize) = n /\
len % blocksize = 0 /\ len % (w * blocksize) = 0)
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 inp_t (w * blocksize) -> a_vec i -> a_vec (i + 1)))
(normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i)))
(i:nat{i < n})
(b_v:lseq inp_t (w * blocksize))
(acc_v:a_vec i)
: prop
=
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)
val lemma_repeat_gen_blocks_multi_vec:
#inp_t:Type0
-> w:pos
-> blocksize:pos{w * blocksize <= max_size_t}
-> n:nat
-> hi_f:nat{w * n <= hi_f}
-> inp:seq inp_t{length inp = w * n * blocksize}
-> 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 inp_t (w * blocksize) -> a_vec i -> a_vec (i + 1))
-> normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i))
-> acc_v0:a_vec 0 ->
Lemma
(requires
(forall (i:nat{i < n}) (b_v:lseq inp_t (w * blocksize)) (acc_v:a_vec i).
repeat_gen_blocks_multi_vec_equiv_pre w blocksize n hi_f a a_vec f f_v normalize_v i b_v acc_v))
(ensures
(len_is_w_n_blocksize w blocksize n;
normalize_v n (repeat_gen_blocks_multi (w * blocksize) 0 n n inp a_vec f_v acc_v0) ==
repeat_gen_blocks_multi blocksize 0 hi_f (w * n) inp a f (normalize_v 0 acc_v0)))
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 < blocksize} -> lseq inp_t len -> a i -> c))
(l_v:(i:nat{i <= n} -> len:nat{len < w * blocksize} -> lseq inp_t len -> a_vec i -> c))
(normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i)))
(rem:nat{rem < w * blocksize})
(b_v:lseq inp_t rem)
(acc_v:a_vec n)
: prop
=
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)
val lemma_repeat_gen_blocks_vec:
#inp_t:Type0
-> #c:Type0
-> w:pos
-> blocksize:pos{w * blocksize <= max_size_t}
-> inp:seq inp_t
-> n:nat{n = length inp / (w * blocksize)}
-> 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 < blocksize} -> lseq inp_t len -> a i -> c)
-> f_v:(i:nat{i < n} -> lseq inp_t (w * blocksize) -> a_vec i -> a_vec (i + 1))
-> l_v:(i:nat{i <= n} -> len:nat{len < w * blocksize} -> lseq inp_t len -> a_vec i -> c)
-> normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i))
-> acc_v0:a_vec 0 ->
Lemma
(requires
(forall (i:nat{i < n}) (b_v:lseq inp_t (w * blocksize)) (acc_v:a_vec i).
repeat_gen_blocks_multi_vec_equiv_pre w blocksize n (w * n + w) a a_vec f f_v normalize_v i b_v acc_v) /\
(forall (rem:nat{rem < w * blocksize}) (b_v:lseq inp_t rem) (acc_v:a_vec n).
repeat_gen_blocks_vec_equiv_pre w blocksize n a a_vec f l l_v normalize_v rem b_v acc_v))
(ensures
repeat_gen_blocks (w * blocksize) 0 n inp a_vec f_v l_v acc_v0 ==
repeat_gen_blocks blocksize 0 (w * n + w) inp a f l (normalize_v 0 acc_v0))
///
/// Lemma
/// (repeat_blocks (w * blocksize) inp f_v l_v acc_v0 ==
/// repeat_blocks blocksize inp f l (normalize_v acc_v0))
///
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.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)
val lemma_repeat_blocks_multi_vec:
#a:Type0
-> #b:Type0
-> #b_vec:Type0
-> w:pos
-> blocksize:pos{w * blocksize <= max_size_t}
-> inp:seq a{length inp % (w * blocksize) = 0 /\ length inp % blocksize = 0}
-> f:(lseq a blocksize -> b -> b)
-> f_v:(lseq a (w * blocksize) -> b_vec -> b_vec)
-> normalize_v:(b_vec -> b)
-> acc_v0:b_vec ->
Lemma
(requires
(forall (b_v:lseq a (w * blocksize)) (acc_v:b_vec).
repeat_blocks_multi_vec_equiv_pre w blocksize f f_v normalize_v b_v acc_v))
(ensures
normalize_v (repeat_blocks_multi #a #b_vec (w * blocksize) inp f_v acc_v0) ==
repeat_blocks_multi #a #b blocksize inp f (normalize_v acc_v0))
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:(b_vec -> b))
(rem:nat{rem < w * blocksize})
(b_v:lseq a rem)
(acc_v:b_vec)
: prop | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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))
(normalize_v: (b_vec -> b))
(rem: nat{rem < w * blocksize})
(b_v: lseq a rem)
(acc_v: b_vec)
: prop | [] | 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_vec -> c) ->
normalize_v: (_: b_vec -> b) ->
rem: Prims.nat{rem < w * blocksize} ->
b_v: Lib.Sequence.lseq a rem ->
acc_v: b_vec
-> Prims.prop | {
"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)))
(i: nat{i < n})
(b_v: lseq a (w * blocksize))
(k: nat{k < w * blocksize})
: prop | [
{
"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,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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 * blocksize))
(k:nat{k < w * blocksize})
: prop
=
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) | 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)))
(i: nat{i < n})
(b_v: lseq a (w * blocksize))
(k: nat{k < w * blocksize})
: prop
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 * blocksize))
(k: nat{k < w * blocksize})
: prop = | 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.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Lib.Vec.Lemmas.fsti"
} | [
"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.lemma_f_map_ind",
"Lib.Sequence.Lemmas.get_block_s",
"FStar.Math.Lemmas.cancel_mul_div",
"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.IntTypes +Lib.Sequence +Lib.Sequence.Lemmas +Lib.LoopCombinators +Lib.Vec.Lemmas'"
val lemma_repeat_gen_vec:
w:pos
-> n:nat
-> a:(i:nat{i <= w * n} -> Type)
-> a_vec:(i:nat{i <= n} -> Type)
-> normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i))
-> f:(i:nat{i < w * n} -> a i -> a (i + 1))
-> f_v:(i:nat{i < n} -> a_vec i -> a_vec (i + 1))
-> acc_v0:a_vec 0 ->
Lemma
(requires (forall (i:nat{i < n}) (acc_v:a_vec i).
(assert (w * (i + 1) <= w * n);
normalize_v (i + 1) (f_v i acc_v) ==
Loops.repeat_right (w * i) (w * (i + 1)) a f (normalize_v i acc_v))))
(ensures
normalize_v n (Loops.repeat_right 0 n a_vec f_v acc_v0) ==
Loops.repeat_right 0 (w * n) a f (normalize_v 0 acc_v0))
val lemma_repeati_vec:
#a:Type0
-> #a_vec:Type0
-> w:pos
-> n:nat
-> normalize_v:(a_vec -> a)
-> f:(i:nat{i < w * n} -> a -> a)
-> f_v:(i:nat{i < n} -> a_vec -> a_vec)
-> acc_v0:a_vec ->
Lemma
(requires (forall (i:nat{i < n}) (acc_v:a_vec).
(assert (w * (i + 1) <= w * n);
normalize_v (f_v i acc_v) ==
Loops.repeat_right (w * i) (w * (i + 1)) (Loops.fixed_a a) f (normalize_v acc_v))))
(ensures
normalize_v (Loops.repeati n f_v acc_v0) ==
Loops.repeati (w * n) f (normalize_v acc_v0))
///
/// Lemma
/// (repeat_gen_blocks (w * blocksize) 0 n inp a_vec f_v l_v acc_v0 ==
/// repeat_gen_blocks blocksize 0 (w * n + w) inp a f l (normalize_v 0 acc_v0))
///
val len_is_w_n_blocksize: w:pos -> blocksize:pos -> n:nat -> Lemma
(let len = w * n * blocksize in
len / blocksize = w * n /\ len / (w * blocksize) = n /\
len % blocksize = 0 /\ len % (w * blocksize) = 0)
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 inp_t (w * blocksize) -> a_vec i -> a_vec (i + 1)))
(normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i)))
(i:nat{i < n})
(b_v:lseq inp_t (w * blocksize))
(acc_v:a_vec i)
: prop
=
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)
val lemma_repeat_gen_blocks_multi_vec:
#inp_t:Type0
-> w:pos
-> blocksize:pos{w * blocksize <= max_size_t}
-> n:nat
-> hi_f:nat{w * n <= hi_f}
-> inp:seq inp_t{length inp = w * n * blocksize}
-> 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 inp_t (w * blocksize) -> a_vec i -> a_vec (i + 1))
-> normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i))
-> acc_v0:a_vec 0 ->
Lemma
(requires
(forall (i:nat{i < n}) (b_v:lseq inp_t (w * blocksize)) (acc_v:a_vec i).
repeat_gen_blocks_multi_vec_equiv_pre w blocksize n hi_f a a_vec f f_v normalize_v i b_v acc_v))
(ensures
(len_is_w_n_blocksize w blocksize n;
normalize_v n (repeat_gen_blocks_multi (w * blocksize) 0 n n inp a_vec f_v acc_v0) ==
repeat_gen_blocks_multi blocksize 0 hi_f (w * n) inp a f (normalize_v 0 acc_v0)))
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 < blocksize} -> lseq inp_t len -> a i -> c))
(l_v:(i:nat{i <= n} -> len:nat{len < w * blocksize} -> lseq inp_t len -> a_vec i -> c))
(normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i)))
(rem:nat{rem < w * blocksize})
(b_v:lseq inp_t rem)
(acc_v:a_vec n)
: prop
=
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)
val lemma_repeat_gen_blocks_vec:
#inp_t:Type0
-> #c:Type0
-> w:pos
-> blocksize:pos{w * blocksize <= max_size_t}
-> inp:seq inp_t
-> n:nat{n = length inp / (w * blocksize)}
-> 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 < blocksize} -> lseq inp_t len -> a i -> c)
-> f_v:(i:nat{i < n} -> lseq inp_t (w * blocksize) -> a_vec i -> a_vec (i + 1))
-> l_v:(i:nat{i <= n} -> len:nat{len < w * blocksize} -> lseq inp_t len -> a_vec i -> c)
-> normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i))
-> acc_v0:a_vec 0 ->
Lemma
(requires
(forall (i:nat{i < n}) (b_v:lseq inp_t (w * blocksize)) (acc_v:a_vec i).
repeat_gen_blocks_multi_vec_equiv_pre w blocksize n (w * n + w) a a_vec f f_v normalize_v i b_v acc_v) /\
(forall (rem:nat{rem < w * blocksize}) (b_v:lseq inp_t rem) (acc_v:a_vec n).
repeat_gen_blocks_vec_equiv_pre w blocksize n a a_vec f l l_v normalize_v rem b_v acc_v))
(ensures
repeat_gen_blocks (w * blocksize) 0 n inp a_vec f_v l_v acc_v0 ==
repeat_gen_blocks blocksize 0 (w * n + w) inp a f l (normalize_v 0 acc_v0))
///
/// Lemma
/// (repeat_blocks (w * blocksize) inp f_v l_v acc_v0 ==
/// repeat_blocks blocksize inp f l (normalize_v acc_v0))
///
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.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)
val lemma_repeat_blocks_multi_vec:
#a:Type0
-> #b:Type0
-> #b_vec:Type0
-> w:pos
-> blocksize:pos{w * blocksize <= max_size_t}
-> inp:seq a{length inp % (w * blocksize) = 0 /\ length inp % blocksize = 0}
-> f:(lseq a blocksize -> b -> b)
-> f_v:(lseq a (w * blocksize) -> b_vec -> b_vec)
-> normalize_v:(b_vec -> b)
-> acc_v0:b_vec ->
Lemma
(requires
(forall (b_v:lseq a (w * blocksize)) (acc_v:b_vec).
repeat_blocks_multi_vec_equiv_pre w blocksize f f_v normalize_v b_v acc_v))
(ensures
normalize_v (repeat_blocks_multi #a #b_vec (w * blocksize) inp f_v acc_v0) ==
repeat_blocks_multi #a #b blocksize inp f (normalize_v acc_v0))
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:(b_vec -> b))
(rem:nat{rem < w * blocksize})
(b_v:lseq a rem)
(acc_v:b_vec)
: prop
=
l_v rem b_v acc_v ==
repeat_blocks blocksize b_v f l (normalize_v acc_v)
val lemma_repeat_blocks_vec:
#a:Type0
-> #b:Type0
-> #b_vec:Type0
-> #c:Type0
-> w:pos
-> blocksize:pos{w * blocksize <= max_size_t}
-> inp:seq a
-> f:(lseq a blocksize -> b -> b)
-> l:(len:nat{len < blocksize} -> lseq a len -> b -> c)
-> f_v:(lseq a (w * blocksize) -> b_vec -> b_vec)
-> l_v:(len:nat{len < w * blocksize} -> lseq a len -> b_vec -> c)
-> normalize_v:(b_vec -> b)
-> acc_v0:b_vec ->
Lemma
(requires
(forall (b_v:lseq a (w * blocksize)) (acc_v:b_vec).
repeat_blocks_multi_vec_equiv_pre w blocksize f f_v normalize_v b_v acc_v) /\
(forall (rem:nat{rem < w * blocksize}) (b_v:lseq a rem) (acc_v:b_vec).
repeat_blocks_vec_equiv_pre w blocksize f l l_v normalize_v rem b_v acc_v))
(ensures
repeat_blocks (w * blocksize) inp f_v l_v acc_v0 ==
repeat_blocks blocksize inp f l (normalize_v acc_v0))
///
/// Lemma
/// (map_blocks (w * blocksize) inp f_v l_v == map_blocks blocksize inp f l)
///
val lemma_f_map_ind: w:pos -> blocksize:pos -> n:nat -> i:nat{i < n} -> k:nat{k < w * blocksize} ->
Lemma (w * i + k / blocksize < w * n)
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 * blocksize))
(k:nat{k < w * blocksize})
: prop | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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)))
(i: nat{i < n})
(b_v: lseq a (w * blocksize))
(k: nat{k < w * blocksize})
: prop | [] | 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 * blocksize)
-> Lib.Sequence.lseq a (w * blocksize)) ->
i: Prims.nat{i < n} ->
b_v: Lib.Sequence.lseq a (w * blocksize) ->
k: Prims.nat{k < w * blocksize}
-> Prims.prop | {
"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: nat{i <= w * n + w} -> len: nat{len < blocksize} -> lseq inp_t len -> a i -> c))
(l_v: (i: nat{i <= n} -> len: nat{len < w * blocksize} -> lseq inp_t len -> a_vec i -> c))
(normalize_v: (i: nat{i <= n} -> a_vec i -> a (w * i)))
(rem: nat{rem < w * blocksize})
(b_v: lseq inp_t rem)
(acc_v: a_vec n)
: prop | [
{
"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,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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 < blocksize} -> lseq inp_t len -> a i -> c))
(l_v:(i:nat{i <= n} -> len:nat{len < w * blocksize} -> lseq inp_t len -> a_vec i -> c))
(normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i)))
(rem:nat{rem < w * blocksize})
(b_v:lseq inp_t rem)
(acc_v:a_vec n)
: prop
=
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) | 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: nat{i <= w * n + w} -> len: nat{len < blocksize} -> lseq inp_t len -> a i -> c))
(l_v: (i: nat{i <= n} -> len: nat{len < w * blocksize} -> lseq inp_t len -> a_vec i -> c))
(normalize_v: (i: nat{i <= n} -> a_vec i -> a (w * i)))
(rem: nat{rem < w * blocksize})
(b_v: lseq inp_t rem)
(acc_v: a_vec n)
: prop
let 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: nat{i <= w * n + w} -> len: nat{len < blocksize} -> lseq inp_t len -> a i -> c))
(l_v: (i: nat{i <= n} -> len: nat{len < w * blocksize} -> lseq inp_t len -> a_vec i -> c))
(normalize_v: (i: nat{i <= n} -> a_vec i -> a (w * i)))
(rem: nat{rem < w * blocksize})
(b_v: lseq inp_t rem)
(acc_v: a_vec n)
: prop = | 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.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Lib.Vec.Lemmas.fsti"
} | [
"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.IntTypes +Lib.Sequence +Lib.Sequence.Lemmas +Lib.LoopCombinators +Lib.Vec.Lemmas'"
val lemma_repeat_gen_vec:
w:pos
-> n:nat
-> a:(i:nat{i <= w * n} -> Type)
-> a_vec:(i:nat{i <= n} -> Type)
-> normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i))
-> f:(i:nat{i < w * n} -> a i -> a (i + 1))
-> f_v:(i:nat{i < n} -> a_vec i -> a_vec (i + 1))
-> acc_v0:a_vec 0 ->
Lemma
(requires (forall (i:nat{i < n}) (acc_v:a_vec i).
(assert (w * (i + 1) <= w * n);
normalize_v (i + 1) (f_v i acc_v) ==
Loops.repeat_right (w * i) (w * (i + 1)) a f (normalize_v i acc_v))))
(ensures
normalize_v n (Loops.repeat_right 0 n a_vec f_v acc_v0) ==
Loops.repeat_right 0 (w * n) a f (normalize_v 0 acc_v0))
val lemma_repeati_vec:
#a:Type0
-> #a_vec:Type0
-> w:pos
-> n:nat
-> normalize_v:(a_vec -> a)
-> f:(i:nat{i < w * n} -> a -> a)
-> f_v:(i:nat{i < n} -> a_vec -> a_vec)
-> acc_v0:a_vec ->
Lemma
(requires (forall (i:nat{i < n}) (acc_v:a_vec).
(assert (w * (i + 1) <= w * n);
normalize_v (f_v i acc_v) ==
Loops.repeat_right (w * i) (w * (i + 1)) (Loops.fixed_a a) f (normalize_v acc_v))))
(ensures
normalize_v (Loops.repeati n f_v acc_v0) ==
Loops.repeati (w * n) f (normalize_v acc_v0))
///
/// Lemma
/// (repeat_gen_blocks (w * blocksize) 0 n inp a_vec f_v l_v acc_v0 ==
/// repeat_gen_blocks blocksize 0 (w * n + w) inp a f l (normalize_v 0 acc_v0))
///
val len_is_w_n_blocksize: w:pos -> blocksize:pos -> n:nat -> Lemma
(let len = w * n * blocksize in
len / blocksize = w * n /\ len / (w * blocksize) = n /\
len % blocksize = 0 /\ len % (w * blocksize) = 0)
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 inp_t (w * blocksize) -> a_vec i -> a_vec (i + 1)))
(normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i)))
(i:nat{i < n})
(b_v:lseq inp_t (w * blocksize))
(acc_v:a_vec i)
: prop
=
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)
val lemma_repeat_gen_blocks_multi_vec:
#inp_t:Type0
-> w:pos
-> blocksize:pos{w * blocksize <= max_size_t}
-> n:nat
-> hi_f:nat{w * n <= hi_f}
-> inp:seq inp_t{length inp = w * n * blocksize}
-> 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 inp_t (w * blocksize) -> a_vec i -> a_vec (i + 1))
-> normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i))
-> acc_v0:a_vec 0 ->
Lemma
(requires
(forall (i:nat{i < n}) (b_v:lseq inp_t (w * blocksize)) (acc_v:a_vec i).
repeat_gen_blocks_multi_vec_equiv_pre w blocksize n hi_f a a_vec f f_v normalize_v i b_v acc_v))
(ensures
(len_is_w_n_blocksize w blocksize n;
normalize_v n (repeat_gen_blocks_multi (w * blocksize) 0 n n inp a_vec f_v acc_v0) ==
repeat_gen_blocks_multi blocksize 0 hi_f (w * n) inp a f (normalize_v 0 acc_v0)))
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 < blocksize} -> lseq inp_t len -> a i -> c))
(l_v:(i:nat{i <= n} -> len:nat{len < w * blocksize} -> lseq inp_t len -> a_vec i -> c))
(normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i)))
(rem:nat{rem < w * blocksize})
(b_v:lseq inp_t rem)
(acc_v:a_vec n)
: prop | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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: nat{i <= w * n + w} -> len: nat{len < blocksize} -> lseq inp_t len -> a i -> c))
(l_v: (i: nat{i <= n} -> len: nat{len < w * blocksize} -> lseq inp_t len -> a_vec i -> c))
(normalize_v: (i: nat{i <= n} -> a_vec i -> a (w * i)))
(rem: nat{rem < w * blocksize})
(b_v: lseq inp_t rem)
(acc_v: a_vec n)
: prop | [] | 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:
(
i: Prims.nat{i <= w * n + w} ->
len: Prims.nat{len < blocksize} ->
_: Lib.Sequence.lseq inp_t len ->
_: a i
-> c) ->
l_v:
(
i: Prims.nat{i <= n} ->
len: Prims.nat{len < w * blocksize} ->
_: Lib.Sequence.lseq inp_t len ->
_: a_vec i
-> c) ->
normalize_v: (i: Prims.nat{i <= n} -> _: a_vec i -> a (w * i)) ->
rem: Prims.nat{rem < w * blocksize} ->
b_v: Lib.Sequence.lseq inp_t rem ->
acc_v: a_vec n
-> Prims.prop | {
"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 -> a (i + 1)))
(f_v: (i: nat{i < n} -> lseq inp_t (w * blocksize) -> a_vec i -> a_vec (i + 1)))
(normalize_v: (i: nat{i <= n} -> a_vec i -> a (w * i)))
(i: nat{i < n})
(b_v: lseq inp_t (w * blocksize))
(acc_v: a_vec i)
: prop | [
{
"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,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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 inp_t (w * blocksize) -> a_vec i -> a_vec (i + 1)))
(normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i)))
(i:nat{i < n})
(b_v:lseq inp_t (w * blocksize))
(acc_v:a_vec i)
: prop
=
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) | 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 -> a (i + 1)))
(f_v: (i: nat{i < n} -> lseq inp_t (w * blocksize) -> a_vec i -> a_vec (i + 1)))
(normalize_v: (i: nat{i <= n} -> a_vec i -> a (w * i)))
(i: nat{i < n})
(b_v: lseq inp_t (w * blocksize))
(acc_v: a_vec i)
: prop
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 inp_t (w * blocksize) -> a_vec i -> a_vec (i + 1)))
(normalize_v: (i: nat{i <= n} -> a_vec i -> a (w * i)))
(i: nat{i < n})
(b_v: lseq inp_t (w * blocksize))
(acc_v: a_vec i)
: prop = | 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.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Lib.Vec.Lemmas.fsti"
} | [
"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",
"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.IntTypes +Lib.Sequence +Lib.Sequence.Lemmas +Lib.LoopCombinators +Lib.Vec.Lemmas'"
val lemma_repeat_gen_vec:
w:pos
-> n:nat
-> a:(i:nat{i <= w * n} -> Type)
-> a_vec:(i:nat{i <= n} -> Type)
-> normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i))
-> f:(i:nat{i < w * n} -> a i -> a (i + 1))
-> f_v:(i:nat{i < n} -> a_vec i -> a_vec (i + 1))
-> acc_v0:a_vec 0 ->
Lemma
(requires (forall (i:nat{i < n}) (acc_v:a_vec i).
(assert (w * (i + 1) <= w * n);
normalize_v (i + 1) (f_v i acc_v) ==
Loops.repeat_right (w * i) (w * (i + 1)) a f (normalize_v i acc_v))))
(ensures
normalize_v n (Loops.repeat_right 0 n a_vec f_v acc_v0) ==
Loops.repeat_right 0 (w * n) a f (normalize_v 0 acc_v0))
val lemma_repeati_vec:
#a:Type0
-> #a_vec:Type0
-> w:pos
-> n:nat
-> normalize_v:(a_vec -> a)
-> f:(i:nat{i < w * n} -> a -> a)
-> f_v:(i:nat{i < n} -> a_vec -> a_vec)
-> acc_v0:a_vec ->
Lemma
(requires (forall (i:nat{i < n}) (acc_v:a_vec).
(assert (w * (i + 1) <= w * n);
normalize_v (f_v i acc_v) ==
Loops.repeat_right (w * i) (w * (i + 1)) (Loops.fixed_a a) f (normalize_v acc_v))))
(ensures
normalize_v (Loops.repeati n f_v acc_v0) ==
Loops.repeati (w * n) f (normalize_v acc_v0))
///
/// Lemma
/// (repeat_gen_blocks (w * blocksize) 0 n inp a_vec f_v l_v acc_v0 ==
/// repeat_gen_blocks blocksize 0 (w * n + w) inp a f l (normalize_v 0 acc_v0))
///
val len_is_w_n_blocksize: w:pos -> blocksize:pos -> n:nat -> Lemma
(let len = w * n * blocksize in
len / blocksize = w * n /\ len / (w * blocksize) = n /\
len % blocksize = 0 /\ len % (w * blocksize) = 0)
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 inp_t (w * blocksize) -> a_vec i -> a_vec (i + 1)))
(normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i)))
(i:nat{i < n})
(b_v:lseq inp_t (w * blocksize))
(acc_v:a_vec i)
: prop | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 -> a (i + 1)))
(f_v: (i: nat{i < n} -> lseq inp_t (w * blocksize) -> a_vec i -> a_vec (i + 1)))
(normalize_v: (i: nat{i <= n} -> a_vec i -> a (w * i)))
(i: nat{i < n})
(b_v: lseq inp_t (w * blocksize))
(acc_v: a_vec i)
: prop | [] | 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 -> a (i + 1)) ->
f_v:
(i: Prims.nat{i < n} -> _: Lib.Sequence.lseq inp_t (w * blocksize) -> _: a_vec i
-> a_vec (i + 1)) ->
normalize_v: (i: Prims.nat{i <= n} -> _: a_vec i -> a (w * i)) ->
i: Prims.nat{i < n} ->
b_v: Lib.Sequence.lseq inp_t (w * blocksize) ->
acc_v: a_vec i
-> Prims.prop | {
"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 <= n} -> rem: nat{rem < w * blocksize} -> lseq a rem -> lseq a rem))
(rem: nat{rem < w * blocksize})
(b_v: lseq a rem)
(k: nat{k < rem})
: prop | [
{
"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,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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} -> lseq a rem -> lseq a rem))
(rem:nat{rem < w * blocksize})
(b_v:lseq a rem)
(k:nat{k < rem})
: prop
=
let j = w * n + k / blocksize in
div_mul_lt blocksize k w;
if k < rem / blocksize * blocksize then begin
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) end
else begin
let block_l = get_last_s blocksize b_v in
mod_div_lt blocksize k rem;
assert (k % blocksize < rem % blocksize);
Seq.index (l_v n rem b_v) k == Seq.index (l j (rem % blocksize) block_l) (k % blocksize) end | 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 <= n} -> rem: nat{rem < w * blocksize} -> lseq a rem -> lseq a rem))
(rem: nat{rem < w * blocksize})
(b_v: lseq a rem)
(k: nat{k < rem})
: prop
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} -> lseq a rem -> lseq a rem))
(rem: nat{rem < w * blocksize})
(b_v: lseq a rem)
(k: nat{k < rem})
: prop = | 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 % blocksize < rem % blocksize);
Seq.index (l_v n rem b_v) k == Seq.index (l j (rem % blocksize) block_l) (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.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Lib.Vec.Lemmas.fsti"
} | [
"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",
"Prims.bool",
"Prims.unit",
"Prims._assert",
"Lib.Sequence.mod_div_lt",
"Lib.Sequence.Lemmas.get_last_s",
"Prims.prop",
"Lib.Sequence.div_mul_lt",
"Prims.int"
] | [] | 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.IntTypes +Lib.Sequence +Lib.Sequence.Lemmas +Lib.LoopCombinators +Lib.Vec.Lemmas'"
val lemma_repeat_gen_vec:
w:pos
-> n:nat
-> a:(i:nat{i <= w * n} -> Type)
-> a_vec:(i:nat{i <= n} -> Type)
-> normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i))
-> f:(i:nat{i < w * n} -> a i -> a (i + 1))
-> f_v:(i:nat{i < n} -> a_vec i -> a_vec (i + 1))
-> acc_v0:a_vec 0 ->
Lemma
(requires (forall (i:nat{i < n}) (acc_v:a_vec i).
(assert (w * (i + 1) <= w * n);
normalize_v (i + 1) (f_v i acc_v) ==
Loops.repeat_right (w * i) (w * (i + 1)) a f (normalize_v i acc_v))))
(ensures
normalize_v n (Loops.repeat_right 0 n a_vec f_v acc_v0) ==
Loops.repeat_right 0 (w * n) a f (normalize_v 0 acc_v0))
val lemma_repeati_vec:
#a:Type0
-> #a_vec:Type0
-> w:pos
-> n:nat
-> normalize_v:(a_vec -> a)
-> f:(i:nat{i < w * n} -> a -> a)
-> f_v:(i:nat{i < n} -> a_vec -> a_vec)
-> acc_v0:a_vec ->
Lemma
(requires (forall (i:nat{i < n}) (acc_v:a_vec).
(assert (w * (i + 1) <= w * n);
normalize_v (f_v i acc_v) ==
Loops.repeat_right (w * i) (w * (i + 1)) (Loops.fixed_a a) f (normalize_v acc_v))))
(ensures
normalize_v (Loops.repeati n f_v acc_v0) ==
Loops.repeati (w * n) f (normalize_v acc_v0))
///
/// Lemma
/// (repeat_gen_blocks (w * blocksize) 0 n inp a_vec f_v l_v acc_v0 ==
/// repeat_gen_blocks blocksize 0 (w * n + w) inp a f l (normalize_v 0 acc_v0))
///
val len_is_w_n_blocksize: w:pos -> blocksize:pos -> n:nat -> Lemma
(let len = w * n * blocksize in
len / blocksize = w * n /\ len / (w * blocksize) = n /\
len % blocksize = 0 /\ len % (w * blocksize) = 0)
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 inp_t (w * blocksize) -> a_vec i -> a_vec (i + 1)))
(normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i)))
(i:nat{i < n})
(b_v:lseq inp_t (w * blocksize))
(acc_v:a_vec i)
: prop
=
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)
val lemma_repeat_gen_blocks_multi_vec:
#inp_t:Type0
-> w:pos
-> blocksize:pos{w * blocksize <= max_size_t}
-> n:nat
-> hi_f:nat{w * n <= hi_f}
-> inp:seq inp_t{length inp = w * n * blocksize}
-> 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 inp_t (w * blocksize) -> a_vec i -> a_vec (i + 1))
-> normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i))
-> acc_v0:a_vec 0 ->
Lemma
(requires
(forall (i:nat{i < n}) (b_v:lseq inp_t (w * blocksize)) (acc_v:a_vec i).
repeat_gen_blocks_multi_vec_equiv_pre w blocksize n hi_f a a_vec f f_v normalize_v i b_v acc_v))
(ensures
(len_is_w_n_blocksize w blocksize n;
normalize_v n (repeat_gen_blocks_multi (w * blocksize) 0 n n inp a_vec f_v acc_v0) ==
repeat_gen_blocks_multi blocksize 0 hi_f (w * n) inp a f (normalize_v 0 acc_v0)))
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 < blocksize} -> lseq inp_t len -> a i -> c))
(l_v:(i:nat{i <= n} -> len:nat{len < w * blocksize} -> lseq inp_t len -> a_vec i -> c))
(normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i)))
(rem:nat{rem < w * blocksize})
(b_v:lseq inp_t rem)
(acc_v:a_vec n)
: prop
=
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)
val lemma_repeat_gen_blocks_vec:
#inp_t:Type0
-> #c:Type0
-> w:pos
-> blocksize:pos{w * blocksize <= max_size_t}
-> inp:seq inp_t
-> n:nat{n = length inp / (w * blocksize)}
-> 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 < blocksize} -> lseq inp_t len -> a i -> c)
-> f_v:(i:nat{i < n} -> lseq inp_t (w * blocksize) -> a_vec i -> a_vec (i + 1))
-> l_v:(i:nat{i <= n} -> len:nat{len < w * blocksize} -> lseq inp_t len -> a_vec i -> c)
-> normalize_v:(i:nat{i <= n} -> a_vec i -> a (w * i))
-> acc_v0:a_vec 0 ->
Lemma
(requires
(forall (i:nat{i < n}) (b_v:lseq inp_t (w * blocksize)) (acc_v:a_vec i).
repeat_gen_blocks_multi_vec_equiv_pre w blocksize n (w * n + w) a a_vec f f_v normalize_v i b_v acc_v) /\
(forall (rem:nat{rem < w * blocksize}) (b_v:lseq inp_t rem) (acc_v:a_vec n).
repeat_gen_blocks_vec_equiv_pre w blocksize n a a_vec f l l_v normalize_v rem b_v acc_v))
(ensures
repeat_gen_blocks (w * blocksize) 0 n inp a_vec f_v l_v acc_v0 ==
repeat_gen_blocks blocksize 0 (w * n + w) inp a f l (normalize_v 0 acc_v0))
///
/// Lemma
/// (repeat_blocks (w * blocksize) inp f_v l_v acc_v0 ==
/// repeat_blocks blocksize inp f l (normalize_v acc_v0))
///
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.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)
val lemma_repeat_blocks_multi_vec:
#a:Type0
-> #b:Type0
-> #b_vec:Type0
-> w:pos
-> blocksize:pos{w * blocksize <= max_size_t}
-> inp:seq a{length inp % (w * blocksize) = 0 /\ length inp % blocksize = 0}
-> f:(lseq a blocksize -> b -> b)
-> f_v:(lseq a (w * blocksize) -> b_vec -> b_vec)
-> normalize_v:(b_vec -> b)
-> acc_v0:b_vec ->
Lemma
(requires
(forall (b_v:lseq a (w * blocksize)) (acc_v:b_vec).
repeat_blocks_multi_vec_equiv_pre w blocksize f f_v normalize_v b_v acc_v))
(ensures
normalize_v (repeat_blocks_multi #a #b_vec (w * blocksize) inp f_v acc_v0) ==
repeat_blocks_multi #a #b blocksize inp f (normalize_v acc_v0))
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:(b_vec -> b))
(rem:nat{rem < w * blocksize})
(b_v:lseq a rem)
(acc_v:b_vec)
: prop
=
l_v rem b_v acc_v ==
repeat_blocks blocksize b_v f l (normalize_v acc_v)
val lemma_repeat_blocks_vec:
#a:Type0
-> #b:Type0
-> #b_vec:Type0
-> #c:Type0
-> w:pos
-> blocksize:pos{w * blocksize <= max_size_t}
-> inp:seq a
-> f:(lseq a blocksize -> b -> b)
-> l:(len:nat{len < blocksize} -> lseq a len -> b -> c)
-> f_v:(lseq a (w * blocksize) -> b_vec -> b_vec)
-> l_v:(len:nat{len < w * blocksize} -> lseq a len -> b_vec -> c)
-> normalize_v:(b_vec -> b)
-> acc_v0:b_vec ->
Lemma
(requires
(forall (b_v:lseq a (w * blocksize)) (acc_v:b_vec).
repeat_blocks_multi_vec_equiv_pre w blocksize f f_v normalize_v b_v acc_v) /\
(forall (rem:nat{rem < w * blocksize}) (b_v:lseq a rem) (acc_v:b_vec).
repeat_blocks_vec_equiv_pre w blocksize f l l_v normalize_v rem b_v acc_v))
(ensures
repeat_blocks (w * blocksize) inp f_v l_v acc_v0 ==
repeat_blocks blocksize inp f l (normalize_v acc_v0))
///
/// Lemma
/// (map_blocks (w * blocksize) inp f_v l_v == map_blocks blocksize inp f l)
///
val lemma_f_map_ind: w:pos -> blocksize:pos -> n:nat -> i:nat{i < n} -> k:nat{k < w * blocksize} ->
Lemma (w * i + k / blocksize < w * n)
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 * blocksize))
(k:nat{k < w * blocksize})
: prop
=
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)
val lemma_map_blocks_multi_vec:
#a:Type
-> w:pos
-> blocksize:pos{w * blocksize <= max_size_t}
-> n:nat
-> inp:seq a{length inp = w * n * blocksize}
-> f:(i:nat{i < w * n} -> lseq a blocksize -> lseq a blocksize)
-> f_v:(i:nat{i < n} -> lseq a (w * blocksize) -> lseq a (w * blocksize)) ->
Lemma
(requires
(forall (i:nat{i < n}) (b_v:lseq a (w * blocksize)) (k:nat{k < w * blocksize}).
map_blocks_multi_vec_equiv_pre_k w blocksize n (w * n) f f_v i b_v k))
(ensures
(len_is_w_n_blocksize w blocksize n;
map_blocks_multi (w * blocksize) n n inp f_v ==
map_blocks_multi blocksize (w * n) (w * n) inp f))
#push-options "--z3rlimit_factor 2"
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} -> lseq a rem -> lseq a rem))
(rem:nat{rem < w * blocksize})
(b_v:lseq a rem)
(k:nat{k < rem}) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 2,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 <= n} -> rem: nat{rem < w * blocksize} -> lseq a rem -> lseq a rem))
(rem: nat{rem < w * blocksize})
(b_v: lseq a rem)
(k: nat{k < rem})
: prop | [] | 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} -> _: Lib.Sequence.lseq a rem
-> Lib.Sequence.lseq a rem) ->
l_v:
(i: Prims.nat{i <= n} -> rem: Prims.nat{rem < w * blocksize} -> _: Lib.Sequence.lseq a rem
-> Lib.Sequence.lseq a rem) ->
rem: Prims.nat{rem < w * blocksize} ->
b_v: Lib.Sequence.lseq a rem ->
k: Prims.nat{k < rem}
-> Prims.prop | {
"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"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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:uint_t a_t SEC{v bits_l < v table_len}
-> tmp:lbuffer (uint_t a_t SEC) len ->
Stack unit
(requires fun h ->
live h table /\ live h tmp /\ disjoint table tmp /\
k.to.linv a /\
(forall (j:nat{j < v table_len}).
precomp_table_inv len ctx_len k a table_len (as_seq h table) j))
(ensures fun h0 _ h1 -> modifies (loc tmp) h0 h1 /\
k.to.linv (as_seq h1 tmp) /\
k.to.refl (as_seq h1 tmp) == S.pow k.to.comm_monoid (k.to.refl a) (v 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
(requires
fun h ->
live h table /\ live h tmp /\ disjoint table tmp /\ k.to.linv a /\
(forall (j: nat{j < v table_len}).
precomp_table_inv len ctx_len k a table_len (as_seq h table) j))
(ensures
fun h0 _ h1 ->
modifies (loc tmp) h0 h1 /\ k.to.linv (as_seq h1 tmp) /\
k.to.refl (as_seq h1 tmp) == S.pow k.to.comm_monoid (k.to.refl a) (v bits_l)) | {
"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.Bignum.Definitions.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.PrecompTable.fsti"
} | [
"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.IntTypes.SEC",
"Prims.l_and",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Lib.Buffer.clbuffer",
"Lib.IntTypes.op_Star_Bang",
"Lib.Buffer.lbuffer",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Lib.Buffer.live",
"Lib.Buffer.CONST",
"Lib.Buffer.MUT",
"Lib.Buffer.disjoint",
"Hacl.Impl.Exponentiation.Definitions.__proj__Mkto_comm_monoid__item__linv",
"FStar.Ghost.reveal",
"Hacl.Impl.Exponentiation.Definitions.to_comm_monoid",
"Hacl.Impl.Exponentiation.Definitions.__proj__Mkconcrete_ops__item__to",
"Prims.l_Forall",
"Prims.nat",
"Hacl.Impl.PrecompTable.precomp_table_inv",
"Lib.Buffer.as_seq",
"Lib.Buffer.modifies",
"Lib.Buffer.loc",
"Prims.eq2",
"Hacl.Impl.Exponentiation.Definitions.__proj__Mkto_comm_monoid__item__a_spec",
"Hacl.Impl.Exponentiation.Definitions.__proj__Mkto_comm_monoid__item__refl",
"Lib.Exponentiation.Definition.pow",
"Hacl.Impl.Exponentiation.Definitions.__proj__Mkto_comm_monoid__item__comm_monoid"
] | [] | 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.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_table_sub_len: len:nat -> table_len:nat -> i:nat{i < table_len} ->
Lemma (i * len + len <= table_len * len)
inline_for_extraction noextract
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
inline_for_extraction noextract
val table_select_consttime:
#t:BD.limb_t
-> len:size_t{v len > 0}
-> table_len:size_t{1 < v table_len /\ v table_len * v len <= max_size_t}
-> table:clbuffer (uint_t t SEC) (table_len *! len)
-> i:uint_t t SEC{v i < v table_len}
-> res:lbuffer (uint_t t SEC) len ->
Stack unit
(requires fun h ->
live h table /\ live h res /\ disjoint table res)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_seq h1 res == spec_table_sub_len (v len) (v table_len) (as_seq h0 table) (v i))
// Precomputed table [a^0 = one; a^1; a^2; ..; a^(table_len - 1)]
//----------------------------------------------------------------
inline_for_extraction noextract
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 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
// This function computes [a^0 = one; a^1; a^2; ..; a^(table_len - 1)]
inline_for_extraction noextract
val lprecomp_table:
#a_t:inttype_a
-> len:size_t{v len > 0}
-> ctx_len:size_t
-> k:concrete_ops a_t len ctx_len
-> ctx:lbuffer (uint_t a_t SEC) ctx_len
-> a:lbuffer (uint_t a_t SEC) len
-> table_len:size_t{1 < v table_len /\ v table_len * v len <= max_size_t /\ v table_len % 2 = 0}
-> table:lbuffer (uint_t a_t SEC) (table_len *! len) ->
Stack unit
(requires fun h ->
live h a /\ live h table /\ live h ctx /\
disjoint a table /\ disjoint ctx table /\ disjoint a ctx /\
k.to.linv (as_seq h a) /\ k.to.linv_ctx (as_seq h ctx))
(ensures fun h0 _ h1 -> modifies (loc table) h0 h1 /\
(forall (j:nat{j < v table_len}).{:pattern precomp_table_inv len ctx_len k (as_seq h1 a) table_len (as_seq h1 table) j}
precomp_table_inv len ctx_len k (as_seq h1 a) table_len (as_seq h1 table) j))
inline_for_extraction noextract
let lprecomp_get_st
(a_t:inttype_a)
(len:size_t{v len > 0})
(ctx_len:size_t) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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: nat{j < v table_len})
: Type0 | [
{
"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"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 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 | 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: nat{j < v table_len})
: Type0
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 = | 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.Bignum.Definitions.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.PrecompTable.fsti"
} | [
"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_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Prims.nat",
"Prims.op_LessThan",
"Prims.l_and",
"Hacl.Impl.Exponentiation.Definitions.__proj__Mkto_comm_monoid__item__linv",
"FStar.Ghost.reveal",
"Hacl.Impl.Exponentiation.Definitions.to_comm_monoid",
"Hacl.Impl.Exponentiation.Definitions.__proj__Mkconcrete_ops__item__to",
"Prims.eq2",
"Hacl.Impl.Exponentiation.Definitions.__proj__Mkto_comm_monoid__item__a_spec",
"Hacl.Impl.Exponentiation.Definitions.__proj__Mkto_comm_monoid__item__refl",
"Lib.Exponentiation.Definition.pow",
"Hacl.Impl.Exponentiation.Definitions.__proj__Mkto_comm_monoid__item__comm_monoid",
"Lib.IntTypes.int_t",
"Hacl.Impl.PrecompTable.spec_table_sub_len"
] | [] | 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.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_table_sub_len: len:nat -> table_len:nat -> i:nat{i < table_len} ->
Lemma (i * len + len <= table_len * len)
inline_for_extraction noextract
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
inline_for_extraction noextract
val table_select_consttime:
#t:BD.limb_t
-> len:size_t{v len > 0}
-> table_len:size_t{1 < v table_len /\ v table_len * v len <= max_size_t}
-> table:clbuffer (uint_t t SEC) (table_len *! len)
-> i:uint_t t SEC{v i < v table_len}
-> res:lbuffer (uint_t t SEC) len ->
Stack unit
(requires fun h ->
live h table /\ live h res /\ disjoint table res)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_seq h1 res == spec_table_sub_len (v len) (v table_len) (as_seq h0 table) (v i))
// Precomputed table [a^0 = one; a^1; a^2; ..; a^(table_len - 1)]
//----------------------------------------------------------------
inline_for_extraction noextract
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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 | [] | 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 table_len * Lib.IntTypes.v len <= Lib.IntTypes.max_size_t} ->
table:
Lib.Sequence.lseq (Lib.IntTypes.uint_t a_t Lib.IntTypes.SEC)
(Lib.IntTypes.v table_len * Lib.IntTypes.v len) ->
j: Prims.nat{j < Lib.IntTypes.v table_len}
-> Type0 | {
"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"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_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 = | 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.Bignum.Definitions.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.PrecompTable.fsti"
} | [
"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",
"Hacl.Impl.PrecompTable.lemma_table_sub_len"
] | [] | 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.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_table_sub_len: len:nat -> table_len:nat -> i:nat{i < table_len} ->
Lemma (i * len + len <= table_len * len)
inline_for_extraction noextract
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 = | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Poly1305.Util.fsti"
} | [
"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 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 s kk) * r)
val poly1305_heap_blocks (h:int) (pad:int) (r:int) (s:Seq.seq nat64) (k:int) : int
val reveal_poly1305_heap_blocks (h:int) (pad:int) (r:int) (s:Seq.seq nat64) (k:int) : Lemma
(requires 0 <= k /\ k <= Seq.length s /\ k % 2 == 0)
(ensures poly1305_heap_blocks h pad r s k = poly1305_heap_blocks' h pad r s k)
type t_seqTo128 = int -> nat128
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 | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Poly1305.Util.fsti"
} | [
"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 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 s kk) * r)
val poly1305_heap_blocks (h:int) (pad:int) (r:int) (s:Seq.seq nat64) (k:int) : int
val reveal_poly1305_heap_blocks (h:int) (pad:int) (r:int) (s:Seq.seq nat64) (k:int) : Lemma
(requires 0 <= k /\ k <= Seq.length s /\ k % 2 == 0)
(ensures poly1305_heap_blocks h pad r s k = poly1305_heap_blocks' h pad r s k)
type t_seqTo128 = int -> nat128
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
let seqTo128_app (s:Seq.seq nat64) (i:int) : nat128 = seqTo128 s i
val lemma_poly1305_heap_hash_blocks_alt (h:int) (pad:int) (r:int) (m:vale_heap) (b:buffer64) (n:int) : Lemma
(requires 0 <= n /\ n + n <= buffer_length b /\ n + n <= Seq.length (buffer64_as_seq m b))
(ensures
((n + n) % 2) == 0 /\ // REVIEW
poly1305_heap_blocks h pad r (buffer64_as_seq m b) (n + n) ==
poly1305_hash_blocks h pad r (seqTo128 (buffer64_as_seq m b)) n)
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'
unfold let modifies_buffer (b:buffer64) (h1 h2:vale_heap) = modifies_mem (loc_buffer b) h1 h2 | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Poly1305.Util.fsti"
} | [
"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 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 s kk) * r)
val poly1305_heap_blocks (h:int) (pad:int) (r:int) (s:Seq.seq nat64) (k:int) : int
val reveal_poly1305_heap_blocks (h:int) (pad:int) (r:int) (s:Seq.seq nat64) (k:int) : Lemma
(requires 0 <= k /\ k <= Seq.length s /\ k % 2 == 0)
(ensures poly1305_heap_blocks h pad r s k = poly1305_heap_blocks' h pad r s k)
type t_seqTo128 = int -> nat128
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
let seqTo128_app (s:Seq.seq nat64) (i:int) : nat128 = seqTo128 s i
val lemma_poly1305_heap_hash_blocks_alt (h:int) (pad:int) (r:int) (m:vale_heap) (b:buffer64) (n:int) : Lemma
(requires 0 <= n /\ n + n <= buffer_length b /\ n + n <= Seq.length (buffer64_as_seq m b))
(ensures
((n + n) % 2) == 0 /\ // REVIEW
poly1305_heap_blocks h pad r (buffer64_as_seq m b) (n + n) ==
poly1305_hash_blocks h pad r (seqTo128 (buffer64_as_seq m b)) n)
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' | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Poly1305.Util.fsti"
} | [
"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.Machine_s.nat128",
"Vale.Poly1305.Util.t_seqTo128"
] | [] | 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 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 s kk) * r)
val poly1305_heap_blocks (h:int) (pad:int) (r:int) (s:Seq.seq nat64) (k:int) : int
val reveal_poly1305_heap_blocks (h:int) (pad:int) (r:int) (s:Seq.seq nat64) (k:int) : Lemma
(requires 0 <= k /\ k <= Seq.length s /\ k % 2 == 0)
(ensures poly1305_heap_blocks h pad r s k = poly1305_heap_blocks' h pad r s k) | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec 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 s kk) * r) | 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.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Poly1305.Util.fsti"
} | [
"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.X64.Machine_s.pow2_64",
"FStar.Seq.Base.index",
"Vale.Poly1305.Util.poly1305_heap_blocks'",
"Prims.op_Subtraction"
] | [] | 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 nat64) (k:int{0 <= k /\ k <= Seq.length s /\ k % 2 == 0}) | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305.Math",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec 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.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Poly1305.Util.fsti"
} | [
"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 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 s kk) * r)
val poly1305_heap_blocks (h:int) (pad:int) (r:int) (s:Seq.seq nat64) (k:int) : int
val reveal_poly1305_heap_blocks (h:int) (pad:int) (r:int) (s:Seq.seq nat64) (k:int) : Lemma
(requires 0 <= k /\ k <= Seq.length s /\ k % 2 == 0)
(ensures poly1305_heap_blocks h pad r s k = poly1305_heap_blocks' h pad r s k)
type t_seqTo128 = int -> nat128
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
let seqTo128_app (s:Seq.seq nat64) (i:int) : nat128 = seqTo128 s i
val lemma_poly1305_heap_hash_blocks_alt (h:int) (pad:int) (r:int) (m:vale_heap) (b:buffer64) (n:int) : Lemma
(requires 0 <= n /\ n + n <= buffer_length b /\ n + n <= Seq.length (buffer64_as_seq m b))
(ensures
((n + n) % 2) == 0 /\ // REVIEW
poly1305_heap_blocks h pad r (buffer64_as_seq m b) (n + n) ==
poly1305_hash_blocks h pad r (seqTo128 (buffer64_as_seq m b)) n) | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.Bignum.ModInvLimb.fst"
} | [
"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/crypto/fipsmodule/bn/montgomery_inv.c *)
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) =
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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.Bignum.ModInvLimb.fst"
} | [
"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",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Less_Less_Dot",
"Lib.IntTypes.size",
"Prims.op_Subtraction"
] | [] | 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/crypto/fipsmodule/bn/montgomery_inv.c *)
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) =
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)
let mod_inv_limb_t (t:limb_t) (i:nat{i <= bits t}) = tuple2 (limb t) (limb t) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.Bignum.ModInvLimb.fst"
} | [
"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.IntTypes.op_Greater_Greater_Dot",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTypes.op_Hat_Dot",
"Lib.IntTypes.op_Subtraction_Dot",
"Lib.IntTypes.uint"
] | [] | 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/crypto/fipsmodule/bn/montgomery_inv.c *)
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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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
else
logand_ones 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.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.Bignum.ModInvLimb.fst"
} | [
"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.op_Subtraction",
"Prims.pow2",
"Lib.IntTypes.bits",
"Prims.op_Minus",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTypes.uint",
"Lib.IntTypes.logand_mask",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Subtraction_Dot"
] | [] | 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/crypto/fipsmodule/bn/montgomery_inv.c *)
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) =
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)
let mod_inv_limb_t (t:limb_t) (i:nat{i <= bits t}) = tuple2 (limb t) (limb t)
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
// Replace with `a >> 1 + b >> 1 + a & b & 1`?
val add_div_2_nooverflow: #t:limb_t -> a:limb t -> b:limb t ->
Lemma (v (((a ^. b) >>. 1ul) +. (a &. b)) == (v a + v b) / 2 % pow2 (bits t))
let add_div_2_nooverflow #t a b = admit()
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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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
| _ -> Lib.IntTypes.v x))) | {
"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
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 + (bn_v n % pow2 (bits t)) * v mu) % pow2 (bits t) == 0);
M.mont_preconditions_n0 (bits t) (bn_v n) (v mu) | 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_n0 (bits t) (bn_v n) (v mu) | {
"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.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.Bignum.ModInvLimb.fst"
} | [
"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",
"Prims.int",
"Prims.op_Modulus",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.pow2",
"Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb_lemma",
"Prims.b2t",
"Prims.op_Equality",
"FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1",
"Hacl.Spec.Bignum.Definitions.bn_eval_index",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.index"
] | [] | 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/crypto/fipsmodule/bn/montgomery_inv.c *)
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) =
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)
let mod_inv_limb_t (t:limb_t) (i:nat{i <= bits t}) = tuple2 (limb t) (limb t)
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
// Replace with `a >> 1 + b >> 1 + a & b & 1`?
val add_div_2_nooverflow: #t:limb_t -> a:limb t -> b:limb t ->
Lemma (v (((a ^. b) >>. 1ul) +. (a &. b)) == (v a + v b) / 2 % pow2 (bits t))
let add_div_2_nooverflow #t a b = admit()
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 =
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
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 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 - v vb0 * v beta) % 2;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (v ub0 * 2 * v alpha) (- v vb0 * v beta) 2 }
(- v vb0 * v beta) % 2;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (- v vb0) (v beta) 2 }
(- v vb0) % 2;
(==) { }
v vb0 % 2;
}
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
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
let ub = v ub0 / 2 % pow2 (bits t) in
let vb = v vb0 / 2 % pow2 (bits t) in
pow2 (bits t - i + 1) == 2 * (ub * 2 * v alpha - vb * v beta)))
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);
assert (ub * 2 * v alpha - vb * v beta == v ub0 / 2 * 2 * v alpha - v vb0 / 2 * v beta);
calc (==) {
2 * (ub * 2 * v alpha - vb * v beta);
(==) { }
2 * (v ub0 / 2 * 2 * v alpha - v vb0 / 2 * v beta);
(==) { Math.Lemmas.distributivity_sub_right 2 (v ub0 / 2 * 2 * v alpha) (v vb0 / 2 * v beta) }
2 * v ub0 / 2 * 2 * v alpha - 2 * (v vb0 / 2) * v beta;
(==) { Math.Lemmas.div_exact_r (v ub0) 2 }
v ub0 * 2 * v alpha - 2 * (v vb0 / 2) * v beta;
(==) { mod_inv_limb_inv_vb_is_even n0 i ub0 vb0; Math.Lemmas.div_exact_r (v vb0) 2 }
v ub0 * 2 * v alpha - v vb0 * v beta;
(==) {assert (pow2 (pbits - i + 1) == v ub0 * 2 * v alpha - v vb0 * v beta) }
pow2 (pbits - i + 1);
};
assert (2 * (ub * 2 * v alpha - vb * v beta) == pow2 (pbits - i + 1))
#push-options "--z3rlimit 150"
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
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
let ub = (v ub0 + v beta) / 2 % pow2 (bits t) in
let vb = (v vb0 / 2 + v alpha) % pow2 (bits t) in
pow2 (bits t - i + 1) == 2 * (ub * 2 * v alpha - vb * v beta)))
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.small_mod ((v ub0 + v beta) / 2) (pow2 pbits) }
2 * ((v ub0 + v beta) / 2 * 2 * v alpha - vb * v beta);
(==) { Math.Lemmas.small_mod (v vb0 / 2 + v alpha) (pow2 pbits) }
2 * ((v ub0 + v beta) / 2 * 2 * v alpha - (v vb0 / 2 + v alpha) * v beta);
(==) { Math.Lemmas.distributivity_sub_right 2 ((v ub0 + v beta) / 2 * 2 * v alpha) ((v vb0 / 2 + v alpha) * v beta) }
2 * (v ub0 + v beta) / 2 * 2 * v alpha - 2 * (v vb0 / 2 + v alpha) * v beta;
(==) { Math.Lemmas.div_exact_r (v ub0 + v beta) 2 }
(v ub0 + v beta) * 2 * v alpha - 2 * (v vb0 / 2 + v alpha) * v beta;
(==) { Math.Lemmas.paren_mul_right 2 (v vb0 / 2 + v alpha) (v beta) }
(v ub0 + v beta) * 2 * v alpha - 2 * ((v vb0 / 2 + v alpha) * v beta);
(==) { Math.Lemmas.distributivity_add_left (v vb0 / 2) (v alpha) (v beta) }
(v ub0 + v beta) * 2 * v alpha - 2 * (v vb0 / 2 * v beta + v alpha * v beta);
(==) { Math.Lemmas.distributivity_add_right 2 (v vb0 / 2 * v beta) (v alpha * v beta);
Math.Lemmas.paren_mul_right 2 (v vb0 / 2) (v beta);
Math.Lemmas.paren_mul_right 2 (v alpha) (v beta) }
(v ub0 + v beta) * 2 * v alpha - (2 * (v vb0 / 2) * v beta + 2 * v alpha * v beta);
(==) { mod_inv_limb_inv_vb_is_even n0 i ub0 vb0; Math.Lemmas.div_exact_r (v vb0) 2 }
(v ub0 + v beta) * 2 * v alpha - (v vb0 * v beta + 2 * v alpha * v beta);
(==) { Math.Lemmas.distributivity_add_left (v ub0) (v beta) (2 * v alpha) }
v ub0 * 2 * v alpha + v beta * 2 * v alpha - (v vb0 * v beta + 2 * v alpha * v beta);
(==) { Math.Lemmas.paren_mul_right (v beta) 2 (v alpha); Math.Lemmas.swap_mul (v beta) (2 * v alpha) }
v ub0 * 2 * v alpha + 2 * v alpha * v beta - v vb0 * v beta - 2 * v alpha * v beta;
(==) { }
v ub0 * 2 * v alpha - v vb0 * v beta;
(==) { assert (pow2 (pbits - i + 1) == v ub0 * 2 * v alpha - v vb0 * v beta) }
pow2 (pbits - i + 1);
};
assert (2 * (ub * 2 * v alpha - vb * v beta) == pow2 (pbits - i + 1))
#pop-options
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 #SEC 1 <<. size (bits t - 1) in let beta = n0 in
let (ub, vb) = mod_inv_limb_f alpha beta (i - 1) (ub0, vb0) in
pow2 (bits t - i) == v ub * 2 * v alpha - v vb * v beta))
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
let alpha_if_u_is_odd = alpha &. u_is_odd in
let vb = (vb0 >>. 1ul) +. alpha_if_u_is_odd in
x_if_u_is_odd beta ub0;
x_if_u_is_odd alpha ub0;
assert (v beta_if_u_is_odd == (if v ub0 % 2 = 0 then 0 else v beta));
assert (v alpha_if_u_is_odd == (if v ub0 % 2 = 0 then 0 else v alpha));
add_div_2_nooverflow ub0 beta_if_u_is_odd;
assert (v ub == (v ub0 + v beta_if_u_is_odd) / 2 % pow2 pbits);
assert (v ub == (if v ub0 % 2 = 0 then v ub0 / 2 % pow2 pbits else (v ub0 + v beta) / 2 % pow2 pbits));
Math.Lemmas.lemma_mod_plus_distr_l (v vb0 / 2) (v alpha_if_u_is_odd) (pow2 pbits);
assert (v vb == (v vb0 / 2 + v alpha_if_u_is_odd) % pow2 pbits);
assert (v vb == (if v ub0 % 2 = 0 then v vb0 / 2 % pow2 pbits else (v vb0 / 2 + v alpha) % pow2 pbits));
if v ub0 % 2 = 0 then
mod_inv_limb_inv_step_even n0 i ub0 vb0
else
mod_inv_limb_inv_step_odd n0 i ub0 vb0;
assert (2 * (v ub * 2 * v alpha - v vb * v beta) == pow2 (pbits - i + 1));
Math.Lemmas.cancel_mul_div (v ub * 2 * v alpha - v vb * v beta) 2;
Math.Lemmas.pow2_minus (pbits - i + 1) 1
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) == v ub * 2 * v alpha - v vb * v beta))
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)
else begin
let (ub0, vb0) = repeat_gen (i - 1) (mod_inv_limb_t t) (mod_inv_limb_f alpha beta) (uint #t 1, uint #t 0) in
mod_inv_limb_inv n0 (i - 1);
assert (pow2 (bits t - i + 1) == v ub0 * 2 * v alpha - v vb0 * v beta);
unfold_repeat_gen i (mod_inv_limb_t t) (mod_inv_limb_f alpha beta) (uint #t 1, uint #t 0) (i - 1);
assert ((ub, vb) == mod_inv_limb_f alpha beta (i - 1) (ub0, vb0));
mod_inv_limb_inv_step n0 i ub0 vb0;
() end
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;
(==) { }
(v ub * 2 * v alpha) % pow2 pbits;
(==) { Math.Lemmas.pow2_plus 1 (pbits - 1) }
(v ub * pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.cancel_mul_mod (v ub) (pow2 pbits) }
0;
};
assert ((1 + v vb * v n0) % pow2 pbits == 0) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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.Definitions.bn_v n * Lib.IntTypes.v mu) %
Prims.pow2 (Lib.IntTypes.bits t) ==
0)) | {
"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 #SEC 1 <<. size (bits t - 1) in let beta = n0 in
let (ub, vb) = mod_inv_limb_f alpha beta (i - 1) (ub0, vb0) in
pow2 (bits t - i) == v ub * 2 * v alpha - v vb * v beta)) | [
{
"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
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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
let alpha_if_u_is_odd = alpha &. u_is_odd in
let vb = (vb0 >>. 1ul) +. alpha_if_u_is_odd in
x_if_u_is_odd beta ub0;
x_if_u_is_odd alpha ub0;
assert (v beta_if_u_is_odd == (if v ub0 % 2 = 0 then 0 else v beta));
assert (v alpha_if_u_is_odd == (if v ub0 % 2 = 0 then 0 else v alpha));
add_div_2_nooverflow ub0 beta_if_u_is_odd;
assert (v ub == (v ub0 + v beta_if_u_is_odd) / 2 % pow2 pbits);
assert (v ub == (if v ub0 % 2 = 0 then v ub0 / 2 % pow2 pbits else (v ub0 + v beta) / 2 % pow2 pbits));
Math.Lemmas.lemma_mod_plus_distr_l (v vb0 / 2) (v alpha_if_u_is_odd) (pow2 pbits);
assert (v vb == (v vb0 / 2 + v alpha_if_u_is_odd) % pow2 pbits);
assert (v vb == (if v ub0 % 2 = 0 then v vb0 / 2 % pow2 pbits else (v vb0 / 2 + v alpha) % pow2 pbits));
if v ub0 % 2 = 0 then
mod_inv_limb_inv_step_even n0 i ub0 vb0
else
mod_inv_limb_inv_step_odd n0 i ub0 vb0;
assert (2 * (v ub * 2 * v alpha - v vb * v beta) == pow2 (pbits - i + 1));
Math.Lemmas.cancel_mul_div (v ub * 2 * v alpha - v vb * v beta) 2;
Math.Lemmas.pow2_minus (pbits - i + 1) 1 | 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 #SEC 1 <<. size (bits t - 1) in let beta = n0 in
let (ub, vb) = mod_inv_limb_f alpha beta (i - 1) (ub0, vb0) in
pow2 (bits t - i) == v ub * 2 * v alpha - v vb * v beta))
let mod_inv_limb_inv_step #t n0 i ub0 vb0 = | 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 >>. 1ul) +. alpha_if_u_is_odd in
x_if_u_is_odd beta ub0;
x_if_u_is_odd alpha ub0;
assert (v beta_if_u_is_odd == (if v ub0 % 2 = 0 then 0 else v beta));
assert (v alpha_if_u_is_odd == (if v ub0 % 2 = 0 then 0 else v alpha));
add_div_2_nooverflow ub0 beta_if_u_is_odd;
assert (v ub == (v ub0 + v beta_if_u_is_odd) / 2 % pow2 pbits);
assert (v ub ==
(if v ub0 % 2 = 0 then v ub0 / 2 % pow2 pbits else (v ub0 + v beta) / 2 % pow2 pbits));
Math.Lemmas.lemma_mod_plus_distr_l (v vb0 / 2) (v alpha_if_u_is_odd) (pow2 pbits);
assert (v vb == (v vb0 / 2 + v alpha_if_u_is_odd) % pow2 pbits);
assert (v vb ==
(if v ub0 % 2 = 0 then v vb0 / 2 % pow2 pbits else (v vb0 / 2 + v alpha) % pow2 pbits));
if v ub0 % 2 = 0
then mod_inv_limb_inv_step_even n0 i ub0 vb0
else mod_inv_limb_inv_step_odd n0 i ub0 vb0;
assert (2 * ((v ub * 2) * v alpha - v vb * v beta) == pow2 (pbits - i + 1));
Math.Lemmas.cancel_mul_div ((v ub * 2) * v alpha - v vb * v beta) 2;
Math.Lemmas.pow2_minus (pbits - i + 1) 1 | {
"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.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.Bignum.ModInvLimb.fst"
} | [
"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_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.pow2",
"Prims.op_Equality",
"Prims.op_Modulus",
"Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb_inv_step_even",
"Prims.bool",
"Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb_inv_step_odd",
"Prims.op_Division",
"FStar.Math.Lemmas.lemma_mod_plus_distr_l",
"Hacl.Spec.Bignum.ModInvLimb.add_div_2_nooverflow",
"Hacl.Spec.Bignum.ModInvLimb.x_if_u_is_odd",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Plus_Dot",
"Lib.IntTypes.op_Greater_Greater_Dot",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTypes.op_Hat_Dot",
"Lib.IntTypes.op_Subtraction_Dot",
"Lib.IntTypes.uint",
"Lib.IntTypes.op_Less_Less_Dot",
"Lib.IntTypes.size"
] | [] | 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/crypto/fipsmodule/bn/montgomery_inv.c *)
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) =
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)
let mod_inv_limb_t (t:limb_t) (i:nat{i <= bits t}) = tuple2 (limb t) (limb t)
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
// Replace with `a >> 1 + b >> 1 + a & b & 1`?
val add_div_2_nooverflow: #t:limb_t -> a:limb t -> b:limb t ->
Lemma (v (((a ^. b) >>. 1ul) +. (a &. b)) == (v a + v b) / 2 % pow2 (bits t))
let add_div_2_nooverflow #t a b = admit()
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 =
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
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 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 - v vb0 * v beta) % 2;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (v ub0 * 2 * v alpha) (- v vb0 * v beta) 2 }
(- v vb0 * v beta) % 2;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (- v vb0) (v beta) 2 }
(- v vb0) % 2;
(==) { }
v vb0 % 2;
}
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
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
let ub = v ub0 / 2 % pow2 (bits t) in
let vb = v vb0 / 2 % pow2 (bits t) in
pow2 (bits t - i + 1) == 2 * (ub * 2 * v alpha - vb * v beta)))
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);
assert (ub * 2 * v alpha - vb * v beta == v ub0 / 2 * 2 * v alpha - v vb0 / 2 * v beta);
calc (==) {
2 * (ub * 2 * v alpha - vb * v beta);
(==) { }
2 * (v ub0 / 2 * 2 * v alpha - v vb0 / 2 * v beta);
(==) { Math.Lemmas.distributivity_sub_right 2 (v ub0 / 2 * 2 * v alpha) (v vb0 / 2 * v beta) }
2 * v ub0 / 2 * 2 * v alpha - 2 * (v vb0 / 2) * v beta;
(==) { Math.Lemmas.div_exact_r (v ub0) 2 }
v ub0 * 2 * v alpha - 2 * (v vb0 / 2) * v beta;
(==) { mod_inv_limb_inv_vb_is_even n0 i ub0 vb0; Math.Lemmas.div_exact_r (v vb0) 2 }
v ub0 * 2 * v alpha - v vb0 * v beta;
(==) {assert (pow2 (pbits - i + 1) == v ub0 * 2 * v alpha - v vb0 * v beta) }
pow2 (pbits - i + 1);
};
assert (2 * (ub * 2 * v alpha - vb * v beta) == pow2 (pbits - i + 1))
#push-options "--z3rlimit 150"
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
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
let ub = (v ub0 + v beta) / 2 % pow2 (bits t) in
let vb = (v vb0 / 2 + v alpha) % pow2 (bits t) in
pow2 (bits t - i + 1) == 2 * (ub * 2 * v alpha - vb * v beta)))
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.small_mod ((v ub0 + v beta) / 2) (pow2 pbits) }
2 * ((v ub0 + v beta) / 2 * 2 * v alpha - vb * v beta);
(==) { Math.Lemmas.small_mod (v vb0 / 2 + v alpha) (pow2 pbits) }
2 * ((v ub0 + v beta) / 2 * 2 * v alpha - (v vb0 / 2 + v alpha) * v beta);
(==) { Math.Lemmas.distributivity_sub_right 2 ((v ub0 + v beta) / 2 * 2 * v alpha) ((v vb0 / 2 + v alpha) * v beta) }
2 * (v ub0 + v beta) / 2 * 2 * v alpha - 2 * (v vb0 / 2 + v alpha) * v beta;
(==) { Math.Lemmas.div_exact_r (v ub0 + v beta) 2 }
(v ub0 + v beta) * 2 * v alpha - 2 * (v vb0 / 2 + v alpha) * v beta;
(==) { Math.Lemmas.paren_mul_right 2 (v vb0 / 2 + v alpha) (v beta) }
(v ub0 + v beta) * 2 * v alpha - 2 * ((v vb0 / 2 + v alpha) * v beta);
(==) { Math.Lemmas.distributivity_add_left (v vb0 / 2) (v alpha) (v beta) }
(v ub0 + v beta) * 2 * v alpha - 2 * (v vb0 / 2 * v beta + v alpha * v beta);
(==) { Math.Lemmas.distributivity_add_right 2 (v vb0 / 2 * v beta) (v alpha * v beta);
Math.Lemmas.paren_mul_right 2 (v vb0 / 2) (v beta);
Math.Lemmas.paren_mul_right 2 (v alpha) (v beta) }
(v ub0 + v beta) * 2 * v alpha - (2 * (v vb0 / 2) * v beta + 2 * v alpha * v beta);
(==) { mod_inv_limb_inv_vb_is_even n0 i ub0 vb0; Math.Lemmas.div_exact_r (v vb0) 2 }
(v ub0 + v beta) * 2 * v alpha - (v vb0 * v beta + 2 * v alpha * v beta);
(==) { Math.Lemmas.distributivity_add_left (v ub0) (v beta) (2 * v alpha) }
v ub0 * 2 * v alpha + v beta * 2 * v alpha - (v vb0 * v beta + 2 * v alpha * v beta);
(==) { Math.Lemmas.paren_mul_right (v beta) 2 (v alpha); Math.Lemmas.swap_mul (v beta) (2 * v alpha) }
v ub0 * 2 * v alpha + 2 * v alpha * v beta - v vb0 * v beta - 2 * v alpha * v beta;
(==) { }
v ub0 * 2 * v alpha - v vb0 * v beta;
(==) { assert (pow2 (pbits - i + 1) == v ub0 * 2 * v alpha - v vb0 * v beta) }
pow2 (pbits - i + 1);
};
assert (2 * (ub * 2 * v alpha - vb * v beta) == pow2 (pbits - i + 1))
#pop-options
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 #SEC 1 <<. size (bits t - 1) in let beta = n0 in
let (ub, vb) = mod_inv_limb_f alpha beta (i - 1) (ub0, vb0) in
pow2 (bits t - i) == v ub * 2 * v alpha - v vb * v beta)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 #SEC 1 <<. size (bits t - 1) in let beta = n0 in
let (ub, vb) = mod_inv_limb_f alpha beta (i - 1) (ub0, vb0) in
pow2 (bits t - i) == v ub * 2 * v alpha - v vb * v beta)) | [] | 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) in
let beta = n0 in
Lib.IntTypes.v n0 % 2 = 1 /\
Prims.pow2 (Lib.IntTypes.bits t - i + 1) ==
(Lib.IntTypes.v ub0 * 2) * Lib.IntTypes.v alpha - Lib.IntTypes.v vb0 * Lib.IntTypes.v beta
))
(ensures
(let alpha = Lib.IntTypes.uint 1 <<. Lib.IntTypes.size (Lib.IntTypes.bits t - 1) in
let beta = n0 in
let _ = Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb_f alpha beta (i - 1) (ub0, vb0) in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ ub vb = _ in
Prims.pow2 (Lib.IntTypes.bits t - i) ==
(Lib.IntTypes.v ub * 2) * Lib.IntTypes.v alpha - Lib.IntTypes.v vb * Lib.IntTypes.v beta
)
<:
Type0)) | {
"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) == v ub * 2 * v alpha - v vb * v beta)) | [
{
"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
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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)
else begin
let (ub0, vb0) = repeat_gen (i - 1) (mod_inv_limb_t t) (mod_inv_limb_f alpha beta) (uint #t 1, uint #t 0) in
mod_inv_limb_inv n0 (i - 1);
assert (pow2 (bits t - i + 1) == v ub0 * 2 * v alpha - v vb0 * v beta);
unfold_repeat_gen i (mod_inv_limb_t t) (mod_inv_limb_f alpha beta) (uint #t 1, uint #t 0) (i - 1);
assert ((ub, vb) == mod_inv_limb_f alpha beta (i - 1) (ub0, vb0));
mod_inv_limb_inv_step n0 i ub0 vb0;
() end | 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) == v ub * 2 * v alpha - v vb * v beta))
let rec mod_inv_limb_inv #t n0 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_inv_limb_t t) (mod_inv_limb_f alpha beta) (uint #t 1, uint #t 0)
in
mod_inv_limb_inv n0 (i - 1);
assert (pow2 (bits t - i + 1) == (v ub0 * 2) * v alpha - v vb0 * v beta);
unfold_repeat_gen i (mod_inv_limb_t t) (mod_inv_limb_f alpha beta) (uint #t 1, uint #t 0) (i - 1);
assert ((ub, vb) == mod_inv_limb_f alpha beta (i - 1) (ub0, vb0));
mod_inv_limb_inv_step n0 i ub0 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.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.Bignum.ModInvLimb.fst"
} | [
"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.ModInvLimb.mod_inv_limb_f",
"FStar.Pervasives.Native.Mktuple2",
"Lib.IntTypes.uint",
"Lib.IntTypes.SEC",
"Prims.bool",
"Prims.unit",
"Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb_inv_step",
"Prims._assert",
"Prims.eq2",
"FStar.Pervasives.Native.tuple2",
"Prims.op_Subtraction",
"Lib.LoopCombinators.unfold_repeat_gen",
"Prims.pow2",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb_inv",
"Lib.LoopCombinators.repeat_gen",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Less_Less_Dot",
"Lib.IntTypes.size"
] | [] | 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/crypto/fipsmodule/bn/montgomery_inv.c *)
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) =
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)
let mod_inv_limb_t (t:limb_t) (i:nat{i <= bits t}) = tuple2 (limb t) (limb t)
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
// Replace with `a >> 1 + b >> 1 + a & b & 1`?
val add_div_2_nooverflow: #t:limb_t -> a:limb t -> b:limb t ->
Lemma (v (((a ^. b) >>. 1ul) +. (a &. b)) == (v a + v b) / 2 % pow2 (bits t))
let add_div_2_nooverflow #t a b = admit()
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 =
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
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 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 - v vb0 * v beta) % 2;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (v ub0 * 2 * v alpha) (- v vb0 * v beta) 2 }
(- v vb0 * v beta) % 2;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (- v vb0) (v beta) 2 }
(- v vb0) % 2;
(==) { }
v vb0 % 2;
}
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
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
let ub = v ub0 / 2 % pow2 (bits t) in
let vb = v vb0 / 2 % pow2 (bits t) in
pow2 (bits t - i + 1) == 2 * (ub * 2 * v alpha - vb * v beta)))
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);
assert (ub * 2 * v alpha - vb * v beta == v ub0 / 2 * 2 * v alpha - v vb0 / 2 * v beta);
calc (==) {
2 * (ub * 2 * v alpha - vb * v beta);
(==) { }
2 * (v ub0 / 2 * 2 * v alpha - v vb0 / 2 * v beta);
(==) { Math.Lemmas.distributivity_sub_right 2 (v ub0 / 2 * 2 * v alpha) (v vb0 / 2 * v beta) }
2 * v ub0 / 2 * 2 * v alpha - 2 * (v vb0 / 2) * v beta;
(==) { Math.Lemmas.div_exact_r (v ub0) 2 }
v ub0 * 2 * v alpha - 2 * (v vb0 / 2) * v beta;
(==) { mod_inv_limb_inv_vb_is_even n0 i ub0 vb0; Math.Lemmas.div_exact_r (v vb0) 2 }
v ub0 * 2 * v alpha - v vb0 * v beta;
(==) {assert (pow2 (pbits - i + 1) == v ub0 * 2 * v alpha - v vb0 * v beta) }
pow2 (pbits - i + 1);
};
assert (2 * (ub * 2 * v alpha - vb * v beta) == pow2 (pbits - i + 1))
#push-options "--z3rlimit 150"
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
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
let ub = (v ub0 + v beta) / 2 % pow2 (bits t) in
let vb = (v vb0 / 2 + v alpha) % pow2 (bits t) in
pow2 (bits t - i + 1) == 2 * (ub * 2 * v alpha - vb * v beta)))
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.small_mod ((v ub0 + v beta) / 2) (pow2 pbits) }
2 * ((v ub0 + v beta) / 2 * 2 * v alpha - vb * v beta);
(==) { Math.Lemmas.small_mod (v vb0 / 2 + v alpha) (pow2 pbits) }
2 * ((v ub0 + v beta) / 2 * 2 * v alpha - (v vb0 / 2 + v alpha) * v beta);
(==) { Math.Lemmas.distributivity_sub_right 2 ((v ub0 + v beta) / 2 * 2 * v alpha) ((v vb0 / 2 + v alpha) * v beta) }
2 * (v ub0 + v beta) / 2 * 2 * v alpha - 2 * (v vb0 / 2 + v alpha) * v beta;
(==) { Math.Lemmas.div_exact_r (v ub0 + v beta) 2 }
(v ub0 + v beta) * 2 * v alpha - 2 * (v vb0 / 2 + v alpha) * v beta;
(==) { Math.Lemmas.paren_mul_right 2 (v vb0 / 2 + v alpha) (v beta) }
(v ub0 + v beta) * 2 * v alpha - 2 * ((v vb0 / 2 + v alpha) * v beta);
(==) { Math.Lemmas.distributivity_add_left (v vb0 / 2) (v alpha) (v beta) }
(v ub0 + v beta) * 2 * v alpha - 2 * (v vb0 / 2 * v beta + v alpha * v beta);
(==) { Math.Lemmas.distributivity_add_right 2 (v vb0 / 2 * v beta) (v alpha * v beta);
Math.Lemmas.paren_mul_right 2 (v vb0 / 2) (v beta);
Math.Lemmas.paren_mul_right 2 (v alpha) (v beta) }
(v ub0 + v beta) * 2 * v alpha - (2 * (v vb0 / 2) * v beta + 2 * v alpha * v beta);
(==) { mod_inv_limb_inv_vb_is_even n0 i ub0 vb0; Math.Lemmas.div_exact_r (v vb0) 2 }
(v ub0 + v beta) * 2 * v alpha - (v vb0 * v beta + 2 * v alpha * v beta);
(==) { Math.Lemmas.distributivity_add_left (v ub0) (v beta) (2 * v alpha) }
v ub0 * 2 * v alpha + v beta * 2 * v alpha - (v vb0 * v beta + 2 * v alpha * v beta);
(==) { Math.Lemmas.paren_mul_right (v beta) 2 (v alpha); Math.Lemmas.swap_mul (v beta) (2 * v alpha) }
v ub0 * 2 * v alpha + 2 * v alpha * v beta - v vb0 * v beta - 2 * v alpha * v beta;
(==) { }
v ub0 * 2 * v alpha - v vb0 * v beta;
(==) { assert (pow2 (pbits - i + 1) == v ub0 * 2 * v alpha - v vb0 * v beta) }
pow2 (pbits - i + 1);
};
assert (2 * (ub * 2 * v alpha - vb * v beta) == pow2 (pbits - i + 1))
#pop-options
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 #SEC 1 <<. size (bits t - 1) in let beta = n0 in
let (ub, vb) = mod_inv_limb_f alpha beta (i - 1) (ub0, vb0) in
pow2 (bits t - i) == v ub * 2 * v alpha - v vb * v beta))
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
let alpha_if_u_is_odd = alpha &. u_is_odd in
let vb = (vb0 >>. 1ul) +. alpha_if_u_is_odd in
x_if_u_is_odd beta ub0;
x_if_u_is_odd alpha ub0;
assert (v beta_if_u_is_odd == (if v ub0 % 2 = 0 then 0 else v beta));
assert (v alpha_if_u_is_odd == (if v ub0 % 2 = 0 then 0 else v alpha));
add_div_2_nooverflow ub0 beta_if_u_is_odd;
assert (v ub == (v ub0 + v beta_if_u_is_odd) / 2 % pow2 pbits);
assert (v ub == (if v ub0 % 2 = 0 then v ub0 / 2 % pow2 pbits else (v ub0 + v beta) / 2 % pow2 pbits));
Math.Lemmas.lemma_mod_plus_distr_l (v vb0 / 2) (v alpha_if_u_is_odd) (pow2 pbits);
assert (v vb == (v vb0 / 2 + v alpha_if_u_is_odd) % pow2 pbits);
assert (v vb == (if v ub0 % 2 = 0 then v vb0 / 2 % pow2 pbits else (v vb0 / 2 + v alpha) % pow2 pbits));
if v ub0 % 2 = 0 then
mod_inv_limb_inv_step_even n0 i ub0 vb0
else
mod_inv_limb_inv_step_odd n0 i ub0 vb0;
assert (2 * (v ub * 2 * v alpha - v vb * v beta) == pow2 (pbits - i + 1));
Math.Lemmas.cancel_mul_div (v ub * 2 * v alpha - v vb * v beta) 2;
Math.Lemmas.pow2_minus (pbits - i + 1) 1
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) == v ub * 2 * v alpha - v vb * v beta)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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) == v ub * 2 * v alpha - v vb * v beta)) | [
"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.LoopCombinators.repeat_gen i
(Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb_t t)
(Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb_f alpha beta)
(Lib.IntTypes.uint 1, Lib.IntTypes.uint 0)
in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ ub vb = _ in
Prims.pow2 (Lib.IntTypes.bits t - i) ==
(Lib.IntTypes.v ub * 2) * Lib.IntTypes.v alpha - Lib.IntTypes.v vb * Lib.IntTypes.v beta
)
<:
Type0)) | {
"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
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
let ub = v ub0 / 2 % pow2 (bits t) in
let vb = v vb0 / 2 % pow2 (bits t) in
pow2 (bits t - i + 1) == 2 * (ub * 2 * v alpha - vb * v beta))) | [
{
"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
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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);
assert (ub * 2 * v alpha - vb * v beta == v ub0 / 2 * 2 * v alpha - v vb0 / 2 * v beta);
calc (==) {
2 * (ub * 2 * v alpha - vb * v beta);
(==) { }
2 * (v ub0 / 2 * 2 * v alpha - v vb0 / 2 * v beta);
(==) { Math.Lemmas.distributivity_sub_right 2 (v ub0 / 2 * 2 * v alpha) (v vb0 / 2 * v beta) }
2 * v ub0 / 2 * 2 * v alpha - 2 * (v vb0 / 2) * v beta;
(==) { Math.Lemmas.div_exact_r (v ub0) 2 }
v ub0 * 2 * v alpha - 2 * (v vb0 / 2) * v beta;
(==) { mod_inv_limb_inv_vb_is_even n0 i ub0 vb0; Math.Lemmas.div_exact_r (v vb0) 2 }
v ub0 * 2 * v alpha - v vb0 * v beta;
(==) {assert (pow2 (pbits - i + 1) == v ub0 * 2 * v alpha - v vb0 * v beta) }
pow2 (pbits - i + 1);
};
assert (2 * (ub * 2 * v alpha - vb * v beta) == pow2 (pbits - i + 1)) | 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
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
let ub = v ub0 / 2 % pow2 (bits t) in
let vb = v vb0 / 2 % pow2 (bits t) in
pow2 (bits t - i + 1) == 2 * (ub * 2 * v alpha - vb * v beta)))
let mod_inv_limb_inv_step_even #t n0 i ub0 vb0 = | 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) * v alpha - (v vb0 / 2) * v beta);
calc ( == ) {
2 * ((ub * 2) * v alpha - vb * v beta);
( == ) { () }
2 * (((v ub0 / 2) * 2) * v alpha - (v vb0 / 2) * v beta);
( == ) { Math.Lemmas.distributivity_sub_right 2
(((v ub0 / 2) * 2) * v alpha)
((v vb0 / 2) * v beta) }
((2 * v ub0 / 2) * 2) * v alpha - (2 * (v vb0 / 2)) * v beta;
( == ) { Math.Lemmas.div_exact_r (v ub0) 2 }
(v ub0 * 2) * v alpha - (2 * (v vb0 / 2)) * v beta;
( == ) { (mod_inv_limb_inv_vb_is_even n0 i ub0 vb0;
Math.Lemmas.div_exact_r (v vb0) 2) }
(v ub0 * 2) * v alpha - v vb0 * v beta;
( == ) { assert (pow2 (pbits - i + 1) == (v ub0 * 2) * v alpha - v vb0 * v beta) }
pow2 (pbits - i + 1);
};
assert (2 * ((ub * 2) * v alpha - vb * v beta) == pow2 (pbits - i + 1)) | {
"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.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.Bignum.ModInvLimb.fst"
} | [
"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",
"Prims.op_Addition",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"Prims.op_Division",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Prims.squash",
"FStar.Math.Lemmas.distributivity_sub_right",
"FStar.Math.Lemmas.div_exact_r",
"Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb_inv_vb_is_even",
"FStar.Math.Lemmas.small_mod",
"Prims.op_Modulus",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Less_Less_Dot",
"Lib.IntTypes.uint",
"Lib.IntTypes.size"
] | [] | 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/crypto/fipsmodule/bn/montgomery_inv.c *)
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) =
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)
let mod_inv_limb_t (t:limb_t) (i:nat{i <= bits t}) = tuple2 (limb t) (limb t)
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
// Replace with `a >> 1 + b >> 1 + a & b & 1`?
val add_div_2_nooverflow: #t:limb_t -> a:limb t -> b:limb t ->
Lemma (v (((a ^. b) >>. 1ul) +. (a &. b)) == (v a + v b) / 2 % pow2 (bits t))
let add_div_2_nooverflow #t a b = admit()
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 =
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
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 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 - v vb0 * v beta) % 2;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (v ub0 * 2 * v alpha) (- v vb0 * v beta) 2 }
(- v vb0 * v beta) % 2;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (- v vb0) (v beta) 2 }
(- v vb0) % 2;
(==) { }
v vb0 % 2;
}
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
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
let ub = v ub0 / 2 % pow2 (bits t) in
let vb = v vb0 / 2 % pow2 (bits t) in
pow2 (bits t - i + 1) == 2 * (ub * 2 * v alpha - vb * v beta))) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
let ub = v ub0 / 2 % pow2 (bits t) in
let vb = v vb0 / 2 % pow2 (bits t) in
pow2 (bits t - i + 1) == 2 * (ub * 2 * v alpha - vb * v beta))) | [] | 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) in
let beta = n0 in
Lib.IntTypes.v n0 % 2 = 1 /\ Lib.IntTypes.v ub0 % 2 = 0 /\
Prims.pow2 (Lib.IntTypes.bits t - i + 1) ==
(Lib.IntTypes.v ub0 * 2) * Lib.IntTypes.v alpha - Lib.IntTypes.v vb0 * Lib.IntTypes.v beta
))
(ensures
(let alpha = Lib.IntTypes.uint 1 <<. Lib.IntTypes.size (Lib.IntTypes.bits t - 1) in
let beta = n0 in
let ub = Lib.IntTypes.v ub0 / 2 % Prims.pow2 (Lib.IntTypes.bits t) in
let vb = Lib.IntTypes.v vb0 / 2 % Prims.pow2 (Lib.IntTypes.bits t) in
Prims.pow2 (Lib.IntTypes.bits t - i + 1) ==
2 * ((ub * 2) * Lib.IntTypes.v alpha - vb * Lib.IntTypes.v beta))) | {
"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
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 - v vb0 * v beta) % 2;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (v ub0 * 2 * v alpha) (- v vb0 * v beta) 2 }
(- v vb0 * v beta) % 2;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (- v vb0) (v beta) 2 }
(- v vb0) % 2;
(==) { }
v vb0 % 2;
} | 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 mod_inv_limb_inv_vb_is_even #t n0 i ub0 vb0 = | 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_plus_distr_l ((v ub0 * 2) * v alpha) (- v vb0 * v beta) 2 }
(- v vb0 * v beta) % 2;
( == ) { Math.Lemmas.lemma_mod_mul_distr_r (- v vb0) (v beta) 2 }
(- v vb0) % 2;
( == ) { () }
v vb0 % 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.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.Bignum.ModInvLimb.fst"
} | [
"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.IntTypes.v",
"Lib.IntTypes.SEC",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"Prims.op_Minus",
"FStar.Mul.op_Star",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Prims.squash",
"FStar.Math.Lemmas.lemma_mod_plus_distr_l",
"FStar.Math.Lemmas.lemma_mod_mul_distr_r",
"Prims._assert",
"FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Less_Less_Dot",
"Lib.IntTypes.uint",
"Lib.IntTypes.size"
] | [] | 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/crypto/fipsmodule/bn/montgomery_inv.c *)
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) =
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)
let mod_inv_limb_t (t:limb_t) (i:nat{i <= bits t}) = tuple2 (limb t) (limb t)
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
// Replace with `a >> 1 + b >> 1 + a & b & 1`?
val add_div_2_nooverflow: #t:limb_t -> a:limb t -> b:limb t ->
Lemma (v (((a ^. b) >>. 1ul) +. (a &. b)) == (v a + v b) / 2 % pow2 (bits t))
let add_div_2_nooverflow #t a b = admit()
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 =
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
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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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) in
let beta = n0 in
Lib.IntTypes.v n0 % 2 = 1 /\
Prims.pow2 (Lib.IntTypes.bits t - i + 1) ==
(Lib.IntTypes.v ub0 * 2) * Lib.IntTypes.v alpha - Lib.IntTypes.v vb0 * Lib.IntTypes.v beta
)) (ensures Lib.IntTypes.v vb0 % 2 = 0) | {
"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
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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;
(==) { }
(v ub * 2 * v alpha) % pow2 pbits;
(==) { Math.Lemmas.pow2_plus 1 (pbits - 1) }
(v ub * pow2 pbits) % pow2 pbits;
(==) { Math.Lemmas.cancel_mul_mod (v ub) (pow2 pbits) }
0;
};
assert ((1 + v vb * v n0) % pow2 pbits == 0) | 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 pbits;
( == ) { Math.Lemmas.pow2_plus 1 (pbits - 1) }
(v ub * pow2 pbits) % pow2 pbits;
( == ) { Math.Lemmas.cancel_mul_mod (v ub) (pow2 pbits) }
0;
};
assert ((1 + v vb * v n0) % pow2 pbits == 0) | {
"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.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.Bignum.ModInvLimb.fst"
} | [
"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",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Prims.squash",
"FStar.Math.Lemmas.pow2_plus",
"Prims.op_Subtraction",
"FStar.Math.Lemmas.cancel_mul_mod",
"Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb_inv",
"Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb_t",
"Lib.LoopCombinators.repeat_gen",
"Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb_f",
"FStar.Pervasives.Native.Mktuple2",
"Lib.IntTypes.uint",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Less_Less_Dot",
"Lib.IntTypes.size",
"Lib.IntTypes.bits"
] | [] | 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/crypto/fipsmodule/bn/montgomery_inv.c *)
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) =
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)
let mod_inv_limb_t (t:limb_t) (i:nat{i <= bits t}) = tuple2 (limb t) (limb t)
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
// Replace with `a >> 1 + b >> 1 + a & b & 1`?
val add_div_2_nooverflow: #t:limb_t -> a:limb t -> b:limb t ->
Lemma (v (((a ^. b) >>. 1ul) +. (a &. b)) == (v a + v b) / 2 % pow2 (bits t))
let add_div_2_nooverflow #t a b = admit()
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 =
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
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 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 - v vb0 * v beta) % 2;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (v ub0 * 2 * v alpha) (- v vb0 * v beta) 2 }
(- v vb0 * v beta) % 2;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (- v vb0) (v beta) 2 }
(- v vb0) % 2;
(==) { }
v vb0 % 2;
}
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
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
let ub = v ub0 / 2 % pow2 (bits t) in
let vb = v vb0 / 2 % pow2 (bits t) in
pow2 (bits t - i + 1) == 2 * (ub * 2 * v alpha - vb * v beta)))
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);
assert (ub * 2 * v alpha - vb * v beta == v ub0 / 2 * 2 * v alpha - v vb0 / 2 * v beta);
calc (==) {
2 * (ub * 2 * v alpha - vb * v beta);
(==) { }
2 * (v ub0 / 2 * 2 * v alpha - v vb0 / 2 * v beta);
(==) { Math.Lemmas.distributivity_sub_right 2 (v ub0 / 2 * 2 * v alpha) (v vb0 / 2 * v beta) }
2 * v ub0 / 2 * 2 * v alpha - 2 * (v vb0 / 2) * v beta;
(==) { Math.Lemmas.div_exact_r (v ub0) 2 }
v ub0 * 2 * v alpha - 2 * (v vb0 / 2) * v beta;
(==) { mod_inv_limb_inv_vb_is_even n0 i ub0 vb0; Math.Lemmas.div_exact_r (v vb0) 2 }
v ub0 * 2 * v alpha - v vb0 * v beta;
(==) {assert (pow2 (pbits - i + 1) == v ub0 * 2 * v alpha - v vb0 * v beta) }
pow2 (pbits - i + 1);
};
assert (2 * (ub * 2 * v alpha - vb * v beta) == pow2 (pbits - i + 1))
#push-options "--z3rlimit 150"
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
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
let ub = (v ub0 + v beta) / 2 % pow2 (bits t) in
let vb = (v vb0 / 2 + v alpha) % pow2 (bits t) in
pow2 (bits t - i + 1) == 2 * (ub * 2 * v alpha - vb * v beta)))
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.small_mod ((v ub0 + v beta) / 2) (pow2 pbits) }
2 * ((v ub0 + v beta) / 2 * 2 * v alpha - vb * v beta);
(==) { Math.Lemmas.small_mod (v vb0 / 2 + v alpha) (pow2 pbits) }
2 * ((v ub0 + v beta) / 2 * 2 * v alpha - (v vb0 / 2 + v alpha) * v beta);
(==) { Math.Lemmas.distributivity_sub_right 2 ((v ub0 + v beta) / 2 * 2 * v alpha) ((v vb0 / 2 + v alpha) * v beta) }
2 * (v ub0 + v beta) / 2 * 2 * v alpha - 2 * (v vb0 / 2 + v alpha) * v beta;
(==) { Math.Lemmas.div_exact_r (v ub0 + v beta) 2 }
(v ub0 + v beta) * 2 * v alpha - 2 * (v vb0 / 2 + v alpha) * v beta;
(==) { Math.Lemmas.paren_mul_right 2 (v vb0 / 2 + v alpha) (v beta) }
(v ub0 + v beta) * 2 * v alpha - 2 * ((v vb0 / 2 + v alpha) * v beta);
(==) { Math.Lemmas.distributivity_add_left (v vb0 / 2) (v alpha) (v beta) }
(v ub0 + v beta) * 2 * v alpha - 2 * (v vb0 / 2 * v beta + v alpha * v beta);
(==) { Math.Lemmas.distributivity_add_right 2 (v vb0 / 2 * v beta) (v alpha * v beta);
Math.Lemmas.paren_mul_right 2 (v vb0 / 2) (v beta);
Math.Lemmas.paren_mul_right 2 (v alpha) (v beta) }
(v ub0 + v beta) * 2 * v alpha - (2 * (v vb0 / 2) * v beta + 2 * v alpha * v beta);
(==) { mod_inv_limb_inv_vb_is_even n0 i ub0 vb0; Math.Lemmas.div_exact_r (v vb0) 2 }
(v ub0 + v beta) * 2 * v alpha - (v vb0 * v beta + 2 * v alpha * v beta);
(==) { Math.Lemmas.distributivity_add_left (v ub0) (v beta) (2 * v alpha) }
v ub0 * 2 * v alpha + v beta * 2 * v alpha - (v vb0 * v beta + 2 * v alpha * v beta);
(==) { Math.Lemmas.paren_mul_right (v beta) 2 (v alpha); Math.Lemmas.swap_mul (v beta) (2 * v alpha) }
v ub0 * 2 * v alpha + 2 * v alpha * v beta - v vb0 * v beta - 2 * v alpha * v beta;
(==) { }
v ub0 * 2 * v alpha - v vb0 * v beta;
(==) { assert (pow2 (pbits - i + 1) == v ub0 * 2 * v alpha - v vb0 * v beta) }
pow2 (pbits - i + 1);
};
assert (2 * (ub * 2 * v alpha - vb * v beta) == pow2 (pbits - i + 1))
#pop-options
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 #SEC 1 <<. size (bits t - 1) in let beta = n0 in
let (ub, vb) = mod_inv_limb_f alpha beta (i - 1) (ub0, vb0) in
pow2 (bits t - i) == v ub * 2 * v alpha - v vb * v beta))
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
let alpha_if_u_is_odd = alpha &. u_is_odd in
let vb = (vb0 >>. 1ul) +. alpha_if_u_is_odd in
x_if_u_is_odd beta ub0;
x_if_u_is_odd alpha ub0;
assert (v beta_if_u_is_odd == (if v ub0 % 2 = 0 then 0 else v beta));
assert (v alpha_if_u_is_odd == (if v ub0 % 2 = 0 then 0 else v alpha));
add_div_2_nooverflow ub0 beta_if_u_is_odd;
assert (v ub == (v ub0 + v beta_if_u_is_odd) / 2 % pow2 pbits);
assert (v ub == (if v ub0 % 2 = 0 then v ub0 / 2 % pow2 pbits else (v ub0 + v beta) / 2 % pow2 pbits));
Math.Lemmas.lemma_mod_plus_distr_l (v vb0 / 2) (v alpha_if_u_is_odd) (pow2 pbits);
assert (v vb == (v vb0 / 2 + v alpha_if_u_is_odd) % pow2 pbits);
assert (v vb == (if v ub0 % 2 = 0 then v vb0 / 2 % pow2 pbits else (v vb0 / 2 + v alpha) % pow2 pbits));
if v ub0 % 2 = 0 then
mod_inv_limb_inv_step_even n0 i ub0 vb0
else
mod_inv_limb_inv_step_odd n0 i ub0 vb0;
assert (2 * (v ub * 2 * v alpha - v vb * v beta) == pow2 (pbits - i + 1));
Math.Lemmas.cancel_mul_div (v ub * 2 * v alpha - v vb * v beta) 2;
Math.Lemmas.pow2_minus (pbits - i + 1) 1
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) == v ub * 2 * v alpha - v vb * v beta))
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)
else begin
let (ub0, vb0) = repeat_gen (i - 1) (mod_inv_limb_t t) (mod_inv_limb_f alpha beta) (uint #t 1, uint #t 0) in
mod_inv_limb_inv n0 (i - 1);
assert (pow2 (bits t - i + 1) == v ub0 * 2 * v alpha - v vb0 * v beta);
unfold_repeat_gen i (mod_inv_limb_t t) (mod_inv_limb_f alpha beta) (uint #t 1, uint #t 0) (i - 1);
assert ((ub, vb) == mod_inv_limb_f alpha beta (i - 1) (ub0, vb0));
mod_inv_limb_inv_step n0 i ub0 vb0;
() end | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
let ub = (v ub0 + v beta) / 2 % pow2 (bits t) in
let vb = (v vb0 / 2 + v alpha) % pow2 (bits t) in
pow2 (bits t - i + 1) == 2 * (ub * 2 * v alpha - vb * v beta))) | [
{
"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
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.small_mod ((v ub0 + v beta) / 2) (pow2 pbits) }
2 * ((v ub0 + v beta) / 2 * 2 * v alpha - vb * v beta);
(==) { Math.Lemmas.small_mod (v vb0 / 2 + v alpha) (pow2 pbits) }
2 * ((v ub0 + v beta) / 2 * 2 * v alpha - (v vb0 / 2 + v alpha) * v beta);
(==) { Math.Lemmas.distributivity_sub_right 2 ((v ub0 + v beta) / 2 * 2 * v alpha) ((v vb0 / 2 + v alpha) * v beta) }
2 * (v ub0 + v beta) / 2 * 2 * v alpha - 2 * (v vb0 / 2 + v alpha) * v beta;
(==) { Math.Lemmas.div_exact_r (v ub0 + v beta) 2 }
(v ub0 + v beta) * 2 * v alpha - 2 * (v vb0 / 2 + v alpha) * v beta;
(==) { Math.Lemmas.paren_mul_right 2 (v vb0 / 2 + v alpha) (v beta) }
(v ub0 + v beta) * 2 * v alpha - 2 * ((v vb0 / 2 + v alpha) * v beta);
(==) { Math.Lemmas.distributivity_add_left (v vb0 / 2) (v alpha) (v beta) }
(v ub0 + v beta) * 2 * v alpha - 2 * (v vb0 / 2 * v beta + v alpha * v beta);
(==) { Math.Lemmas.distributivity_add_right 2 (v vb0 / 2 * v beta) (v alpha * v beta);
Math.Lemmas.paren_mul_right 2 (v vb0 / 2) (v beta);
Math.Lemmas.paren_mul_right 2 (v alpha) (v beta) }
(v ub0 + v beta) * 2 * v alpha - (2 * (v vb0 / 2) * v beta + 2 * v alpha * v beta);
(==) { mod_inv_limb_inv_vb_is_even n0 i ub0 vb0; Math.Lemmas.div_exact_r (v vb0) 2 }
(v ub0 + v beta) * 2 * v alpha - (v vb0 * v beta + 2 * v alpha * v beta);
(==) { Math.Lemmas.distributivity_add_left (v ub0) (v beta) (2 * v alpha) }
v ub0 * 2 * v alpha + v beta * 2 * v alpha - (v vb0 * v beta + 2 * v alpha * v beta);
(==) { Math.Lemmas.paren_mul_right (v beta) 2 (v alpha); Math.Lemmas.swap_mul (v beta) (2 * v alpha) }
v ub0 * 2 * v alpha + 2 * v alpha * v beta - v vb0 * v beta - 2 * v alpha * v beta;
(==) { }
v ub0 * 2 * v alpha - v vb0 * v beta;
(==) { assert (pow2 (pbits - i + 1) == v ub0 * 2 * v alpha - v vb0 * v beta) }
pow2 (pbits - i + 1);
};
assert (2 * (ub * 2 * v alpha - vb * v beta) == pow2 (pbits - i + 1)) | 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
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
let ub = (v ub0 + v beta) / 2 % pow2 (bits t) in
let vb = (v vb0 / 2 + v alpha) % pow2 (bits t) in
pow2 (bits t - i + 1) == 2 * (ub * 2 * v alpha - vb * v beta)))
let mod_inv_limb_inv_step_odd #t n0 i ub0 vb0 = | 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 * ((((v ub0 + v beta) / 2) * 2) * v alpha - vb * v beta);
( == ) { Math.Lemmas.small_mod (v vb0 / 2 + v alpha) (pow2 pbits) }
2 * ((((v ub0 + v beta) / 2) * 2) * v alpha - (v vb0 / 2 + v alpha) * v beta);
( == ) { Math.Lemmas.distributivity_sub_right 2
((((v ub0 + v beta) / 2) * 2) * v alpha)
((v vb0 / 2 + v alpha) * v beta) }
((2 * (v ub0 + v beta) / 2) * 2) * v alpha - (2 * (v vb0 / 2 + v alpha)) * v beta;
( == ) { Math.Lemmas.div_exact_r (v ub0 + v beta) 2 }
((v ub0 + v beta) * 2) * v alpha - (2 * (v vb0 / 2 + v alpha)) * v beta;
( == ) { Math.Lemmas.paren_mul_right 2 (v vb0 / 2 + v alpha) (v beta) }
((v ub0 + v beta) * 2) * v alpha - 2 * ((v vb0 / 2 + v alpha) * v beta);
( == ) { Math.Lemmas.distributivity_add_left (v vb0 / 2) (v alpha) (v beta) }
((v ub0 + v beta) * 2) * v alpha - 2 * ((v vb0 / 2) * v beta + v alpha * v beta);
( == ) { (Math.Lemmas.distributivity_add_right 2 ((v vb0 / 2) * v beta) (v alpha * v beta);
Math.Lemmas.paren_mul_right 2 (v vb0 / 2) (v beta);
Math.Lemmas.paren_mul_right 2 (v alpha) (v beta)) }
((v ub0 + v beta) * 2) * v alpha - ((2 * (v vb0 / 2)) * v beta + (2 * v alpha) * v beta);
( == ) { (mod_inv_limb_inv_vb_is_even n0 i ub0 vb0;
Math.Lemmas.div_exact_r (v vb0) 2) }
((v ub0 + v beta) * 2) * v alpha - (v vb0 * v beta + (2 * v alpha) * v beta);
( == ) { Math.Lemmas.distributivity_add_left (v ub0) (v beta) (2 * v alpha) }
(v ub0 * 2) * v alpha + (v beta * 2) * v alpha - (v vb0 * v beta + (2 * v alpha) * v beta);
( == ) { (Math.Lemmas.paren_mul_right (v beta) 2 (v alpha);
Math.Lemmas.swap_mul (v beta) (2 * v alpha)) }
(v ub0 * 2) * v alpha + (2 * v alpha) * v beta - v vb0 * v beta - (2 * v alpha) * v beta;
( == ) { () }
(v ub0 * 2) * v alpha - v vb0 * v beta;
( == ) { assert (pow2 (pbits - i + 1) == (v ub0 * 2) * v alpha - v vb0 * v beta) }
pow2 (pbits - i + 1);
};
assert (2 * ((ub * 2) * v alpha - vb * v beta) == pow2 (pbits - i + 1)) | {
"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.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.Bignum.ModInvLimb.fst"
} | [
"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",
"Prims.op_Addition",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"Prims.op_Division",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.small_mod",
"Prims.squash",
"FStar.Math.Lemmas.distributivity_sub_right",
"FStar.Math.Lemmas.div_exact_r",
"FStar.Math.Lemmas.paren_mul_right",
"FStar.Math.Lemmas.distributivity_add_left",
"FStar.Math.Lemmas.distributivity_add_right",
"Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb_inv_vb_is_even",
"FStar.Math.Lemmas.swap_mul",
"Prims.op_Modulus",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Less_Less_Dot",
"Lib.IntTypes.uint",
"Lib.IntTypes.size"
] | [] | 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/crypto/fipsmodule/bn/montgomery_inv.c *)
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) =
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)
let mod_inv_limb_t (t:limb_t) (i:nat{i <= bits t}) = tuple2 (limb t) (limb t)
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
// Replace with `a >> 1 + b >> 1 + a & b & 1`?
val add_div_2_nooverflow: #t:limb_t -> a:limb t -> b:limb t ->
Lemma (v (((a ^. b) >>. 1ul) +. (a &. b)) == (v a + v b) / 2 % pow2 (bits t))
let add_div_2_nooverflow #t a b = admit()
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 =
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
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 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 - v vb0 * v beta) % 2;
(==) { Math.Lemmas.lemma_mod_plus_distr_l (v ub0 * 2 * v alpha) (- v vb0 * v beta) 2 }
(- v vb0 * v beta) % 2;
(==) { Math.Lemmas.lemma_mod_mul_distr_r (- v vb0) (v beta) 2 }
(- v vb0) % 2;
(==) { }
v vb0 % 2;
}
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
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
let ub = v ub0 / 2 % pow2 (bits t) in
let vb = v vb0 / 2 % pow2 (bits t) in
pow2 (bits t - i + 1) == 2 * (ub * 2 * v alpha - vb * v beta)))
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);
assert (ub * 2 * v alpha - vb * v beta == v ub0 / 2 * 2 * v alpha - v vb0 / 2 * v beta);
calc (==) {
2 * (ub * 2 * v alpha - vb * v beta);
(==) { }
2 * (v ub0 / 2 * 2 * v alpha - v vb0 / 2 * v beta);
(==) { Math.Lemmas.distributivity_sub_right 2 (v ub0 / 2 * 2 * v alpha) (v vb0 / 2 * v beta) }
2 * v ub0 / 2 * 2 * v alpha - 2 * (v vb0 / 2) * v beta;
(==) { Math.Lemmas.div_exact_r (v ub0) 2 }
v ub0 * 2 * v alpha - 2 * (v vb0 / 2) * v beta;
(==) { mod_inv_limb_inv_vb_is_even n0 i ub0 vb0; Math.Lemmas.div_exact_r (v vb0) 2 }
v ub0 * 2 * v alpha - v vb0 * v beta;
(==) {assert (pow2 (pbits - i + 1) == v ub0 * 2 * v alpha - v vb0 * v beta) }
pow2 (pbits - i + 1);
};
assert (2 * (ub * 2 * v alpha - vb * v beta) == pow2 (pbits - i + 1))
#push-options "--z3rlimit 150"
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
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
let ub = (v ub0 + v beta) / 2 % pow2 (bits t) in
let vb = (v vb0 / 2 + v alpha) % pow2 (bits t) in
pow2 (bits t - i + 1) == 2 * (ub * 2 * v alpha - vb * v beta))) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 150,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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
(let alpha = uint #t #SEC 1 <<. size (bits t - 1) in let beta = n0 in
let ub = (v ub0 + v beta) / 2 % pow2 (bits t) in
let vb = (v vb0 / 2 + v alpha) % pow2 (bits t) in
pow2 (bits t - i + 1) == 2 * (ub * 2 * v alpha - vb * v beta))) | [] | 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) in
let beta = n0 in
Lib.IntTypes.v n0 % 2 = 1 /\ Lib.IntTypes.v ub0 % 2 = 1 /\
Prims.pow2 (Lib.IntTypes.bits t - i + 1) ==
(Lib.IntTypes.v ub0 * 2) * Lib.IntTypes.v alpha - Lib.IntTypes.v vb0 * Lib.IntTypes.v beta
))
(ensures
(let alpha = Lib.IntTypes.uint 1 <<. Lib.IntTypes.size (Lib.IntTypes.bits t - 1) in
let beta = n0 in
let ub =
(Lib.IntTypes.v ub0 + Lib.IntTypes.v beta) / 2 % Prims.pow2 (Lib.IntTypes.bits t)
in
let vb =
(Lib.IntTypes.v vb0 / 2 + Lib.IntTypes.v alpha) % Prims.pow2 (Lib.IntTypes.bits t)
in
Prims.pow2 (Lib.IntTypes.bits t - i + 1) ==
2 * ((ub * 2) * Lib.IntTypes.v alpha - vb * Lib.IntTypes.v beta))) | {
"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_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Chacha20.Core32.fst"
} | [
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Chacha20.Core32.fst"
} | [
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Chacha20.Core32.fst"
} | [] | [
"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",
"Lib.Buffer.MUT"
] | [] | 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_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 () = create (size 16) (u32 0)
inline_for_extraction
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 =
uints_from_bytes_le st b
inline_for_extraction
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 =
uints_to_bytes_le 16ul st b
inline_for_extraction
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 =
st.(size 12) <- size_to_uint32 c
inline_for_extraction
val incr_counter:
st:state ->
Stack unit
(requires fun h -> live h st)
(ensures fun h0 _ h1 -> modifies (loc st) h0 h1) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Chacha20.Core32.fst"
} | [] | [
"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_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 () = create (size 16) (u32 0)
inline_for_extraction
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 =
uints_from_bytes_le st b
inline_for_extraction
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 =
uints_to_bytes_le 16ul st b
inline_for_extraction
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 =
st.(size 12) <- size_to_uint32 c
inline_for_extraction
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 =
let c = st.(size 12) in
st.(size 12) <- c +. u32 1
inline_for_extraction
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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Chacha20.Core32.fst"
} | [] | [
"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_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 () = create (size 16) (u32 0)
inline_for_extraction
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 =
uints_from_bytes_le st b
inline_for_extraction
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 =
uints_to_bytes_le 16ul st b
inline_for_extraction
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 =
st.(size 12) <- size_to_uint32 c
inline_for_extraction
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 =
let c = st.(size 12) in
st.(size 12) <- c +. u32 1
inline_for_extraction
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 = copy #MUT #uint32 #(size 16) st ost
inline_for_extraction
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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Chacha20.Core32.fst"
} | [] | [
"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_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))) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Chacha20.Core32.fst"
} | [] | [
"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.IntTypes.op_Hat_Dot",
"Lib.IntTypes.op_Plus_Dot",
"Lib.Buffer.op_Array_Access",
"Lib.Buffer.MUT"
] | [] | 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_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 () = create (size 16) (u32 0)
inline_for_extraction
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 =
uints_from_bytes_le st b
inline_for_extraction
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 =
uints_to_bytes_le 16ul st b
inline_for_extraction
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 =
st.(size 12) <- size_to_uint32 c
inline_for_extraction
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 =
let c = st.(size 12) in
st.(size 12) <- c +. u32 1
inline_for_extraction
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 = copy #MUT #uint32 #(size 16) st ost
inline_for_extraction
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 = map2T #MUT #MUT #uint32 #uint32 #uint32 (size 16) st ( +. ) st ost
#set-options "--z3rlimit 100"
inline_for_extraction
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 =
push_frame();
let bl = create_state() in
load_state bl b;
map2T (size 16) bl ( ^. ) bl st;
store_state o bl;
pop_frame()
inline_for_extraction
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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Chacha20.Core32.fst"
} | [] | [
"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_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 () = create (size 16) (u32 0)
inline_for_extraction
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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Chacha20.Core32.fst"
} | [] | [
"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_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 () = create (size 16) (u32 0)
inline_for_extraction
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 =
uints_from_bytes_le st b
inline_for_extraction
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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Chacha20.Core32.fst"
} | [] | [
"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_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 () = create (size 16) (u32 0)
inline_for_extraction
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 =
uints_from_bytes_le st b
inline_for_extraction
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 =
uints_to_bytes_le 16ul st b
inline_for_extraction
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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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 d = | 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.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Chacha20.Core32.fst"
} | [] | [
"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_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 () = create (size 16) (u32 0)
inline_for_extraction
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 =
uints_from_bytes_le st b
inline_for_extraction
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 =
uints_to_bytes_le 16ul st b
inline_for_extraction
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 =
st.(size 12) <- size_to_uint32 c
inline_for_extraction
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 =
let c = st.(size 12) in
st.(size 12) <- c +. u32 1
inline_for_extraction
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 = copy #MUT #uint32 #(size 16) st ost
inline_for_extraction
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 = map2T #MUT #MUT #uint32 #uint32 #uint32 (size 16) st ( +. ) st ost
#set-options "--z3rlimit 100"
inline_for_extraction
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 =
push_frame();
let bl = create_state() in
load_state bl b;
map2T (size 16) bl ( ^. ) bl st;
store_state o bl;
pop_frame()
inline_for_extraction
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 =
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 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))
[@ CInline ] | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Chacha20.Core32.fst"
} | [] | [
"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_Hat_Dot",
"Lib.IntTypes.U32",
"Lib.IntTypes.SEC",
"Hacl.Impl.Chacha20.Core32.load_state",
"Hacl.Impl.Chacha20.Core32.create_state",
"FStar.HyperStack.ST.push_frame"
] | [] | 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_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 () = create (size 16) (u32 0)
inline_for_extraction
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 =
uints_from_bytes_le st b
inline_for_extraction
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 =
uints_to_bytes_le 16ul st b
inline_for_extraction
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 =
st.(size 12) <- size_to_uint32 c
inline_for_extraction
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 =
let c = st.(size 12) in
st.(size 12) <- c +. u32 1
inline_for_extraction
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 = copy #MUT #uint32 #(size 16) st ost
inline_for_extraction
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 = map2T #MUT #MUT #uint32 #uint32 #uint32 (size 16) st ( +. ) st ost
#set-options "--z3rlimit 100"
inline_for_extraction
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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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_round st (size 1) (size 6) (size 11) (size 12);
quarter_round st (size 2) (size 7) (size 8) (size 13);
quarter_round st (size 3) (size 4) (size 9) (size 14) | 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 11) (size 12);
quarter_round st (size 2) (size 7) (size 8) (size 13);
quarter_round st (size 3) (size 4) (size 9) (size 14) | {
"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.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Chacha20.Core32.fst"
} | [] | [
"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_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 () = create (size 16) (u32 0)
inline_for_extraction
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 =
uints_from_bytes_le st b
inline_for_extraction
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 =
uints_to_bytes_le 16ul st b
inline_for_extraction
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 =
st.(size 12) <- size_to_uint32 c
inline_for_extraction
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 =
let c = st.(size 12) in
st.(size 12) <- c +. u32 1
inline_for_extraction
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 = copy #MUT #uint32 #(size 16) st ost
inline_for_extraction
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 = map2T #MUT #MUT #uint32 #uint32 #uint32 (size 16) st ( +. ) st ost
#set-options "--z3rlimit 100"
inline_for_extraction
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 =
push_frame();
let bl = create_state() in
load_state bl b;
map2T (size 16) bl ( ^. ) bl st;
store_state o bl;
pop_frame()
inline_for_extraction
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 =
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 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))
[@ CInline ]
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)
#reset-options "--z3rlimit 50"
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))
[@ CInline] | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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_buffer) (va_wpProof_AES256EncryptBlock
input key round_keys keys_buffer)) | 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))
(keys_buffer: buffer128)
: (va_quickCode unit (va_code_AES256EncryptBlock ())) = | 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.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.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",
"Vale.AES.AES256_helpers_BE.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.PPC64LE.AES256.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",
"Vale.PPC64LE.QuickCode.va_Mod_reg",
"Prims.Nil",
"Vale.AES.PPC64LE.AES256.va_wp_AES256EncryptBlock",
"Vale.AES.PPC64LE.AES256.va_wpProof_AES256EncryptBlock",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | 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.QuickCode
open Vale.PPC64LE.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES256_helpers_BE
#reset-options "--z3rlimit 20"
//-- KeyExpansion256Stdcall
val va_code_KeyExpansion256Stdcall : va_dummy:unit -> Tot va_code
val va_codegen_success_KeyExpansion256Stdcall : va_dummy:unit -> Tot va_pbool
val va_lemma_KeyExpansion256Stdcall : va_b0:va_code -> va_s0:va_state -> input_key_b:buffer128 ->
output_key_expansion_b:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansion256Stdcall ()) va_s0 /\ 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.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 1
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_s0) (va_get_reg 4 va_s0) input_key_b 2 (va_get_mem_layout va_s0) Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg 3 va_s0)
output_key_expansion_b 15 (va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(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.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 1
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_sM) (va_get_reg 4 va_sM) input_key_b 2 (va_get_mem_layout va_sM) Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg 3 va_sM)
output_key_expansion_b 15 (va_get_mem_layout va_sM) Secret) /\ (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.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 1 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) /\ (forall (j:nat) . {:pattern(reverse_bytes_quad32
(buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1 va_sM)))}j <= 14 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read output_key_expansion_b
j (va_get_mem_heaplet 1 va_sM)) == FStar.Seq.Base.index #Vale.Def.Types_s.quad32
(Vale.AES.AES_BE_s.key_to_round_keys_word AES_256 key) j)) /\ va_state_eq va_sM (va_update_vec
5 va_sM (va_update_vec 4 va_sM (va_update_vec 3 va_sM (va_update_vec 2 va_sM (va_update_vec 1
va_sM (va_update_vec 0 va_sM (va_update_reg 10 va_sM (va_update_mem_heaplet 1 va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
[@ va_qattr]
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
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0)))
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 1
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_s0) (va_get_reg 4 va_s0) input_key_b 2 (va_get_mem_layout va_s0) Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg 3 va_s0)
output_key_expansion_b 15 (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_heap1:vale_heap) (va_x_r10:nat64) (va_x_v0:quad32) (va_x_v1:quad32) (va_x_v2:quad32)
(va_x_v3:quad32) (va_x_v4:quad32) (va_x_v5:quad32) . let va_sM = va_upd_vec 5 va_x_v5
(va_upd_vec 4 va_x_v4 (va_upd_vec 3 va_x_v3 (va_upd_vec 2 va_x_v2 (va_upd_vec 1 va_x_v1
(va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 (va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem
va_x_mem va_s0)))))))) in va_get_ok va_sM /\ (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.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 1 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM) (va_get_reg 4 va_sM)
input_key_b 2 (va_get_mem_layout va_sM) Secret /\ Vale.PPC64LE.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_sM) (va_get_reg 3 va_sM) output_key_expansion_b 15 (va_get_mem_layout
va_sM) Secret) /\ (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.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 1
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.modifies_buffer128 output_key_expansion_b
(va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet 1 va_sM) /\ (forall (j:nat) .
{:pattern(reverse_bytes_quad32 (buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1
va_sM)))}j <= 14 ==> Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read
output_key_expansion_b j (va_get_mem_heaplet 1 va_sM)) == FStar.Seq.Base.index
#Vale.Def.Types_s.quad32 (Vale.AES.AES_BE_s.key_to_round_keys_word AES_256 key) j)) ==> va_k
va_sM (())))
val va_wpProof_KeyExpansion256Stdcall : input_key_b:buffer128 -> output_key_expansion_b:buffer128
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansion256Stdcall input_key_b output_key_expansion_b
va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (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_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
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_heaplet 1; va_Mod_mem])
(va_wp_KeyExpansion256Stdcall input_key_b output_key_expansion_b)
(va_wpProof_KeyExpansion256Stdcall input_key_b output_key_expansion_b))
//--
//-- AES256EncryptBlock
val va_code_AES256EncryptBlock : va_dummy:unit -> Tot va_code
val va_codegen_success_AES256EncryptBlock : va_dummy:unit -> Tot va_pbool
val va_lemma_AES256EncryptBlock : va_b0:va_code -> va_s0:va_state -> input:quad32 -> key:(seq
nat32) -> round_keys:(seq quad32) -> keys_buffer:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_AES256EncryptBlock ()) va_s0 /\ 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_buffer (va_get_mem_heaplet 0 va_s0) /\ Vale.PPC64LE.Decls.validSrcAddrs128
(va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0) keys_buffer 15 (va_get_mem_layout va_s0)
Secret /\ (forall (i:nat) . i < 15 ==> Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read keys_buffer i (va_get_mem_heaplet 0 va_s0)) ==
FStar.Seq.Base.index #quad32 round_keys i)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_get_vec 0 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key input /\ va_state_eq va_sM
(va_update_vec 2 va_sM (va_update_vec 0 va_sM (va_update_reg 10 va_sM (va_update_ok va_sM
va_s0))))))
[@ va_qattr]
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.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_buffer (va_get_mem_heaplet 0 va_s0) /\
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0)
keys_buffer 15 (va_get_mem_layout va_s0) Secret /\ (forall (i:nat) . i < 15 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read keys_buffer i
(va_get_mem_heaplet 0 va_s0)) == FStar.Seq.Base.index #quad32 round_keys i) /\ (forall
(va_x_r10:nat64) (va_x_v0:quad32) (va_x_v2:quad32) . let va_sM = va_upd_vec 2 va_x_v2
(va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 va_s0)) in va_get_ok va_sM /\ va_get_vec 0 va_sM
== Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key input ==> va_k va_sM (())))
val va_wpProof_AES256EncryptBlock : input:quad32 -> key:(seq nat32) -> round_keys:(seq quad32) ->
keys_buffer:buffer128 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_AES256EncryptBlock input key round_keys keys_buffer va_s0
va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_AES256EncryptBlock ()) ([va_Mod_vec 2;
va_Mod_vec 0; va_Mod_reg 10]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_AES256EncryptBlock (input:quad32) (key:(seq nat32)) (round_keys:(seq quad32)) | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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.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_buffer (va_get_mem_heaplet 0 va_s0) /\
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0)
keys_buffer 15 (va_get_mem_layout va_s0) Secret /\ (forall (i:nat) . i < 15 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read keys_buffer i
(va_get_mem_heaplet 0 va_s0)) == FStar.Seq.Base.index #quad32 round_keys i) /\ (forall
(va_x_r10:nat64) (va_x_v0:quad32) (va_x_v2:quad32) . let va_sM = va_upd_vec 2 va_x_v2
(va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 va_s0)) in va_get_ok va_sM /\ va_get_vec 0 va_sM
== Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key input ==> va_k va_sM (()))) | 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 quad32))
(keys_buffer: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | 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_buffer
(va_get_mem_heaplet 0 va_s0) /\
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
(va_get_reg 4 va_s0)
keys_buffer
15
(va_get_mem_layout va_s0)
Secret /\
(forall (i: nat).
i < 15 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read keys_buffer
i
(va_get_mem_heaplet 0 va_s0)) ==
FStar.Seq.Base.index #quad32 round_keys i) /\
(forall (va_x_r10: nat64) (va_x_v0: quad32) (va_x_v2: quad32).
let va_sM = va_upd_vec 2 va_x_v2 (va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 va_s0)) in
va_get_ok va_sM /\ va_get_vec 0 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key input ==>
va_k va_sM (()))) | {
"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.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.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",
"Vale.AES.AES256_helpers_BE.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.PPC64LE.AES256.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",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"Vale.AES.AES_BE_s.key_to_round_keys_word",
"Vale.Def.Types_s.quad32",
"Vale.PPC64LE.Decls.va_get_vec",
"Vale.PPC64LE.Decls.va_get_reg",
"Vale.PPC64LE.Memory.buffer_addr",
"Vale.PPC64LE.Memory.vuint128",
"Vale.PPC64LE.Decls.va_get_mem_heaplet",
"Vale.PPC64LE.Decls.validSrcAddrs128",
"Vale.PPC64LE.Decls.va_get_mem_layout",
"Vale.Arch.HeapTypes_s.Secret",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.op_LessThan",
"Vale.Def.Types_s.reverse_bytes_quad32",
"Vale.PPC64LE.Decls.buffer128_read",
"FStar.Seq.Base.index",
"Vale.PPC64LE.Memory.nat64",
"Vale.AES.AES_BE_s.aes_encrypt_word",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_vec",
"Vale.PPC64LE.Decls.va_upd_reg"
] | [] | 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.QuickCode
open Vale.PPC64LE.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES256_helpers_BE
#reset-options "--z3rlimit 20"
//-- KeyExpansion256Stdcall
val va_code_KeyExpansion256Stdcall : va_dummy:unit -> Tot va_code
val va_codegen_success_KeyExpansion256Stdcall : va_dummy:unit -> Tot va_pbool
val va_lemma_KeyExpansion256Stdcall : va_b0:va_code -> va_s0:va_state -> input_key_b:buffer128 ->
output_key_expansion_b:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansion256Stdcall ()) va_s0 /\ 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.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 1
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_s0) (va_get_reg 4 va_s0) input_key_b 2 (va_get_mem_layout va_s0) Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg 3 va_s0)
output_key_expansion_b 15 (va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(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.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 1
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_sM) (va_get_reg 4 va_sM) input_key_b 2 (va_get_mem_layout va_sM) Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg 3 va_sM)
output_key_expansion_b 15 (va_get_mem_layout va_sM) Secret) /\ (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.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 1 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) /\ (forall (j:nat) . {:pattern(reverse_bytes_quad32
(buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1 va_sM)))}j <= 14 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read output_key_expansion_b
j (va_get_mem_heaplet 1 va_sM)) == FStar.Seq.Base.index #Vale.Def.Types_s.quad32
(Vale.AES.AES_BE_s.key_to_round_keys_word AES_256 key) j)) /\ va_state_eq va_sM (va_update_vec
5 va_sM (va_update_vec 4 va_sM (va_update_vec 3 va_sM (va_update_vec 2 va_sM (va_update_vec 1
va_sM (va_update_vec 0 va_sM (va_update_reg 10 va_sM (va_update_mem_heaplet 1 va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
[@ va_qattr]
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
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0)))
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 1
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_s0) (va_get_reg 4 va_s0) input_key_b 2 (va_get_mem_layout va_s0) Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg 3 va_s0)
output_key_expansion_b 15 (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_heap1:vale_heap) (va_x_r10:nat64) (va_x_v0:quad32) (va_x_v1:quad32) (va_x_v2:quad32)
(va_x_v3:quad32) (va_x_v4:quad32) (va_x_v5:quad32) . let va_sM = va_upd_vec 5 va_x_v5
(va_upd_vec 4 va_x_v4 (va_upd_vec 3 va_x_v3 (va_upd_vec 2 va_x_v2 (va_upd_vec 1 va_x_v1
(va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 (va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem
va_x_mem va_s0)))))))) in va_get_ok va_sM /\ (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.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 1 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM) (va_get_reg 4 va_sM)
input_key_b 2 (va_get_mem_layout va_sM) Secret /\ Vale.PPC64LE.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_sM) (va_get_reg 3 va_sM) output_key_expansion_b 15 (va_get_mem_layout
va_sM) Secret) /\ (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.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 1
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.modifies_buffer128 output_key_expansion_b
(va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet 1 va_sM) /\ (forall (j:nat) .
{:pattern(reverse_bytes_quad32 (buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1
va_sM)))}j <= 14 ==> Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read
output_key_expansion_b j (va_get_mem_heaplet 1 va_sM)) == FStar.Seq.Base.index
#Vale.Def.Types_s.quad32 (Vale.AES.AES_BE_s.key_to_round_keys_word AES_256 key) j)) ==> va_k
va_sM (())))
val va_wpProof_KeyExpansion256Stdcall : input_key_b:buffer128 -> output_key_expansion_b:buffer128
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansion256Stdcall input_key_b output_key_expansion_b
va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (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_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
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_heaplet 1; va_Mod_mem])
(va_wp_KeyExpansion256Stdcall input_key_b output_key_expansion_b)
(va_wpProof_KeyExpansion256Stdcall input_key_b output_key_expansion_b))
//--
//-- AES256EncryptBlock
val va_code_AES256EncryptBlock : va_dummy:unit -> Tot va_code
val va_codegen_success_AES256EncryptBlock : va_dummy:unit -> Tot va_pbool
val va_lemma_AES256EncryptBlock : va_b0:va_code -> va_s0:va_state -> input:quad32 -> key:(seq
nat32) -> round_keys:(seq quad32) -> keys_buffer:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_AES256EncryptBlock ()) va_s0 /\ 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_buffer (va_get_mem_heaplet 0 va_s0) /\ Vale.PPC64LE.Decls.validSrcAddrs128
(va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0) keys_buffer 15 (va_get_mem_layout va_s0)
Secret /\ (forall (i:nat) . i < 15 ==> Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read keys_buffer i (va_get_mem_heaplet 0 va_s0)) ==
FStar.Seq.Base.index #quad32 round_keys i)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_get_vec 0 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key input /\ va_state_eq va_sM
(va_update_vec 2 va_sM (va_update_vec 0 va_sM (va_update_reg 10 va_sM (va_update_ok va_sM
va_s0))))))
[@ va_qattr]
let va_wp_AES256EncryptBlock (input:quad32) (key:(seq nat32)) (round_keys:(seq quad32)) | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 -> Type0)
-> Type0 | {
"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": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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_heaplet 1; va_Mod_mem])
(va_wp_KeyExpansion256Stdcall input_key_b output_key_expansion_b)
(va_wpProof_KeyExpansion256Stdcall input_key_b output_key_expansion_b)) | 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_key_expansion_b)
(va_wpProof_KeyExpansion256Stdcall input_key_b output_key_expansion_b)) | {
"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.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.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",
"Vale.AES.AES256_helpers_BE.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.PPC64LE.AES256.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_heaplet",
"Vale.PPC64LE.QuickCode.va_Mod_mem",
"Prims.Nil",
"Vale.AES.PPC64LE.AES256.va_wp_KeyExpansion256Stdcall",
"Vale.AES.PPC64LE.AES256.va_wpProof_KeyExpansion256Stdcall",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | 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.QuickCode
open Vale.PPC64LE.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES256_helpers_BE
#reset-options "--z3rlimit 20"
//-- KeyExpansion256Stdcall
val va_code_KeyExpansion256Stdcall : va_dummy:unit -> Tot va_code
val va_codegen_success_KeyExpansion256Stdcall : va_dummy:unit -> Tot va_pbool
val va_lemma_KeyExpansion256Stdcall : va_b0:va_code -> va_s0:va_state -> input_key_b:buffer128 ->
output_key_expansion_b:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansion256Stdcall ()) va_s0 /\ 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.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 1
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_s0) (va_get_reg 4 va_s0) input_key_b 2 (va_get_mem_layout va_s0) Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg 3 va_s0)
output_key_expansion_b 15 (va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(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.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 1
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_sM) (va_get_reg 4 va_sM) input_key_b 2 (va_get_mem_layout va_sM) Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg 3 va_sM)
output_key_expansion_b 15 (va_get_mem_layout va_sM) Secret) /\ (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.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 1 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) /\ (forall (j:nat) . {:pattern(reverse_bytes_quad32
(buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1 va_sM)))}j <= 14 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read output_key_expansion_b
j (va_get_mem_heaplet 1 va_sM)) == FStar.Seq.Base.index #Vale.Def.Types_s.quad32
(Vale.AES.AES_BE_s.key_to_round_keys_word AES_256 key) j)) /\ va_state_eq va_sM (va_update_vec
5 va_sM (va_update_vec 4 va_sM (va_update_vec 3 va_sM (va_update_vec 2 va_sM (va_update_vec 1
va_sM (va_update_vec 0 va_sM (va_update_reg 10 va_sM (va_update_mem_heaplet 1 va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
[@ va_qattr]
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
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0)))
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 1
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_s0) (va_get_reg 4 va_s0) input_key_b 2 (va_get_mem_layout va_s0) Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg 3 va_s0)
output_key_expansion_b 15 (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_heap1:vale_heap) (va_x_r10:nat64) (va_x_v0:quad32) (va_x_v1:quad32) (va_x_v2:quad32)
(va_x_v3:quad32) (va_x_v4:quad32) (va_x_v5:quad32) . let va_sM = va_upd_vec 5 va_x_v5
(va_upd_vec 4 va_x_v4 (va_upd_vec 3 va_x_v3 (va_upd_vec 2 va_x_v2 (va_upd_vec 1 va_x_v1
(va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 (va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem
va_x_mem va_s0)))))))) in va_get_ok va_sM /\ (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.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 1 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM) (va_get_reg 4 va_sM)
input_key_b 2 (va_get_mem_layout va_sM) Secret /\ Vale.PPC64LE.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_sM) (va_get_reg 3 va_sM) output_key_expansion_b 15 (va_get_mem_layout
va_sM) Secret) /\ (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.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 1
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.modifies_buffer128 output_key_expansion_b
(va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet 1 va_sM) /\ (forall (j:nat) .
{:pattern(reverse_bytes_quad32 (buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1
va_sM)))}j <= 14 ==> Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read
output_key_expansion_b j (va_get_mem_heaplet 1 va_sM)) == FStar.Seq.Base.index
#Vale.Def.Types_s.quad32 (Vale.AES.AES_BE_s.key_to_round_keys_word AES_256 key) j)) ==> va_k
va_sM (())))
val va_wpProof_KeyExpansion256Stdcall : input_key_b:buffer128 -> output_key_expansion_b:buffer128
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansion256Stdcall input_key_b output_key_expansion_b
va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (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_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_KeyExpansion256Stdcall (input_key_b:buffer128) (output_key_expansion_b:buffer128) : | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0)))
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 1
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_s0) (va_get_reg 4 va_s0) input_key_b 2 (va_get_mem_layout va_s0) Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg 3 va_s0)
output_key_expansion_b 15 (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_heap1:vale_heap) (va_x_r10:nat64) (va_x_v0:quad32) (va_x_v1:quad32) (va_x_v2:quad32)
(va_x_v3:quad32) (va_x_v4:quad32) (va_x_v5:quad32) . let va_sM = va_upd_vec 5 va_x_v5
(va_upd_vec 4 va_x_v4 (va_upd_vec 3 va_x_v3 (va_upd_vec 2 va_x_v2 (va_upd_vec 1 va_x_v1
(va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 (va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem
va_x_mem va_s0)))))))) in va_get_ok va_sM /\ (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.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 1 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM) (va_get_reg 4 va_sM)
input_key_b 2 (va_get_mem_layout va_sM) Secret /\ Vale.PPC64LE.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_sM) (va_get_reg 3 va_sM) output_key_expansion_b 15 (va_get_mem_layout
va_sM) Secret) /\ (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.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 1
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.modifies_buffer128 output_key_expansion_b
(va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet 1 va_sM) /\ (forall (j:nat) .
{:pattern(reverse_bytes_quad32 (buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1
va_sM)))}j <= 14 ==> Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read
output_key_expansion_b j (va_get_mem_heaplet 1 va_sM)) == FStar.Seq.Base.index
#Vale.Def.Types_s.quad32 (Vale.AES.AES_BE_s.key_to_round_keys_word AES_256 key) j)) ==> va_k
va_sM (()))) | 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))
: 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.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b
1
(va_get_mem_heaplet 0 va_s0)))
in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
(va_get_reg 4 va_s0)
input_key_b
2
(va_get_mem_layout va_s0)
Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0)
(va_get_reg 3 va_s0)
output_key_expansion_b
15
(va_get_mem_layout va_s0)
Secret) /\
(forall (va_x_mem: vale_heap)
(va_x_heap1: vale_heap)
(va_x_r10: nat64)
(va_x_v0: quad32)
(va_x_v1: quad32)
(va_x_v2: quad32)
(va_x_v3: quad32)
(va_x_v4: quad32)
(va_x_v5: quad32).
let va_sM =
va_upd_vec 5
va_x_v5
(va_upd_vec 4
va_x_v4
(va_upd_vec 3
va_x_v3
(va_upd_vec 2
va_x_v2
(va_upd_vec 1
va_x_v1
(va_upd_vec 0
va_x_v0
(va_upd_reg 10
va_x_r10
(va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem va_x_mem va_s0)))))))
)
in
va_get_ok va_sM /\
(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.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b
1
(va_get_mem_heaplet 0 va_s0)))
in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM)
(va_get_reg 4 va_sM)
input_key_b
2
(va_get_mem_layout va_sM)
Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM)
(va_get_reg 3 va_sM)
output_key_expansion_b
15
(va_get_mem_layout va_sM)
Secret) /\
(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.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b
1
(va_get_mem_heaplet 0 va_s0)))
in
Vale.PPC64LE.Decls.modifies_buffer128 output_key_expansion_b
(va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) /\
(forall (j: nat).
{:pattern
(reverse_bytes_quad32 (buffer128_read output_key_expansion_b
j
(va_get_mem_heaplet 1 va_sM)))}
j <= 14 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read output_key_expansion_b
j
(va_get_mem_heaplet 1 va_sM)) ==
FStar.Seq.Base.index #Vale.Def.Types_s.quad32
(Vale.AES.AES_BE_s.key_to_round_keys_word AES_256 key)
j)) ==>
va_k va_sM (()))) | {
"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.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.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",
"Vale.AES.AES256_helpers_BE.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.PPC64LE.AES256.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.Arch.HeapTypes_s.Secret",
"Vale.PPC64LE.Decls.validDstAddrs128",
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.nat32",
"Vale.AES.AES256_helpers_BE.make_AES256_key",
"Vale.Def.Types_s.reverse_bytes_quad32",
"Vale.PPC64LE.Decls.buffer128_read",
"Prims.l_Forall",
"Vale.PPC64LE.InsBasic.vale_heap",
"Vale.PPC64LE.Memory.nat64",
"Vale.PPC64LE.Memory.quad32",
"Prims.l_imp",
"Vale.PPC64LE.Decls.modifies_buffer128",
"Prims.nat",
"Prims.op_LessThanOrEqual",
"Prims.eq2",
"Vale.Def.Types_s.quad32",
"FStar.Seq.Base.index",
"Vale.AES.AES_BE_s.key_to_round_keys_word",
"Vale.AES.AES_common_s.AES_256",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_vec",
"Vale.PPC64LE.Decls.va_upd_reg",
"Vale.PPC64LE.Decls.va_upd_mem_heaplet",
"Vale.PPC64LE.Decls.va_upd_mem"
] | [] | 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.QuickCode
open Vale.PPC64LE.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES256_helpers_BE
#reset-options "--z3rlimit 20"
//-- KeyExpansion256Stdcall
val va_code_KeyExpansion256Stdcall : va_dummy:unit -> Tot va_code
val va_codegen_success_KeyExpansion256Stdcall : va_dummy:unit -> Tot va_pbool
val va_lemma_KeyExpansion256Stdcall : va_b0:va_code -> va_s0:va_state -> input_key_b:buffer128 ->
output_key_expansion_b:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansion256Stdcall ()) va_s0 /\ 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.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 1
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_s0) (va_get_reg 4 va_s0) input_key_b 2 (va_get_mem_layout va_s0) Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg 3 va_s0)
output_key_expansion_b 15 (va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(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.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 1
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_sM) (va_get_reg 4 va_sM) input_key_b 2 (va_get_mem_layout va_sM) Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg 3 va_sM)
output_key_expansion_b 15 (va_get_mem_layout va_sM) Secret) /\ (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.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 1 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) /\ (forall (j:nat) . {:pattern(reverse_bytes_quad32
(buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1 va_sM)))}j <= 14 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read output_key_expansion_b
j (va_get_mem_heaplet 1 va_sM)) == FStar.Seq.Base.index #Vale.Def.Types_s.quad32
(Vale.AES.AES_BE_s.key_to_round_keys_word AES_256 key) j)) /\ va_state_eq va_sM (va_update_vec
5 va_sM (va_update_vec 4 va_sM (va_update_vec 3 va_sM (va_update_vec 2 va_sM (va_update_vec 1
va_sM (va_update_vec 0 va_sM (va_update_reg 10 va_sM (va_update_mem_heaplet 1 va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
[@ va_qattr]
let va_wp_KeyExpansion256Stdcall (input_key_b:buffer128) (output_key_expansion_b:buffer128) | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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_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_buffer)
(va_wpProof_AES256EncryptBlock_6way in1 in2 in3 in4 in5 in6 key round_keys keys_buffer)) | 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: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
: (va_quickCode unit (va_code_AES256EncryptBlock_6way ())) = | 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_buffer)
(va_wpProof_AES256EncryptBlock_6way in1 in2 in3 in4 in5 in6 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.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.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",
"Vale.AES.AES256_helpers_BE.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.PPC64LE.AES256.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_vec",
"Vale.PPC64LE.QuickCode.va_Mod_reg",
"Prims.Nil",
"Vale.AES.PPC64LE.AES256.va_wp_AES256EncryptBlock_6way",
"Vale.AES.PPC64LE.AES256.va_wpProof_AES256EncryptBlock_6way",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | 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.QuickCode
open Vale.PPC64LE.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES256_helpers_BE
#reset-options "--z3rlimit 20"
//-- KeyExpansion256Stdcall
val va_code_KeyExpansion256Stdcall : va_dummy:unit -> Tot va_code
val va_codegen_success_KeyExpansion256Stdcall : va_dummy:unit -> Tot va_pbool
val va_lemma_KeyExpansion256Stdcall : va_b0:va_code -> va_s0:va_state -> input_key_b:buffer128 ->
output_key_expansion_b:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansion256Stdcall ()) va_s0 /\ 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.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 1
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_s0) (va_get_reg 4 va_s0) input_key_b 2 (va_get_mem_layout va_s0) Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg 3 va_s0)
output_key_expansion_b 15 (va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(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.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 1
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_sM) (va_get_reg 4 va_sM) input_key_b 2 (va_get_mem_layout va_sM) Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg 3 va_sM)
output_key_expansion_b 15 (va_get_mem_layout va_sM) Secret) /\ (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.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 1 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) /\ (forall (j:nat) . {:pattern(reverse_bytes_quad32
(buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1 va_sM)))}j <= 14 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read output_key_expansion_b
j (va_get_mem_heaplet 1 va_sM)) == FStar.Seq.Base.index #Vale.Def.Types_s.quad32
(Vale.AES.AES_BE_s.key_to_round_keys_word AES_256 key) j)) /\ va_state_eq va_sM (va_update_vec
5 va_sM (va_update_vec 4 va_sM (va_update_vec 3 va_sM (va_update_vec 2 va_sM (va_update_vec 1
va_sM (va_update_vec 0 va_sM (va_update_reg 10 va_sM (va_update_mem_heaplet 1 va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
[@ va_qattr]
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
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0)))
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 1
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_s0) (va_get_reg 4 va_s0) input_key_b 2 (va_get_mem_layout va_s0) Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg 3 va_s0)
output_key_expansion_b 15 (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_heap1:vale_heap) (va_x_r10:nat64) (va_x_v0:quad32) (va_x_v1:quad32) (va_x_v2:quad32)
(va_x_v3:quad32) (va_x_v4:quad32) (va_x_v5:quad32) . let va_sM = va_upd_vec 5 va_x_v5
(va_upd_vec 4 va_x_v4 (va_upd_vec 3 va_x_v3 (va_upd_vec 2 va_x_v2 (va_upd_vec 1 va_x_v1
(va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 (va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem
va_x_mem va_s0)))))))) in va_get_ok va_sM /\ (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.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 1 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM) (va_get_reg 4 va_sM)
input_key_b 2 (va_get_mem_layout va_sM) Secret /\ Vale.PPC64LE.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_sM) (va_get_reg 3 va_sM) output_key_expansion_b 15 (va_get_mem_layout
va_sM) Secret) /\ (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.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 1
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.modifies_buffer128 output_key_expansion_b
(va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet 1 va_sM) /\ (forall (j:nat) .
{:pattern(reverse_bytes_quad32 (buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1
va_sM)))}j <= 14 ==> Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read
output_key_expansion_b j (va_get_mem_heaplet 1 va_sM)) == FStar.Seq.Base.index
#Vale.Def.Types_s.quad32 (Vale.AES.AES_BE_s.key_to_round_keys_word AES_256 key) j)) ==> va_k
va_sM (())))
val va_wpProof_KeyExpansion256Stdcall : input_key_b:buffer128 -> output_key_expansion_b:buffer128
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansion256Stdcall input_key_b output_key_expansion_b
va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (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_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
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_heaplet 1; va_Mod_mem])
(va_wp_KeyExpansion256Stdcall input_key_b output_key_expansion_b)
(va_wpProof_KeyExpansion256Stdcall input_key_b output_key_expansion_b))
//--
//-- AES256EncryptBlock
val va_code_AES256EncryptBlock : va_dummy:unit -> Tot va_code
val va_codegen_success_AES256EncryptBlock : va_dummy:unit -> Tot va_pbool
val va_lemma_AES256EncryptBlock : va_b0:va_code -> va_s0:va_state -> input:quad32 -> key:(seq
nat32) -> round_keys:(seq quad32) -> keys_buffer:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_AES256EncryptBlock ()) va_s0 /\ 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_buffer (va_get_mem_heaplet 0 va_s0) /\ Vale.PPC64LE.Decls.validSrcAddrs128
(va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0) keys_buffer 15 (va_get_mem_layout va_s0)
Secret /\ (forall (i:nat) . i < 15 ==> Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read keys_buffer i (va_get_mem_heaplet 0 va_s0)) ==
FStar.Seq.Base.index #quad32 round_keys i)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_get_vec 0 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key input /\ va_state_eq va_sM
(va_update_vec 2 va_sM (va_update_vec 0 va_sM (va_update_reg 10 va_sM (va_update_ok va_sM
va_s0))))))
[@ va_qattr]
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.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_buffer (va_get_mem_heaplet 0 va_s0) /\
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0)
keys_buffer 15 (va_get_mem_layout va_s0) Secret /\ (forall (i:nat) . i < 15 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read keys_buffer i
(va_get_mem_heaplet 0 va_s0)) == FStar.Seq.Base.index #quad32 round_keys i) /\ (forall
(va_x_r10:nat64) (va_x_v0:quad32) (va_x_v2:quad32) . let va_sM = va_upd_vec 2 va_x_v2
(va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 va_s0)) in va_get_ok va_sM /\ va_get_vec 0 va_sM
== Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key input ==> va_k va_sM (())))
val va_wpProof_AES256EncryptBlock : input:quad32 -> key:(seq nat32) -> round_keys:(seq quad32) ->
keys_buffer:buffer128 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_AES256EncryptBlock input key round_keys keys_buffer va_s0
va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_AES256EncryptBlock ()) ([va_Mod_vec 2;
va_Mod_vec 0; va_Mod_reg 10]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
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_buffer) (va_wpProof_AES256EncryptBlock
input key round_keys keys_buffer))
//--
//-- AES256EncryptBlock_6way
val va_code_AES256EncryptBlock_6way : va_dummy:unit -> Tot va_code
val va_codegen_success_AES256EncryptBlock_6way : va_dummy:unit -> Tot va_pbool
val va_lemma_AES256EncryptBlock_6way : va_b0:va_code -> va_s0:va_state -> in1:quad32 -> in2:quad32
-> in3:quad32 -> in4:quad32 -> in5:quad32 -> in6:quad32 -> key:(seq nat32) -> round_keys:(seq
quad32) -> keys_buffer:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_AES256EncryptBlock_6way ()) va_s0 /\ 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_vec 4 va_s0 == in5 /\ va_get_vec 5 va_s0 == in6 /\ va_get_reg 4 va_s0 ==
Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128 keys_buffer (va_get_mem_heaplet 0
va_s0) /\ Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0)
keys_buffer 15 (va_get_mem_layout va_s0) Secret /\ (forall (i:nat) . i < 15 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read keys_buffer i
(va_get_mem_heaplet 0 va_s0)) == FStar.Seq.Base.index #quad32 round_keys i)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_get_vec 0 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in1 /\ va_get_vec 1 va_sM
== Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in2 /\ va_get_vec 2 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in3 /\ va_get_vec 3 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in4 /\ va_get_vec 4 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in5 /\ va_get_vec 5 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in6 /\ va_state_eq va_sM (va_update_vec 6 va_sM
(va_update_vec 5 va_sM (va_update_vec 4 va_sM (va_update_vec 3 va_sM (va_update_vec 2 va_sM
(va_update_vec 1 va_sM (va_update_vec 0 va_sM (va_update_reg 10 va_sM (va_update_ok va_sM
va_s0)))))))))))
[@ va_qattr]
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 /\ 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_vec 4 va_s0 == in5 /\ va_get_vec 5 va_s0 == in6 /\
va_get_reg 4 va_s0 == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128 keys_buffer
(va_get_mem_heaplet 0 va_s0) /\ Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_s0) (va_get_reg 4 va_s0) keys_buffer 15 (va_get_mem_layout va_s0) Secret /\ (forall (i:nat)
. i < 15 ==> Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read
keys_buffer i (va_get_mem_heaplet 0 va_s0)) == FStar.Seq.Base.index #quad32 round_keys i) /\
(forall (va_x_r10:nat64) (va_x_v0:quad32) (va_x_v1:quad32) (va_x_v2:quad32) (va_x_v3:quad32)
(va_x_v4:quad32) (va_x_v5:quad32) (va_x_v6:quad32) . let va_sM = va_upd_vec 6 va_x_v6
(va_upd_vec 5 va_x_v5 (va_upd_vec 4 va_x_v4 (va_upd_vec 3 va_x_v3 (va_upd_vec 2 va_x_v2
(va_upd_vec 1 va_x_v1 (va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 va_s0))))))) in va_get_ok
va_sM /\ va_get_vec 0 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in1 /\ va_get_vec
1 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in2 /\ va_get_vec 2 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in3 /\ va_get_vec 3 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in4 /\ va_get_vec 4 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in5 /\ va_get_vec 5 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in6 ==> va_k va_sM (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_AES256EncryptBlock_6way in1 in2 in3 in4 in5 in6 key
round_keys keys_buffer va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (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_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
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) : | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.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_6way ()) | {
"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": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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 /\ 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_vec 4 va_s0 == in5 /\ va_get_vec 5 va_s0 == in6 /\
va_get_reg 4 va_s0 == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128 keys_buffer
(va_get_mem_heaplet 0 va_s0) /\ Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_s0) (va_get_reg 4 va_s0) keys_buffer 15 (va_get_mem_layout va_s0) Secret /\ (forall (i:nat)
. i < 15 ==> Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read
keys_buffer i (va_get_mem_heaplet 0 va_s0)) == FStar.Seq.Base.index #quad32 round_keys i) /\
(forall (va_x_r10:nat64) (va_x_v0:quad32) (va_x_v1:quad32) (va_x_v2:quad32) (va_x_v3:quad32)
(va_x_v4:quad32) (va_x_v5:quad32) (va_x_v6:quad32) . let va_sM = va_upd_vec 6 va_x_v6
(va_upd_vec 5 va_x_v5 (va_upd_vec 4 va_x_v4 (va_upd_vec 3 va_x_v3 (va_upd_vec 2 va_x_v2
(va_upd_vec 1 va_x_v1 (va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 va_s0))))))) in va_get_ok
va_sM /\ va_get_vec 0 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in1 /\ va_get_vec
1 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in2 /\ va_get_vec 2 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in3 /\ va_get_vec 3 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in4 /\ va_get_vec 4 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in5 /\ va_get_vec 5 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in6 ==> va_k va_sM (()))) | 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)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | 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_vec 4 va_s0 == in5 /\ va_get_vec 5 va_s0 == in6 /\
va_get_reg 4 va_s0 ==
Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
keys_buffer
(va_get_mem_heaplet 0 va_s0) /\
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
(va_get_reg 4 va_s0)
keys_buffer
15
(va_get_mem_layout va_s0)
Secret /\
(forall (i: nat).
i < 15 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read keys_buffer
i
(va_get_mem_heaplet 0 va_s0)) ==
FStar.Seq.Base.index #quad32 round_keys i) /\
(forall (va_x_r10: nat64)
(va_x_v0: quad32)
(va_x_v1: quad32)
(va_x_v2: quad32)
(va_x_v3: quad32)
(va_x_v4: quad32)
(va_x_v5: quad32)
(va_x_v6: quad32).
let va_sM =
va_upd_vec 6
va_x_v6
(va_upd_vec 5
va_x_v5
(va_upd_vec 4
va_x_v4
(va_upd_vec 3
va_x_v3
(va_upd_vec 2
va_x_v2
(va_upd_vec 1
va_x_v1
(va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 va_s0)))))))
in
va_get_ok va_sM /\ va_get_vec 0 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in1 /\
va_get_vec 1 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in2 /\
va_get_vec 2 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in3 /\
va_get_vec 3 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in4 /\
va_get_vec 4 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in5 /\
va_get_vec 5 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in6 ==>
va_k va_sM (()))) | {
"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.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.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",
"Vale.AES.AES256_helpers_BE.fsti.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.PPC64LE.AES256.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",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"Vale.AES.AES_BE_s.key_to_round_keys_word",
"Vale.Def.Types_s.quad32",
"Vale.PPC64LE.Decls.va_get_vec",
"Vale.PPC64LE.Decls.va_get_reg",
"Vale.PPC64LE.Memory.buffer_addr",
"Vale.PPC64LE.Memory.vuint128",
"Vale.PPC64LE.Decls.va_get_mem_heaplet",
"Vale.PPC64LE.Decls.validSrcAddrs128",
"Vale.PPC64LE.Decls.va_get_mem_layout",
"Vale.Arch.HeapTypes_s.Secret",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.op_LessThan",
"Vale.Def.Types_s.reverse_bytes_quad32",
"Vale.PPC64LE.Decls.buffer128_read",
"FStar.Seq.Base.index",
"Vale.PPC64LE.Memory.nat64",
"Vale.AES.AES_BE_s.aes_encrypt_word",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_vec",
"Vale.PPC64LE.Decls.va_upd_reg"
] | [] | 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.QuickCode
open Vale.PPC64LE.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES256_helpers_BE
#reset-options "--z3rlimit 20"
//-- KeyExpansion256Stdcall
val va_code_KeyExpansion256Stdcall : va_dummy:unit -> Tot va_code
val va_codegen_success_KeyExpansion256Stdcall : va_dummy:unit -> Tot va_pbool
val va_lemma_KeyExpansion256Stdcall : va_b0:va_code -> va_s0:va_state -> input_key_b:buffer128 ->
output_key_expansion_b:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansion256Stdcall ()) va_s0 /\ 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.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 1
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_s0) (va_get_reg 4 va_s0) input_key_b 2 (va_get_mem_layout va_s0) Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg 3 va_s0)
output_key_expansion_b 15 (va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(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.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 1
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_sM) (va_get_reg 4 va_sM) input_key_b 2 (va_get_mem_layout va_sM) Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg 3 va_sM)
output_key_expansion_b 15 (va_get_mem_layout va_sM) Secret) /\ (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.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 1 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) /\ (forall (j:nat) . {:pattern(reverse_bytes_quad32
(buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1 va_sM)))}j <= 14 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read output_key_expansion_b
j (va_get_mem_heaplet 1 va_sM)) == FStar.Seq.Base.index #Vale.Def.Types_s.quad32
(Vale.AES.AES_BE_s.key_to_round_keys_word AES_256 key) j)) /\ va_state_eq va_sM (va_update_vec
5 va_sM (va_update_vec 4 va_sM (va_update_vec 3 va_sM (va_update_vec 2 va_sM (va_update_vec 1
va_sM (va_update_vec 0 va_sM (va_update_reg 10 va_sM (va_update_mem_heaplet 1 va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))
[@ va_qattr]
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
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0)))
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 1
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_s0) (va_get_reg 4 va_s0) input_key_b 2 (va_get_mem_layout va_s0) Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg 3 va_s0)
output_key_expansion_b 15 (va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap)
(va_x_heap1:vale_heap) (va_x_r10:nat64) (va_x_v0:quad32) (va_x_v1:quad32) (va_x_v2:quad32)
(va_x_v3:quad32) (va_x_v4:quad32) (va_x_v5:quad32) . let va_sM = va_upd_vec 5 va_x_v5
(va_upd_vec 4 va_x_v4 (va_upd_vec 3 va_x_v3 (va_upd_vec 2 va_x_v2 (va_upd_vec 1 va_x_v1
(va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 (va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem
va_x_mem va_s0)))))))) in va_get_ok va_sM /\ (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.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 1 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM) (va_get_reg 4 va_sM)
input_key_b 2 (va_get_mem_layout va_sM) Secret /\ Vale.PPC64LE.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_sM) (va_get_reg 3 va_sM) output_key_expansion_b 15 (va_get_mem_layout
va_sM) Secret) /\ (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.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 1
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.modifies_buffer128 output_key_expansion_b
(va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet 1 va_sM) /\ (forall (j:nat) .
{:pattern(reverse_bytes_quad32 (buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1
va_sM)))}j <= 14 ==> Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read
output_key_expansion_b j (va_get_mem_heaplet 1 va_sM)) == FStar.Seq.Base.index
#Vale.Def.Types_s.quad32 (Vale.AES.AES_BE_s.key_to_round_keys_word AES_256 key) j)) ==> va_k
va_sM (())))
val va_wpProof_KeyExpansion256Stdcall : input_key_b:buffer128 -> output_key_expansion_b:buffer128
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansion256Stdcall input_key_b output_key_expansion_b
va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (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_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
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_heaplet 1; va_Mod_mem])
(va_wp_KeyExpansion256Stdcall input_key_b output_key_expansion_b)
(va_wpProof_KeyExpansion256Stdcall input_key_b output_key_expansion_b))
//--
//-- AES256EncryptBlock
val va_code_AES256EncryptBlock : va_dummy:unit -> Tot va_code
val va_codegen_success_AES256EncryptBlock : va_dummy:unit -> Tot va_pbool
val va_lemma_AES256EncryptBlock : va_b0:va_code -> va_s0:va_state -> input:quad32 -> key:(seq
nat32) -> round_keys:(seq quad32) -> keys_buffer:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_AES256EncryptBlock ()) va_s0 /\ 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_buffer (va_get_mem_heaplet 0 va_s0) /\ Vale.PPC64LE.Decls.validSrcAddrs128
(va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0) keys_buffer 15 (va_get_mem_layout va_s0)
Secret /\ (forall (i:nat) . i < 15 ==> Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read keys_buffer i (va_get_mem_heaplet 0 va_s0)) ==
FStar.Seq.Base.index #quad32 round_keys i)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_get_vec 0 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key input /\ va_state_eq va_sM
(va_update_vec 2 va_sM (va_update_vec 0 va_sM (va_update_reg 10 va_sM (va_update_ok va_sM
va_s0))))))
[@ va_qattr]
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.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_buffer (va_get_mem_heaplet 0 va_s0) /\
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0)
keys_buffer 15 (va_get_mem_layout va_s0) Secret /\ (forall (i:nat) . i < 15 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read keys_buffer i
(va_get_mem_heaplet 0 va_s0)) == FStar.Seq.Base.index #quad32 round_keys i) /\ (forall
(va_x_r10:nat64) (va_x_v0:quad32) (va_x_v2:quad32) . let va_sM = va_upd_vec 2 va_x_v2
(va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 va_s0)) in va_get_ok va_sM /\ va_get_vec 0 va_sM
== Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key input ==> va_k va_sM (())))
val va_wpProof_AES256EncryptBlock : input:quad32 -> key:(seq nat32) -> round_keys:(seq quad32) ->
keys_buffer:buffer128 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_AES256EncryptBlock input key round_keys keys_buffer va_s0
va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_AES256EncryptBlock ()) ([va_Mod_vec 2;
va_Mod_vec 0; va_Mod_reg 10]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
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_buffer) (va_wpProof_AES256EncryptBlock
input key round_keys keys_buffer))
//--
//-- AES256EncryptBlock_6way
val va_code_AES256EncryptBlock_6way : va_dummy:unit -> Tot va_code
val va_codegen_success_AES256EncryptBlock_6way : va_dummy:unit -> Tot va_pbool
val va_lemma_AES256EncryptBlock_6way : va_b0:va_code -> va_s0:va_state -> in1:quad32 -> in2:quad32
-> in3:quad32 -> in4:quad32 -> in5:quad32 -> in6:quad32 -> key:(seq nat32) -> round_keys:(seq
quad32) -> keys_buffer:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_AES256EncryptBlock_6way ()) va_s0 /\ 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_vec 4 va_s0 == in5 /\ va_get_vec 5 va_s0 == in6 /\ va_get_reg 4 va_s0 ==
Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128 keys_buffer (va_get_mem_heaplet 0
va_s0) /\ Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0)
keys_buffer 15 (va_get_mem_layout va_s0) Secret /\ (forall (i:nat) . i < 15 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read keys_buffer i
(va_get_mem_heaplet 0 va_s0)) == FStar.Seq.Base.index #quad32 round_keys i)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_get_vec 0 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in1 /\ va_get_vec 1 va_sM
== Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in2 /\ va_get_vec 2 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in3 /\ va_get_vec 3 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in4 /\ va_get_vec 4 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in5 /\ va_get_vec 5 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_256 key in6 /\ va_state_eq va_sM (va_update_vec 6 va_sM
(va_update_vec 5 va_sM (va_update_vec 4 va_sM (va_update_vec 3 va_sM (va_update_vec 2 va_sM
(va_update_vec 1 va_sM (va_update_vec 0 va_sM (va_update_reg 10 va_sM (va_update_ok va_sM
va_s0)))))))))))
[@ va_qattr]
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) | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.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 -> Type0)
-> Type0 | {
"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,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Primitive.ForkJoin.fst"
} | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Primitive.ForkJoin
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module L = Steel.SpinLock
open Steel.FractionalPermission
open Steel.Reference
//////////////////////////////////////////////////////////////////////////////// | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Primitive.ForkJoin.fst"
} | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Primitive.ForkJoin
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module L = Steel.SpinLock
open Steel.FractionalPermission
open Steel.Reference
////////////////////////////////////////////////////////////////////////////////
let maybe_p (p:vprop) (v:bool) = if v then p else emp
[@@__reduce__] | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Primitive.ForkJoin.fst"
} | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Primitive.ForkJoin
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module L = Steel.SpinLock
open Steel.FractionalPermission
open Steel.Reference
////////////////////////////////////////////////////////////////////////////////
let maybe_p (p:vprop) (v:bool) = if v then p else emp
[@@__reduce__]
let lock_inv_pred (r:ref bool) (p:vprop) (v:bool) : vprop =
pts_to r full_perm v `star` maybe_p p v
let lock_inv (r:ref bool) (p:vprop) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Primitive.ForkJoin.fst"
} | [] | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Primitive.ForkJoin
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module L = Steel.SpinLock
open Steel.FractionalPermission
open Steel.Reference
////////////////////////////////////////////////////////////////////////////////
let maybe_p (p:vprop) (v:bool) = if v then p else emp
[@@__reduce__]
let lock_inv_pred (r:ref bool) (p:vprop) (v:bool) : vprop =
pts_to r full_perm v `star` maybe_p p v
let lock_inv (r:ref bool) (p:vprop)
: vprop
= h_exists (lock_inv_pred r p)
noeq
type thread (p:vprop) = {
r:ref bool;
l:L.lock (lock_inv r p)
}
let intro_maybe_p_false (p:vprop) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Primitive.ForkJoin.fst"
} | [] | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Primitive.ForkJoin
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module L = Steel.SpinLock
open Steel.FractionalPermission
open Steel.Reference
////////////////////////////////////////////////////////////////////////////////
let maybe_p (p:vprop) (v:bool) = if v then p else emp
[@@__reduce__]
let lock_inv_pred (r:ref bool) (p:vprop) (v:bool) : vprop =
pts_to r full_perm v `star` maybe_p p v
let lock_inv (r:ref bool) (p:vprop)
: vprop
= h_exists (lock_inv_pred r p)
noeq
type thread (p:vprop) = {
r:ref bool;
l:L.lock (lock_inv r p)
}
let intro_maybe_p_false (p:vprop)
: SteelT unit emp (fun _ -> maybe_p p false)
= rewrite_slprop emp (maybe_p p false) (fun _ -> ())
let intro_maybe_p_true (p:vprop) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Primitive.ForkJoin.fst"
} | [] | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Primitive.ForkJoin
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module L = Steel.SpinLock
open Steel.FractionalPermission
open Steel.Reference
////////////////////////////////////////////////////////////////////////////////
let maybe_p (p:vprop) (v:bool) = if v then p else emp
[@@__reduce__]
let lock_inv_pred (r:ref bool) (p:vprop) (v:bool) : vprop =
pts_to r full_perm v `star` maybe_p p v
let lock_inv (r:ref bool) (p:vprop)
: vprop
= h_exists (lock_inv_pred r p)
noeq
type thread (p:vprop) = {
r:ref bool;
l:L.lock (lock_inv r p)
}
let intro_maybe_p_false (p:vprop)
: SteelT unit emp (fun _ -> maybe_p p false)
= rewrite_slprop emp (maybe_p p false) (fun _ -> ())
let intro_maybe_p_true (p:vprop)
: SteelT unit p (fun _ -> maybe_p p true)
= rewrite_slprop p (maybe_p p true) (fun _ -> ())
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
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
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
let spawn (#p #q:vprop)
($f: (unit -> SteelT unit p (fun _ -> q)))
(t:thread q)
(_:unit) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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 _ -> s)))
: SteelT unit (p `star` r) (fun _ -> s) = | 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.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Primitive.ForkJoin.fst"
} | [] | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Primitive.ForkJoin
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module L = Steel.SpinLock
open Steel.FractionalPermission
open Steel.Reference
////////////////////////////////////////////////////////////////////////////////
let maybe_p (p:vprop) (v:bool) = if v then p else emp
[@@__reduce__]
let lock_inv_pred (r:ref bool) (p:vprop) (v:bool) : vprop =
pts_to r full_perm v `star` maybe_p p v
let lock_inv (r:ref bool) (p:vprop)
: vprop
= h_exists (lock_inv_pred r p)
noeq
type thread (p:vprop) = {
r:ref bool;
l:L.lock (lock_inv r p)
}
let intro_maybe_p_false (p:vprop)
: SteelT unit emp (fun _ -> maybe_p p false)
= rewrite_slprop emp (maybe_p p false) (fun _ -> ())
let intro_maybe_p_true (p:vprop)
: SteelT unit p (fun _ -> maybe_p p true)
= rewrite_slprop p (maybe_p p true) (fun _ -> ())
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
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
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
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
let fork (#p #q #r #s:vprop)
(f: (unit -> SteelT unit p (fun _ -> q)))
(g: (thread q -> unit -> SteelT unit r (fun _ -> s))) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Primitive.ForkJoin.fst"
} | [] | [
"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",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.Primitive.ForkJoin.lock_inv_pred",
"Steel.Primitive.ForkJoin.intro_maybe_p_true",
"Steel.Reference.write_pt",
"Steel.Effect.Common.star",
"Steel.Reference.pts_to",
"Steel.FractionalPermission.full_perm",
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Primitive.ForkJoin
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module L = Steel.SpinLock
open Steel.FractionalPermission
open Steel.Reference
////////////////////////////////////////////////////////////////////////////////
let maybe_p (p:vprop) (v:bool) = if v then p else emp
[@@__reduce__]
let lock_inv_pred (r:ref bool) (p:vprop) (v:bool) : vprop =
pts_to r full_perm v `star` maybe_p p v
let lock_inv (r:ref bool) (p:vprop)
: vprop
= h_exists (lock_inv_pred r p)
noeq
type thread (p:vprop) = {
r:ref bool;
l:L.lock (lock_inv r p)
}
let intro_maybe_p_false (p:vprop)
: SteelT unit emp (fun _ -> maybe_p p false)
= rewrite_slprop emp (maybe_p p false) (fun _ -> ())
let intro_maybe_p_true (p:vprop)
: SteelT unit p (fun _ -> maybe_p p true)
= rewrite_slprop p (maybe_p p true) (fun _ -> ())
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
let finish (#p:vprop) (t:thread p) (v:bool) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Primitive.ForkJoin.fst"
} | [] | [
"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.full_perm",
"Prims.unit",
"Steel.Effect.Atomic.drop",
"Steel.Primitive.ForkJoin.maybe_p",
"Steel.Reference.read_refine_pt",
"Steel.SpinLock.acquire",
"Steel.Primitive.ForkJoin.lock_inv",
"Steel.Primitive.ForkJoin.__proj__Mkthread__item__l",
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Primitive.ForkJoin
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module L = Steel.SpinLock
open Steel.FractionalPermission
open Steel.Reference
////////////////////////////////////////////////////////////////////////////////
let maybe_p (p:vprop) (v:bool) = if v then p else emp
[@@__reduce__]
let lock_inv_pred (r:ref bool) (p:vprop) (v:bool) : vprop =
pts_to r full_perm v `star` maybe_p p v
let lock_inv (r:ref bool) (p:vprop)
: vprop
= h_exists (lock_inv_pred r p)
noeq
type thread (p:vprop) = {
r:ref bool;
l:L.lock (lock_inv r p)
}
let intro_maybe_p_false (p:vprop)
: SteelT unit emp (fun _ -> maybe_p p false)
= rewrite_slprop emp (maybe_p p false) (fun _ -> ())
let intro_maybe_p_true (p:vprop)
: SteelT unit p (fun _ -> maybe_p p true)
= rewrite_slprop p (maybe_p p true) (fun _ -> ())
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
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
let acquire (#p:vprop) (t:thread p) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Primitive.ForkJoin.fst"
} | [] | [
"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",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.Primitive.ForkJoin.lock_inv_pred",
"Steel.Primitive.ForkJoin.intro_maybe_p_false",
"Steel.Reference.ref",
"Steel.Reference.alloc_pt",
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Primitive.ForkJoin
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module L = Steel.SpinLock
open Steel.FractionalPermission
open Steel.Reference
////////////////////////////////////////////////////////////////////////////////
let maybe_p (p:vprop) (v:bool) = if v then p else emp
[@@__reduce__]
let lock_inv_pred (r:ref bool) (p:vprop) (v:bool) : vprop =
pts_to r full_perm v `star` maybe_p p v
let lock_inv (r:ref bool) (p:vprop)
: vprop
= h_exists (lock_inv_pred r p)
noeq
type thread (p:vprop) = {
r:ref bool;
l:L.lock (lock_inv r p)
}
let intro_maybe_p_false (p:vprop)
: SteelT unit emp (fun _ -> maybe_p p false)
= rewrite_slprop emp (maybe_p p false) (fun _ -> ())
let intro_maybe_p_true (p:vprop)
: SteelT unit p (fun _ -> maybe_p p true)
= rewrite_slprop p (maybe_p p true) (fun _ -> ())
let new_thread (p:vprop) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Primitive",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec 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 _ -> ());
intro_exists false (lock_inv_pred t.r p);
L.release t.l;
join t) | 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.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Primitive.ForkJoin.fst"
} | [] | [
"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__Mkthread__item__r",
"Steel.Memory.mem",
"Prims.bool",
"Steel.Primitive.ForkJoin.join",
"Steel.SpinLock.release",
"Steel.Primitive.ForkJoin.lock_inv",
"Steel.Primitive.ForkJoin.__proj__Mkthread__item__l",
"Steel.Effect.Atomic.intro_exists",
"Steel.Reference.read_refine_pt",
"Steel.FractionalPermission.full_perm",
"Steel.Primitive.ForkJoin.maybe_p",
"Steel.SpinLock.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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Primitive.ForkJoin
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module L = Steel.SpinLock
open Steel.FractionalPermission
open Steel.Reference
////////////////////////////////////////////////////////////////////////////////
let maybe_p (p:vprop) (v:bool) = if v then p else emp
[@@__reduce__]
let lock_inv_pred (r:ref bool) (p:vprop) (v:bool) : vprop =
pts_to r full_perm v `star` maybe_p p v
let lock_inv (r:ref bool) (p:vprop)
: vprop
= h_exists (lock_inv_pred r p)
noeq
type thread (p:vprop) = {
r:ref bool;
l:L.lock (lock_inv r p)
}
let intro_maybe_p_false (p:vprop)
: SteelT unit emp (fun _ -> maybe_p p false)
= rewrite_slprop emp (maybe_p p false) (fun _ -> ())
let intro_maybe_p_true (p:vprop)
: SteelT unit p (fun _ -> maybe_p p true)
= rewrite_slprop p (maybe_p p true) (fun _ -> ())
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
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
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
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
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
()
let rec join (#p:vprop) (t:thread p) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Matrix.fst.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Frodo.Sample.fst"
} | [
"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.Frodo.Lemmas
module S = Spec.Frodo.Sample
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
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 =
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
inline_for_extraction noextract
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 =
Lemmas.lemma_frodo_sample2 sign sample;
((lognot sign +. u16 1) ^. sample) +. sign
inline_for_extraction noextract | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Matrix.fst.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Frodo.Sample.fst"
} | [
"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.Frodo.Lemmas
module S = Spec.Frodo.Sample
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
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 =
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
inline_for_extraction noextract
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 =
Lemmas.lemma_frodo_sample2 sign sample;
((lognot sign +. u16 1) ^. sample) +. sign
inline_for_extraction noextract
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)
#push-options "--fuel 1"
inline_for_extraction noextract
val frodo_sample: a:FP.frodo_alg -> frodo_sample_st a
let frodo_sample a r =
push_frame();
let prnd = r >>. 1ul in
let sign = r &. u16 1 in
mod_mask_lemma r 1ul;
assert (v #U16 #SEC (mod_mask 1ul) == 1);
assert (v sign == 0 \/ v sign == 1);
let sample :lbuffer uint16 1ul = create (size 1) (u16 0) in
let h = ST.get () in
assert (LSeq.index #_ #1 (as_seq h sample) 0 == u16 0);
assert (bget h sample 0 == u16 0);
let bound = cdf_table_len a -! 1ul in
let h0 = ST.get () in
Lib.Loops.for 0ul bound
(fun h i ->
modifies1 sample h0 h /\
v (bget h sample 0) == S.frodo_sample_fc a prnd i)
(fun i ->
let sample0 = sample.(0ul) in
let samplei = frodo_sample_f a prnd i in
sample.(0ul) <- samplei +. sample0
);
let sample0 = sample.(0ul) in
assert (v sample0 == S.frodo_sample_fc a prnd (v bound));
let res = frodo_sample_res a sign sample0 in
pop_frame();
res
#pop-options
inline_for_extraction noextract
val frodo_sample_matrix1:
a:FP.frodo_alg
-> frodo_sample:frodo_sample_st a
-> n1:size_t
-> n2:size_t{0 < 2 * v n1 * v n2 /\ 2 * v n1 * v n2 <= max_size_t}
-> r:lbuffer uint8 (size 2 *! n1 *! n2)
-> i:size_t{v i < v n1}
-> res:matrix_t n1 n2
-> Stack unit
(requires fun h ->
live h r /\ live h res /\ disjoint r res)
(ensures fun h0 _ h1 -> modifies1 res h0 h1 /\
as_matrix h1 res ==
S.frodo_sample_matrix1 a (v n1) (v n2) (as_seq h0 r) (v i) (as_matrix h0 res))
let frodo_sample_matrix1 a frodo_sample n1 n2 r i res =
[@ inline_let]
let spec h0 = S.frodo_sample_matrix0 a (v n1) (v n2) (as_seq h0 r) (v i) in
let h0 = ST.get () in
loop1 h0 n2 res spec
(fun j ->
Loops.unfold_repeati (v n2) (spec h0) (as_seq h0 res) (v j);
Lemmas.lemma_matrix_index_repeati1 (v n1) (v n2) (v i) (v j);
let resij = sub r (size 2 *! (n2 *! i +! j)) (size 2) in
mset res i j (frodo_sample (uint_from_bytes_le #U16 resij))
)
inline_for_extraction noextract
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 h1 /\
as_matrix h1 res == S.frodo_sample_matrix a (v n1) (v n2) (as_seq h0 r))
inline_for_extraction noextract
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 =
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);
frodo_sample_matrix1 a frodo_sample n1 n2 r i res
)
[@CInline]
let frodo_sample_matrix64 : frodo_sample_matrix_st FP.Frodo64 =
frodo_sample_matrix_ FP.Frodo64 (frodo_sample FP.Frodo64)
[@CInline]
let frodo_sample_matrix640 : frodo_sample_matrix_st FP.Frodo640 =
frodo_sample_matrix_ FP.Frodo640 (frodo_sample FP.Frodo640)
[@CInline]
let frodo_sample_matrix976 : frodo_sample_matrix_st FP.Frodo976 =
frodo_sample_matrix_ FP.Frodo976 (frodo_sample FP.Frodo976)
[@CInline] | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Matrix.fst.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Frodo.Sample.fst"
} | [
"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.Frodo.Lemmas
module S = Spec.Frodo.Sample
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
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 =
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
inline_for_extraction noextract
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 =
Lemmas.lemma_frodo_sample2 sign sample;
((lognot sign +. u16 1) ^. sample) +. sign
inline_for_extraction noextract
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)
#push-options "--fuel 1"
inline_for_extraction noextract
val frodo_sample: a:FP.frodo_alg -> frodo_sample_st a
let frodo_sample a r =
push_frame();
let prnd = r >>. 1ul in
let sign = r &. u16 1 in
mod_mask_lemma r 1ul;
assert (v #U16 #SEC (mod_mask 1ul) == 1);
assert (v sign == 0 \/ v sign == 1);
let sample :lbuffer uint16 1ul = create (size 1) (u16 0) in
let h = ST.get () in
assert (LSeq.index #_ #1 (as_seq h sample) 0 == u16 0);
assert (bget h sample 0 == u16 0);
let bound = cdf_table_len a -! 1ul in
let h0 = ST.get () in
Lib.Loops.for 0ul bound
(fun h i ->
modifies1 sample h0 h /\
v (bget h sample 0) == S.frodo_sample_fc a prnd i)
(fun i ->
let sample0 = sample.(0ul) in
let samplei = frodo_sample_f a prnd i in
sample.(0ul) <- samplei +. sample0
);
let sample0 = sample.(0ul) in
assert (v sample0 == S.frodo_sample_fc a prnd (v bound));
let res = frodo_sample_res a sign sample0 in
pop_frame();
res
#pop-options
inline_for_extraction noextract
val frodo_sample_matrix1:
a:FP.frodo_alg
-> frodo_sample:frodo_sample_st a
-> n1:size_t
-> n2:size_t{0 < 2 * v n1 * v n2 /\ 2 * v n1 * v n2 <= max_size_t}
-> r:lbuffer uint8 (size 2 *! n1 *! n2)
-> i:size_t{v i < v n1}
-> res:matrix_t n1 n2
-> Stack unit
(requires fun h ->
live h r /\ live h res /\ disjoint r res)
(ensures fun h0 _ h1 -> modifies1 res h0 h1 /\
as_matrix h1 res ==
S.frodo_sample_matrix1 a (v n1) (v n2) (as_seq h0 r) (v i) (as_matrix h0 res))
let frodo_sample_matrix1 a frodo_sample n1 n2 r i res =
[@ inline_let]
let spec h0 = S.frodo_sample_matrix0 a (v n1) (v n2) (as_seq h0 r) (v i) in
let h0 = ST.get () in
loop1 h0 n2 res spec
(fun j ->
Loops.unfold_repeati (v n2) (spec h0) (as_seq h0 res) (v j);
Lemmas.lemma_matrix_index_repeati1 (v n1) (v n2) (v i) (v j);
let resij = sub r (size 2 *! (n2 *! i +! j)) (size 2) in
mset res i j (frodo_sample (uint_from_bytes_le #U16 resij))
)
inline_for_extraction noextract
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 h1 /\
as_matrix h1 res == S.frodo_sample_matrix a (v n1) (v n2) (as_seq h0 r))
inline_for_extraction noextract
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 =
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);
frodo_sample_matrix1 a frodo_sample n1 n2 r i res
)
[@CInline]
let frodo_sample_matrix64 : frodo_sample_matrix_st FP.Frodo64 =
frodo_sample_matrix_ FP.Frodo64 (frodo_sample FP.Frodo64)
[@CInline] | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Matrix.fst.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Frodo.Sample.fst"
} | [
"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.Frodo.Lemmas
module S = Spec.Frodo.Sample
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
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 =
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
inline_for_extraction noextract
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 =
Lemmas.lemma_frodo_sample2 sign sample;
((lognot sign +. u16 1) ^. sample) +. sign
inline_for_extraction noextract
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)
#push-options "--fuel 1"
inline_for_extraction noextract
val frodo_sample: a:FP.frodo_alg -> frodo_sample_st a
let frodo_sample a r =
push_frame();
let prnd = r >>. 1ul in
let sign = r &. u16 1 in
mod_mask_lemma r 1ul;
assert (v #U16 #SEC (mod_mask 1ul) == 1);
assert (v sign == 0 \/ v sign == 1);
let sample :lbuffer uint16 1ul = create (size 1) (u16 0) in
let h = ST.get () in
assert (LSeq.index #_ #1 (as_seq h sample) 0 == u16 0);
assert (bget h sample 0 == u16 0);
let bound = cdf_table_len a -! 1ul in
let h0 = ST.get () in
Lib.Loops.for 0ul bound
(fun h i ->
modifies1 sample h0 h /\
v (bget h sample 0) == S.frodo_sample_fc a prnd i)
(fun i ->
let sample0 = sample.(0ul) in
let samplei = frodo_sample_f a prnd i in
sample.(0ul) <- samplei +. sample0
);
let sample0 = sample.(0ul) in
assert (v sample0 == S.frodo_sample_fc a prnd (v bound));
let res = frodo_sample_res a sign sample0 in
pop_frame();
res
#pop-options
inline_for_extraction noextract
val frodo_sample_matrix1:
a:FP.frodo_alg
-> frodo_sample:frodo_sample_st a
-> n1:size_t
-> n2:size_t{0 < 2 * v n1 * v n2 /\ 2 * v n1 * v n2 <= max_size_t}
-> r:lbuffer uint8 (size 2 *! n1 *! n2)
-> i:size_t{v i < v n1}
-> res:matrix_t n1 n2
-> Stack unit
(requires fun h ->
live h r /\ live h res /\ disjoint r res)
(ensures fun h0 _ h1 -> modifies1 res h0 h1 /\
as_matrix h1 res ==
S.frodo_sample_matrix1 a (v n1) (v n2) (as_seq h0 r) (v i) (as_matrix h0 res))
let frodo_sample_matrix1 a frodo_sample n1 n2 r i res =
[@ inline_let]
let spec h0 = S.frodo_sample_matrix0 a (v n1) (v n2) (as_seq h0 r) (v i) in
let h0 = ST.get () in
loop1 h0 n2 res spec
(fun j ->
Loops.unfold_repeati (v n2) (spec h0) (as_seq h0 res) (v j);
Lemmas.lemma_matrix_index_repeati1 (v n1) (v n2) (v i) (v j);
let resij = sub r (size 2 *! (n2 *! i +! j)) (size 2) in
mset res i j (frodo_sample (uint_from_bytes_le #U16 resij))
)
inline_for_extraction noextract
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 h1 /\
as_matrix h1 res == S.frodo_sample_matrix a (v n1) (v n2) (as_seq h0 r))
inline_for_extraction noextract
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 =
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);
frodo_sample_matrix1 a frodo_sample n1 n2 r i res
)
[@CInline]
let frodo_sample_matrix64 : frodo_sample_matrix_st FP.Frodo64 =
frodo_sample_matrix_ FP.Frodo64 (frodo_sample FP.Frodo64)
[@CInline]
let frodo_sample_matrix640 : frodo_sample_matrix_st FP.Frodo640 =
frodo_sample_matrix_ FP.Frodo640 (frodo_sample FP.Frodo640)
[@CInline] | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Matrix.fst.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Frodo.Sample.fst"
} | [
"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.Frodo.Lemmas
module S = Spec.Frodo.Sample
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
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 =
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
inline_for_extraction noextract
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 =
Lemmas.lemma_frodo_sample2 sign sample;
((lognot sign +. u16 1) ^. sample) +. sign
inline_for_extraction noextract
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)
#push-options "--fuel 1"
inline_for_extraction noextract
val frodo_sample: a:FP.frodo_alg -> frodo_sample_st a
let frodo_sample a r =
push_frame();
let prnd = r >>. 1ul in
let sign = r &. u16 1 in
mod_mask_lemma r 1ul;
assert (v #U16 #SEC (mod_mask 1ul) == 1);
assert (v sign == 0 \/ v sign == 1);
let sample :lbuffer uint16 1ul = create (size 1) (u16 0) in
let h = ST.get () in
assert (LSeq.index #_ #1 (as_seq h sample) 0 == u16 0);
assert (bget h sample 0 == u16 0);
let bound = cdf_table_len a -! 1ul in
let h0 = ST.get () in
Lib.Loops.for 0ul bound
(fun h i ->
modifies1 sample h0 h /\
v (bget h sample 0) == S.frodo_sample_fc a prnd i)
(fun i ->
let sample0 = sample.(0ul) in
let samplei = frodo_sample_f a prnd i in
sample.(0ul) <- samplei +. sample0
);
let sample0 = sample.(0ul) in
assert (v sample0 == S.frodo_sample_fc a prnd (v bound));
let res = frodo_sample_res a sign sample0 in
pop_frame();
res
#pop-options
inline_for_extraction noextract
val frodo_sample_matrix1:
a:FP.frodo_alg
-> frodo_sample:frodo_sample_st a
-> n1:size_t
-> n2:size_t{0 < 2 * v n1 * v n2 /\ 2 * v n1 * v n2 <= max_size_t}
-> r:lbuffer uint8 (size 2 *! n1 *! n2)
-> i:size_t{v i < v n1}
-> res:matrix_t n1 n2
-> Stack unit
(requires fun h ->
live h r /\ live h res /\ disjoint r res)
(ensures fun h0 _ h1 -> modifies1 res h0 h1 /\
as_matrix h1 res ==
S.frodo_sample_matrix1 a (v n1) (v n2) (as_seq h0 r) (v i) (as_matrix h0 res))
let frodo_sample_matrix1 a frodo_sample n1 n2 r i res =
[@ inline_let]
let spec h0 = S.frodo_sample_matrix0 a (v n1) (v n2) (as_seq h0 r) (v i) in
let h0 = ST.get () in
loop1 h0 n2 res spec
(fun j ->
Loops.unfold_repeati (v n2) (spec h0) (as_seq h0 res) (v j);
Lemmas.lemma_matrix_index_repeati1 (v n1) (v n2) (v i) (v j);
let resij = sub r (size 2 *! (n2 *! i +! j)) (size 2) in
mset res i j (frodo_sample (uint_from_bytes_le #U16 resij))
)
inline_for_extraction noextract
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 h1 /\
as_matrix h1 res == S.frodo_sample_matrix a (v n1) (v n2) (as_seq h0 r))
inline_for_extraction noextract
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 =
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);
frodo_sample_matrix1 a frodo_sample n1 n2 r i res
)
[@CInline] | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Matrix.fst.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Frodo.Sample.fst"
} | [
"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.Frodo.Lemmas
module S = Spec.Frodo.Sample
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
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 =
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
inline_for_extraction noextract
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 =
Lemmas.lemma_frodo_sample2 sign sample;
((lognot sign +. u16 1) ^. sample) +. sign
inline_for_extraction noextract
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)
#push-options "--fuel 1"
inline_for_extraction noextract
val frodo_sample: a:FP.frodo_alg -> frodo_sample_st a
let frodo_sample a r =
push_frame();
let prnd = r >>. 1ul in
let sign = r &. u16 1 in
mod_mask_lemma r 1ul;
assert (v #U16 #SEC (mod_mask 1ul) == 1);
assert (v sign == 0 \/ v sign == 1);
let sample :lbuffer uint16 1ul = create (size 1) (u16 0) in
let h = ST.get () in
assert (LSeq.index #_ #1 (as_seq h sample) 0 == u16 0);
assert (bget h sample 0 == u16 0);
let bound = cdf_table_len a -! 1ul in
let h0 = ST.get () in
Lib.Loops.for 0ul bound
(fun h i ->
modifies1 sample h0 h /\
v (bget h sample 0) == S.frodo_sample_fc a prnd i)
(fun i ->
let sample0 = sample.(0ul) in
let samplei = frodo_sample_f a prnd i in
sample.(0ul) <- samplei +. sample0
);
let sample0 = sample.(0ul) in
assert (v sample0 == S.frodo_sample_fc a prnd (v bound));
let res = frodo_sample_res a sign sample0 in
pop_frame();
res
#pop-options
inline_for_extraction noextract
val frodo_sample_matrix1:
a:FP.frodo_alg
-> frodo_sample:frodo_sample_st a
-> n1:size_t
-> n2:size_t{0 < 2 * v n1 * v n2 /\ 2 * v n1 * v n2 <= max_size_t}
-> r:lbuffer uint8 (size 2 *! n1 *! n2)
-> i:size_t{v i < v n1}
-> res:matrix_t n1 n2
-> Stack unit
(requires fun h ->
live h r /\ live h res /\ disjoint r res)
(ensures fun h0 _ h1 -> modifies1 res h0 h1 /\
as_matrix h1 res ==
S.frodo_sample_matrix1 a (v n1) (v n2) (as_seq h0 r) (v i) (as_matrix h0 res))
let frodo_sample_matrix1 a frodo_sample n1 n2 r i res =
[@ inline_let]
let spec h0 = S.frodo_sample_matrix0 a (v n1) (v n2) (as_seq h0 r) (v i) in
let h0 = ST.get () in
loop1 h0 n2 res spec
(fun j ->
Loops.unfold_repeati (v n2) (spec h0) (as_seq h0 res) (v j);
Lemmas.lemma_matrix_index_repeati1 (v n1) (v n2) (v i) (v j);
let resij = sub r (size 2 *! (n2 *! i +! j)) (size 2) in
mset res i j (frodo_sample (uint_from_bytes_le #U16 resij))
)
inline_for_extraction noextract
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 h1 /\
as_matrix h1 res == S.frodo_sample_matrix a (v n1) (v n2) (as_seq h0 r))
inline_for_extraction noextract
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 =
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);
frodo_sample_matrix1 a frodo_sample n1 n2 r i res
)
[@CInline]
let frodo_sample_matrix64 : frodo_sample_matrix_st FP.Frodo64 =
frodo_sample_matrix_ FP.Frodo64 (frodo_sample FP.Frodo64)
[@CInline]
let frodo_sample_matrix640 : frodo_sample_matrix_st FP.Frodo640 =
frodo_sample_matrix_ FP.Frodo640 (frodo_sample FP.Frodo640)
[@CInline]
let frodo_sample_matrix976 : frodo_sample_matrix_st FP.Frodo976 =
frodo_sample_matrix_ FP.Frodo976 (frodo_sample FP.Frodo976)
[@CInline]
let frodo_sample_matrix1344 : frodo_sample_matrix_st FP.Frodo1344=
frodo_sample_matrix_ FP.Frodo1344 (frodo_sample FP.Frodo1344)
inline_for_extraction noextract | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Matrix.fst.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Frodo.Sample.fst"
} | [
"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.IntTypes.op_Hat_Dot",
"Lib.IntTypes.lognot",
"Lib.IntTypes.u16",
"Prims.unit",
"Spec.Frodo.Lemmas.lemma_frodo_sample2",
"Prims.eq2",
"Spec.Frodo.Sample.frodo_sample_res"
] | [] | 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.Frodo.Lemmas
module S = Spec.Frodo.Sample
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
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 =
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
inline_for_extraction noextract
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)} | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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.IntTypes.v sample)} | {
"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_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 h1 /\
as_matrix h1 res == S.frodo_sample_matrix a (v n1) (v n2) (as_seq h0 r)) | 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 /\
as_matrix h1 res == S.frodo_sample_matrix a (v n1) (v n2) (as_seq h0 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",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Matrix.fst.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Frodo.Sample.fst"
} | [
"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",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.Matrix.matrix_t",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint8",
"Hacl.Impl.Matrix.elem",
"Lib.Buffer.disjoint",
"Lib.Buffer.modifies1",
"Prims.eq2",
"Spec.Matrix.matrix",
"Hacl.Impl.Matrix.as_matrix",
"Spec.Frodo.Sample.frodo_sample_matrix",
"Lib.Buffer.as_seq"
] | [] | 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.Frodo.Lemmas
module S = Spec.Frodo.Sample
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
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 =
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
inline_for_extraction noextract
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 =
Lemmas.lemma_frodo_sample2 sign sample;
((lognot sign +. u16 1) ^. sample) +. sign
inline_for_extraction noextract
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)
#push-options "--fuel 1"
inline_for_extraction noextract
val frodo_sample: a:FP.frodo_alg -> frodo_sample_st a
let frodo_sample a r =
push_frame();
let prnd = r >>. 1ul in
let sign = r &. u16 1 in
mod_mask_lemma r 1ul;
assert (v #U16 #SEC (mod_mask 1ul) == 1);
assert (v sign == 0 \/ v sign == 1);
let sample :lbuffer uint16 1ul = create (size 1) (u16 0) in
let h = ST.get () in
assert (LSeq.index #_ #1 (as_seq h sample) 0 == u16 0);
assert (bget h sample 0 == u16 0);
let bound = cdf_table_len a -! 1ul in
let h0 = ST.get () in
Lib.Loops.for 0ul bound
(fun h i ->
modifies1 sample h0 h /\
v (bget h sample 0) == S.frodo_sample_fc a prnd i)
(fun i ->
let sample0 = sample.(0ul) in
let samplei = frodo_sample_f a prnd i in
sample.(0ul) <- samplei +. sample0
);
let sample0 = sample.(0ul) in
assert (v sample0 == S.frodo_sample_fc a prnd (v bound));
let res = frodo_sample_res a sign sample0 in
pop_frame();
res
#pop-options
inline_for_extraction noextract
val frodo_sample_matrix1:
a:FP.frodo_alg
-> frodo_sample:frodo_sample_st a
-> n1:size_t
-> n2:size_t{0 < 2 * v n1 * v n2 /\ 2 * v n1 * v n2 <= max_size_t}
-> r:lbuffer uint8 (size 2 *! n1 *! n2)
-> i:size_t{v i < v n1}
-> res:matrix_t n1 n2
-> Stack unit
(requires fun h ->
live h r /\ live h res /\ disjoint r res)
(ensures fun h0 _ h1 -> modifies1 res h0 h1 /\
as_matrix h1 res ==
S.frodo_sample_matrix1 a (v n1) (v n2) (as_seq h0 r) (v i) (as_matrix h0 res))
let frodo_sample_matrix1 a frodo_sample n1 n2 r i res =
[@ inline_let]
let spec h0 = S.frodo_sample_matrix0 a (v n1) (v n2) (as_seq h0 r) (v i) in
let h0 = ST.get () in
loop1 h0 n2 res spec
(fun j ->
Loops.unfold_repeati (v n2) (spec h0) (as_seq h0 res) (v j);
Lemmas.lemma_matrix_index_repeati1 (v n1) (v n2) (v i) (v j);
let resij = sub r (size 2 *! (n2 *! i +! j)) (size 2) in
mset res i j (frodo_sample (uint_from_bytes_le #U16 resij))
)
inline_for_extraction noextract | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Matrix.fst.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Frodo.Sample.fst"
} | [] | [
"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.IntTypes.op_Greater_Greater_Dot",
"Lib.IntTypes.to_u16",
"Lib.IntTypes.to_u32",
"Lib.IntTypes.op_Subtraction_Dot",
"FStar.UInt32.__uint_to_t",
"Prims.unit",
"Spec.Frodo.Lemmas.lemma_frodo_sample",
"Spec.Frodo.Params.lemma_cdf_list",
"Lib.IntTypes.int_t",
"Lib.Buffer.index",
"Lib.Buffer.CONST",
"Hacl.Impl.Frodo.Params.cdf_table",
"Lib.Buffer.recall_contents",
"Spec.Frodo.Params.cdf_table"
] | [] | 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.Frodo.Lemmas
module S = Spec.Frodo.Sample
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 ->
Loops.unfold_repeati (v n1) (spec h0) (as_seq h0 res) (v i);
frodo_sample_matrix1 a frodo_sample n1 n2 r i res
) | 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);
frodo_sample_matrix1 a frodo_sample n1 n2 r i res) | {
"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",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Matrix.fst.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Frodo.Sample.fst"
} | [
"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.Matrix.lbytes",
"Lib.IntTypes.op_Star_Bang",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.Matrix.matrix_t",
"Lib.Buffer.loop1",
"Hacl.Impl.Matrix.elem",
"Hacl.Impl.Frodo.Sample.frodo_sample_matrix1",
"Prims.unit",
"Lib.LoopCombinators.unfold_repeati",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U16",
"Lib.IntTypes.SEC",
"Prims.op_Multiply",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"FStar.Monotonic.HyperStack.mem",
"Prims.nat",
"Prims.op_Subtraction",
"Prims.pow2",
"Spec.Frodo.Sample.frodo_sample_matrix1",
"Lib.IntTypes.uint8",
"Lib.Sequence.eq_intro",
"Lib.Sequence.sub",
"FStar.HyperStack.ST.get",
"Lib.Buffer.memset",
"Lib.IntTypes.u16"
] | [] | 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.Frodo.Lemmas
module S = Spec.Frodo.Sample
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
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 =
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
inline_for_extraction noextract
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 =
Lemmas.lemma_frodo_sample2 sign sample;
((lognot sign +. u16 1) ^. sample) +. sign
inline_for_extraction noextract
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)
#push-options "--fuel 1"
inline_for_extraction noextract
val frodo_sample: a:FP.frodo_alg -> frodo_sample_st a
let frodo_sample a r =
push_frame();
let prnd = r >>. 1ul in
let sign = r &. u16 1 in
mod_mask_lemma r 1ul;
assert (v #U16 #SEC (mod_mask 1ul) == 1);
assert (v sign == 0 \/ v sign == 1);
let sample :lbuffer uint16 1ul = create (size 1) (u16 0) in
let h = ST.get () in
assert (LSeq.index #_ #1 (as_seq h sample) 0 == u16 0);
assert (bget h sample 0 == u16 0);
let bound = cdf_table_len a -! 1ul in
let h0 = ST.get () in
Lib.Loops.for 0ul bound
(fun h i ->
modifies1 sample h0 h /\
v (bget h sample 0) == S.frodo_sample_fc a prnd i)
(fun i ->
let sample0 = sample.(0ul) in
let samplei = frodo_sample_f a prnd i in
sample.(0ul) <- samplei +. sample0
);
let sample0 = sample.(0ul) in
assert (v sample0 == S.frodo_sample_fc a prnd (v bound));
let res = frodo_sample_res a sign sample0 in
pop_frame();
res
#pop-options
inline_for_extraction noextract
val frodo_sample_matrix1:
a:FP.frodo_alg
-> frodo_sample:frodo_sample_st a
-> n1:size_t
-> n2:size_t{0 < 2 * v n1 * v n2 /\ 2 * v n1 * v n2 <= max_size_t}
-> r:lbuffer uint8 (size 2 *! n1 *! n2)
-> i:size_t{v i < v n1}
-> res:matrix_t n1 n2
-> Stack unit
(requires fun h ->
live h r /\ live h res /\ disjoint r res)
(ensures fun h0 _ h1 -> modifies1 res h0 h1 /\
as_matrix h1 res ==
S.frodo_sample_matrix1 a (v n1) (v n2) (as_seq h0 r) (v i) (as_matrix h0 res))
let frodo_sample_matrix1 a frodo_sample n1 n2 r i res =
[@ inline_let]
let spec h0 = S.frodo_sample_matrix0 a (v n1) (v n2) (as_seq h0 r) (v i) in
let h0 = ST.get () in
loop1 h0 n2 res spec
(fun j ->
Loops.unfold_repeati (v n2) (spec h0) (as_seq h0 res) (v j);
Lemmas.lemma_matrix_index_repeati1 (v n1) (v n2) (v i) (v j);
let resij = sub r (size 2 *! (n2 *! i +! j)) (size 2) in
mset res i j (frodo_sample (uint_from_bytes_le #U16 resij))
)
inline_for_extraction noextract
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 h1 /\
as_matrix h1 res == S.frodo_sample_matrix a (v n1) (v n2) (as_seq h0 r))
inline_for_extraction noextract
val frodo_sample_matrix_:
a:FP.frodo_alg
-> frodo_sample:frodo_sample_st a
-> frodo_sample_matrix_st a | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val 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 saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.