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.HyperStack.ST.Stack | val verify:
public_key:lbuffer uint8 32ul
-> msg_len:size_t
-> msg:lbuffer uint8 msg_len
-> signature:lbuffer uint8 64ul ->
Stack bool
(requires fun h -> live h public_key /\ live h msg /\ live h signature)
(ensures fun h0 b h1 -> modifies0 h0 h1 /\
b == Spec.Ed25519.verify (as_seq h0 public_key) (as_seq h0 msg) (as_seq h0 signature)) | [
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"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": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": 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 verify public_key msg_len msg signature =
Hacl.Ed25519.verify public_key msg_len msg signature | val verify:
public_key:lbuffer uint8 32ul
-> msg_len:size_t
-> msg:lbuffer uint8 msg_len
-> signature:lbuffer uint8 64ul ->
Stack bool
(requires fun h -> live h public_key /\ live h msg /\ live h signature)
(ensures fun h0 b h1 -> modifies0 h0 h1 /\
b == Spec.Ed25519.verify (as_seq h0 public_key) (as_seq h0 msg) (as_seq h0 signature))
let verify public_key msg_len msg signature = | true | null | false | Hacl.Ed25519.verify public_key msg_len msg signature | {
"checked_file": "EverCrypt.Ed25519.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Ed25519.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "EverCrypt.Ed25519.fst"
} | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.size_t",
"Hacl.Ed25519.verify",
"Prims.bool"
] | [] | module EverCrypt.Ed25519
/// For now, only one implementation... to be improved in the future.
let secret_to_public public_key private_key =
Hacl.Ed25519.secret_to_public public_key private_key
let expand_keys expanded_keys private_key =
Hacl.Ed25519.expand_keys expanded_keys private_key
let sign_expanded signature expanded_keys msg_len msg =
Hacl.Ed25519.sign_expanded signature expanded_keys msg_len msg
let sign signature private_key msg_len msg =
Hacl.Ed25519.sign signature private_key msg_len msg | false | false | EverCrypt.Ed25519.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 verify:
public_key:lbuffer uint8 32ul
-> msg_len:size_t
-> msg:lbuffer uint8 msg_len
-> signature:lbuffer uint8 64ul ->
Stack bool
(requires fun h -> live h public_key /\ live h msg /\ live h signature)
(ensures fun h0 b h1 -> modifies0 h0 h1 /\
b == Spec.Ed25519.verify (as_seq h0 public_key) (as_seq h0 msg) (as_seq h0 signature)) | [] | EverCrypt.Ed25519.verify | {
"file_name": "providers/evercrypt/fst/EverCrypt.Ed25519.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
public_key: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul ->
msg_len: Lib.IntTypes.size_t ->
msg: Lib.Buffer.lbuffer Lib.IntTypes.uint8 msg_len ->
signature: Lib.Buffer.lbuffer Lib.IntTypes.uint8 64ul
-> FStar.HyperStack.ST.Stack Prims.bool | {
"end_col": 54,
"end_line": 18,
"start_col": 2,
"start_line": 18
} |
FStar.HyperStack.ST.Stack | val sign_expanded:
signature:lbuffer uint8 64ul
-> expanded_keys:lbuffer uint8 96ul
-> msg_len:size_t
-> msg:lbuffer uint8 msg_len ->
Stack unit
(requires fun h ->
live h signature /\ live h msg /\ live h expanded_keys /\
disjoint signature msg /\ disjoint signature expanded_keys)
(ensures fun h0 _ h1 -> modifies (loc signature) h0 h1 /\
as_seq h1 signature == Spec.Ed25519.sign_expanded
(as_seq h0 (gsub expanded_keys 0ul 32ul))
(as_seq h0 (gsub expanded_keys 32ul 32ul))
(as_seq h0 (gsub expanded_keys 64ul 32ul))
(as_seq h0 msg)) | [
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"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": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": 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 sign_expanded signature expanded_keys msg_len msg =
Hacl.Ed25519.sign_expanded signature expanded_keys msg_len msg | val sign_expanded:
signature:lbuffer uint8 64ul
-> expanded_keys:lbuffer uint8 96ul
-> msg_len:size_t
-> msg:lbuffer uint8 msg_len ->
Stack unit
(requires fun h ->
live h signature /\ live h msg /\ live h expanded_keys /\
disjoint signature msg /\ disjoint signature expanded_keys)
(ensures fun h0 _ h1 -> modifies (loc signature) h0 h1 /\
as_seq h1 signature == Spec.Ed25519.sign_expanded
(as_seq h0 (gsub expanded_keys 0ul 32ul))
(as_seq h0 (gsub expanded_keys 32ul 32ul))
(as_seq h0 (gsub expanded_keys 64ul 32ul))
(as_seq h0 msg))
let sign_expanded signature expanded_keys msg_len msg = | true | null | false | Hacl.Ed25519.sign_expanded signature expanded_keys msg_len msg | {
"checked_file": "EverCrypt.Ed25519.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Ed25519.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "EverCrypt.Ed25519.fst"
} | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.size_t",
"Hacl.Ed25519.sign_expanded",
"Prims.unit"
] | [] | module EverCrypt.Ed25519
/// For now, only one implementation... to be improved in the future.
let secret_to_public public_key private_key =
Hacl.Ed25519.secret_to_public public_key private_key
let expand_keys expanded_keys private_key =
Hacl.Ed25519.expand_keys expanded_keys private_key | false | false | EverCrypt.Ed25519.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 sign_expanded:
signature:lbuffer uint8 64ul
-> expanded_keys:lbuffer uint8 96ul
-> msg_len:size_t
-> msg:lbuffer uint8 msg_len ->
Stack unit
(requires fun h ->
live h signature /\ live h msg /\ live h expanded_keys /\
disjoint signature msg /\ disjoint signature expanded_keys)
(ensures fun h0 _ h1 -> modifies (loc signature) h0 h1 /\
as_seq h1 signature == Spec.Ed25519.sign_expanded
(as_seq h0 (gsub expanded_keys 0ul 32ul))
(as_seq h0 (gsub expanded_keys 32ul 32ul))
(as_seq h0 (gsub expanded_keys 64ul 32ul))
(as_seq h0 msg)) | [] | EverCrypt.Ed25519.sign_expanded | {
"file_name": "providers/evercrypt/fst/EverCrypt.Ed25519.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
signature: Lib.Buffer.lbuffer Lib.IntTypes.uint8 64ul ->
expanded_keys: Lib.Buffer.lbuffer Lib.IntTypes.uint8 96ul ->
msg_len: Lib.IntTypes.size_t ->
msg: Lib.Buffer.lbuffer Lib.IntTypes.uint8 msg_len
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 64,
"end_line": 12,
"start_col": 2,
"start_line": 12
} |
FStar.HyperStack.ST.Stack | val expand_keys:
expanded_keys:lbuffer uint8 96ul
-> private_key:lbuffer uint8 32ul ->
Stack unit
(requires fun h ->
live h expanded_keys /\ live h private_key /\ disjoint expanded_keys private_key)
(ensures fun h0 _ h1 -> modifies (loc expanded_keys) h0 h1 /\
(let public_key, s, prefix = Spec.Ed25519.expand_keys (as_seq h0 private_key) in
as_seq h1 (gsub expanded_keys 0ul 32ul) == public_key /\
as_seq h1 (gsub expanded_keys 32ul 32ul) == s /\
as_seq h1 (gsub expanded_keys 64ul 32ul) == prefix)) | [
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"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": "EverCrypt",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt",
"short_module": null
},
{
"abbrev": 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_keys expanded_keys private_key =
Hacl.Ed25519.expand_keys expanded_keys private_key | val expand_keys:
expanded_keys:lbuffer uint8 96ul
-> private_key:lbuffer uint8 32ul ->
Stack unit
(requires fun h ->
live h expanded_keys /\ live h private_key /\ disjoint expanded_keys private_key)
(ensures fun h0 _ h1 -> modifies (loc expanded_keys) h0 h1 /\
(let public_key, s, prefix = Spec.Ed25519.expand_keys (as_seq h0 private_key) in
as_seq h1 (gsub expanded_keys 0ul 32ul) == public_key /\
as_seq h1 (gsub expanded_keys 32ul 32ul) == s /\
as_seq h1 (gsub expanded_keys 64ul 32ul) == prefix))
let expand_keys expanded_keys private_key = | true | null | false | Hacl.Ed25519.expand_keys expanded_keys private_key | {
"checked_file": "EverCrypt.Ed25519.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Ed25519.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "EverCrypt.Ed25519.fst"
} | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Hacl.Ed25519.expand_keys",
"Prims.unit"
] | [] | module EverCrypt.Ed25519
/// For now, only one implementation... to be improved in the future.
let secret_to_public public_key private_key =
Hacl.Ed25519.secret_to_public public_key private_key | false | false | EverCrypt.Ed25519.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 expand_keys:
expanded_keys:lbuffer uint8 96ul
-> private_key:lbuffer uint8 32ul ->
Stack unit
(requires fun h ->
live h expanded_keys /\ live h private_key /\ disjoint expanded_keys private_key)
(ensures fun h0 _ h1 -> modifies (loc expanded_keys) h0 h1 /\
(let public_key, s, prefix = Spec.Ed25519.expand_keys (as_seq h0 private_key) in
as_seq h1 (gsub expanded_keys 0ul 32ul) == public_key /\
as_seq h1 (gsub expanded_keys 32ul 32ul) == s /\
as_seq h1 (gsub expanded_keys 64ul 32ul) == prefix)) | [] | EverCrypt.Ed25519.expand_keys | {
"file_name": "providers/evercrypt/fst/EverCrypt.Ed25519.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
expanded_keys: Lib.Buffer.lbuffer Lib.IntTypes.uint8 96ul ->
private_key: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 52,
"end_line": 9,
"start_col": 2,
"start_line": 9
} |
Prims.Tot | val exists_intro
(a:Type)
(p:a -> Type)
(v:a)
(x: unit -> Tot (squash (p v)))
: Tot (squash (exists x. p x)) | [
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": 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 exists_intro
(a:Type)
(p:a -> Type)
(v:a)
(f: unit -> Tot (squash (p v)))
: Tot (squash (exists x. p x))
= exists_intro_simple a p v (f()) | val exists_intro
(a:Type)
(p:a -> Type)
(v:a)
(x: unit -> Tot (squash (p v)))
: Tot (squash (exists x. p x))
let exists_intro (a: Type) (p: (a -> Type)) (v: a) (f: (unit -> Tot (squash (p v))))
: Tot (squash (exists x. p x)) = | false | null | true | exists_intro_simple a p v (f ()) | {
"checked_file": "FStar.Classical.Sugar.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Classical.Sugar.fst"
} | [
"total"
] | [
"Prims.unit",
"Prims.squash",
"FStar.Classical.Sugar.exists_intro_simple",
"Prims.l_Exists"
] | [] | (*
Copyright 2021 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 FStar.Classical.Sugar
/// This module provides a few combinators that are targeted
/// by the desugaring phase of the F* front end
let forall_elim
(#a:Type)
(#p:a -> Type)
(v:a)
(f:squash (forall (x:a). p x))
: Tot (squash (p v))
= ()
let exists_elim #t #p #q s_ex_p f
= let open FStar.Squash in
bind_squash s_ex_p (fun ex_p ->
bind_squash ex_p (fun (sig_p: (x:t & p x)) ->
let (| x, px |) = sig_p in
f x (return_squash px)))
let or_elim_simple
(p:Type)
(q:Type)
(r:Type)
(x:squash (p \/ q))
(f:squash p -> Tot (squash r))
(g:squash q -> Tot (squash r))
: Tot (squash r)
= let open FStar.Squash in
bind_squash x (fun p_or_q ->
bind_squash p_or_q (fun p_cor_q ->
match p_cor_q with
| Prims.Left p ->
f (return_squash p)
| Prims.Right q ->
g (return_squash q)))
let or_elim
(p:Type)
(q:squash (~p) -> Type)
(r:Type)
(p_or:squash (p \/ q()))
(left:squash p -> Tot (squash r))
(right:squash (~p) -> squash (q()) -> Tot (squash r))
: Tot (squash r)
= or_elim_simple p (~p) r ()
(fun (s:squash p) -> left s)
(fun (np:squash (~p)) ->
or_elim_simple p (q ()) r p_or
(fun (pf_p:squash p) -> left pf_p)
(fun (pf_q:squash (q())) -> right np pf_q))
let and_elim (p:Type)
(q:squash p -> Type)
(r:Type)
(x:squash (p /\ q()))
(f:squash p -> squash (q()) -> Tot (squash r))
: Tot (squash r)
= let open FStar.Squash in
bind_squash x (fun p_and_q ->
bind_squash p_and_q (fun (Prims.Pair p q) ->
f (return_squash p) (return_squash q)))
let forall_intro
(a:Type)
(p:a -> Type)
(f: (x:a -> Tot (squash (p x))))
: Tot (squash (forall x. p x))
= let open FStar.Squash in
let f' (x:a)
: GTot (squash (p x))
= f x
in
return_squash (squash_double_arrow (return_squash f'))
let exists_intro_simple
(a:Type)
(p:a -> Type)
(v:a)
(f: squash (p v))
: Tot (squash (exists x. p x))
= let open FStar.Squash in
let p = (| v, f |) in
squash_double_sum (return_squash p)
let exists_intro
(a:Type)
(p:a -> Type)
(v:a)
(f: unit -> Tot (squash (p v))) | false | false | FStar.Classical.Sugar.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 exists_intro
(a:Type)
(p:a -> Type)
(v:a)
(x: unit -> Tot (squash (p v)))
: Tot (squash (exists x. p x)) | [] | FStar.Classical.Sugar.exists_intro | {
"file_name": "ulib/FStar.Classical.Sugar.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: Type -> p: (_: a -> Type0) -> v: a -> x: (_: Prims.unit -> Prims.squash (p v))
-> Prims.squash (exists (x: a). p x) | {
"end_col": 35,
"end_line": 107,
"start_col": 4,
"start_line": 107
} |
Prims.Tot | val forall_intro
(a:Type)
(p:a -> Type)
(f: (x:a -> Tot (squash (p x))))
: Tot (squash (forall x. p x)) | [
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": 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 forall_intro
(a:Type)
(p:a -> Type)
(f: (x:a -> Tot (squash (p x))))
: Tot (squash (forall x. p x))
= let open FStar.Squash in
let f' (x:a)
: GTot (squash (p x))
= f x
in
return_squash (squash_double_arrow (return_squash f')) | val forall_intro
(a:Type)
(p:a -> Type)
(f: (x:a -> Tot (squash (p x))))
: Tot (squash (forall x. p x))
let forall_intro (a: Type) (p: (a -> Type)) (f: (x: a -> Tot (squash (p x))))
: Tot (squash (forall x. p x)) = | false | null | true | let open FStar.Squash in
let f' (x: a) : GTot (squash (p x)) = f x in
return_squash (squash_double_arrow (return_squash f')) | {
"checked_file": "FStar.Classical.Sugar.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Classical.Sugar.fst"
} | [
"total"
] | [
"Prims.squash",
"FStar.Squash.return_squash",
"Prims.l_Forall",
"FStar.Squash.squash_double_arrow"
] | [] | (*
Copyright 2021 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 FStar.Classical.Sugar
/// This module provides a few combinators that are targeted
/// by the desugaring phase of the F* front end
let forall_elim
(#a:Type)
(#p:a -> Type)
(v:a)
(f:squash (forall (x:a). p x))
: Tot (squash (p v))
= ()
let exists_elim #t #p #q s_ex_p f
= let open FStar.Squash in
bind_squash s_ex_p (fun ex_p ->
bind_squash ex_p (fun (sig_p: (x:t & p x)) ->
let (| x, px |) = sig_p in
f x (return_squash px)))
let or_elim_simple
(p:Type)
(q:Type)
(r:Type)
(x:squash (p \/ q))
(f:squash p -> Tot (squash r))
(g:squash q -> Tot (squash r))
: Tot (squash r)
= let open FStar.Squash in
bind_squash x (fun p_or_q ->
bind_squash p_or_q (fun p_cor_q ->
match p_cor_q with
| Prims.Left p ->
f (return_squash p)
| Prims.Right q ->
g (return_squash q)))
let or_elim
(p:Type)
(q:squash (~p) -> Type)
(r:Type)
(p_or:squash (p \/ q()))
(left:squash p -> Tot (squash r))
(right:squash (~p) -> squash (q()) -> Tot (squash r))
: Tot (squash r)
= or_elim_simple p (~p) r ()
(fun (s:squash p) -> left s)
(fun (np:squash (~p)) ->
or_elim_simple p (q ()) r p_or
(fun (pf_p:squash p) -> left pf_p)
(fun (pf_q:squash (q())) -> right np pf_q))
let and_elim (p:Type)
(q:squash p -> Type)
(r:Type)
(x:squash (p /\ q()))
(f:squash p -> squash (q()) -> Tot (squash r))
: Tot (squash r)
= let open FStar.Squash in
bind_squash x (fun p_and_q ->
bind_squash p_and_q (fun (Prims.Pair p q) ->
f (return_squash p) (return_squash q)))
let forall_intro
(a:Type)
(p:a -> Type)
(f: (x:a -> Tot (squash (p x)))) | false | false | FStar.Classical.Sugar.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 forall_intro
(a:Type)
(p:a -> Type)
(f: (x:a -> Tot (squash (p x))))
: Tot (squash (forall x. p x)) | [] | FStar.Classical.Sugar.forall_intro | {
"file_name": "ulib/FStar.Classical.Sugar.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: Type -> p: (_: a -> Type0) -> f: (x: a -> Prims.squash (p x))
-> Prims.squash (forall (x: a). p x) | {
"end_col": 58,
"end_line": 89,
"start_col": 4,
"start_line": 84
} |
Prims.Tot | val exists_elim
(#t:Type)
(#p:t -> Type)
(#q:Type)
($s_ex_p: squash (exists (x:t). p x))
(f: (x:t -> squash (p x) -> Tot (squash q)))
: Tot (squash q) | [
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": 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 exists_elim #t #p #q s_ex_p f
= let open FStar.Squash in
bind_squash s_ex_p (fun ex_p ->
bind_squash ex_p (fun (sig_p: (x:t & p x)) ->
let (| x, px |) = sig_p in
f x (return_squash px))) | val exists_elim
(#t:Type)
(#p:t -> Type)
(#q:Type)
($s_ex_p: squash (exists (x:t). p x))
(f: (x:t -> squash (p x) -> Tot (squash q)))
: Tot (squash q)
let exists_elim #t #p #q s_ex_p f = | false | null | true | let open FStar.Squash in
bind_squash s_ex_p
(fun ex_p ->
bind_squash ex_p
(fun (sig_p: (x: t & p x)) ->
let (| x , px |) = sig_p in
f x (return_squash px))) | {
"checked_file": "FStar.Classical.Sugar.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Classical.Sugar.fst"
} | [
"total"
] | [
"Prims.squash",
"Prims.l_Exists",
"FStar.Squash.bind_squash",
"Prims.dtuple2",
"FStar.Squash.return_squash"
] | [] | (*
Copyright 2021 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 FStar.Classical.Sugar
/// This module provides a few combinators that are targeted
/// by the desugaring phase of the F* front end
let forall_elim
(#a:Type)
(#p:a -> Type)
(v:a)
(f:squash (forall (x:a). p x))
: Tot (squash (p v))
= () | false | false | FStar.Classical.Sugar.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 exists_elim
(#t:Type)
(#p:t -> Type)
(#q:Type)
($s_ex_p: squash (exists (x:t). p x))
(f: (x:t -> squash (p x) -> Tot (squash q)))
: Tot (squash q) | [] | FStar.Classical.Sugar.exists_elim | {
"file_name": "ulib/FStar.Classical.Sugar.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | $s_ex_p: Prims.squash (exists (x: t). p x) -> f: (x: t -> _: Prims.squash (p x) -> Prims.squash q)
-> Prims.squash q | {
"end_col": 28,
"end_line": 34,
"start_col": 4,
"start_line": 30
} |
Prims.Tot | val or_intro_left
(p:Type)
(q:squash (~p) -> Type)
(f:unit -> Tot (squash p))
: Tot (squash (p \/ q())) | [
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": 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 or_intro_left
(p:Type)
(q:squash (~p) -> Type)
(f:unit -> Tot (squash p))
: Tot (squash (p \/ q()))
= f() | val or_intro_left
(p:Type)
(q:squash (~p) -> Type)
(f:unit -> Tot (squash p))
: Tot (squash (p \/ q()))
let or_intro_left (p: Type) (q: (squash (~p) -> Type)) (f: (unit -> Tot (squash p)))
: Tot (squash (p \/ q ())) = | false | null | true | f () | {
"checked_file": "FStar.Classical.Sugar.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Classical.Sugar.fst"
} | [
"total"
] | [
"Prims.squash",
"Prims.l_not",
"Prims.unit",
"Prims.l_or"
] | [] | (*
Copyright 2021 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 FStar.Classical.Sugar
/// This module provides a few combinators that are targeted
/// by the desugaring phase of the F* front end
let forall_elim
(#a:Type)
(#p:a -> Type)
(v:a)
(f:squash (forall (x:a). p x))
: Tot (squash (p v))
= ()
let exists_elim #t #p #q s_ex_p f
= let open FStar.Squash in
bind_squash s_ex_p (fun ex_p ->
bind_squash ex_p (fun (sig_p: (x:t & p x)) ->
let (| x, px |) = sig_p in
f x (return_squash px)))
let or_elim_simple
(p:Type)
(q:Type)
(r:Type)
(x:squash (p \/ q))
(f:squash p -> Tot (squash r))
(g:squash q -> Tot (squash r))
: Tot (squash r)
= let open FStar.Squash in
bind_squash x (fun p_or_q ->
bind_squash p_or_q (fun p_cor_q ->
match p_cor_q with
| Prims.Left p ->
f (return_squash p)
| Prims.Right q ->
g (return_squash q)))
let or_elim
(p:Type)
(q:squash (~p) -> Type)
(r:Type)
(p_or:squash (p \/ q()))
(left:squash p -> Tot (squash r))
(right:squash (~p) -> squash (q()) -> Tot (squash r))
: Tot (squash r)
= or_elim_simple p (~p) r ()
(fun (s:squash p) -> left s)
(fun (np:squash (~p)) ->
or_elim_simple p (q ()) r p_or
(fun (pf_p:squash p) -> left pf_p)
(fun (pf_q:squash (q())) -> right np pf_q))
let and_elim (p:Type)
(q:squash p -> Type)
(r:Type)
(x:squash (p /\ q()))
(f:squash p -> squash (q()) -> Tot (squash r))
: Tot (squash r)
= let open FStar.Squash in
bind_squash x (fun p_and_q ->
bind_squash p_and_q (fun (Prims.Pair p q) ->
f (return_squash p) (return_squash q)))
let forall_intro
(a:Type)
(p:a -> Type)
(f: (x:a -> Tot (squash (p x))))
: Tot (squash (forall x. p x))
= let open FStar.Squash in
let f' (x:a)
: GTot (squash (p x))
= f x
in
return_squash (squash_double_arrow (return_squash f'))
let exists_intro_simple
(a:Type)
(p:a -> Type)
(v:a)
(f: squash (p v))
: Tot (squash (exists x. p x))
= let open FStar.Squash in
let p = (| v, f |) in
squash_double_sum (return_squash p)
let exists_intro
(a:Type)
(p:a -> Type)
(v:a)
(f: unit -> Tot (squash (p v)))
: Tot (squash (exists x. p x))
= exists_intro_simple a p v (f())
let implies_intro
(p:Type)
(q:squash p -> Type)
(f:(squash p -> Tot (squash (q()))))
: Tot (squash (p ==> q()))
= let open FStar.Squash in
let f' (x:p)
: GTot (squash (q ()))
= f (return_squash x)
in
return_squash (squash_double_arrow (return_squash f'))
let or_intro_left
(p:Type)
(q:squash (~p) -> Type)
(f:unit -> Tot (squash p)) | false | false | FStar.Classical.Sugar.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 or_intro_left
(p:Type)
(q:squash (~p) -> Type)
(f:unit -> Tot (squash p))
: Tot (squash (p \/ q())) | [] | FStar.Classical.Sugar.or_intro_left | {
"file_name": "ulib/FStar.Classical.Sugar.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | p: Type0 -> q: (_: Prims.squash (~p) -> Type0) -> f: (_: Prims.unit -> Prims.squash p)
-> Prims.squash (p \/ q ()) | {
"end_col": 7,
"end_line": 127,
"start_col": 4,
"start_line": 127
} |
Prims.Tot | val or_elim_simple
(p q r: Type)
(x: squash (p \/ q))
(f: (squash p -> Tot (squash r)))
(g: (squash q -> Tot (squash r)))
: Tot (squash r) | [
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": 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 or_elim_simple
(p:Type)
(q:Type)
(r:Type)
(x:squash (p \/ q))
(f:squash p -> Tot (squash r))
(g:squash q -> Tot (squash r))
: Tot (squash r)
= let open FStar.Squash in
bind_squash x (fun p_or_q ->
bind_squash p_or_q (fun p_cor_q ->
match p_cor_q with
| Prims.Left p ->
f (return_squash p)
| Prims.Right q ->
g (return_squash q))) | val or_elim_simple
(p q r: Type)
(x: squash (p \/ q))
(f: (squash p -> Tot (squash r)))
(g: (squash q -> Tot (squash r)))
: Tot (squash r)
let or_elim_simple
(p q r: Type)
(x: squash (p \/ q))
(f: (squash p -> Tot (squash r)))
(g: (squash q -> Tot (squash r)))
: Tot (squash r) = | false | null | true | let open FStar.Squash in
bind_squash x
(fun p_or_q ->
bind_squash p_or_q
(function
| Prims.Left p -> f (return_squash p)
| Prims.Right q -> g (return_squash q))) | {
"checked_file": "FStar.Classical.Sugar.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Classical.Sugar.fst"
} | [
"total"
] | [
"Prims.squash",
"Prims.l_or",
"FStar.Squash.bind_squash",
"Prims.sum",
"FStar.Squash.return_squash"
] | [] | (*
Copyright 2021 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 FStar.Classical.Sugar
/// This module provides a few combinators that are targeted
/// by the desugaring phase of the F* front end
let forall_elim
(#a:Type)
(#p:a -> Type)
(v:a)
(f:squash (forall (x:a). p x))
: Tot (squash (p v))
= ()
let exists_elim #t #p #q s_ex_p f
= let open FStar.Squash in
bind_squash s_ex_p (fun ex_p ->
bind_squash ex_p (fun (sig_p: (x:t & p x)) ->
let (| x, px |) = sig_p in
f x (return_squash px)))
let or_elim_simple
(p:Type)
(q:Type)
(r:Type)
(x:squash (p \/ q))
(f:squash p -> Tot (squash r))
(g:squash q -> Tot (squash r)) | false | false | FStar.Classical.Sugar.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 or_elim_simple
(p q r: Type)
(x: squash (p \/ q))
(f: (squash p -> Tot (squash r)))
(g: (squash q -> Tot (squash r)))
: Tot (squash r) | [] | FStar.Classical.Sugar.or_elim_simple | {
"file_name": "ulib/FStar.Classical.Sugar.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
p: Type0 ->
q: Type0 ->
r: Type ->
x: Prims.squash (p \/ q) ->
f: (_: Prims.squash p -> Prims.squash r) ->
g: (_: Prims.squash q -> Prims.squash r)
-> Prims.squash r | {
"end_col": 27,
"end_line": 51,
"start_col": 4,
"start_line": 44
} |
Prims.Tot | val exists_intro_simple (a: Type) (p: (a -> Type)) (v: a) (f: squash (p v))
: Tot (squash (exists x. p x)) | [
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": 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 exists_intro_simple
(a:Type)
(p:a -> Type)
(v:a)
(f: squash (p v))
: Tot (squash (exists x. p x))
= let open FStar.Squash in
let p = (| v, f |) in
squash_double_sum (return_squash p) | val exists_intro_simple (a: Type) (p: (a -> Type)) (v: a) (f: squash (p v))
: Tot (squash (exists x. p x))
let exists_intro_simple (a: Type) (p: (a -> Type)) (v: a) (f: squash (p v))
: Tot (squash (exists x. p x)) = | false | null | true | let open FStar.Squash in
let p = (| v, f |) in
squash_double_sum (return_squash p) | {
"checked_file": "FStar.Classical.Sugar.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Classical.Sugar.fst"
} | [
"total"
] | [
"Prims.squash",
"FStar.Squash.squash_double_sum",
"FStar.Squash.return_squash",
"Prims.dtuple2",
"Prims.Mkdtuple2",
"Prims.l_Exists"
] | [] | (*
Copyright 2021 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 FStar.Classical.Sugar
/// This module provides a few combinators that are targeted
/// by the desugaring phase of the F* front end
let forall_elim
(#a:Type)
(#p:a -> Type)
(v:a)
(f:squash (forall (x:a). p x))
: Tot (squash (p v))
= ()
let exists_elim #t #p #q s_ex_p f
= let open FStar.Squash in
bind_squash s_ex_p (fun ex_p ->
bind_squash ex_p (fun (sig_p: (x:t & p x)) ->
let (| x, px |) = sig_p in
f x (return_squash px)))
let or_elim_simple
(p:Type)
(q:Type)
(r:Type)
(x:squash (p \/ q))
(f:squash p -> Tot (squash r))
(g:squash q -> Tot (squash r))
: Tot (squash r)
= let open FStar.Squash in
bind_squash x (fun p_or_q ->
bind_squash p_or_q (fun p_cor_q ->
match p_cor_q with
| Prims.Left p ->
f (return_squash p)
| Prims.Right q ->
g (return_squash q)))
let or_elim
(p:Type)
(q:squash (~p) -> Type)
(r:Type)
(p_or:squash (p \/ q()))
(left:squash p -> Tot (squash r))
(right:squash (~p) -> squash (q()) -> Tot (squash r))
: Tot (squash r)
= or_elim_simple p (~p) r ()
(fun (s:squash p) -> left s)
(fun (np:squash (~p)) ->
or_elim_simple p (q ()) r p_or
(fun (pf_p:squash p) -> left pf_p)
(fun (pf_q:squash (q())) -> right np pf_q))
let and_elim (p:Type)
(q:squash p -> Type)
(r:Type)
(x:squash (p /\ q()))
(f:squash p -> squash (q()) -> Tot (squash r))
: Tot (squash r)
= let open FStar.Squash in
bind_squash x (fun p_and_q ->
bind_squash p_and_q (fun (Prims.Pair p q) ->
f (return_squash p) (return_squash q)))
let forall_intro
(a:Type)
(p:a -> Type)
(f: (x:a -> Tot (squash (p x))))
: Tot (squash (forall x. p x))
= let open FStar.Squash in
let f' (x:a)
: GTot (squash (p x))
= f x
in
return_squash (squash_double_arrow (return_squash f'))
let exists_intro_simple
(a:Type)
(p:a -> Type)
(v:a)
(f: squash (p v)) | false | false | FStar.Classical.Sugar.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 exists_intro_simple (a: Type) (p: (a -> Type)) (v: a) (f: squash (p v))
: Tot (squash (exists x. p x)) | [] | FStar.Classical.Sugar.exists_intro_simple | {
"file_name": "ulib/FStar.Classical.Sugar.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: Type -> p: (_: a -> Type0) -> v: a -> f: Prims.squash (p v) -> Prims.squash (exists (x: a). p x) | {
"end_col": 39,
"end_line": 99,
"start_col": 4,
"start_line": 97
} |
Prims.Tot | val or_intro_right
(p:Type)
(q:squash (~p) -> Type)
(f:squash (~p) -> Tot (squash (q())))
: Tot (squash (p \/ q())) | [
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": 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 or_intro_right
(p:Type)
(q:squash (~p) -> Type)
(f:squash (~p) -> Tot (squash (q())))
: Tot (squash (p \/ q()))
= or_elim_simple p (~p)
(p \/ q())
()
(fun s_p -> or_intro_left p q (fun _ -> s_p))
(fun s_np -> f s_np) | val or_intro_right
(p:Type)
(q:squash (~p) -> Type)
(f:squash (~p) -> Tot (squash (q())))
: Tot (squash (p \/ q()))
let or_intro_right (p: Type) (q: (squash (~p) -> Type)) (f: (squash (~p) -> Tot (squash (q ()))))
: Tot (squash (p \/ q ())) = | false | null | true | or_elim_simple p
(~p)
(p \/ q ())
()
(fun s_p -> or_intro_left p q (fun _ -> s_p))
(fun s_np -> f s_np) | {
"checked_file": "FStar.Classical.Sugar.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Classical.Sugar.fst"
} | [
"total"
] | [
"Prims.squash",
"Prims.l_not",
"FStar.Classical.Sugar.or_elim_simple",
"Prims.l_or",
"FStar.Classical.Sugar.or_intro_left",
"Prims.unit"
] | [] | (*
Copyright 2021 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 FStar.Classical.Sugar
/// This module provides a few combinators that are targeted
/// by the desugaring phase of the F* front end
let forall_elim
(#a:Type)
(#p:a -> Type)
(v:a)
(f:squash (forall (x:a). p x))
: Tot (squash (p v))
= ()
let exists_elim #t #p #q s_ex_p f
= let open FStar.Squash in
bind_squash s_ex_p (fun ex_p ->
bind_squash ex_p (fun (sig_p: (x:t & p x)) ->
let (| x, px |) = sig_p in
f x (return_squash px)))
let or_elim_simple
(p:Type)
(q:Type)
(r:Type)
(x:squash (p \/ q))
(f:squash p -> Tot (squash r))
(g:squash q -> Tot (squash r))
: Tot (squash r)
= let open FStar.Squash in
bind_squash x (fun p_or_q ->
bind_squash p_or_q (fun p_cor_q ->
match p_cor_q with
| Prims.Left p ->
f (return_squash p)
| Prims.Right q ->
g (return_squash q)))
let or_elim
(p:Type)
(q:squash (~p) -> Type)
(r:Type)
(p_or:squash (p \/ q()))
(left:squash p -> Tot (squash r))
(right:squash (~p) -> squash (q()) -> Tot (squash r))
: Tot (squash r)
= or_elim_simple p (~p) r ()
(fun (s:squash p) -> left s)
(fun (np:squash (~p)) ->
or_elim_simple p (q ()) r p_or
(fun (pf_p:squash p) -> left pf_p)
(fun (pf_q:squash (q())) -> right np pf_q))
let and_elim (p:Type)
(q:squash p -> Type)
(r:Type)
(x:squash (p /\ q()))
(f:squash p -> squash (q()) -> Tot (squash r))
: Tot (squash r)
= let open FStar.Squash in
bind_squash x (fun p_and_q ->
bind_squash p_and_q (fun (Prims.Pair p q) ->
f (return_squash p) (return_squash q)))
let forall_intro
(a:Type)
(p:a -> Type)
(f: (x:a -> Tot (squash (p x))))
: Tot (squash (forall x. p x))
= let open FStar.Squash in
let f' (x:a)
: GTot (squash (p x))
= f x
in
return_squash (squash_double_arrow (return_squash f'))
let exists_intro_simple
(a:Type)
(p:a -> Type)
(v:a)
(f: squash (p v))
: Tot (squash (exists x. p x))
= let open FStar.Squash in
let p = (| v, f |) in
squash_double_sum (return_squash p)
let exists_intro
(a:Type)
(p:a -> Type)
(v:a)
(f: unit -> Tot (squash (p v)))
: Tot (squash (exists x. p x))
= exists_intro_simple a p v (f())
let implies_intro
(p:Type)
(q:squash p -> Type)
(f:(squash p -> Tot (squash (q()))))
: Tot (squash (p ==> q()))
= let open FStar.Squash in
let f' (x:p)
: GTot (squash (q ()))
= f (return_squash x)
in
return_squash (squash_double_arrow (return_squash f'))
let or_intro_left
(p:Type)
(q:squash (~p) -> Type)
(f:unit -> Tot (squash p))
: Tot (squash (p \/ q()))
= f()
let or_intro_right
(p:Type)
(q:squash (~p) -> Type)
(f:squash (~p) -> Tot (squash (q()))) | false | false | FStar.Classical.Sugar.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 or_intro_right
(p:Type)
(q:squash (~p) -> Type)
(f:squash (~p) -> Tot (squash (q())))
: Tot (squash (p \/ q())) | [] | FStar.Classical.Sugar.or_intro_right | {
"file_name": "ulib/FStar.Classical.Sugar.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | p: Type0 -> q: (_: Prims.squash (~p) -> Type0) -> f: (_: Prims.squash (~p) -> Prims.squash (q ()))
-> Prims.squash (p \/ q ()) | {
"end_col": 38,
"end_line": 138,
"start_col": 4,
"start_line": 134
} |
Prims.Tot | val or_elim
(p:Type)
(q:squash (~p) -> Type)
(r:Type)
(p_or:squash (p \/ q()))
(left:squash p -> Tot (squash r))
(right:squash (~p) -> squash (q()) -> Tot (squash r))
: Tot (squash r) | [
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": 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 or_elim
(p:Type)
(q:squash (~p) -> Type)
(r:Type)
(p_or:squash (p \/ q()))
(left:squash p -> Tot (squash r))
(right:squash (~p) -> squash (q()) -> Tot (squash r))
: Tot (squash r)
= or_elim_simple p (~p) r ()
(fun (s:squash p) -> left s)
(fun (np:squash (~p)) ->
or_elim_simple p (q ()) r p_or
(fun (pf_p:squash p) -> left pf_p)
(fun (pf_q:squash (q())) -> right np pf_q)) | val or_elim
(p:Type)
(q:squash (~p) -> Type)
(r:Type)
(p_or:squash (p \/ q()))
(left:squash p -> Tot (squash r))
(right:squash (~p) -> squash (q()) -> Tot (squash r))
: Tot (squash r)
let or_elim
(p: Type)
(q: (squash (~p) -> Type))
(r: Type)
(p_or: squash (p \/ q ()))
(left: (squash p -> Tot (squash r)))
(right: (squash (~p) -> squash (q ()) -> Tot (squash r)))
: Tot (squash r) = | false | null | true | or_elim_simple p
(~p)
r
()
(fun (s: squash p) -> left s)
(fun (np: squash (~p)) ->
or_elim_simple p
(q ())
r
p_or
(fun (pf_p: squash p) -> left pf_p)
(fun (pf_q: squash (q ())) -> right np pf_q)) | {
"checked_file": "FStar.Classical.Sugar.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Classical.Sugar.fst"
} | [
"total"
] | [
"Prims.squash",
"Prims.l_not",
"Prims.l_or",
"FStar.Classical.Sugar.or_elim_simple"
] | [] | (*
Copyright 2021 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 FStar.Classical.Sugar
/// This module provides a few combinators that are targeted
/// by the desugaring phase of the F* front end
let forall_elim
(#a:Type)
(#p:a -> Type)
(v:a)
(f:squash (forall (x:a). p x))
: Tot (squash (p v))
= ()
let exists_elim #t #p #q s_ex_p f
= let open FStar.Squash in
bind_squash s_ex_p (fun ex_p ->
bind_squash ex_p (fun (sig_p: (x:t & p x)) ->
let (| x, px |) = sig_p in
f x (return_squash px)))
let or_elim_simple
(p:Type)
(q:Type)
(r:Type)
(x:squash (p \/ q))
(f:squash p -> Tot (squash r))
(g:squash q -> Tot (squash r))
: Tot (squash r)
= let open FStar.Squash in
bind_squash x (fun p_or_q ->
bind_squash p_or_q (fun p_cor_q ->
match p_cor_q with
| Prims.Left p ->
f (return_squash p)
| Prims.Right q ->
g (return_squash q)))
let or_elim
(p:Type)
(q:squash (~p) -> Type)
(r:Type)
(p_or:squash (p \/ q()))
(left:squash p -> Tot (squash r))
(right:squash (~p) -> squash (q()) -> Tot (squash r)) | false | false | FStar.Classical.Sugar.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 or_elim
(p:Type)
(q:squash (~p) -> Type)
(r:Type)
(p_or:squash (p \/ q()))
(left:squash p -> Tot (squash r))
(right:squash (~p) -> squash (q()) -> Tot (squash r))
: Tot (squash r) | [] | FStar.Classical.Sugar.or_elim | {
"file_name": "ulib/FStar.Classical.Sugar.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
p: Type0 ->
q: (_: Prims.squash (~p) -> Type0) ->
r: Type ->
p_or: Prims.squash (p \/ q ()) ->
left: (_: Prims.squash p -> Prims.squash r) ->
right: (_: Prims.squash (~p) -> _: Prims.squash (q ()) -> Prims.squash r)
-> Prims.squash r | {
"end_col": 59,
"end_line": 66,
"start_col": 4,
"start_line": 61
} |
Prims.Tot | val implies_intro
(p:Type)
(q:squash p -> Type)
(f:(squash p -> Tot (squash (q()))))
: Tot (squash (p ==> q())) | [
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": 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 implies_intro
(p:Type)
(q:squash p -> Type)
(f:(squash p -> Tot (squash (q()))))
: Tot (squash (p ==> q()))
= let open FStar.Squash in
let f' (x:p)
: GTot (squash (q ()))
= f (return_squash x)
in
return_squash (squash_double_arrow (return_squash f')) | val implies_intro
(p:Type)
(q:squash p -> Type)
(f:(squash p -> Tot (squash (q()))))
: Tot (squash (p ==> q()))
let implies_intro (p: Type) (q: (squash p -> Type)) (f: (squash p -> Tot (squash (q ()))))
: Tot (squash (p ==> q ())) = | false | null | true | let open FStar.Squash in
let f' (x: p) : GTot (squash (q ())) = f (return_squash x) in
return_squash (squash_double_arrow (return_squash f')) | {
"checked_file": "FStar.Classical.Sugar.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Classical.Sugar.fst"
} | [
"total"
] | [
"Prims.squash",
"FStar.Squash.return_squash",
"Prims.l_imp",
"FStar.Squash.squash_double_arrow"
] | [] | (*
Copyright 2021 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 FStar.Classical.Sugar
/// This module provides a few combinators that are targeted
/// by the desugaring phase of the F* front end
let forall_elim
(#a:Type)
(#p:a -> Type)
(v:a)
(f:squash (forall (x:a). p x))
: Tot (squash (p v))
= ()
let exists_elim #t #p #q s_ex_p f
= let open FStar.Squash in
bind_squash s_ex_p (fun ex_p ->
bind_squash ex_p (fun (sig_p: (x:t & p x)) ->
let (| x, px |) = sig_p in
f x (return_squash px)))
let or_elim_simple
(p:Type)
(q:Type)
(r:Type)
(x:squash (p \/ q))
(f:squash p -> Tot (squash r))
(g:squash q -> Tot (squash r))
: Tot (squash r)
= let open FStar.Squash in
bind_squash x (fun p_or_q ->
bind_squash p_or_q (fun p_cor_q ->
match p_cor_q with
| Prims.Left p ->
f (return_squash p)
| Prims.Right q ->
g (return_squash q)))
let or_elim
(p:Type)
(q:squash (~p) -> Type)
(r:Type)
(p_or:squash (p \/ q()))
(left:squash p -> Tot (squash r))
(right:squash (~p) -> squash (q()) -> Tot (squash r))
: Tot (squash r)
= or_elim_simple p (~p) r ()
(fun (s:squash p) -> left s)
(fun (np:squash (~p)) ->
or_elim_simple p (q ()) r p_or
(fun (pf_p:squash p) -> left pf_p)
(fun (pf_q:squash (q())) -> right np pf_q))
let and_elim (p:Type)
(q:squash p -> Type)
(r:Type)
(x:squash (p /\ q()))
(f:squash p -> squash (q()) -> Tot (squash r))
: Tot (squash r)
= let open FStar.Squash in
bind_squash x (fun p_and_q ->
bind_squash p_and_q (fun (Prims.Pair p q) ->
f (return_squash p) (return_squash q)))
let forall_intro
(a:Type)
(p:a -> Type)
(f: (x:a -> Tot (squash (p x))))
: Tot (squash (forall x. p x))
= let open FStar.Squash in
let f' (x:a)
: GTot (squash (p x))
= f x
in
return_squash (squash_double_arrow (return_squash f'))
let exists_intro_simple
(a:Type)
(p:a -> Type)
(v:a)
(f: squash (p v))
: Tot (squash (exists x. p x))
= let open FStar.Squash in
let p = (| v, f |) in
squash_double_sum (return_squash p)
let exists_intro
(a:Type)
(p:a -> Type)
(v:a)
(f: unit -> Tot (squash (p v)))
: Tot (squash (exists x. p x))
= exists_intro_simple a p v (f())
let implies_intro
(p:Type)
(q:squash p -> Type)
(f:(squash p -> Tot (squash (q())))) | false | false | FStar.Classical.Sugar.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 implies_intro
(p:Type)
(q:squash p -> Type)
(f:(squash p -> Tot (squash (q()))))
: Tot (squash (p ==> q())) | [] | FStar.Classical.Sugar.implies_intro | {
"file_name": "ulib/FStar.Classical.Sugar.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | p: Type0 -> q: (_: Prims.squash p -> Type0) -> f: (_: Prims.squash p -> Prims.squash (q ()))
-> Prims.squash (p ==> q ()) | {
"end_col": 58,
"end_line": 120,
"start_col": 4,
"start_line": 115
} |
Prims.Tot | val and_elim
(p:Type)
(q:squash p -> Type)
(r:Type)
(_:squash (p /\ q()))
(f:squash p -> squash (q()) -> Tot (squash r))
: Tot (squash r) | [
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": 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 and_elim (p:Type)
(q:squash p -> Type)
(r:Type)
(x:squash (p /\ q()))
(f:squash p -> squash (q()) -> Tot (squash r))
: Tot (squash r)
= let open FStar.Squash in
bind_squash x (fun p_and_q ->
bind_squash p_and_q (fun (Prims.Pair p q) ->
f (return_squash p) (return_squash q))) | val and_elim
(p:Type)
(q:squash p -> Type)
(r:Type)
(_:squash (p /\ q()))
(f:squash p -> squash (q()) -> Tot (squash r))
: Tot (squash r)
let and_elim
(p: Type)
(q: (squash p -> Type))
(r: Type)
(x: squash (p /\ q ()))
(f: (squash p -> squash (q ()) -> Tot (squash r)))
: Tot (squash r) = | false | null | true | let open FStar.Squash in
bind_squash x
(fun p_and_q ->
bind_squash p_and_q (fun (Prims.Pair p q) -> f (return_squash p) (return_squash q))) | {
"checked_file": "FStar.Classical.Sugar.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Classical.Sugar.fst"
} | [
"total"
] | [
"Prims.squash",
"Prims.l_and",
"FStar.Squash.bind_squash",
"Prims.pair",
"FStar.Squash.return_squash"
] | [] | (*
Copyright 2021 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 FStar.Classical.Sugar
/// This module provides a few combinators that are targeted
/// by the desugaring phase of the F* front end
let forall_elim
(#a:Type)
(#p:a -> Type)
(v:a)
(f:squash (forall (x:a). p x))
: Tot (squash (p v))
= ()
let exists_elim #t #p #q s_ex_p f
= let open FStar.Squash in
bind_squash s_ex_p (fun ex_p ->
bind_squash ex_p (fun (sig_p: (x:t & p x)) ->
let (| x, px |) = sig_p in
f x (return_squash px)))
let or_elim_simple
(p:Type)
(q:Type)
(r:Type)
(x:squash (p \/ q))
(f:squash p -> Tot (squash r))
(g:squash q -> Tot (squash r))
: Tot (squash r)
= let open FStar.Squash in
bind_squash x (fun p_or_q ->
bind_squash p_or_q (fun p_cor_q ->
match p_cor_q with
| Prims.Left p ->
f (return_squash p)
| Prims.Right q ->
g (return_squash q)))
let or_elim
(p:Type)
(q:squash (~p) -> Type)
(r:Type)
(p_or:squash (p \/ q()))
(left:squash p -> Tot (squash r))
(right:squash (~p) -> squash (q()) -> Tot (squash r))
: Tot (squash r)
= or_elim_simple p (~p) r ()
(fun (s:squash p) -> left s)
(fun (np:squash (~p)) ->
or_elim_simple p (q ()) r p_or
(fun (pf_p:squash p) -> left pf_p)
(fun (pf_q:squash (q())) -> right np pf_q))
let and_elim (p:Type)
(q:squash p -> Type)
(r:Type)
(x:squash (p /\ q()))
(f:squash p -> squash (q()) -> Tot (squash r)) | false | false | FStar.Classical.Sugar.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 and_elim
(p:Type)
(q:squash p -> Type)
(r:Type)
(_:squash (p /\ q()))
(f:squash p -> squash (q()) -> Tot (squash r))
: Tot (squash r) | [] | FStar.Classical.Sugar.and_elim | {
"file_name": "ulib/FStar.Classical.Sugar.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
p: Type0 ->
q: (_: Prims.squash p -> Type0) ->
r: Type ->
x: Prims.squash (p /\ q ()) ->
f: (_: Prims.squash p -> _: Prims.squash (q ()) -> Prims.squash r)
-> Prims.squash r | {
"end_col": 43,
"end_line": 77,
"start_col": 4,
"start_line": 74
} |
Prims.Tot | val and_intro
(p:Type)
(q:squash p -> Type)
(left:unit -> Tot (squash p))
(right:squash p -> Tot (squash (q())))
: Tot (squash (p /\ q())) | [
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": 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 and_intro
(p:Type)
(q:squash p -> Type)
(f:unit -> Tot (squash p))
(g:squash p -> Tot (squash (q())))
: Tot (squash (p /\ q()))
= let _ = f() in g() | val and_intro
(p:Type)
(q:squash p -> Type)
(left:unit -> Tot (squash p))
(right:squash p -> Tot (squash (q())))
: Tot (squash (p /\ q()))
let and_intro
(p: Type)
(q: (squash p -> Type))
(f: (unit -> Tot (squash p)))
(g: (squash p -> Tot (squash (q ()))))
: Tot (squash (p /\ q ())) = | false | null | true | let _ = f () in
g () | {
"checked_file": "FStar.Classical.Sugar.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Classical.Sugar.fst"
} | [
"total"
] | [
"Prims.squash",
"Prims.unit",
"Prims.l_and"
] | [] | (*
Copyright 2021 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 FStar.Classical.Sugar
/// This module provides a few combinators that are targeted
/// by the desugaring phase of the F* front end
let forall_elim
(#a:Type)
(#p:a -> Type)
(v:a)
(f:squash (forall (x:a). p x))
: Tot (squash (p v))
= ()
let exists_elim #t #p #q s_ex_p f
= let open FStar.Squash in
bind_squash s_ex_p (fun ex_p ->
bind_squash ex_p (fun (sig_p: (x:t & p x)) ->
let (| x, px |) = sig_p in
f x (return_squash px)))
let or_elim_simple
(p:Type)
(q:Type)
(r:Type)
(x:squash (p \/ q))
(f:squash p -> Tot (squash r))
(g:squash q -> Tot (squash r))
: Tot (squash r)
= let open FStar.Squash in
bind_squash x (fun p_or_q ->
bind_squash p_or_q (fun p_cor_q ->
match p_cor_q with
| Prims.Left p ->
f (return_squash p)
| Prims.Right q ->
g (return_squash q)))
let or_elim
(p:Type)
(q:squash (~p) -> Type)
(r:Type)
(p_or:squash (p \/ q()))
(left:squash p -> Tot (squash r))
(right:squash (~p) -> squash (q()) -> Tot (squash r))
: Tot (squash r)
= or_elim_simple p (~p) r ()
(fun (s:squash p) -> left s)
(fun (np:squash (~p)) ->
or_elim_simple p (q ()) r p_or
(fun (pf_p:squash p) -> left pf_p)
(fun (pf_q:squash (q())) -> right np pf_q))
let and_elim (p:Type)
(q:squash p -> Type)
(r:Type)
(x:squash (p /\ q()))
(f:squash p -> squash (q()) -> Tot (squash r))
: Tot (squash r)
= let open FStar.Squash in
bind_squash x (fun p_and_q ->
bind_squash p_and_q (fun (Prims.Pair p q) ->
f (return_squash p) (return_squash q)))
let forall_intro
(a:Type)
(p:a -> Type)
(f: (x:a -> Tot (squash (p x))))
: Tot (squash (forall x. p x))
= let open FStar.Squash in
let f' (x:a)
: GTot (squash (p x))
= f x
in
return_squash (squash_double_arrow (return_squash f'))
let exists_intro_simple
(a:Type)
(p:a -> Type)
(v:a)
(f: squash (p v))
: Tot (squash (exists x. p x))
= let open FStar.Squash in
let p = (| v, f |) in
squash_double_sum (return_squash p)
let exists_intro
(a:Type)
(p:a -> Type)
(v:a)
(f: unit -> Tot (squash (p v)))
: Tot (squash (exists x. p x))
= exists_intro_simple a p v (f())
let implies_intro
(p:Type)
(q:squash p -> Type)
(f:(squash p -> Tot (squash (q()))))
: Tot (squash (p ==> q()))
= let open FStar.Squash in
let f' (x:p)
: GTot (squash (q ()))
= f (return_squash x)
in
return_squash (squash_double_arrow (return_squash f'))
let or_intro_left
(p:Type)
(q:squash (~p) -> Type)
(f:unit -> Tot (squash p))
: Tot (squash (p \/ q()))
= f()
let or_intro_right
(p:Type)
(q:squash (~p) -> Type)
(f:squash (~p) -> Tot (squash (q())))
: Tot (squash (p \/ q()))
= or_elim_simple p (~p)
(p \/ q())
()
(fun s_p -> or_intro_left p q (fun _ -> s_p))
(fun s_np -> f s_np)
let and_intro
(p:Type)
(q:squash p -> Type)
(f:unit -> Tot (squash p))
(g:squash p -> Tot (squash (q()))) | false | false | FStar.Classical.Sugar.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 and_intro
(p:Type)
(q:squash p -> Type)
(left:unit -> Tot (squash p))
(right:squash p -> Tot (squash (q())))
: Tot (squash (p /\ q())) | [] | FStar.Classical.Sugar.and_intro | {
"file_name": "ulib/FStar.Classical.Sugar.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
p: Type0 ->
q: (_: Prims.squash p -> Type0) ->
left: (_: Prims.unit -> Prims.squash p) ->
right: (_: Prims.squash p -> Prims.squash (q ()))
-> Prims.squash (p /\ q ()) | {
"end_col": 22,
"end_line": 146,
"start_col": 3,
"start_line": 146
} |
Prims.Tot | val bn_mod_exp_mont_ladder_swap_precomp: #t:limb_t -> len:BN.bn_len t -> bn_mod_exp_precomp_st t len | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.AlmostMontExponentiation",
"short_module": "AE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.MontExponentiation",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.ModInvLimb",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Exponentiation.Lemmas",
"short_module": "E"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let bn_mod_exp_mont_ladder_swap_precomp #t len n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len ME.bn_exp_mont_bm_consttime n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len AE.bn_exp_almost_mont_bm_consttime n mu r2 a bBits b | val bn_mod_exp_mont_ladder_swap_precomp: #t:limb_t -> len:BN.bn_len t -> bn_mod_exp_precomp_st t len
let bn_mod_exp_mont_ladder_swap_precomp #t len n mu r2 a bBits b = | false | null | false | mk_bn_mod_exp_precomp_amont #t len AE.bn_exp_almost_mont_bm_consttime n mu r2 a bBits b | {
"checked_file": "Hacl.Spec.Bignum.Exponentiation.fst.checked",
"dependencies": [
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Exponentiation.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.MontExponentiation.fst.checked",
"Hacl.Spec.Bignum.ModInvLimb.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.AlmostMontExponentiation.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.Bignum.Exponentiation.fst"
} | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.bn_len",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.limb",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.blocks0",
"Lib.IntTypes.bits",
"Hacl.Spec.Bignum.Exponentiation.mk_bn_mod_exp_precomp_amont",
"Hacl.Spec.Bignum.AlmostMontExponentiation.bn_exp_almost_mont_bm_consttime"
] | [] | module Hacl.Spec.Bignum.Exponentiation
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module E = Hacl.Spec.Exponentiation.Lemmas
module M = Hacl.Spec.Montgomery.Lemmas
module BN = Hacl.Spec.Bignum
module BM = Hacl.Spec.Bignum.Montgomery
module BI = Hacl.Spec.Bignum.ModInvLimb
module ME = Hacl.Spec.Bignum.MontExponentiation
module AE = Hacl.Spec.Bignum.AlmostMontExponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let bn_check_mod_exp #t #len n a bBits b =
let pbits = bits t in
let m0 = BM.bn_check_modulus n in
bn_eval_bound b (blocks0 bBits pbits);
let m1 =
if bBits < pbits * blocks0 bBits pbits then begin
BN.bn_lt_pow2_mask_lemma b bBits;
BN.bn_lt_pow2_mask b bBits end
else begin
Math.Lemmas.pow2_le_compat bBits (pbits * blocks bBits pbits);
ones t SEC end in
assert (if v m1 = 0 then pow2 bBits <= bn_v b else bn_v b < pow2 bBits);
let m2 = BN.bn_lt_mask a n in
BN.bn_lt_mask_lemma a n;
assert (if v m2 = 0 then bn_v a >= bn_v n else bn_v a < bn_v n);
let m = m1 &. m2 in
logand_lemma m1 m2;
let r = m0 &. m in
logand_lemma m0 m;
r
val mk_bn_mod_exp_precomp_mont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_mont:ME.bn_exp_mont_st t len ->
bn_mod_exp_precomp_st t len
let mk_bn_mod_exp_precomp_mont #t len bn_exp_mont n mu r2 a bBits b =
bn_eval_bound n len;
let aM = BM.bn_to_mont n mu r2 a in
BM.bn_to_mont_lemma n mu r2 a;
let accM = bn_exp_mont n mu aM bBits b in
let acc = BM.bn_from_mont n mu accM in
BM.bn_from_mont_lemma n mu accM;
E.mod_exp_mont_ll_lemma (bits t) len (bn_v n) (v mu) (bn_v a) (bn_v b);
assert (bn_v acc == Lib.NatMod.pow_mod #(bn_v n) (bn_v a) (bn_v b));
acc
val mk_bn_mod_exp_precomp_amont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_almost_mont:AE.bn_exp_almost_mont_st t len ->
bn_mod_exp_precomp_st t len
let mk_bn_mod_exp_precomp_amont #t len bn_exp_almost_mont n mu r2 a bBits b =
bn_eval_bound n len;
let aM = BM.bn_to_mont n mu r2 a in
BM.bn_to_mont_lemma n mu r2 a;
M.to_mont_lemma (bits t) len (bn_v n) (v mu) (bn_v a);
let accM = bn_exp_almost_mont n mu aM bBits b in
let acc = BM.bn_from_mont n mu accM in
BM.bn_from_mont_lemma n mu accM;
bn_eval_bound accM len;
E.mod_exp_mont_ll_mod_lemma (bits t) len (bn_v n) (v mu) (bn_v a) (bn_v b) (bn_v accM);
assert (bn_v acc == Lib.NatMod.pow_mod #(bn_v n) (bn_v a) (bn_v b));
acc
let bn_mod_exp_rl_precomp #t len n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len ME.bn_exp_mont_bm_vartime n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len AE.bn_exp_almost_mont_bm_vartime n mu r2 a bBits b
let bn_mod_exp_mont_ladder_swap_precomp #t len n mu r2 a bBits b = | false | false | Hacl.Spec.Bignum.Exponentiation.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_exp_mont_ladder_swap_precomp: #t:limb_t -> len:BN.bn_len t -> bn_mod_exp_precomp_st t len | [] | Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_mont_ladder_swap_precomp | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Hacl.Spec.Bignum.bn_len t -> Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_precomp_st t len | {
"end_col": 89,
"end_line": 99,
"start_col": 2,
"start_line": 99
} |
Prims.Tot | val bn_mod_exp_consttime_precompr2: #t:limb_t -> len:BN.bn_len t -> bn_mod_exp_precompr2_st t len | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.AlmostMontExponentiation",
"short_module": "AE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.MontExponentiation",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.ModInvLimb",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Exponentiation.Lemmas",
"short_module": "E"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let bn_mod_exp_consttime_precompr2 #t len n r2 a bBits b =
mk_bn_mod_exp_precompr2 #t len (bn_mod_exp_consttime_precomp len) n r2 a bBits b | val bn_mod_exp_consttime_precompr2: #t:limb_t -> len:BN.bn_len t -> bn_mod_exp_precompr2_st t len
let bn_mod_exp_consttime_precompr2 #t len n r2 a bBits b = | false | null | false | mk_bn_mod_exp_precompr2 #t len (bn_mod_exp_consttime_precomp len) n r2 a bBits b | {
"checked_file": "Hacl.Spec.Bignum.Exponentiation.fst.checked",
"dependencies": [
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Exponentiation.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.MontExponentiation.fst.checked",
"Hacl.Spec.Bignum.ModInvLimb.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.AlmostMontExponentiation.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.Bignum.Exponentiation.fst"
} | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.bn_len",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.blocks0",
"Lib.IntTypes.bits",
"Hacl.Spec.Bignum.Exponentiation.mk_bn_mod_exp_precompr2",
"Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_consttime_precomp"
] | [] | module Hacl.Spec.Bignum.Exponentiation
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module E = Hacl.Spec.Exponentiation.Lemmas
module M = Hacl.Spec.Montgomery.Lemmas
module BN = Hacl.Spec.Bignum
module BM = Hacl.Spec.Bignum.Montgomery
module BI = Hacl.Spec.Bignum.ModInvLimb
module ME = Hacl.Spec.Bignum.MontExponentiation
module AE = Hacl.Spec.Bignum.AlmostMontExponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let bn_check_mod_exp #t #len n a bBits b =
let pbits = bits t in
let m0 = BM.bn_check_modulus n in
bn_eval_bound b (blocks0 bBits pbits);
let m1 =
if bBits < pbits * blocks0 bBits pbits then begin
BN.bn_lt_pow2_mask_lemma b bBits;
BN.bn_lt_pow2_mask b bBits end
else begin
Math.Lemmas.pow2_le_compat bBits (pbits * blocks bBits pbits);
ones t SEC end in
assert (if v m1 = 0 then pow2 bBits <= bn_v b else bn_v b < pow2 bBits);
let m2 = BN.bn_lt_mask a n in
BN.bn_lt_mask_lemma a n;
assert (if v m2 = 0 then bn_v a >= bn_v n else bn_v a < bn_v n);
let m = m1 &. m2 in
logand_lemma m1 m2;
let r = m0 &. m in
logand_lemma m0 m;
r
val mk_bn_mod_exp_precomp_mont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_mont:ME.bn_exp_mont_st t len ->
bn_mod_exp_precomp_st t len
let mk_bn_mod_exp_precomp_mont #t len bn_exp_mont n mu r2 a bBits b =
bn_eval_bound n len;
let aM = BM.bn_to_mont n mu r2 a in
BM.bn_to_mont_lemma n mu r2 a;
let accM = bn_exp_mont n mu aM bBits b in
let acc = BM.bn_from_mont n mu accM in
BM.bn_from_mont_lemma n mu accM;
E.mod_exp_mont_ll_lemma (bits t) len (bn_v n) (v mu) (bn_v a) (bn_v b);
assert (bn_v acc == Lib.NatMod.pow_mod #(bn_v n) (bn_v a) (bn_v b));
acc
val mk_bn_mod_exp_precomp_amont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_almost_mont:AE.bn_exp_almost_mont_st t len ->
bn_mod_exp_precomp_st t len
let mk_bn_mod_exp_precomp_amont #t len bn_exp_almost_mont n mu r2 a bBits b =
bn_eval_bound n len;
let aM = BM.bn_to_mont n mu r2 a in
BM.bn_to_mont_lemma n mu r2 a;
M.to_mont_lemma (bits t) len (bn_v n) (v mu) (bn_v a);
let accM = bn_exp_almost_mont n mu aM bBits b in
let acc = BM.bn_from_mont n mu accM in
BM.bn_from_mont_lemma n mu accM;
bn_eval_bound accM len;
E.mod_exp_mont_ll_mod_lemma (bits t) len (bn_v n) (v mu) (bn_v a) (bn_v b) (bn_v accM);
assert (bn_v acc == Lib.NatMod.pow_mod #(bn_v n) (bn_v a) (bn_v b));
acc
let bn_mod_exp_rl_precomp #t len n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len ME.bn_exp_mont_bm_vartime n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len AE.bn_exp_almost_mont_bm_vartime n mu r2 a bBits b
let bn_mod_exp_mont_ladder_swap_precomp #t len n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len ME.bn_exp_mont_bm_consttime n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len AE.bn_exp_almost_mont_bm_consttime n mu r2 a bBits b
let bn_mod_exp_fw_precomp #t len l n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len (ME.bn_exp_mont_fw l) n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len (AE.bn_exp_almost_mont_fw l) n mu r2 a bBits b
let bn_mod_exp_vartime_precomp #t len n mu r2 a bBits b =
if bBits < ME.bn_exp_mont_vartime_threshold then
bn_mod_exp_rl_precomp #t len n mu r2 a bBits b
else
bn_mod_exp_fw_precomp #t len 4 n mu r2 a bBits b
let bn_mod_exp_consttime_precomp #t len n mu r2 a bBits b =
if bBits < ME.bn_exp_mont_consttime_threshold then
bn_mod_exp_mont_ladder_swap_precomp #t len n mu r2 a bBits b
else
bn_mod_exp_fw_precomp #t len 4 n mu r2 a bBits b
val mk_bn_mod_exp_precompr2:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_precomp:bn_mod_exp_precomp_st t len ->
bn_mod_exp_precompr2_st t len
let mk_bn_mod_exp_precompr2 #t len bn_exp_precomp n r2 a bBits b =
let mu = BI.mod_inv_limb n.[0] in
BI.bn_mod_inv_limb_lemma n;
bn_exp_precomp n mu r2 a bBits b
let bn_mod_exp_vartime_precompr2 #t len n r2 a bBits b =
mk_bn_mod_exp_precompr2 #t len (bn_mod_exp_vartime_precomp len) n r2 a bBits b | false | false | Hacl.Spec.Bignum.Exponentiation.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_exp_consttime_precompr2: #t:limb_t -> len:BN.bn_len t -> bn_mod_exp_precompr2_st t len | [] | Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_consttime_precompr2 | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Hacl.Spec.Bignum.bn_len t -> Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_precompr2_st t len | {
"end_col": 82,
"end_line": 135,
"start_col": 2,
"start_line": 135
} |
Prims.Tot | val bn_mod_exp_vartime: #t:limb_t -> len:BN.bn_len t -> bn_mod_exp_st t len | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.AlmostMontExponentiation",
"short_module": "AE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.MontExponentiation",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.ModInvLimb",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Exponentiation.Lemmas",
"short_module": "E"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let bn_mod_exp_vartime #t len nBits n a bBits b =
mk_bn_mod_exp len (bn_mod_exp_vartime_precomp len) nBits n a bBits b | val bn_mod_exp_vartime: #t:limb_t -> len:BN.bn_len t -> bn_mod_exp_st t len
let bn_mod_exp_vartime #t len nBits n a bBits b = | false | null | false | mk_bn_mod_exp len (bn_mod_exp_vartime_precomp len) nBits n a bBits b | {
"checked_file": "Hacl.Spec.Bignum.Exponentiation.fst.checked",
"dependencies": [
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Exponentiation.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.MontExponentiation.fst.checked",
"Hacl.Spec.Bignum.ModInvLimb.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.AlmostMontExponentiation.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.Bignum.Exponentiation.fst"
} | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.bn_len",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.blocks0",
"Lib.IntTypes.bits",
"Hacl.Spec.Bignum.Exponentiation.mk_bn_mod_exp",
"Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_vartime_precomp"
] | [] | module Hacl.Spec.Bignum.Exponentiation
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module E = Hacl.Spec.Exponentiation.Lemmas
module M = Hacl.Spec.Montgomery.Lemmas
module BN = Hacl.Spec.Bignum
module BM = Hacl.Spec.Bignum.Montgomery
module BI = Hacl.Spec.Bignum.ModInvLimb
module ME = Hacl.Spec.Bignum.MontExponentiation
module AE = Hacl.Spec.Bignum.AlmostMontExponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let bn_check_mod_exp #t #len n a bBits b =
let pbits = bits t in
let m0 = BM.bn_check_modulus n in
bn_eval_bound b (blocks0 bBits pbits);
let m1 =
if bBits < pbits * blocks0 bBits pbits then begin
BN.bn_lt_pow2_mask_lemma b bBits;
BN.bn_lt_pow2_mask b bBits end
else begin
Math.Lemmas.pow2_le_compat bBits (pbits * blocks bBits pbits);
ones t SEC end in
assert (if v m1 = 0 then pow2 bBits <= bn_v b else bn_v b < pow2 bBits);
let m2 = BN.bn_lt_mask a n in
BN.bn_lt_mask_lemma a n;
assert (if v m2 = 0 then bn_v a >= bn_v n else bn_v a < bn_v n);
let m = m1 &. m2 in
logand_lemma m1 m2;
let r = m0 &. m in
logand_lemma m0 m;
r
val mk_bn_mod_exp_precomp_mont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_mont:ME.bn_exp_mont_st t len ->
bn_mod_exp_precomp_st t len
let mk_bn_mod_exp_precomp_mont #t len bn_exp_mont n mu r2 a bBits b =
bn_eval_bound n len;
let aM = BM.bn_to_mont n mu r2 a in
BM.bn_to_mont_lemma n mu r2 a;
let accM = bn_exp_mont n mu aM bBits b in
let acc = BM.bn_from_mont n mu accM in
BM.bn_from_mont_lemma n mu accM;
E.mod_exp_mont_ll_lemma (bits t) len (bn_v n) (v mu) (bn_v a) (bn_v b);
assert (bn_v acc == Lib.NatMod.pow_mod #(bn_v n) (bn_v a) (bn_v b));
acc
val mk_bn_mod_exp_precomp_amont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_almost_mont:AE.bn_exp_almost_mont_st t len ->
bn_mod_exp_precomp_st t len
let mk_bn_mod_exp_precomp_amont #t len bn_exp_almost_mont n mu r2 a bBits b =
bn_eval_bound n len;
let aM = BM.bn_to_mont n mu r2 a in
BM.bn_to_mont_lemma n mu r2 a;
M.to_mont_lemma (bits t) len (bn_v n) (v mu) (bn_v a);
let accM = bn_exp_almost_mont n mu aM bBits b in
let acc = BM.bn_from_mont n mu accM in
BM.bn_from_mont_lemma n mu accM;
bn_eval_bound accM len;
E.mod_exp_mont_ll_mod_lemma (bits t) len (bn_v n) (v mu) (bn_v a) (bn_v b) (bn_v accM);
assert (bn_v acc == Lib.NatMod.pow_mod #(bn_v n) (bn_v a) (bn_v b));
acc
let bn_mod_exp_rl_precomp #t len n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len ME.bn_exp_mont_bm_vartime n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len AE.bn_exp_almost_mont_bm_vartime n mu r2 a bBits b
let bn_mod_exp_mont_ladder_swap_precomp #t len n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len ME.bn_exp_mont_bm_consttime n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len AE.bn_exp_almost_mont_bm_consttime n mu r2 a bBits b
let bn_mod_exp_fw_precomp #t len l n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len (ME.bn_exp_mont_fw l) n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len (AE.bn_exp_almost_mont_fw l) n mu r2 a bBits b
let bn_mod_exp_vartime_precomp #t len n mu r2 a bBits b =
if bBits < ME.bn_exp_mont_vartime_threshold then
bn_mod_exp_rl_precomp #t len n mu r2 a bBits b
else
bn_mod_exp_fw_precomp #t len 4 n mu r2 a bBits b
let bn_mod_exp_consttime_precomp #t len n mu r2 a bBits b =
if bBits < ME.bn_exp_mont_consttime_threshold then
bn_mod_exp_mont_ladder_swap_precomp #t len n mu r2 a bBits b
else
bn_mod_exp_fw_precomp #t len 4 n mu r2 a bBits b
val mk_bn_mod_exp_precompr2:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_precomp:bn_mod_exp_precomp_st t len ->
bn_mod_exp_precompr2_st t len
let mk_bn_mod_exp_precompr2 #t len bn_exp_precomp n r2 a bBits b =
let mu = BI.mod_inv_limb n.[0] in
BI.bn_mod_inv_limb_lemma n;
bn_exp_precomp n mu r2 a bBits b
let bn_mod_exp_vartime_precompr2 #t len n r2 a bBits b =
mk_bn_mod_exp_precompr2 #t len (bn_mod_exp_vartime_precomp len) n r2 a bBits b
let bn_mod_exp_consttime_precompr2 #t len n r2 a bBits b =
mk_bn_mod_exp_precompr2 #t len (bn_mod_exp_consttime_precomp len) n r2 a bBits b
val mk_bn_mod_exp:
#t:limb_t
-> len:BN.bn_len t
-> bn_mod_exp_precomp:bn_mod_exp_precomp_st t len ->
bn_mod_exp_st t len
let mk_bn_mod_exp #t len bn_mod_exp_precomp nBits n a bBits b =
let r2, mu = BM.bn_mont_precomp nBits n in
bn_mod_exp_precomp n mu r2 a bBits b | false | false | Hacl.Spec.Bignum.Exponentiation.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_exp_vartime: #t:limb_t -> len:BN.bn_len t -> bn_mod_exp_st t len | [] | Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_vartime | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Hacl.Spec.Bignum.bn_len t -> Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_st t len | {
"end_col": 70,
"end_line": 150,
"start_col": 2,
"start_line": 150
} |
Prims.Tot | val bn_mod_exp_consttime: #t:limb_t -> len:BN.bn_len t -> bn_mod_exp_st t len | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.AlmostMontExponentiation",
"short_module": "AE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.MontExponentiation",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.ModInvLimb",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Exponentiation.Lemmas",
"short_module": "E"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let bn_mod_exp_consttime #t len nBits n a bBits b =
mk_bn_mod_exp len (bn_mod_exp_consttime_precomp len) nBits n a bBits b | val bn_mod_exp_consttime: #t:limb_t -> len:BN.bn_len t -> bn_mod_exp_st t len
let bn_mod_exp_consttime #t len nBits n a bBits b = | false | null | false | mk_bn_mod_exp len (bn_mod_exp_consttime_precomp len) nBits n a bBits b | {
"checked_file": "Hacl.Spec.Bignum.Exponentiation.fst.checked",
"dependencies": [
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Exponentiation.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.MontExponentiation.fst.checked",
"Hacl.Spec.Bignum.ModInvLimb.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.AlmostMontExponentiation.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.Bignum.Exponentiation.fst"
} | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.bn_len",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.blocks0",
"Lib.IntTypes.bits",
"Hacl.Spec.Bignum.Exponentiation.mk_bn_mod_exp",
"Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_consttime_precomp"
] | [] | module Hacl.Spec.Bignum.Exponentiation
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module E = Hacl.Spec.Exponentiation.Lemmas
module M = Hacl.Spec.Montgomery.Lemmas
module BN = Hacl.Spec.Bignum
module BM = Hacl.Spec.Bignum.Montgomery
module BI = Hacl.Spec.Bignum.ModInvLimb
module ME = Hacl.Spec.Bignum.MontExponentiation
module AE = Hacl.Spec.Bignum.AlmostMontExponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let bn_check_mod_exp #t #len n a bBits b =
let pbits = bits t in
let m0 = BM.bn_check_modulus n in
bn_eval_bound b (blocks0 bBits pbits);
let m1 =
if bBits < pbits * blocks0 bBits pbits then begin
BN.bn_lt_pow2_mask_lemma b bBits;
BN.bn_lt_pow2_mask b bBits end
else begin
Math.Lemmas.pow2_le_compat bBits (pbits * blocks bBits pbits);
ones t SEC end in
assert (if v m1 = 0 then pow2 bBits <= bn_v b else bn_v b < pow2 bBits);
let m2 = BN.bn_lt_mask a n in
BN.bn_lt_mask_lemma a n;
assert (if v m2 = 0 then bn_v a >= bn_v n else bn_v a < bn_v n);
let m = m1 &. m2 in
logand_lemma m1 m2;
let r = m0 &. m in
logand_lemma m0 m;
r
val mk_bn_mod_exp_precomp_mont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_mont:ME.bn_exp_mont_st t len ->
bn_mod_exp_precomp_st t len
let mk_bn_mod_exp_precomp_mont #t len bn_exp_mont n mu r2 a bBits b =
bn_eval_bound n len;
let aM = BM.bn_to_mont n mu r2 a in
BM.bn_to_mont_lemma n mu r2 a;
let accM = bn_exp_mont n mu aM bBits b in
let acc = BM.bn_from_mont n mu accM in
BM.bn_from_mont_lemma n mu accM;
E.mod_exp_mont_ll_lemma (bits t) len (bn_v n) (v mu) (bn_v a) (bn_v b);
assert (bn_v acc == Lib.NatMod.pow_mod #(bn_v n) (bn_v a) (bn_v b));
acc
val mk_bn_mod_exp_precomp_amont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_almost_mont:AE.bn_exp_almost_mont_st t len ->
bn_mod_exp_precomp_st t len
let mk_bn_mod_exp_precomp_amont #t len bn_exp_almost_mont n mu r2 a bBits b =
bn_eval_bound n len;
let aM = BM.bn_to_mont n mu r2 a in
BM.bn_to_mont_lemma n mu r2 a;
M.to_mont_lemma (bits t) len (bn_v n) (v mu) (bn_v a);
let accM = bn_exp_almost_mont n mu aM bBits b in
let acc = BM.bn_from_mont n mu accM in
BM.bn_from_mont_lemma n mu accM;
bn_eval_bound accM len;
E.mod_exp_mont_ll_mod_lemma (bits t) len (bn_v n) (v mu) (bn_v a) (bn_v b) (bn_v accM);
assert (bn_v acc == Lib.NatMod.pow_mod #(bn_v n) (bn_v a) (bn_v b));
acc
let bn_mod_exp_rl_precomp #t len n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len ME.bn_exp_mont_bm_vartime n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len AE.bn_exp_almost_mont_bm_vartime n mu r2 a bBits b
let bn_mod_exp_mont_ladder_swap_precomp #t len n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len ME.bn_exp_mont_bm_consttime n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len AE.bn_exp_almost_mont_bm_consttime n mu r2 a bBits b
let bn_mod_exp_fw_precomp #t len l n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len (ME.bn_exp_mont_fw l) n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len (AE.bn_exp_almost_mont_fw l) n mu r2 a bBits b
let bn_mod_exp_vartime_precomp #t len n mu r2 a bBits b =
if bBits < ME.bn_exp_mont_vartime_threshold then
bn_mod_exp_rl_precomp #t len n mu r2 a bBits b
else
bn_mod_exp_fw_precomp #t len 4 n mu r2 a bBits b
let bn_mod_exp_consttime_precomp #t len n mu r2 a bBits b =
if bBits < ME.bn_exp_mont_consttime_threshold then
bn_mod_exp_mont_ladder_swap_precomp #t len n mu r2 a bBits b
else
bn_mod_exp_fw_precomp #t len 4 n mu r2 a bBits b
val mk_bn_mod_exp_precompr2:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_precomp:bn_mod_exp_precomp_st t len ->
bn_mod_exp_precompr2_st t len
let mk_bn_mod_exp_precompr2 #t len bn_exp_precomp n r2 a bBits b =
let mu = BI.mod_inv_limb n.[0] in
BI.bn_mod_inv_limb_lemma n;
bn_exp_precomp n mu r2 a bBits b
let bn_mod_exp_vartime_precompr2 #t len n r2 a bBits b =
mk_bn_mod_exp_precompr2 #t len (bn_mod_exp_vartime_precomp len) n r2 a bBits b
let bn_mod_exp_consttime_precompr2 #t len n r2 a bBits b =
mk_bn_mod_exp_precompr2 #t len (bn_mod_exp_consttime_precomp len) n r2 a bBits b
val mk_bn_mod_exp:
#t:limb_t
-> len:BN.bn_len t
-> bn_mod_exp_precomp:bn_mod_exp_precomp_st t len ->
bn_mod_exp_st t len
let mk_bn_mod_exp #t len bn_mod_exp_precomp nBits n a bBits b =
let r2, mu = BM.bn_mont_precomp nBits n in
bn_mod_exp_precomp n mu r2 a bBits b
let bn_mod_exp_vartime #t len nBits n a bBits b =
mk_bn_mod_exp len (bn_mod_exp_vartime_precomp len) nBits n a bBits b | false | false | Hacl.Spec.Bignum.Exponentiation.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_exp_consttime: #t:limb_t -> len:BN.bn_len t -> bn_mod_exp_st t len | [] | Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_consttime | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Hacl.Spec.Bignum.bn_len t -> Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_st t len | {
"end_col": 72,
"end_line": 153,
"start_col": 2,
"start_line": 153
} |
Prims.Tot | val bn_mod_exp_vartime_precompr2: #t:limb_t -> len:BN.bn_len t -> bn_mod_exp_precompr2_st t len | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.AlmostMontExponentiation",
"short_module": "AE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.MontExponentiation",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.ModInvLimb",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Exponentiation.Lemmas",
"short_module": "E"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let bn_mod_exp_vartime_precompr2 #t len n r2 a bBits b =
mk_bn_mod_exp_precompr2 #t len (bn_mod_exp_vartime_precomp len) n r2 a bBits b | val bn_mod_exp_vartime_precompr2: #t:limb_t -> len:BN.bn_len t -> bn_mod_exp_precompr2_st t len
let bn_mod_exp_vartime_precompr2 #t len n r2 a bBits b = | false | null | false | mk_bn_mod_exp_precompr2 #t len (bn_mod_exp_vartime_precomp len) n r2 a bBits b | {
"checked_file": "Hacl.Spec.Bignum.Exponentiation.fst.checked",
"dependencies": [
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Exponentiation.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.MontExponentiation.fst.checked",
"Hacl.Spec.Bignum.ModInvLimb.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.AlmostMontExponentiation.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.Bignum.Exponentiation.fst"
} | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.bn_len",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.blocks0",
"Lib.IntTypes.bits",
"Hacl.Spec.Bignum.Exponentiation.mk_bn_mod_exp_precompr2",
"Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_vartime_precomp"
] | [] | module Hacl.Spec.Bignum.Exponentiation
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module E = Hacl.Spec.Exponentiation.Lemmas
module M = Hacl.Spec.Montgomery.Lemmas
module BN = Hacl.Spec.Bignum
module BM = Hacl.Spec.Bignum.Montgomery
module BI = Hacl.Spec.Bignum.ModInvLimb
module ME = Hacl.Spec.Bignum.MontExponentiation
module AE = Hacl.Spec.Bignum.AlmostMontExponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let bn_check_mod_exp #t #len n a bBits b =
let pbits = bits t in
let m0 = BM.bn_check_modulus n in
bn_eval_bound b (blocks0 bBits pbits);
let m1 =
if bBits < pbits * blocks0 bBits pbits then begin
BN.bn_lt_pow2_mask_lemma b bBits;
BN.bn_lt_pow2_mask b bBits end
else begin
Math.Lemmas.pow2_le_compat bBits (pbits * blocks bBits pbits);
ones t SEC end in
assert (if v m1 = 0 then pow2 bBits <= bn_v b else bn_v b < pow2 bBits);
let m2 = BN.bn_lt_mask a n in
BN.bn_lt_mask_lemma a n;
assert (if v m2 = 0 then bn_v a >= bn_v n else bn_v a < bn_v n);
let m = m1 &. m2 in
logand_lemma m1 m2;
let r = m0 &. m in
logand_lemma m0 m;
r
val mk_bn_mod_exp_precomp_mont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_mont:ME.bn_exp_mont_st t len ->
bn_mod_exp_precomp_st t len
let mk_bn_mod_exp_precomp_mont #t len bn_exp_mont n mu r2 a bBits b =
bn_eval_bound n len;
let aM = BM.bn_to_mont n mu r2 a in
BM.bn_to_mont_lemma n mu r2 a;
let accM = bn_exp_mont n mu aM bBits b in
let acc = BM.bn_from_mont n mu accM in
BM.bn_from_mont_lemma n mu accM;
E.mod_exp_mont_ll_lemma (bits t) len (bn_v n) (v mu) (bn_v a) (bn_v b);
assert (bn_v acc == Lib.NatMod.pow_mod #(bn_v n) (bn_v a) (bn_v b));
acc
val mk_bn_mod_exp_precomp_amont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_almost_mont:AE.bn_exp_almost_mont_st t len ->
bn_mod_exp_precomp_st t len
let mk_bn_mod_exp_precomp_amont #t len bn_exp_almost_mont n mu r2 a bBits b =
bn_eval_bound n len;
let aM = BM.bn_to_mont n mu r2 a in
BM.bn_to_mont_lemma n mu r2 a;
M.to_mont_lemma (bits t) len (bn_v n) (v mu) (bn_v a);
let accM = bn_exp_almost_mont n mu aM bBits b in
let acc = BM.bn_from_mont n mu accM in
BM.bn_from_mont_lemma n mu accM;
bn_eval_bound accM len;
E.mod_exp_mont_ll_mod_lemma (bits t) len (bn_v n) (v mu) (bn_v a) (bn_v b) (bn_v accM);
assert (bn_v acc == Lib.NatMod.pow_mod #(bn_v n) (bn_v a) (bn_v b));
acc
let bn_mod_exp_rl_precomp #t len n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len ME.bn_exp_mont_bm_vartime n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len AE.bn_exp_almost_mont_bm_vartime n mu r2 a bBits b
let bn_mod_exp_mont_ladder_swap_precomp #t len n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len ME.bn_exp_mont_bm_consttime n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len AE.bn_exp_almost_mont_bm_consttime n mu r2 a bBits b
let bn_mod_exp_fw_precomp #t len l n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len (ME.bn_exp_mont_fw l) n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len (AE.bn_exp_almost_mont_fw l) n mu r2 a bBits b
let bn_mod_exp_vartime_precomp #t len n mu r2 a bBits b =
if bBits < ME.bn_exp_mont_vartime_threshold then
bn_mod_exp_rl_precomp #t len n mu r2 a bBits b
else
bn_mod_exp_fw_precomp #t len 4 n mu r2 a bBits b
let bn_mod_exp_consttime_precomp #t len n mu r2 a bBits b =
if bBits < ME.bn_exp_mont_consttime_threshold then
bn_mod_exp_mont_ladder_swap_precomp #t len n mu r2 a bBits b
else
bn_mod_exp_fw_precomp #t len 4 n mu r2 a bBits b
val mk_bn_mod_exp_precompr2:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_precomp:bn_mod_exp_precomp_st t len ->
bn_mod_exp_precompr2_st t len
let mk_bn_mod_exp_precompr2 #t len bn_exp_precomp n r2 a bBits b =
let mu = BI.mod_inv_limb n.[0] in
BI.bn_mod_inv_limb_lemma n;
bn_exp_precomp n mu r2 a bBits b | false | false | Hacl.Spec.Bignum.Exponentiation.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_exp_vartime_precompr2: #t:limb_t -> len:BN.bn_len t -> bn_mod_exp_precompr2_st t len | [] | Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_vartime_precompr2 | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Hacl.Spec.Bignum.bn_len t -> Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_precompr2_st t len | {
"end_col": 80,
"end_line": 132,
"start_col": 2,
"start_line": 132
} |
Prims.Tot | val bn_mod_exp_fw_precomp:
#t:limb_t
-> len:BN.bn_len t
-> l:size_pos{l < bits t /\ pow2 l * len <= max_size_t} ->
bn_mod_exp_precomp_st t len | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.AlmostMontExponentiation",
"short_module": "AE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.MontExponentiation",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.ModInvLimb",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Exponentiation.Lemmas",
"short_module": "E"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let bn_mod_exp_fw_precomp #t len l n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len (ME.bn_exp_mont_fw l) n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len (AE.bn_exp_almost_mont_fw l) n mu r2 a bBits b | val bn_mod_exp_fw_precomp:
#t:limb_t
-> len:BN.bn_len t
-> l:size_pos{l < bits t /\ pow2 l * len <= max_size_t} ->
bn_mod_exp_precomp_st t len
let bn_mod_exp_fw_precomp #t len l n mu r2 a bBits b = | false | null | false | mk_bn_mod_exp_precomp_amont #t len (AE.bn_exp_almost_mont_fw l) n mu r2 a bBits b | {
"checked_file": "Hacl.Spec.Bignum.Exponentiation.fst.checked",
"dependencies": [
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Exponentiation.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.MontExponentiation.fst.checked",
"Hacl.Spec.Bignum.ModInvLimb.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.AlmostMontExponentiation.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.Bignum.Exponentiation.fst"
} | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.bn_len",
"Lib.IntTypes.size_pos",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.bits",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Prims.pow2",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.limb",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.blocks0",
"Hacl.Spec.Bignum.Exponentiation.mk_bn_mod_exp_precomp_amont",
"Hacl.Spec.Bignum.AlmostMontExponentiation.bn_exp_almost_mont_fw"
] | [] | module Hacl.Spec.Bignum.Exponentiation
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module E = Hacl.Spec.Exponentiation.Lemmas
module M = Hacl.Spec.Montgomery.Lemmas
module BN = Hacl.Spec.Bignum
module BM = Hacl.Spec.Bignum.Montgomery
module BI = Hacl.Spec.Bignum.ModInvLimb
module ME = Hacl.Spec.Bignum.MontExponentiation
module AE = Hacl.Spec.Bignum.AlmostMontExponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let bn_check_mod_exp #t #len n a bBits b =
let pbits = bits t in
let m0 = BM.bn_check_modulus n in
bn_eval_bound b (blocks0 bBits pbits);
let m1 =
if bBits < pbits * blocks0 bBits pbits then begin
BN.bn_lt_pow2_mask_lemma b bBits;
BN.bn_lt_pow2_mask b bBits end
else begin
Math.Lemmas.pow2_le_compat bBits (pbits * blocks bBits pbits);
ones t SEC end in
assert (if v m1 = 0 then pow2 bBits <= bn_v b else bn_v b < pow2 bBits);
let m2 = BN.bn_lt_mask a n in
BN.bn_lt_mask_lemma a n;
assert (if v m2 = 0 then bn_v a >= bn_v n else bn_v a < bn_v n);
let m = m1 &. m2 in
logand_lemma m1 m2;
let r = m0 &. m in
logand_lemma m0 m;
r
val mk_bn_mod_exp_precomp_mont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_mont:ME.bn_exp_mont_st t len ->
bn_mod_exp_precomp_st t len
let mk_bn_mod_exp_precomp_mont #t len bn_exp_mont n mu r2 a bBits b =
bn_eval_bound n len;
let aM = BM.bn_to_mont n mu r2 a in
BM.bn_to_mont_lemma n mu r2 a;
let accM = bn_exp_mont n mu aM bBits b in
let acc = BM.bn_from_mont n mu accM in
BM.bn_from_mont_lemma n mu accM;
E.mod_exp_mont_ll_lemma (bits t) len (bn_v n) (v mu) (bn_v a) (bn_v b);
assert (bn_v acc == Lib.NatMod.pow_mod #(bn_v n) (bn_v a) (bn_v b));
acc
val mk_bn_mod_exp_precomp_amont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_almost_mont:AE.bn_exp_almost_mont_st t len ->
bn_mod_exp_precomp_st t len
let mk_bn_mod_exp_precomp_amont #t len bn_exp_almost_mont n mu r2 a bBits b =
bn_eval_bound n len;
let aM = BM.bn_to_mont n mu r2 a in
BM.bn_to_mont_lemma n mu r2 a;
M.to_mont_lemma (bits t) len (bn_v n) (v mu) (bn_v a);
let accM = bn_exp_almost_mont n mu aM bBits b in
let acc = BM.bn_from_mont n mu accM in
BM.bn_from_mont_lemma n mu accM;
bn_eval_bound accM len;
E.mod_exp_mont_ll_mod_lemma (bits t) len (bn_v n) (v mu) (bn_v a) (bn_v b) (bn_v accM);
assert (bn_v acc == Lib.NatMod.pow_mod #(bn_v n) (bn_v a) (bn_v b));
acc
let bn_mod_exp_rl_precomp #t len n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len ME.bn_exp_mont_bm_vartime n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len AE.bn_exp_almost_mont_bm_vartime n mu r2 a bBits b
let bn_mod_exp_mont_ladder_swap_precomp #t len n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len ME.bn_exp_mont_bm_consttime n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len AE.bn_exp_almost_mont_bm_consttime n mu r2 a bBits b
let bn_mod_exp_fw_precomp #t len l n mu r2 a bBits b = | false | false | Hacl.Spec.Bignum.Exponentiation.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_exp_fw_precomp:
#t:limb_t
-> len:BN.bn_len t
-> l:size_pos{l < bits t /\ pow2 l * len <= max_size_t} ->
bn_mod_exp_precomp_st t len | [] | Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_fw_precomp | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
len: Hacl.Spec.Bignum.bn_len t ->
l:
Lib.IntTypes.size_pos
{l < Lib.IntTypes.bits t /\ Prims.pow2 l * len <= Lib.IntTypes.max_size_t}
-> Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_precomp_st t len | {
"end_col": 83,
"end_line": 103,
"start_col": 2,
"start_line": 103
} |
Prims.Tot | val bn_mod_exp_rl_precomp: #t:limb_t -> len:BN.bn_len t -> bn_mod_exp_precomp_st t len | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.AlmostMontExponentiation",
"short_module": "AE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.MontExponentiation",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.ModInvLimb",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Exponentiation.Lemmas",
"short_module": "E"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let bn_mod_exp_rl_precomp #t len n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len ME.bn_exp_mont_bm_vartime n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len AE.bn_exp_almost_mont_bm_vartime n mu r2 a bBits b | val bn_mod_exp_rl_precomp: #t:limb_t -> len:BN.bn_len t -> bn_mod_exp_precomp_st t len
let bn_mod_exp_rl_precomp #t len n mu r2 a bBits b = | false | null | false | mk_bn_mod_exp_precomp_amont #t len AE.bn_exp_almost_mont_bm_vartime n mu r2 a bBits b | {
"checked_file": "Hacl.Spec.Bignum.Exponentiation.fst.checked",
"dependencies": [
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Exponentiation.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.MontExponentiation.fst.checked",
"Hacl.Spec.Bignum.ModInvLimb.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.AlmostMontExponentiation.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.Bignum.Exponentiation.fst"
} | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.bn_len",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.limb",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.blocks0",
"Lib.IntTypes.bits",
"Hacl.Spec.Bignum.Exponentiation.mk_bn_mod_exp_precomp_amont",
"Hacl.Spec.Bignum.AlmostMontExponentiation.bn_exp_almost_mont_bm_vartime"
] | [] | module Hacl.Spec.Bignum.Exponentiation
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module E = Hacl.Spec.Exponentiation.Lemmas
module M = Hacl.Spec.Montgomery.Lemmas
module BN = Hacl.Spec.Bignum
module BM = Hacl.Spec.Bignum.Montgomery
module BI = Hacl.Spec.Bignum.ModInvLimb
module ME = Hacl.Spec.Bignum.MontExponentiation
module AE = Hacl.Spec.Bignum.AlmostMontExponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let bn_check_mod_exp #t #len n a bBits b =
let pbits = bits t in
let m0 = BM.bn_check_modulus n in
bn_eval_bound b (blocks0 bBits pbits);
let m1 =
if bBits < pbits * blocks0 bBits pbits then begin
BN.bn_lt_pow2_mask_lemma b bBits;
BN.bn_lt_pow2_mask b bBits end
else begin
Math.Lemmas.pow2_le_compat bBits (pbits * blocks bBits pbits);
ones t SEC end in
assert (if v m1 = 0 then pow2 bBits <= bn_v b else bn_v b < pow2 bBits);
let m2 = BN.bn_lt_mask a n in
BN.bn_lt_mask_lemma a n;
assert (if v m2 = 0 then bn_v a >= bn_v n else bn_v a < bn_v n);
let m = m1 &. m2 in
logand_lemma m1 m2;
let r = m0 &. m in
logand_lemma m0 m;
r
val mk_bn_mod_exp_precomp_mont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_mont:ME.bn_exp_mont_st t len ->
bn_mod_exp_precomp_st t len
let mk_bn_mod_exp_precomp_mont #t len bn_exp_mont n mu r2 a bBits b =
bn_eval_bound n len;
let aM = BM.bn_to_mont n mu r2 a in
BM.bn_to_mont_lemma n mu r2 a;
let accM = bn_exp_mont n mu aM bBits b in
let acc = BM.bn_from_mont n mu accM in
BM.bn_from_mont_lemma n mu accM;
E.mod_exp_mont_ll_lemma (bits t) len (bn_v n) (v mu) (bn_v a) (bn_v b);
assert (bn_v acc == Lib.NatMod.pow_mod #(bn_v n) (bn_v a) (bn_v b));
acc
val mk_bn_mod_exp_precomp_amont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_almost_mont:AE.bn_exp_almost_mont_st t len ->
bn_mod_exp_precomp_st t len
let mk_bn_mod_exp_precomp_amont #t len bn_exp_almost_mont n mu r2 a bBits b =
bn_eval_bound n len;
let aM = BM.bn_to_mont n mu r2 a in
BM.bn_to_mont_lemma n mu r2 a;
M.to_mont_lemma (bits t) len (bn_v n) (v mu) (bn_v a);
let accM = bn_exp_almost_mont n mu aM bBits b in
let acc = BM.bn_from_mont n mu accM in
BM.bn_from_mont_lemma n mu accM;
bn_eval_bound accM len;
E.mod_exp_mont_ll_mod_lemma (bits t) len (bn_v n) (v mu) (bn_v a) (bn_v b) (bn_v accM);
assert (bn_v acc == Lib.NatMod.pow_mod #(bn_v n) (bn_v a) (bn_v b));
acc
let bn_mod_exp_rl_precomp #t len n mu r2 a bBits b = | false | false | Hacl.Spec.Bignum.Exponentiation.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_exp_rl_precomp: #t:limb_t -> len:BN.bn_len t -> bn_mod_exp_precomp_st t len | [] | Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_rl_precomp | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Hacl.Spec.Bignum.bn_len t -> Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_precomp_st t len | {
"end_col": 87,
"end_line": 95,
"start_col": 2,
"start_line": 95
} |
Prims.Tot | val mk_bn_mod_exp:
#t:limb_t
-> len:BN.bn_len t
-> bn_mod_exp_precomp:bn_mod_exp_precomp_st t len ->
bn_mod_exp_st t len | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.AlmostMontExponentiation",
"short_module": "AE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.MontExponentiation",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.ModInvLimb",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Exponentiation.Lemmas",
"short_module": "E"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let mk_bn_mod_exp #t len bn_mod_exp_precomp nBits n a bBits b =
let r2, mu = BM.bn_mont_precomp nBits n in
bn_mod_exp_precomp n mu r2 a bBits b | val mk_bn_mod_exp:
#t:limb_t
-> len:BN.bn_len t
-> bn_mod_exp_precomp:bn_mod_exp_precomp_st t len ->
bn_mod_exp_st t len
let mk_bn_mod_exp #t len bn_mod_exp_precomp nBits n a bBits b = | false | null | false | let r2, mu = BM.bn_mont_precomp nBits n in
bn_mod_exp_precomp n mu r2 a bBits b | {
"checked_file": "Hacl.Spec.Bignum.Exponentiation.fst.checked",
"dependencies": [
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Exponentiation.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.MontExponentiation.fst.checked",
"Hacl.Spec.Bignum.ModInvLimb.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.AlmostMontExponentiation.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.Bignum.Exponentiation.fst"
} | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.bn_len",
"Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_precomp_st",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.blocks0",
"Lib.IntTypes.bits",
"Hacl.Spec.Bignum.Definitions.limb",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Montgomery.bn_mont_precomp"
] | [] | module Hacl.Spec.Bignum.Exponentiation
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module E = Hacl.Spec.Exponentiation.Lemmas
module M = Hacl.Spec.Montgomery.Lemmas
module BN = Hacl.Spec.Bignum
module BM = Hacl.Spec.Bignum.Montgomery
module BI = Hacl.Spec.Bignum.ModInvLimb
module ME = Hacl.Spec.Bignum.MontExponentiation
module AE = Hacl.Spec.Bignum.AlmostMontExponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let bn_check_mod_exp #t #len n a bBits b =
let pbits = bits t in
let m0 = BM.bn_check_modulus n in
bn_eval_bound b (blocks0 bBits pbits);
let m1 =
if bBits < pbits * blocks0 bBits pbits then begin
BN.bn_lt_pow2_mask_lemma b bBits;
BN.bn_lt_pow2_mask b bBits end
else begin
Math.Lemmas.pow2_le_compat bBits (pbits * blocks bBits pbits);
ones t SEC end in
assert (if v m1 = 0 then pow2 bBits <= bn_v b else bn_v b < pow2 bBits);
let m2 = BN.bn_lt_mask a n in
BN.bn_lt_mask_lemma a n;
assert (if v m2 = 0 then bn_v a >= bn_v n else bn_v a < bn_v n);
let m = m1 &. m2 in
logand_lemma m1 m2;
let r = m0 &. m in
logand_lemma m0 m;
r
val mk_bn_mod_exp_precomp_mont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_mont:ME.bn_exp_mont_st t len ->
bn_mod_exp_precomp_st t len
let mk_bn_mod_exp_precomp_mont #t len bn_exp_mont n mu r2 a bBits b =
bn_eval_bound n len;
let aM = BM.bn_to_mont n mu r2 a in
BM.bn_to_mont_lemma n mu r2 a;
let accM = bn_exp_mont n mu aM bBits b in
let acc = BM.bn_from_mont n mu accM in
BM.bn_from_mont_lemma n mu accM;
E.mod_exp_mont_ll_lemma (bits t) len (bn_v n) (v mu) (bn_v a) (bn_v b);
assert (bn_v acc == Lib.NatMod.pow_mod #(bn_v n) (bn_v a) (bn_v b));
acc
val mk_bn_mod_exp_precomp_amont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_almost_mont:AE.bn_exp_almost_mont_st t len ->
bn_mod_exp_precomp_st t len
let mk_bn_mod_exp_precomp_amont #t len bn_exp_almost_mont n mu r2 a bBits b =
bn_eval_bound n len;
let aM = BM.bn_to_mont n mu r2 a in
BM.bn_to_mont_lemma n mu r2 a;
M.to_mont_lemma (bits t) len (bn_v n) (v mu) (bn_v a);
let accM = bn_exp_almost_mont n mu aM bBits b in
let acc = BM.bn_from_mont n mu accM in
BM.bn_from_mont_lemma n mu accM;
bn_eval_bound accM len;
E.mod_exp_mont_ll_mod_lemma (bits t) len (bn_v n) (v mu) (bn_v a) (bn_v b) (bn_v accM);
assert (bn_v acc == Lib.NatMod.pow_mod #(bn_v n) (bn_v a) (bn_v b));
acc
let bn_mod_exp_rl_precomp #t len n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len ME.bn_exp_mont_bm_vartime n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len AE.bn_exp_almost_mont_bm_vartime n mu r2 a bBits b
let bn_mod_exp_mont_ladder_swap_precomp #t len n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len ME.bn_exp_mont_bm_consttime n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len AE.bn_exp_almost_mont_bm_consttime n mu r2 a bBits b
let bn_mod_exp_fw_precomp #t len l n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len (ME.bn_exp_mont_fw l) n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len (AE.bn_exp_almost_mont_fw l) n mu r2 a bBits b
let bn_mod_exp_vartime_precomp #t len n mu r2 a bBits b =
if bBits < ME.bn_exp_mont_vartime_threshold then
bn_mod_exp_rl_precomp #t len n mu r2 a bBits b
else
bn_mod_exp_fw_precomp #t len 4 n mu r2 a bBits b
let bn_mod_exp_consttime_precomp #t len n mu r2 a bBits b =
if bBits < ME.bn_exp_mont_consttime_threshold then
bn_mod_exp_mont_ladder_swap_precomp #t len n mu r2 a bBits b
else
bn_mod_exp_fw_precomp #t len 4 n mu r2 a bBits b
val mk_bn_mod_exp_precompr2:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_precomp:bn_mod_exp_precomp_st t len ->
bn_mod_exp_precompr2_st t len
let mk_bn_mod_exp_precompr2 #t len bn_exp_precomp n r2 a bBits b =
let mu = BI.mod_inv_limb n.[0] in
BI.bn_mod_inv_limb_lemma n;
bn_exp_precomp n mu r2 a bBits b
let bn_mod_exp_vartime_precompr2 #t len n r2 a bBits b =
mk_bn_mod_exp_precompr2 #t len (bn_mod_exp_vartime_precomp len) n r2 a bBits b
let bn_mod_exp_consttime_precompr2 #t len n r2 a bBits b =
mk_bn_mod_exp_precompr2 #t len (bn_mod_exp_consttime_precomp len) n r2 a bBits b
val mk_bn_mod_exp:
#t:limb_t
-> len:BN.bn_len t
-> bn_mod_exp_precomp:bn_mod_exp_precomp_st t len ->
bn_mod_exp_st t len | false | false | Hacl.Spec.Bignum.Exponentiation.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 mk_bn_mod_exp:
#t:limb_t
-> len:BN.bn_len t
-> bn_mod_exp_precomp:bn_mod_exp_precomp_st t len ->
bn_mod_exp_st t len | [] | Hacl.Spec.Bignum.Exponentiation.mk_bn_mod_exp | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
len: Hacl.Spec.Bignum.bn_len t ->
bn_mod_exp_precomp: Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_precomp_st t len
-> Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_st t len | {
"end_col": 38,
"end_line": 146,
"start_col": 63,
"start_line": 144
} |
Prims.Tot | val mk_bn_mod_exp_precompr2:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_precomp:bn_mod_exp_precomp_st t len ->
bn_mod_exp_precompr2_st t len | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.AlmostMontExponentiation",
"short_module": "AE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.MontExponentiation",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.ModInvLimb",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Exponentiation.Lemmas",
"short_module": "E"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let mk_bn_mod_exp_precompr2 #t len bn_exp_precomp n r2 a bBits b =
let mu = BI.mod_inv_limb n.[0] in
BI.bn_mod_inv_limb_lemma n;
bn_exp_precomp n mu r2 a bBits b | val mk_bn_mod_exp_precompr2:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_precomp:bn_mod_exp_precomp_st t len ->
bn_mod_exp_precompr2_st t len
let mk_bn_mod_exp_precompr2 #t len bn_exp_precomp n r2 a bBits b = | false | null | false | let mu = BI.mod_inv_limb n.[ 0 ] in
BI.bn_mod_inv_limb_lemma n;
bn_exp_precomp n mu r2 a bBits b | {
"checked_file": "Hacl.Spec.Bignum.Exponentiation.fst.checked",
"dependencies": [
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Exponentiation.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.MontExponentiation.fst.checked",
"Hacl.Spec.Bignum.ModInvLimb.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.AlmostMontExponentiation.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.Bignum.Exponentiation.fst"
} | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.bn_len",
"Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_precomp_st",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.blocks0",
"Lib.IntTypes.bits",
"Prims.unit",
"Hacl.Spec.Bignum.ModInvLimb.bn_mod_inv_limb_lemma",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.ModInvLimb.mod_inv_limb",
"Lib.Sequence.op_String_Access"
] | [] | module Hacl.Spec.Bignum.Exponentiation
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module E = Hacl.Spec.Exponentiation.Lemmas
module M = Hacl.Spec.Montgomery.Lemmas
module BN = Hacl.Spec.Bignum
module BM = Hacl.Spec.Bignum.Montgomery
module BI = Hacl.Spec.Bignum.ModInvLimb
module ME = Hacl.Spec.Bignum.MontExponentiation
module AE = Hacl.Spec.Bignum.AlmostMontExponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let bn_check_mod_exp #t #len n a bBits b =
let pbits = bits t in
let m0 = BM.bn_check_modulus n in
bn_eval_bound b (blocks0 bBits pbits);
let m1 =
if bBits < pbits * blocks0 bBits pbits then begin
BN.bn_lt_pow2_mask_lemma b bBits;
BN.bn_lt_pow2_mask b bBits end
else begin
Math.Lemmas.pow2_le_compat bBits (pbits * blocks bBits pbits);
ones t SEC end in
assert (if v m1 = 0 then pow2 bBits <= bn_v b else bn_v b < pow2 bBits);
let m2 = BN.bn_lt_mask a n in
BN.bn_lt_mask_lemma a n;
assert (if v m2 = 0 then bn_v a >= bn_v n else bn_v a < bn_v n);
let m = m1 &. m2 in
logand_lemma m1 m2;
let r = m0 &. m in
logand_lemma m0 m;
r
val mk_bn_mod_exp_precomp_mont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_mont:ME.bn_exp_mont_st t len ->
bn_mod_exp_precomp_st t len
let mk_bn_mod_exp_precomp_mont #t len bn_exp_mont n mu r2 a bBits b =
bn_eval_bound n len;
let aM = BM.bn_to_mont n mu r2 a in
BM.bn_to_mont_lemma n mu r2 a;
let accM = bn_exp_mont n mu aM bBits b in
let acc = BM.bn_from_mont n mu accM in
BM.bn_from_mont_lemma n mu accM;
E.mod_exp_mont_ll_lemma (bits t) len (bn_v n) (v mu) (bn_v a) (bn_v b);
assert (bn_v acc == Lib.NatMod.pow_mod #(bn_v n) (bn_v a) (bn_v b));
acc
val mk_bn_mod_exp_precomp_amont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_almost_mont:AE.bn_exp_almost_mont_st t len ->
bn_mod_exp_precomp_st t len
let mk_bn_mod_exp_precomp_amont #t len bn_exp_almost_mont n mu r2 a bBits b =
bn_eval_bound n len;
let aM = BM.bn_to_mont n mu r2 a in
BM.bn_to_mont_lemma n mu r2 a;
M.to_mont_lemma (bits t) len (bn_v n) (v mu) (bn_v a);
let accM = bn_exp_almost_mont n mu aM bBits b in
let acc = BM.bn_from_mont n mu accM in
BM.bn_from_mont_lemma n mu accM;
bn_eval_bound accM len;
E.mod_exp_mont_ll_mod_lemma (bits t) len (bn_v n) (v mu) (bn_v a) (bn_v b) (bn_v accM);
assert (bn_v acc == Lib.NatMod.pow_mod #(bn_v n) (bn_v a) (bn_v b));
acc
let bn_mod_exp_rl_precomp #t len n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len ME.bn_exp_mont_bm_vartime n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len AE.bn_exp_almost_mont_bm_vartime n mu r2 a bBits b
let bn_mod_exp_mont_ladder_swap_precomp #t len n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len ME.bn_exp_mont_bm_consttime n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len AE.bn_exp_almost_mont_bm_consttime n mu r2 a bBits b
let bn_mod_exp_fw_precomp #t len l n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len (ME.bn_exp_mont_fw l) n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len (AE.bn_exp_almost_mont_fw l) n mu r2 a bBits b
let bn_mod_exp_vartime_precomp #t len n mu r2 a bBits b =
if bBits < ME.bn_exp_mont_vartime_threshold then
bn_mod_exp_rl_precomp #t len n mu r2 a bBits b
else
bn_mod_exp_fw_precomp #t len 4 n mu r2 a bBits b
let bn_mod_exp_consttime_precomp #t len n mu r2 a bBits b =
if bBits < ME.bn_exp_mont_consttime_threshold then
bn_mod_exp_mont_ladder_swap_precomp #t len n mu r2 a bBits b
else
bn_mod_exp_fw_precomp #t len 4 n mu r2 a bBits b
val mk_bn_mod_exp_precompr2:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_precomp:bn_mod_exp_precomp_st t len ->
bn_mod_exp_precompr2_st t len | false | false | Hacl.Spec.Bignum.Exponentiation.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 mk_bn_mod_exp_precompr2:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_precomp:bn_mod_exp_precomp_st t len ->
bn_mod_exp_precompr2_st t len | [] | Hacl.Spec.Bignum.Exponentiation.mk_bn_mod_exp_precompr2 | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
len: Hacl.Spec.Bignum.bn_len t ->
bn_exp_precomp: Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_precomp_st t len
-> Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_precompr2_st t len | {
"end_col": 34,
"end_line": 128,
"start_col": 66,
"start_line": 125
} |
Prims.Tot | val bn_mod_exp_consttime_precomp: #t:limb_t -> len:BN.bn_len t -> bn_mod_exp_precomp_st t len | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.AlmostMontExponentiation",
"short_module": "AE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.MontExponentiation",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.ModInvLimb",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Exponentiation.Lemmas",
"short_module": "E"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let bn_mod_exp_consttime_precomp #t len n mu r2 a bBits b =
if bBits < ME.bn_exp_mont_consttime_threshold then
bn_mod_exp_mont_ladder_swap_precomp #t len n mu r2 a bBits b
else
bn_mod_exp_fw_precomp #t len 4 n mu r2 a bBits b | val bn_mod_exp_consttime_precomp: #t:limb_t -> len:BN.bn_len t -> bn_mod_exp_precomp_st t len
let bn_mod_exp_consttime_precomp #t len n mu r2 a bBits b = | false | null | false | if bBits < ME.bn_exp_mont_consttime_threshold
then bn_mod_exp_mont_ladder_swap_precomp #t len n mu r2 a bBits b
else bn_mod_exp_fw_precomp #t len 4 n mu r2 a bBits b | {
"checked_file": "Hacl.Spec.Bignum.Exponentiation.fst.checked",
"dependencies": [
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Exponentiation.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.MontExponentiation.fst.checked",
"Hacl.Spec.Bignum.ModInvLimb.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.AlmostMontExponentiation.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.Bignum.Exponentiation.fst"
} | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.bn_len",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.limb",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.blocks0",
"Lib.IntTypes.bits",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.MontExponentiation.bn_exp_mont_consttime_threshold",
"Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_mont_ladder_swap_precomp",
"Prims.bool",
"Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_fw_precomp"
] | [] | module Hacl.Spec.Bignum.Exponentiation
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module E = Hacl.Spec.Exponentiation.Lemmas
module M = Hacl.Spec.Montgomery.Lemmas
module BN = Hacl.Spec.Bignum
module BM = Hacl.Spec.Bignum.Montgomery
module BI = Hacl.Spec.Bignum.ModInvLimb
module ME = Hacl.Spec.Bignum.MontExponentiation
module AE = Hacl.Spec.Bignum.AlmostMontExponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let bn_check_mod_exp #t #len n a bBits b =
let pbits = bits t in
let m0 = BM.bn_check_modulus n in
bn_eval_bound b (blocks0 bBits pbits);
let m1 =
if bBits < pbits * blocks0 bBits pbits then begin
BN.bn_lt_pow2_mask_lemma b bBits;
BN.bn_lt_pow2_mask b bBits end
else begin
Math.Lemmas.pow2_le_compat bBits (pbits * blocks bBits pbits);
ones t SEC end in
assert (if v m1 = 0 then pow2 bBits <= bn_v b else bn_v b < pow2 bBits);
let m2 = BN.bn_lt_mask a n in
BN.bn_lt_mask_lemma a n;
assert (if v m2 = 0 then bn_v a >= bn_v n else bn_v a < bn_v n);
let m = m1 &. m2 in
logand_lemma m1 m2;
let r = m0 &. m in
logand_lemma m0 m;
r
val mk_bn_mod_exp_precomp_mont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_mont:ME.bn_exp_mont_st t len ->
bn_mod_exp_precomp_st t len
let mk_bn_mod_exp_precomp_mont #t len bn_exp_mont n mu r2 a bBits b =
bn_eval_bound n len;
let aM = BM.bn_to_mont n mu r2 a in
BM.bn_to_mont_lemma n mu r2 a;
let accM = bn_exp_mont n mu aM bBits b in
let acc = BM.bn_from_mont n mu accM in
BM.bn_from_mont_lemma n mu accM;
E.mod_exp_mont_ll_lemma (bits t) len (bn_v n) (v mu) (bn_v a) (bn_v b);
assert (bn_v acc == Lib.NatMod.pow_mod #(bn_v n) (bn_v a) (bn_v b));
acc
val mk_bn_mod_exp_precomp_amont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_almost_mont:AE.bn_exp_almost_mont_st t len ->
bn_mod_exp_precomp_st t len
let mk_bn_mod_exp_precomp_amont #t len bn_exp_almost_mont n mu r2 a bBits b =
bn_eval_bound n len;
let aM = BM.bn_to_mont n mu r2 a in
BM.bn_to_mont_lemma n mu r2 a;
M.to_mont_lemma (bits t) len (bn_v n) (v mu) (bn_v a);
let accM = bn_exp_almost_mont n mu aM bBits b in
let acc = BM.bn_from_mont n mu accM in
BM.bn_from_mont_lemma n mu accM;
bn_eval_bound accM len;
E.mod_exp_mont_ll_mod_lemma (bits t) len (bn_v n) (v mu) (bn_v a) (bn_v b) (bn_v accM);
assert (bn_v acc == Lib.NatMod.pow_mod #(bn_v n) (bn_v a) (bn_v b));
acc
let bn_mod_exp_rl_precomp #t len n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len ME.bn_exp_mont_bm_vartime n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len AE.bn_exp_almost_mont_bm_vartime n mu r2 a bBits b
let bn_mod_exp_mont_ladder_swap_precomp #t len n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len ME.bn_exp_mont_bm_consttime n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len AE.bn_exp_almost_mont_bm_consttime n mu r2 a bBits b
let bn_mod_exp_fw_precomp #t len l n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len (ME.bn_exp_mont_fw l) n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len (AE.bn_exp_almost_mont_fw l) n mu r2 a bBits b
let bn_mod_exp_vartime_precomp #t len n mu r2 a bBits b =
if bBits < ME.bn_exp_mont_vartime_threshold then
bn_mod_exp_rl_precomp #t len n mu r2 a bBits b
else
bn_mod_exp_fw_precomp #t len 4 n mu r2 a bBits b | false | false | Hacl.Spec.Bignum.Exponentiation.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_exp_consttime_precomp: #t:limb_t -> len:BN.bn_len t -> bn_mod_exp_precomp_st t len | [] | Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_consttime_precomp | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Hacl.Spec.Bignum.bn_len t -> Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_precomp_st t len | {
"end_col": 52,
"end_line": 116,
"start_col": 2,
"start_line": 113
} |
Prims.Tot | val bn_mod_exp_vartime_precomp: #t:limb_t -> len:BN.bn_len t -> bn_mod_exp_precomp_st t len | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.AlmostMontExponentiation",
"short_module": "AE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.MontExponentiation",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.ModInvLimb",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Exponentiation.Lemmas",
"short_module": "E"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let bn_mod_exp_vartime_precomp #t len n mu r2 a bBits b =
if bBits < ME.bn_exp_mont_vartime_threshold then
bn_mod_exp_rl_precomp #t len n mu r2 a bBits b
else
bn_mod_exp_fw_precomp #t len 4 n mu r2 a bBits b | val bn_mod_exp_vartime_precomp: #t:limb_t -> len:BN.bn_len t -> bn_mod_exp_precomp_st t len
let bn_mod_exp_vartime_precomp #t len n mu r2 a bBits b = | false | null | false | if bBits < ME.bn_exp_mont_vartime_threshold
then bn_mod_exp_rl_precomp #t len n mu r2 a bBits b
else bn_mod_exp_fw_precomp #t len 4 n mu r2 a bBits b | {
"checked_file": "Hacl.Spec.Bignum.Exponentiation.fst.checked",
"dependencies": [
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Exponentiation.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.MontExponentiation.fst.checked",
"Hacl.Spec.Bignum.ModInvLimb.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.AlmostMontExponentiation.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.Bignum.Exponentiation.fst"
} | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.bn_len",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.limb",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.blocks0",
"Lib.IntTypes.bits",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.MontExponentiation.bn_exp_mont_vartime_threshold",
"Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_rl_precomp",
"Prims.bool",
"Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_fw_precomp"
] | [] | module Hacl.Spec.Bignum.Exponentiation
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module E = Hacl.Spec.Exponentiation.Lemmas
module M = Hacl.Spec.Montgomery.Lemmas
module BN = Hacl.Spec.Bignum
module BM = Hacl.Spec.Bignum.Montgomery
module BI = Hacl.Spec.Bignum.ModInvLimb
module ME = Hacl.Spec.Bignum.MontExponentiation
module AE = Hacl.Spec.Bignum.AlmostMontExponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let bn_check_mod_exp #t #len n a bBits b =
let pbits = bits t in
let m0 = BM.bn_check_modulus n in
bn_eval_bound b (blocks0 bBits pbits);
let m1 =
if bBits < pbits * blocks0 bBits pbits then begin
BN.bn_lt_pow2_mask_lemma b bBits;
BN.bn_lt_pow2_mask b bBits end
else begin
Math.Lemmas.pow2_le_compat bBits (pbits * blocks bBits pbits);
ones t SEC end in
assert (if v m1 = 0 then pow2 bBits <= bn_v b else bn_v b < pow2 bBits);
let m2 = BN.bn_lt_mask a n in
BN.bn_lt_mask_lemma a n;
assert (if v m2 = 0 then bn_v a >= bn_v n else bn_v a < bn_v n);
let m = m1 &. m2 in
logand_lemma m1 m2;
let r = m0 &. m in
logand_lemma m0 m;
r
val mk_bn_mod_exp_precomp_mont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_mont:ME.bn_exp_mont_st t len ->
bn_mod_exp_precomp_st t len
let mk_bn_mod_exp_precomp_mont #t len bn_exp_mont n mu r2 a bBits b =
bn_eval_bound n len;
let aM = BM.bn_to_mont n mu r2 a in
BM.bn_to_mont_lemma n mu r2 a;
let accM = bn_exp_mont n mu aM bBits b in
let acc = BM.bn_from_mont n mu accM in
BM.bn_from_mont_lemma n mu accM;
E.mod_exp_mont_ll_lemma (bits t) len (bn_v n) (v mu) (bn_v a) (bn_v b);
assert (bn_v acc == Lib.NatMod.pow_mod #(bn_v n) (bn_v a) (bn_v b));
acc
val mk_bn_mod_exp_precomp_amont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_almost_mont:AE.bn_exp_almost_mont_st t len ->
bn_mod_exp_precomp_st t len
let mk_bn_mod_exp_precomp_amont #t len bn_exp_almost_mont n mu r2 a bBits b =
bn_eval_bound n len;
let aM = BM.bn_to_mont n mu r2 a in
BM.bn_to_mont_lemma n mu r2 a;
M.to_mont_lemma (bits t) len (bn_v n) (v mu) (bn_v a);
let accM = bn_exp_almost_mont n mu aM bBits b in
let acc = BM.bn_from_mont n mu accM in
BM.bn_from_mont_lemma n mu accM;
bn_eval_bound accM len;
E.mod_exp_mont_ll_mod_lemma (bits t) len (bn_v n) (v mu) (bn_v a) (bn_v b) (bn_v accM);
assert (bn_v acc == Lib.NatMod.pow_mod #(bn_v n) (bn_v a) (bn_v b));
acc
let bn_mod_exp_rl_precomp #t len n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len ME.bn_exp_mont_bm_vartime n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len AE.bn_exp_almost_mont_bm_vartime n mu r2 a bBits b
let bn_mod_exp_mont_ladder_swap_precomp #t len n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len ME.bn_exp_mont_bm_consttime n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len AE.bn_exp_almost_mont_bm_consttime n mu r2 a bBits b
let bn_mod_exp_fw_precomp #t len l n mu r2 a bBits b =
//mk_bn_mod_exp_precomp_mont #t len (ME.bn_exp_mont_fw l) n mu r2 a bBits b
mk_bn_mod_exp_precomp_amont #t len (AE.bn_exp_almost_mont_fw l) n mu r2 a bBits b | false | false | Hacl.Spec.Bignum.Exponentiation.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_exp_vartime_precomp: #t:limb_t -> len:BN.bn_len t -> bn_mod_exp_precomp_st t len | [] | Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_vartime_precomp | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Hacl.Spec.Bignum.bn_len t -> Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_precomp_st t len | {
"end_col": 52,
"end_line": 110,
"start_col": 2,
"start_line": 107
} |
Prims.Tot | val mk_bn_mod_exp_precomp_mont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_mont:ME.bn_exp_mont_st t len ->
bn_mod_exp_precomp_st t len | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.AlmostMontExponentiation",
"short_module": "AE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.MontExponentiation",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.ModInvLimb",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Exponentiation.Lemmas",
"short_module": "E"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let mk_bn_mod_exp_precomp_mont #t len bn_exp_mont n mu r2 a bBits b =
bn_eval_bound n len;
let aM = BM.bn_to_mont n mu r2 a in
BM.bn_to_mont_lemma n mu r2 a;
let accM = bn_exp_mont n mu aM bBits b in
let acc = BM.bn_from_mont n mu accM in
BM.bn_from_mont_lemma n mu accM;
E.mod_exp_mont_ll_lemma (bits t) len (bn_v n) (v mu) (bn_v a) (bn_v b);
assert (bn_v acc == Lib.NatMod.pow_mod #(bn_v n) (bn_v a) (bn_v b));
acc | val mk_bn_mod_exp_precomp_mont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_mont:ME.bn_exp_mont_st t len ->
bn_mod_exp_precomp_st t len
let mk_bn_mod_exp_precomp_mont #t len bn_exp_mont n mu r2 a bBits b = | false | null | false | bn_eval_bound n len;
let aM = BM.bn_to_mont n mu r2 a in
BM.bn_to_mont_lemma n mu r2 a;
let accM = bn_exp_mont n mu aM bBits b in
let acc = BM.bn_from_mont n mu accM in
BM.bn_from_mont_lemma n mu accM;
E.mod_exp_mont_ll_lemma (bits t) len (bn_v n) (v mu) (bn_v a) (bn_v b);
assert (bn_v acc == Lib.NatMod.pow_mod #(bn_v n) (bn_v a) (bn_v b));
acc | {
"checked_file": "Hacl.Spec.Bignum.Exponentiation.fst.checked",
"dependencies": [
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Exponentiation.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.MontExponentiation.fst.checked",
"Hacl.Spec.Bignum.ModInvLimb.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.AlmostMontExponentiation.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.Bignum.Exponentiation.fst"
} | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.bn_len",
"Hacl.Spec.Bignum.MontExponentiation.bn_exp_mont_st",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.limb",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.blocks0",
"Lib.IntTypes.bits",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.nat",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Lib.NatMod.pow_mod",
"Hacl.Spec.Exponentiation.Lemmas.mod_exp_mont_ll_lemma",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Hacl.Spec.Bignum.Montgomery.bn_from_mont_lemma",
"Hacl.Spec.Bignum.Montgomery.bn_from_mont",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Montgomery.bn_to_mont_lemma",
"Hacl.Spec.Bignum.Montgomery.bn_to_mont",
"Hacl.Spec.Bignum.Definitions.bn_eval_bound"
] | [] | module Hacl.Spec.Bignum.Exponentiation
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module E = Hacl.Spec.Exponentiation.Lemmas
module M = Hacl.Spec.Montgomery.Lemmas
module BN = Hacl.Spec.Bignum
module BM = Hacl.Spec.Bignum.Montgomery
module BI = Hacl.Spec.Bignum.ModInvLimb
module ME = Hacl.Spec.Bignum.MontExponentiation
module AE = Hacl.Spec.Bignum.AlmostMontExponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let bn_check_mod_exp #t #len n a bBits b =
let pbits = bits t in
let m0 = BM.bn_check_modulus n in
bn_eval_bound b (blocks0 bBits pbits);
let m1 =
if bBits < pbits * blocks0 bBits pbits then begin
BN.bn_lt_pow2_mask_lemma b bBits;
BN.bn_lt_pow2_mask b bBits end
else begin
Math.Lemmas.pow2_le_compat bBits (pbits * blocks bBits pbits);
ones t SEC end in
assert (if v m1 = 0 then pow2 bBits <= bn_v b else bn_v b < pow2 bBits);
let m2 = BN.bn_lt_mask a n in
BN.bn_lt_mask_lemma a n;
assert (if v m2 = 0 then bn_v a >= bn_v n else bn_v a < bn_v n);
let m = m1 &. m2 in
logand_lemma m1 m2;
let r = m0 &. m in
logand_lemma m0 m;
r
val mk_bn_mod_exp_precomp_mont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_mont:ME.bn_exp_mont_st t len ->
bn_mod_exp_precomp_st t len | false | false | Hacl.Spec.Bignum.Exponentiation.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 mk_bn_mod_exp_precomp_mont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_mont:ME.bn_exp_mont_st t len ->
bn_mod_exp_precomp_st t len | [] | Hacl.Spec.Bignum.Exponentiation.mk_bn_mod_exp_precomp_mont | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
len: Hacl.Spec.Bignum.bn_len t ->
bn_exp_mont: Hacl.Spec.Bignum.MontExponentiation.bn_exp_mont_st t len
-> Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_precomp_st t len | {
"end_col": 5,
"end_line": 67,
"start_col": 2,
"start_line": 56
} |
Prims.Tot | val mk_bn_mod_exp_precomp_amont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_almost_mont:AE.bn_exp_almost_mont_st t len ->
bn_mod_exp_precomp_st t len | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.AlmostMontExponentiation",
"short_module": "AE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.MontExponentiation",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.ModInvLimb",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Exponentiation.Lemmas",
"short_module": "E"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let mk_bn_mod_exp_precomp_amont #t len bn_exp_almost_mont n mu r2 a bBits b =
bn_eval_bound n len;
let aM = BM.bn_to_mont n mu r2 a in
BM.bn_to_mont_lemma n mu r2 a;
M.to_mont_lemma (bits t) len (bn_v n) (v mu) (bn_v a);
let accM = bn_exp_almost_mont n mu aM bBits b in
let acc = BM.bn_from_mont n mu accM in
BM.bn_from_mont_lemma n mu accM;
bn_eval_bound accM len;
E.mod_exp_mont_ll_mod_lemma (bits t) len (bn_v n) (v mu) (bn_v a) (bn_v b) (bn_v accM);
assert (bn_v acc == Lib.NatMod.pow_mod #(bn_v n) (bn_v a) (bn_v b));
acc | val mk_bn_mod_exp_precomp_amont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_almost_mont:AE.bn_exp_almost_mont_st t len ->
bn_mod_exp_precomp_st t len
let mk_bn_mod_exp_precomp_amont #t len bn_exp_almost_mont n mu r2 a bBits b = | false | null | false | bn_eval_bound n len;
let aM = BM.bn_to_mont n mu r2 a in
BM.bn_to_mont_lemma n mu r2 a;
M.to_mont_lemma (bits t) len (bn_v n) (v mu) (bn_v a);
let accM = bn_exp_almost_mont n mu aM bBits b in
let acc = BM.bn_from_mont n mu accM in
BM.bn_from_mont_lemma n mu accM;
bn_eval_bound accM len;
E.mod_exp_mont_ll_mod_lemma (bits t) len (bn_v n) (v mu) (bn_v a) (bn_v b) (bn_v accM);
assert (bn_v acc == Lib.NatMod.pow_mod #(bn_v n) (bn_v a) (bn_v b));
acc | {
"checked_file": "Hacl.Spec.Bignum.Exponentiation.fst.checked",
"dependencies": [
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Exponentiation.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.MontExponentiation.fst.checked",
"Hacl.Spec.Bignum.ModInvLimb.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.AlmostMontExponentiation.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.Bignum.Exponentiation.fst"
} | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.bn_len",
"Hacl.Spec.Bignum.AlmostMontExponentiation.bn_exp_almost_mont_st",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.limb",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.blocks0",
"Lib.IntTypes.bits",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.nat",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Lib.NatMod.pow_mod",
"Hacl.Spec.Exponentiation.Lemmas.mod_exp_mont_ll_mod_lemma",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Hacl.Spec.Bignum.Definitions.bn_eval_bound",
"Hacl.Spec.Bignum.Montgomery.bn_from_mont_lemma",
"Hacl.Spec.Bignum.Montgomery.bn_from_mont",
"Hacl.Spec.Montgomery.Lemmas.to_mont_lemma",
"Hacl.Spec.Bignum.Montgomery.bn_to_mont_lemma",
"Hacl.Spec.Bignum.Montgomery.bn_to_mont"
] | [] | module Hacl.Spec.Bignum.Exponentiation
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module E = Hacl.Spec.Exponentiation.Lemmas
module M = Hacl.Spec.Montgomery.Lemmas
module BN = Hacl.Spec.Bignum
module BM = Hacl.Spec.Bignum.Montgomery
module BI = Hacl.Spec.Bignum.ModInvLimb
module ME = Hacl.Spec.Bignum.MontExponentiation
module AE = Hacl.Spec.Bignum.AlmostMontExponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let bn_check_mod_exp #t #len n a bBits b =
let pbits = bits t in
let m0 = BM.bn_check_modulus n in
bn_eval_bound b (blocks0 bBits pbits);
let m1 =
if bBits < pbits * blocks0 bBits pbits then begin
BN.bn_lt_pow2_mask_lemma b bBits;
BN.bn_lt_pow2_mask b bBits end
else begin
Math.Lemmas.pow2_le_compat bBits (pbits * blocks bBits pbits);
ones t SEC end in
assert (if v m1 = 0 then pow2 bBits <= bn_v b else bn_v b < pow2 bBits);
let m2 = BN.bn_lt_mask a n in
BN.bn_lt_mask_lemma a n;
assert (if v m2 = 0 then bn_v a >= bn_v n else bn_v a < bn_v n);
let m = m1 &. m2 in
logand_lemma m1 m2;
let r = m0 &. m in
logand_lemma m0 m;
r
val mk_bn_mod_exp_precomp_mont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_mont:ME.bn_exp_mont_st t len ->
bn_mod_exp_precomp_st t len
let mk_bn_mod_exp_precomp_mont #t len bn_exp_mont n mu r2 a bBits b =
bn_eval_bound n len;
let aM = BM.bn_to_mont n mu r2 a in
BM.bn_to_mont_lemma n mu r2 a;
let accM = bn_exp_mont n mu aM bBits b in
let acc = BM.bn_from_mont n mu accM in
BM.bn_from_mont_lemma n mu accM;
E.mod_exp_mont_ll_lemma (bits t) len (bn_v n) (v mu) (bn_v a) (bn_v b);
assert (bn_v acc == Lib.NatMod.pow_mod #(bn_v n) (bn_v a) (bn_v b));
acc
val mk_bn_mod_exp_precomp_amont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_almost_mont:AE.bn_exp_almost_mont_st t len ->
bn_mod_exp_precomp_st t len | false | false | Hacl.Spec.Bignum.Exponentiation.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 mk_bn_mod_exp_precomp_amont:
#t:limb_t
-> len:BN.bn_len t
-> bn_exp_almost_mont:AE.bn_exp_almost_mont_st t len ->
bn_mod_exp_precomp_st t len | [] | Hacl.Spec.Bignum.Exponentiation.mk_bn_mod_exp_precomp_amont | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Exponentiation.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
len: Hacl.Spec.Bignum.bn_len t ->
bn_exp_almost_mont: Hacl.Spec.Bignum.AlmostMontExponentiation.bn_exp_almost_mont_st t len
-> Hacl.Spec.Bignum.Exponentiation.bn_mod_exp_precomp_st t len | {
"end_col": 5,
"end_line": 90,
"start_col": 2,
"start_line": 77
} |
Prims.Tot | val bn_check_mod_exp:
#t:limb_t
-> #len:BN.bn_len t
-> n:lbignum t len
-> a:lbignum t len
-> bBits:size_nat
-> b:lbignum t (blocks0 bBits (bits t)) ->
res:limb t{
let b =
bn_v n % 2 = 1 && 1 < bn_v n &&
bn_v b < pow2 bBits &&
bn_v a < bn_v n in
v res == (if b then v (ones t SEC) else v (zeros t SEC))} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.AlmostMontExponentiation",
"short_module": "AE"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.MontExponentiation",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.ModInvLimb",
"short_module": "BI"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Exponentiation.Lemmas",
"short_module": "E"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let bn_check_mod_exp #t #len n a bBits b =
let pbits = bits t in
let m0 = BM.bn_check_modulus n in
bn_eval_bound b (blocks0 bBits pbits);
let m1 =
if bBits < pbits * blocks0 bBits pbits then begin
BN.bn_lt_pow2_mask_lemma b bBits;
BN.bn_lt_pow2_mask b bBits end
else begin
Math.Lemmas.pow2_le_compat bBits (pbits * blocks bBits pbits);
ones t SEC end in
assert (if v m1 = 0 then pow2 bBits <= bn_v b else bn_v b < pow2 bBits);
let m2 = BN.bn_lt_mask a n in
BN.bn_lt_mask_lemma a n;
assert (if v m2 = 0 then bn_v a >= bn_v n else bn_v a < bn_v n);
let m = m1 &. m2 in
logand_lemma m1 m2;
let r = m0 &. m in
logand_lemma m0 m;
r | val bn_check_mod_exp:
#t:limb_t
-> #len:BN.bn_len t
-> n:lbignum t len
-> a:lbignum t len
-> bBits:size_nat
-> b:lbignum t (blocks0 bBits (bits t)) ->
res:limb t{
let b =
bn_v n % 2 = 1 && 1 < bn_v n &&
bn_v b < pow2 bBits &&
bn_v a < bn_v n in
v res == (if b then v (ones t SEC) else v (zeros t SEC))}
let bn_check_mod_exp #t #len n a bBits b = | false | null | false | let pbits = bits t in
let m0 = BM.bn_check_modulus n in
bn_eval_bound b (blocks0 bBits pbits);
let m1 =
if bBits < pbits * blocks0 bBits pbits
then
(BN.bn_lt_pow2_mask_lemma b bBits;
BN.bn_lt_pow2_mask b bBits)
else
(Math.Lemmas.pow2_le_compat bBits (pbits * blocks bBits pbits);
ones t SEC)
in
assert (if v m1 = 0 then pow2 bBits <= bn_v b else bn_v b < pow2 bBits);
let m2 = BN.bn_lt_mask a n in
BN.bn_lt_mask_lemma a n;
assert (if v m2 = 0 then bn_v a >= bn_v n else bn_v a < bn_v n);
let m = m1 &. m2 in
logand_lemma m1 m2;
let r = m0 &. m in
logand_lemma m0 m;
r | {
"checked_file": "Hacl.Spec.Bignum.Exponentiation.fst.checked",
"dependencies": [
"Spec.Exponentiation.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Exponentiation.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.MontExponentiation.fst.checked",
"Hacl.Spec.Bignum.ModInvLimb.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.AlmostMontExponentiation.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.Bignum.Exponentiation.fst"
} | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.bn_len",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.blocks0",
"Lib.IntTypes.bits",
"Prims.unit",
"Lib.IntTypes.logand_lemma",
"Lib.IntTypes.SEC",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Amp_Dot",
"Prims._assert",
"Prims.op_Equality",
"Prims.int",
"Lib.IntTypes.v",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.bool",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.bn_lt_mask_lemma",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.bn_lt_mask",
"Prims.op_LessThanOrEqual",
"Prims.pow2",
"FStar.Mul.op_Star",
"Hacl.Spec.Bignum.bn_lt_pow2_mask",
"Hacl.Spec.Bignum.bn_lt_pow2_mask_lemma",
"Lib.IntTypes.ones",
"FStar.Math.Lemmas.pow2_le_compat",
"Hacl.Spec.Bignum.Definitions.blocks",
"Hacl.Spec.Bignum.Definitions.bn_eval_bound",
"Prims.eq2",
"Lib.IntTypes.range",
"Prims.op_AmpAmp",
"Prims.op_Modulus",
"Lib.IntTypes.zeros",
"Hacl.Spec.Bignum.Montgomery.bn_check_modulus",
"Lib.IntTypes.range_t"
] | [] | module Hacl.Spec.Bignum.Exponentiation
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module E = Hacl.Spec.Exponentiation.Lemmas
module M = Hacl.Spec.Montgomery.Lemmas
module BN = Hacl.Spec.Bignum
module BM = Hacl.Spec.Bignum.Montgomery
module BI = Hacl.Spec.Bignum.ModInvLimb
module ME = Hacl.Spec.Bignum.MontExponentiation
module AE = Hacl.Spec.Bignum.AlmostMontExponentiation
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" | false | false | Hacl.Spec.Bignum.Exponentiation.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_check_mod_exp:
#t:limb_t
-> #len:BN.bn_len t
-> n:lbignum t len
-> a:lbignum t len
-> bBits:size_nat
-> b:lbignum t (blocks0 bBits (bits t)) ->
res:limb t{
let b =
bn_v n % 2 = 1 && 1 < bn_v n &&
bn_v b < pow2 bBits &&
bn_v a < bn_v n in
v res == (if b then v (ones t SEC) else v (zeros t SEC))} | [] | Hacl.Spec.Bignum.Exponentiation.bn_check_mod_exp | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Exponentiation.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 len ->
a: Hacl.Spec.Bignum.Definitions.lbignum t len ->
bBits: Lib.IntTypes.size_nat ->
b:
Hacl.Spec.Bignum.Definitions.lbignum t
(Hacl.Spec.Bignum.Definitions.blocks0 bBits (Lib.IntTypes.bits t))
-> res:
Hacl.Spec.Bignum.Definitions.limb t
{ let b =
Hacl.Spec.Bignum.Definitions.bn_v n % 2 = 1 && 1 < Hacl.Spec.Bignum.Definitions.bn_v n &&
Hacl.Spec.Bignum.Definitions.bn_v b < Prims.pow2 bBits &&
Hacl.Spec.Bignum.Definitions.bn_v a < Hacl.Spec.Bignum.Definitions.bn_v n
in
Lib.IntTypes.v res ==
(match b with
| true -> Lib.IntTypes.v (Lib.IntTypes.ones t Lib.IntTypes.SEC)
| _ -> Lib.IntTypes.v (Lib.IntTypes.zeros t Lib.IntTypes.SEC)) } | {
"end_col": 3,
"end_line": 46,
"start_col": 42,
"start_line": 24
} |
Prims.Tot | [
{
"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 lbignum (t:limb_t) len = lseq (limb t) len | let lbignum (t: limb_t) len = | false | null | false | lseq (limb t) len | {
"checked_file": "Hacl.Spec.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Definitions.fst"
} | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Lib.Sequence.lseq",
"Hacl.Spec.Bignum.Definitions.limb"
] | [] | module Hacl.Spec.Bignum.Definitions
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val blocks0: x:size_nat -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks0 x m = if x = 0 then 1 else (x - 1) / m + 1
inline_for_extraction noextract
let limb_t = t:inttype{t = U32 \/ t = U64}
inline_for_extraction noextract | false | true | Hacl.Spec.Bignum.Definitions.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 lbignum : t: Hacl.Spec.Bignum.Definitions.limb_t -> len: Lib.IntTypes.size_nat -> Type0 | [] | Hacl.Spec.Bignum.Definitions.lbignum | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Definitions.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 -> Type0 | {
"end_col": 46,
"end_line": 21,
"start_col": 29,
"start_line": 21
} |
|
Prims.Tot | [
{
"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_v (#t:limb_t) (#len:size_nat) (s:lbignum t len) = eval_ #t len s len | let bn_v (#t: limb_t) (#len: size_nat) (s: lbignum t len) = | false | null | false | eval_ #t len s len | {
"checked_file": "Hacl.Spec.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Definitions.fst"
} | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.eval_",
"Prims.nat"
] | [] | module Hacl.Spec.Bignum.Definitions
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val blocks0: x:size_nat -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks0 x m = if x = 0 then 1 else (x - 1) / m + 1
inline_for_extraction noextract
let limb_t = t:inttype{t = U32 \/ t = U64}
inline_for_extraction noextract
let limb (t:limb_t) = uint_t t SEC
let lbignum (t:limb_t) len = lseq (limb t) len
val eval_: #t:limb_t -> len:size_nat -> s:lbignum t len -> i:nat{i <= len} -> nat
let rec eval_ #t len s i =
if i = 0 then 0
else eval_ #t len s (i - 1) + v s.[i - 1] * pow2 (bits t * (i - 1)) | false | false | Hacl.Spec.Bignum.Definitions.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_v : s: Hacl.Spec.Bignum.Definitions.lbignum t len -> Prims.nat | [] | Hacl.Spec.Bignum.Definitions.bn_v | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Spec.Bignum.Definitions.lbignum t len -> Prims.nat | {
"end_col": 75,
"end_line": 28,
"start_col": 57,
"start_line": 28
} |
|
Prims.Tot | [
{
"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 limb_t = t:inttype{t = U32 \/ t = U64} | let limb_t = | false | null | false | t: inttype{t = U32 \/ t = U64} | {
"checked_file": "Hacl.Spec.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Definitions.fst"
} | [
"total"
] | [
"Lib.IntTypes.inttype",
"Prims.l_or",
"Prims.b2t",
"Prims.op_Equality",
"Lib.IntTypes.U32",
"Lib.IntTypes.U64"
] | [] | module Hacl.Spec.Bignum.Definitions
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val blocks0: x:size_nat -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks0 x m = if x = 0 then 1 else (x - 1) / m + 1 | false | true | Hacl.Spec.Bignum.Definitions.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 limb_t : Type0 | [] | Hacl.Spec.Bignum.Definitions.limb_t | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 42,
"end_line": 18,
"start_col": 13,
"start_line": 18
} |
|
Prims.Tot | val blocks0: x:size_nat -> m:size_pos -> Tot (r:size_pos{x <= m * r}) | [
{
"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 blocks0 x m = if x = 0 then 1 else (x - 1) / m + 1 | val blocks0: x:size_nat -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks0 x m = | false | null | false | if x = 0 then 1 else (x - 1) / m + 1 | {
"checked_file": "Hacl.Spec.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Definitions.fst"
} | [
"total"
] | [
"Lib.IntTypes.size_nat",
"Lib.IntTypes.size_pos",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"Prims.op_Addition",
"Prims.op_Division",
"Prims.op_Subtraction",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star"
] | [] | module Hacl.Spec.Bignum.Definitions
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1 | false | false | Hacl.Spec.Bignum.Definitions.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 blocks0: x:size_nat -> m:size_pos -> Tot (r:size_pos{x <= m * r}) | [] | Hacl.Spec.Bignum.Definitions.blocks0 | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Lib.IntTypes.size_nat -> m: Lib.IntTypes.size_pos -> r: Lib.IntTypes.size_pos{x <= m * r} | {
"end_col": 54,
"end_line": 14,
"start_col": 18,
"start_line": 14
} |
Prims.Tot | [
{
"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 limb (t:limb_t) = uint_t t SEC | let limb (t: limb_t) = | false | null | false | uint_t t SEC | {
"checked_file": "Hacl.Spec.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Definitions.fst"
} | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.SEC"
] | [] | module Hacl.Spec.Bignum.Definitions
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val blocks0: x:size_nat -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks0 x m = if x = 0 then 1 else (x - 1) / m + 1
inline_for_extraction noextract
let limb_t = t:inttype{t = U32 \/ t = U64} | false | true | Hacl.Spec.Bignum.Definitions.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 limb : t: Hacl.Spec.Bignum.Definitions.limb_t -> Type0 | [] | Hacl.Spec.Bignum.Definitions.limb | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Definitions.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 -> Type0 | {
"end_col": 34,
"end_line": 20,
"start_col": 22,
"start_line": 20
} |
|
Prims.Tot | val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r}) | [
{
"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 blocks x m = (x - 1) / m + 1 | val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = | false | null | false | (x - 1) / m + 1 | {
"checked_file": "Hacl.Spec.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Definitions.fst"
} | [
"total"
] | [
"Lib.IntTypes.size_pos",
"Prims.op_Addition",
"Prims.op_Division",
"Prims.op_Subtraction",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star"
] | [] | module Hacl.Spec.Bignum.Definitions
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0" | false | false | Hacl.Spec.Bignum.Definitions.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 blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r}) | [] | Hacl.Spec.Bignum.Definitions.blocks | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Lib.IntTypes.size_pos -> m: Lib.IntTypes.size_pos -> r: Lib.IntTypes.size_pos{x <= m * r} | {
"end_col": 32,
"end_line": 11,
"start_col": 17,
"start_line": 11
} |
Prims.Tot | val eval_: #t:limb_t -> len:size_nat -> s:lbignum t len -> i:nat{i <= len} -> nat | [
{
"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 eval_ #t len s i =
if i = 0 then 0
else eval_ #t len s (i - 1) + v s.[i - 1] * pow2 (bits t * (i - 1)) | val eval_: #t:limb_t -> len:size_nat -> s:lbignum t len -> i:nat{i <= len} -> nat
let rec eval_ #t len s i = | false | null | false | if i = 0 then 0 else eval_ #t len s (i - 1) + v s.[ i - 1 ] * pow2 (bits t * (i - 1)) | {
"checked_file": "Hacl.Spec.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Definitions.fst"
} | [
"total"
] | [
"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",
"Prims.bool",
"Prims.op_Addition",
"Hacl.Spec.Bignum.Definitions.eval_",
"Prims.op_Subtraction",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.pow2",
"Lib.IntTypes.bits"
] | [] | module Hacl.Spec.Bignum.Definitions
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val blocks0: x:size_nat -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks0 x m = if x = 0 then 1 else (x - 1) / m + 1
inline_for_extraction noextract
let limb_t = t:inttype{t = U32 \/ t = U64}
inline_for_extraction noextract
let limb (t:limb_t) = uint_t t SEC
let lbignum (t:limb_t) len = lseq (limb t) len
val eval_: #t:limb_t -> len:size_nat -> s:lbignum t len -> i:nat{i <= len} -> nat | false | false | Hacl.Spec.Bignum.Definitions.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 eval_: #t:limb_t -> len:size_nat -> s:lbignum t len -> i:nat{i <= len} -> nat | [
"recursion"
] | Hacl.Spec.Bignum.Definitions.eval_ | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
len: Lib.IntTypes.size_nat ->
s: Hacl.Spec.Bignum.Definitions.lbignum t len ->
i: Prims.nat{i <= len}
-> Prims.nat | {
"end_col": 69,
"end_line": 26,
"start_col": 2,
"start_line": 25
} |
FStar.Pervasives.Lemma | val bn_eval_create1: #t:limb_t -> c:limb t -> Lemma (bn_v (create 1 c) == v c) | [
{
"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_eval_create1 #t c =
bn_eval1 (create 1 c) | val bn_eval_create1: #t:limb_t -> c:limb t -> Lemma (bn_v (create 1 c) == v c)
let bn_eval_create1 #t c = | false | null | true | bn_eval1 (create 1 c) | {
"checked_file": "Hacl.Spec.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Definitions.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Definitions.bn_eval1",
"Lib.Sequence.create",
"Prims.unit"
] | [] | module Hacl.Spec.Bignum.Definitions
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val blocks0: x:size_nat -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks0 x m = if x = 0 then 1 else (x - 1) / m + 1
inline_for_extraction noextract
let limb_t = t:inttype{t = U32 \/ t = U64}
inline_for_extraction noextract
let limb (t:limb_t) = uint_t t SEC
let lbignum (t:limb_t) len = lseq (limb t) len
val eval_: #t:limb_t -> len:size_nat -> s:lbignum t len -> i:nat{i <= len} -> nat
let rec eval_ #t len s i =
if i = 0 then 0
else eval_ #t len s (i - 1) + v s.[i - 1] * pow2 (bits t * (i - 1))
let bn_v (#t:limb_t) (#len:size_nat) (s:lbignum t len) = eval_ #t len s len
///
/// Lemmas
///
#push-options "--fuel 2"
val bn_eval0: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (eval_ len b 0 == 0)
let bn_eval0 #t #len b = ()
val bn_eval1: #t:limb_t -> b:lbignum t 1 -> Lemma (bn_v b == v b.[0])
let bn_eval1 b = ()
val bn_eval_unfold_i: #t:limb_t -> #len:size_pos -> b:lbignum t len -> i:pos{i <= len} ->
Lemma (eval_ len b i == eval_ len b (i - 1) + v b.[i - 1] * pow2 (bits t * (i - 1)))
let bn_eval_unfold_i #t #len b i = ()
#pop-options
val bn_eval_zeroes: #t:limb_t -> len:size_nat -> i:nat{i <= len} ->
Lemma (eval_ len (create len (uint #t 0)) i == 0)
let rec bn_eval_zeroes #t len i =
let b = create len (uint #t 0) in
if i = 0 then
bn_eval0 b
else begin
bn_eval_unfold_i b i;
bn_eval_zeroes #t len (i - 1) end
val bn_eval_create1: #t:limb_t -> c:limb t -> Lemma (bn_v (create 1 c) == v c) | false | false | Hacl.Spec.Bignum.Definitions.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_eval_create1: #t:limb_t -> c:limb t -> Lemma (bn_v (create 1 c) == v c) | [] | Hacl.Spec.Bignum.Definitions.bn_eval_create1 | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | c: Hacl.Spec.Bignum.Definitions.limb t
-> FStar.Pervasives.Lemma
(ensures Hacl.Spec.Bignum.Definitions.bn_v (Lib.Sequence.create 1 c) == Lib.IntTypes.v c) | {
"end_col": 23,
"end_line": 58,
"start_col": 2,
"start_line": 58
} |
FStar.Pervasives.Lemma | val bn_eval_inj: #t:limb_t -> len:size_nat -> b1:lbignum t len -> b2:lbignum t len -> Lemma
(requires bn_v b1 == bn_v b2)
(ensures equal b1 b2)
(decreases len) | [
{
"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_eval_inj #t len b1 b2 =
if len = 0 then ()
else begin
bn_eval_split_i b1 1;
bn_eval_split_i b2 1;
bn_eval1 (slice b1 0 1);
bn_eval1 (slice b2 0 1);
bn_eval_inj (len - 1) (slice b1 1 len) (slice b2 1 len);
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end | val bn_eval_inj: #t:limb_t -> len:size_nat -> b1:lbignum t len -> b2:lbignum t len -> Lemma
(requires bn_v b1 == bn_v b2)
(ensures equal b1 b2)
(decreases len)
let rec bn_eval_inj #t len b1 b2 = | false | null | true | if len = 0
then ()
else
(bn_eval_split_i b1 1;
bn_eval_split_i b2 1;
bn_eval1 (slice b1 0 1);
bn_eval1 (slice b2 0 1);
bn_eval_inj (len - 1) (slice b1 1 len) (slice b2 1 len);
Seq.lemma_split b1 1;
Seq.lemma_split b2 1) | {
"checked_file": "Hacl.Spec.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Definitions.fst"
} | [
"lemma",
""
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"FStar.Seq.Properties.lemma_split",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.unit",
"Hacl.Spec.Bignum.Definitions.bn_eval_inj",
"Prims.op_Subtraction",
"Lib.Sequence.slice",
"Hacl.Spec.Bignum.Definitions.bn_eval1",
"Hacl.Spec.Bignum.Definitions.bn_eval_split_i"
] | [] | module Hacl.Spec.Bignum.Definitions
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val blocks0: x:size_nat -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks0 x m = if x = 0 then 1 else (x - 1) / m + 1
inline_for_extraction noextract
let limb_t = t:inttype{t = U32 \/ t = U64}
inline_for_extraction noextract
let limb (t:limb_t) = uint_t t SEC
let lbignum (t:limb_t) len = lseq (limb t) len
val eval_: #t:limb_t -> len:size_nat -> s:lbignum t len -> i:nat{i <= len} -> nat
let rec eval_ #t len s i =
if i = 0 then 0
else eval_ #t len s (i - 1) + v s.[i - 1] * pow2 (bits t * (i - 1))
let bn_v (#t:limb_t) (#len:size_nat) (s:lbignum t len) = eval_ #t len s len
///
/// Lemmas
///
#push-options "--fuel 2"
val bn_eval0: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (eval_ len b 0 == 0)
let bn_eval0 #t #len b = ()
val bn_eval1: #t:limb_t -> b:lbignum t 1 -> Lemma (bn_v b == v b.[0])
let bn_eval1 b = ()
val bn_eval_unfold_i: #t:limb_t -> #len:size_pos -> b:lbignum t len -> i:pos{i <= len} ->
Lemma (eval_ len b i == eval_ len b (i - 1) + v b.[i - 1] * pow2 (bits t * (i - 1)))
let bn_eval_unfold_i #t #len b i = ()
#pop-options
val bn_eval_zeroes: #t:limb_t -> len:size_nat -> i:nat{i <= len} ->
Lemma (eval_ len (create len (uint #t 0)) i == 0)
let rec bn_eval_zeroes #t len i =
let b = create len (uint #t 0) in
if i = 0 then
bn_eval0 b
else begin
bn_eval_unfold_i b i;
bn_eval_zeroes #t len (i - 1) end
val bn_eval_create1: #t:limb_t -> c:limb t -> Lemma (bn_v (create 1 c) == v c)
let bn_eval_create1 #t c =
bn_eval1 (create 1 c)
val bn_eval_extensionality_j:
#t:limb_t
-> #len1:size_nat
-> #len2:size_nat
-> b1:lbignum t len1
-> b2:lbignum t len2
-> j:nat{j <= len1 /\ j <= len2} ->
Lemma
(requires sub b1 0 j == sub b2 0 j)
(ensures eval_ len1 b1 j == eval_ len2 b2 j)
(decreases j)
let rec bn_eval_extensionality_j #t #len1 #len2 b1 b2 j =
if j = 0 then begin
bn_eval0 b1;
bn_eval0 b2 end
else begin
bn_eval_unfold_i b1 j;
bn_eval_unfold_i b2 j;
let b1j = slice b1 0 j in
let b2j = slice b2 0 j in
let c1 = slice b1j 0 (j - 1) in
let c2 = slice b2j 0 (j - 1) in
eq_intro c1 c2;
bn_eval_extensionality_j #t #len1 #len2 b1 b2 (j - 1);
Seq.lemma_index_slice b1 0 j (j - 1);
Seq.lemma_index_slice b2 0 j (j - 1);
assert (v b1.[j - 1] == v b2.[j - 1]);
() end
val bn_eval_snoc: #t:limb_t -> #len:size_nat{len + 1 <= max_size_t} -> b:lbignum t len -> e:limb t ->
Lemma (bn_v #t #(len + 1) (Seq.snoc b e) == bn_v b + v e * pow2 (bits t * len))
let bn_eval_snoc #t #len b e =
let b1 = Seq.snoc b e in
bn_eval_unfold_i #t #(len + 1) b1 (len + 1);
bn_eval_extensionality_j #t #(len+1) #len b1 (slice #_ #(len+1) b1 0 len) len;
eq_intro (sub #_ #(len + 1) b1 0 len) b
val bn_eval_split_i_aux: p:nat -> a:nat -> b:nat -> c:nat -> i:nat -> Lemma
(requires pow2 p * c == a - b)
(ensures pow2 (p * (i + 1)) * c == pow2 (p * i) * a - pow2 (p * i) * b)
let bn_eval_split_i_aux p a b c i =
calc (==) {
pow2 (p * (i + 1)) * c;
(==) { Math.Lemmas.pow2_plus (p * i) p }
pow2 (p * i) * pow2 p * c;
(==) { Math.Lemmas.paren_mul_right (pow2 (p * i)) (pow2 p) c }
pow2 (p * i) * (pow2 p * c);
(==) { }
pow2 (p * i) * (a - b);
(==) { Math.Lemmas.distributivity_sub_right (pow2 (p * i)) a b }
pow2 (p * i) * a - pow2 (p * i) * b;
}
#restart-solver
val bn_eval_split_i: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i <= len} -> Lemma
(ensures bn_v b == bn_v (slice b 0 i) + pow2 (bits t * i) * bn_v (slice b i len))
(decreases (len - i))
// 20220513 JP: this proof broke somewhere in the calc, but even with --quake
// 3/3 it goes through. Solver inconsistency? The restart solver above fixes it.
let rec bn_eval_split_i #t #len b i =
let pbits = bits t in
if i = 0 then
bn_eval0 (slice b 0 i)
else begin
if len = i then
bn_eval0 (slice b i len)
else begin
let b1 = slice b i len in
bn_eval_split_i b1 1;
bn_eval1 (slice b1 0 1);
assert (bn_v b1 == v b1.[0] + pow2 pbits * bn_v (slice b1 1 (len - i)));
Seq.lemma_index_slice b i len 0;
assert (bn_v b1 == v b.[i] + pow2 pbits * bn_v (slice b (i + 1) len));
calc (==) {
bn_v b;
(==) { bn_eval_split_i b (i + 1) }
bn_v (slice b 0 (i + 1)) + pow2 (pbits * (i + 1)) * bn_v (slice b (i + 1) len);
(==) { bn_eval_split_i_aux pbits (bn_v b1) (v b.[i]) (bn_v (slice b (i + 1) len)) i }
bn_v (slice b 0 (i + 1)) + pow2 (pbits * i) * bn_v b1 - pow2 (pbits * i) * v b.[i];
(==) { bn_eval_unfold_i (slice b 0 (i + 1)) (i + 1)}
eval_ (i + 1) (slice b 0 (i + 1)) i + pow2 (pbits * i) * bn_v b1;
(==) { bn_eval_extensionality_j (slice b 0 (i + 1)) (slice b 0 i) i }
eval_ i (slice b 0 i) i + pow2 (pbits * i) * bn_v b1;
}; () end end
val bn_eval_inj: #t:limb_t -> len:size_nat -> b1:lbignum t len -> b2:lbignum t len -> Lemma
(requires bn_v b1 == bn_v b2)
(ensures equal b1 b2)
(decreases len) | false | false | Hacl.Spec.Bignum.Definitions.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_eval_inj: #t:limb_t -> len:size_nat -> b1:lbignum t len -> b2:lbignum t len -> Lemma
(requires bn_v b1 == bn_v b2)
(ensures equal b1 b2)
(decreases len) | [
"recursion"
] | Hacl.Spec.Bignum.Definitions.bn_eval_inj | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
len: Lib.IntTypes.size_nat ->
b1: Hacl.Spec.Bignum.Definitions.lbignum t len ->
b2: Hacl.Spec.Bignum.Definitions.lbignum t len
-> FStar.Pervasives.Lemma
(requires Hacl.Spec.Bignum.Definitions.bn_v b1 == Hacl.Spec.Bignum.Definitions.bn_v b2)
(ensures Lib.Sequence.equal b1 b2)
(decreases len) | {
"end_col": 5,
"end_line": 168,
"start_col": 2,
"start_line": 159
} |
FStar.Pervasives.Lemma | val bn_mask_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> mask:limb t -> Lemma
(requires v mask == v (ones t SEC) \/ v mask == 0)
(ensures bn_v (map (logand mask) b) == (if v mask = 0 then 0 else bn_v b)) | [
{
"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_mask_lemma #t #len b mask =
let res = map (logand mask) b in
//assert (forall (i:nat{i < len}). res.[i] == (mask &. b.[i]));
let lemma_aux (i:nat{i < len}) : Lemma (v res.[i] == (if v mask = 0 then 0 else v b.[i])) =
logand_lemma mask b.[i] in
Classical.forall_intro lemma_aux;
if v mask = 0 then begin
eq_intro res (create len (uint #t 0));
bn_eval_zeroes #t len len;
assert (bn_v res == 0) end
else eq_intro res b | val bn_mask_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> mask:limb t -> Lemma
(requires v mask == v (ones t SEC) \/ v mask == 0)
(ensures bn_v (map (logand mask) b) == (if v mask = 0 then 0 else bn_v b))
let bn_mask_lemma #t #len b mask = | false | null | true | let res = map (logand mask) b in
let lemma_aux (i: nat{i < len}) : Lemma (v res.[ i ] == (if v mask = 0 then 0 else v b.[ i ])) =
logand_lemma mask b.[ i ]
in
Classical.forall_intro lemma_aux;
if v mask = 0
then
(eq_intro res (create len (uint #t 0));
bn_eval_zeroes #t len len;
assert (bn_v res == 0))
else eq_intro res b | {
"checked_file": "Hacl.Spec.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Definitions.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.op_Equality",
"Prims.int",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Prims._assert",
"Prims.eq2",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.unit",
"Hacl.Spec.Bignum.Definitions.bn_eval_zeroes",
"Lib.Sequence.eq_intro",
"Lib.IntTypes.int_t",
"Lib.Sequence.create",
"Lib.IntTypes.uint",
"Prims.bool",
"FStar.Classical.forall_intro",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.Sequence.op_String_Access",
"Prims.l_True",
"Prims.squash",
"Lib.Sequence.index",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Lib.IntTypes.logand_lemma",
"Lib.Sequence.lseq",
"Prims.l_Forall",
"Prims.l_imp",
"Lib.IntTypes.logand",
"Lib.Sequence.map"
] | [] | module Hacl.Spec.Bignum.Definitions
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val blocks0: x:size_nat -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks0 x m = if x = 0 then 1 else (x - 1) / m + 1
inline_for_extraction noextract
let limb_t = t:inttype{t = U32 \/ t = U64}
inline_for_extraction noextract
let limb (t:limb_t) = uint_t t SEC
let lbignum (t:limb_t) len = lseq (limb t) len
val eval_: #t:limb_t -> len:size_nat -> s:lbignum t len -> i:nat{i <= len} -> nat
let rec eval_ #t len s i =
if i = 0 then 0
else eval_ #t len s (i - 1) + v s.[i - 1] * pow2 (bits t * (i - 1))
let bn_v (#t:limb_t) (#len:size_nat) (s:lbignum t len) = eval_ #t len s len
///
/// Lemmas
///
#push-options "--fuel 2"
val bn_eval0: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (eval_ len b 0 == 0)
let bn_eval0 #t #len b = ()
val bn_eval1: #t:limb_t -> b:lbignum t 1 -> Lemma (bn_v b == v b.[0])
let bn_eval1 b = ()
val bn_eval_unfold_i: #t:limb_t -> #len:size_pos -> b:lbignum t len -> i:pos{i <= len} ->
Lemma (eval_ len b i == eval_ len b (i - 1) + v b.[i - 1] * pow2 (bits t * (i - 1)))
let bn_eval_unfold_i #t #len b i = ()
#pop-options
val bn_eval_zeroes: #t:limb_t -> len:size_nat -> i:nat{i <= len} ->
Lemma (eval_ len (create len (uint #t 0)) i == 0)
let rec bn_eval_zeroes #t len i =
let b = create len (uint #t 0) in
if i = 0 then
bn_eval0 b
else begin
bn_eval_unfold_i b i;
bn_eval_zeroes #t len (i - 1) end
val bn_eval_create1: #t:limb_t -> c:limb t -> Lemma (bn_v (create 1 c) == v c)
let bn_eval_create1 #t c =
bn_eval1 (create 1 c)
val bn_eval_extensionality_j:
#t:limb_t
-> #len1:size_nat
-> #len2:size_nat
-> b1:lbignum t len1
-> b2:lbignum t len2
-> j:nat{j <= len1 /\ j <= len2} ->
Lemma
(requires sub b1 0 j == sub b2 0 j)
(ensures eval_ len1 b1 j == eval_ len2 b2 j)
(decreases j)
let rec bn_eval_extensionality_j #t #len1 #len2 b1 b2 j =
if j = 0 then begin
bn_eval0 b1;
bn_eval0 b2 end
else begin
bn_eval_unfold_i b1 j;
bn_eval_unfold_i b2 j;
let b1j = slice b1 0 j in
let b2j = slice b2 0 j in
let c1 = slice b1j 0 (j - 1) in
let c2 = slice b2j 0 (j - 1) in
eq_intro c1 c2;
bn_eval_extensionality_j #t #len1 #len2 b1 b2 (j - 1);
Seq.lemma_index_slice b1 0 j (j - 1);
Seq.lemma_index_slice b2 0 j (j - 1);
assert (v b1.[j - 1] == v b2.[j - 1]);
() end
val bn_eval_snoc: #t:limb_t -> #len:size_nat{len + 1 <= max_size_t} -> b:lbignum t len -> e:limb t ->
Lemma (bn_v #t #(len + 1) (Seq.snoc b e) == bn_v b + v e * pow2 (bits t * len))
let bn_eval_snoc #t #len b e =
let b1 = Seq.snoc b e in
bn_eval_unfold_i #t #(len + 1) b1 (len + 1);
bn_eval_extensionality_j #t #(len+1) #len b1 (slice #_ #(len+1) b1 0 len) len;
eq_intro (sub #_ #(len + 1) b1 0 len) b
val bn_eval_split_i_aux: p:nat -> a:nat -> b:nat -> c:nat -> i:nat -> Lemma
(requires pow2 p * c == a - b)
(ensures pow2 (p * (i + 1)) * c == pow2 (p * i) * a - pow2 (p * i) * b)
let bn_eval_split_i_aux p a b c i =
calc (==) {
pow2 (p * (i + 1)) * c;
(==) { Math.Lemmas.pow2_plus (p * i) p }
pow2 (p * i) * pow2 p * c;
(==) { Math.Lemmas.paren_mul_right (pow2 (p * i)) (pow2 p) c }
pow2 (p * i) * (pow2 p * c);
(==) { }
pow2 (p * i) * (a - b);
(==) { Math.Lemmas.distributivity_sub_right (pow2 (p * i)) a b }
pow2 (p * i) * a - pow2 (p * i) * b;
}
#restart-solver
val bn_eval_split_i: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i <= len} -> Lemma
(ensures bn_v b == bn_v (slice b 0 i) + pow2 (bits t * i) * bn_v (slice b i len))
(decreases (len - i))
// 20220513 JP: this proof broke somewhere in the calc, but even with --quake
// 3/3 it goes through. Solver inconsistency? The restart solver above fixes it.
let rec bn_eval_split_i #t #len b i =
let pbits = bits t in
if i = 0 then
bn_eval0 (slice b 0 i)
else begin
if len = i then
bn_eval0 (slice b i len)
else begin
let b1 = slice b i len in
bn_eval_split_i b1 1;
bn_eval1 (slice b1 0 1);
assert (bn_v b1 == v b1.[0] + pow2 pbits * bn_v (slice b1 1 (len - i)));
Seq.lemma_index_slice b i len 0;
assert (bn_v b1 == v b.[i] + pow2 pbits * bn_v (slice b (i + 1) len));
calc (==) {
bn_v b;
(==) { bn_eval_split_i b (i + 1) }
bn_v (slice b 0 (i + 1)) + pow2 (pbits * (i + 1)) * bn_v (slice b (i + 1) len);
(==) { bn_eval_split_i_aux pbits (bn_v b1) (v b.[i]) (bn_v (slice b (i + 1) len)) i }
bn_v (slice b 0 (i + 1)) + pow2 (pbits * i) * bn_v b1 - pow2 (pbits * i) * v b.[i];
(==) { bn_eval_unfold_i (slice b 0 (i + 1)) (i + 1)}
eval_ (i + 1) (slice b 0 (i + 1)) i + pow2 (pbits * i) * bn_v b1;
(==) { bn_eval_extensionality_j (slice b 0 (i + 1)) (slice b 0 i) i }
eval_ i (slice b 0 i) i + pow2 (pbits * i) * bn_v b1;
}; () end end
val bn_eval_inj: #t:limb_t -> len:size_nat -> b1:lbignum t len -> b2:lbignum t len -> Lemma
(requires bn_v b1 == bn_v b2)
(ensures equal b1 b2)
(decreases len)
let rec bn_eval_inj #t len b1 b2 =
if len = 0 then ()
else begin
bn_eval_split_i b1 1;
bn_eval_split_i b2 1;
bn_eval1 (slice b1 0 1);
bn_eval1 (slice b2 0 1);
bn_eval_inj (len - 1) (slice b1 1 len) (slice b2 1 len);
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
val bn_eval_bound: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i <= len} ->
Lemma (eval_ len b i < pow2 (bits t * i))
let rec bn_eval_bound #t #len b i =
let pbits = bits t in
if i = 0 then
bn_eval0 b
else begin
bn_eval_unfold_i b i;
assert (eval_ len b i == eval_ len b (i - 1) + pow2 (pbits * (i - 1)) * v b.[i - 1]);
calc (<) {
eval_ len b (i - 1) + pow2 (pbits * (i - 1)) * v b.[i - 1];
(<) { bn_eval_bound #t #len b (i - 1) }
pow2 (pbits * (i - 1)) + pow2 (pbits * (i - 1)) * v b.[i - 1];
(==) { Math.Lemmas.distributivity_add_right (pow2 (pbits * (i - 1))) 1 (v b.[i - 1]) }
pow2 (pbits * (i - 1)) * (1 + v b.[i - 1]);
(<=) { Math.Lemmas.lemma_mult_le_left (pow2 (pbits * (i - 1))) (1 + v b.[i - 1]) (pow2 pbits) }
pow2 (pbits * (i - 1)) * pow2 pbits;
(==) { Math.Lemmas.pow2_plus (pbits * (i - 1)) pbits }
pow2 (pbits * i);
};
assert (eval_ len b i < pow2 (pbits * i))
end
val bn_eval_index: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i < len} ->
Lemma (v b.[i] == bn_v b / pow2 (bits t * i) % pow2 (bits t))
let bn_eval_index #t #len b i =
let pbits = bits t in
calc (==) {
bn_v b / pow2 (pbits * i) % pow2 pbits;
(==) { bn_eval_split_i #t #len b i }
(bn_v (slice b 0 i) + pow2 (pbits * i) * bn_v (slice b i len)) / pow2 (pbits * i) % pow2 pbits;
(==) { Math.Lemmas.division_addition_lemma (bn_v (slice b 0 i)) (pow2 (pbits * i)) (bn_v (slice b i len)) }
(bn_v (slice b 0 i) / pow2 (pbits * i) + bn_v (slice b i len)) % pow2 pbits;
(==) { bn_eval_bound (slice b 0 i) i; Math.Lemmas.small_division_lemma_1 (bn_v (slice b 0 i)) (pow2 (pbits * i)) }
bn_v (slice b i len) % pow2 pbits;
(==) { bn_eval_split_i (slice b i len) 1 }
(bn_v (slice b i (i + 1)) + pow2 pbits * bn_v (slice b (i + 1) len)) % pow2 pbits;
(==) { Math.Lemmas.modulo_addition_lemma (bn_v (slice b i (i + 1))) (pow2 pbits) (bn_v (slice b (i + 1) len)) }
bn_v (slice b i (i + 1)) % pow2 pbits;
(==) { bn_eval1 (slice b i (i + 1)); Seq.lemma_index_slice b i (i + 1) 0 }
v b.[i] % pow2 pbits;
(==) { Math.Lemmas.modulo_lemma (v b.[i]) (pow2 pbits) }
v b.[i];
};
assert (bn_v b / pow2 (pbits * i) % pow2 pbits == v b.[i])
val bn_eval_lt: #t:limb_t -> len:size_nat -> a:lbignum t len -> b:lbignum t len -> k:pos{k <= len} -> Lemma
(requires v a.[k - 1] < v b.[k - 1])
(ensures eval_ len a k < eval_ len b k)
let bn_eval_lt #t len a b k =
let pbits = bits t in
calc (==) {
eval_ len b k - eval_ len a k;
(==) { bn_eval_unfold_i b k }
eval_ len b (k - 1) + v b.[k - 1] * pow2 (pbits * (k - 1)) - eval_ len a k;
(==) { bn_eval_unfold_i a k }
eval_ len b (k - 1) + v b.[k - 1] * pow2 (pbits * (k - 1)) - eval_ len a (k - 1) - v a.[k - 1] * pow2 (pbits * (k - 1));
(==) { Math.Lemmas.distributivity_sub_left (v b.[k - 1]) (v a.[k - 1]) (pow2 (pbits * (k - 1))) }
eval_ len b (k - 1) - eval_ len a (k - 1) + (v b.[k - 1] - v a.[k - 1]) * pow2 (pbits * (k - 1));
};
bn_eval_bound a (k - 1);
bn_eval_bound b (k - 1);
assert (eval_ len b (k - 1) - eval_ len a (k - 1) > - pow2 (pbits * (k - 1)));
assert ((v b.[k - 1] - v a.[k - 1]) * pow2 (pbits * (k - 1)) >= pow2 (pbits * (k - 1)))
val bn_eval_update_sub: #t:limb_t -> len1:size_nat -> b1:lbignum t len1 -> len2:size_nat{len1 <= len2} ->
Lemma (let b2 = create len2 (uint #t 0) in bn_v b1 == bn_v (update_sub b2 0 len1 b1))
let bn_eval_update_sub #t len1 b1 len2 =
let b2 = create len2 (uint #t 0) in
let b2 = update_sub b2 0 len1 b1 in
bn_eval_split_i b2 len1;
assert (bn_v b2 == bn_v b1 + pow2 (bits t * len1) * bn_v (slice b2 len1 len2));
let b_zeroes = create (len2 - len1) (uint #t 0) in
eq_intro b_zeroes (slice b2 len1 len2);
bn_eval_zeroes #t (len2 - len1) (len2 - len1)
val bn_update_sub_eval:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t bLen
-> i:nat{i + bLen <= aLen} ->
Lemma (bn_v (update_sub a i bLen b) == bn_v a - bn_v (sub a i bLen) * pow2 (bits t * i) + bn_v b * pow2 (bits t * i))
let bn_update_sub_eval #t #aLen #bLen a b i =
let pbits = bits t in
let a' = update_sub a i bLen b in
let c = bn_v (sub a i bLen) * pow2 (bits t * i) in
calc (==) {
bn_v a' + c;
(==) { bn_eval_split_i a' i }
bn_v (slice a' 0 i) + pow2 (pbits * i) * bn_v (slice a' i aLen) + c;
(==) { eq_intro (slice a 0 i) (slice a' 0 i) }
bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v (slice a' i aLen) + c;
(==) { bn_eval_split_i (slice a' i aLen) bLen }
bn_v (slice a 0 i) + pow2 (pbits * i) * (bn_v (sub a' i bLen) + pow2 (pbits * bLen) * bn_v (slice a' (i + bLen) aLen)) + c;
(==) { eq_intro (slice a' (i + bLen) aLen) (slice a (i + bLen) aLen) }
bn_v (slice a 0 i) + pow2 (pbits * i) * (bn_v (sub a' i bLen) + pow2 (pbits * bLen) * bn_v (slice a (i + bLen) aLen)) + c;
(==) {eq_intro (sub a' i bLen) b }
bn_v (slice a 0 i) + pow2 (pbits * i) * (bn_v b + pow2 (pbits * bLen) * bn_v (slice a (i + bLen) aLen)) + c;
(==) { Math.Lemmas.distributivity_add_right (pow2 (pbits * i)) (bn_v b) (pow2 (pbits * bLen) * bn_v (slice a (i + bLen) aLen)) }
bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v b + pow2 (pbits * i) * (pow2 (pbits * bLen) * bn_v (slice a (i + bLen) aLen)) + c;
(==) { Math.Lemmas.paren_mul_right (pow2 (pbits * i)) (pow2 (pbits * bLen)) (bn_v (slice a (i + bLen) aLen));
Math.Lemmas.pow2_plus (pbits * i) (pbits * bLen) }
bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v b + pow2 (pbits * (i + bLen)) * bn_v (slice a (i + bLen) aLen) + c;
(==) { bn_eval_split_i (slice a 0 (i + bLen)) i }
bn_v (slice a 0 (i + bLen)) + pow2 (pbits * i) * bn_v b + pow2 (pbits * (i + bLen)) * bn_v (slice a (i + bLen) aLen);
(==) { bn_eval_split_i a (i + bLen) }
bn_v a + pow2 (pbits * i) * bn_v b;
}
val bn_upd_eval:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b1:limb t
-> i:nat{i < aLen} ->
Lemma (bn_v (upd a i b1) == bn_v a - v a.[i] * pow2 (bits t * i) + v b1 * pow2 (bits t * i))
let bn_upd_eval #t #aLen a b1 i =
let b = create 1 b1 in
bn_update_sub_eval a b i;
bn_eval1 (sub a i 1);
bn_eval1 b;
assert (bn_v (update_sub a i 1 b) == bn_v a - v a.[i] * pow2 (bits t * i) + v b1 * pow2 (bits t * i));
eq_intro (update_sub a i 1 b) (upd a i b1)
val bn_concat_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{aLen + bLen <= max_size_t}
-> a:lbignum t aLen
-> b:lbignum t bLen ->
Lemma (bn_v (concat a b) == bn_v a + pow2 (bits t * aLen) * bn_v b)
let bn_concat_lemma #t #aLen #bLen a b =
let pbits = bits t in
let res = concat a b in
calc (==) {
bn_v res;
(==) { bn_eval_split_i res aLen }
bn_v (slice res 0 aLen) + pow2 (pbits * aLen) * bn_v (slice res aLen (aLen + bLen));
(==) { eq_intro (slice res 0 aLen) a }
bn_v a + pow2 (pbits * aLen) * bn_v (slice res aLen (aLen + bLen));
(==) { eq_intro (slice res aLen (aLen + bLen)) b }
bn_v a + pow2 (pbits * aLen) * bn_v b;
}
val bn_mask_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> mask:limb t -> Lemma
(requires v mask == v (ones t SEC) \/ v mask == 0)
(ensures bn_v (map (logand mask) b) == (if v mask = 0 then 0 else bn_v b)) | false | false | Hacl.Spec.Bignum.Definitions.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_mask_lemma: #t:limb_t -> #len:size_nat -> b:lbignum t len -> mask:limb t -> Lemma
(requires v mask == v (ones t SEC) \/ v mask == 0)
(ensures bn_v (map (logand mask) b) == (if v mask = 0 then 0 else bn_v b)) | [] | Hacl.Spec.Bignum.Definitions.bn_mask_lemma | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Definitions.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 -> mask: Hacl.Spec.Bignum.Definitions.limb t
-> FStar.Pervasives.Lemma
(requires
Lib.IntTypes.v mask == Lib.IntTypes.v (Lib.IntTypes.ones t Lib.IntTypes.SEC) \/
Lib.IntTypes.v mask == 0)
(ensures
Hacl.Spec.Bignum.Definitions.bn_v (Lib.Sequence.map (Lib.IntTypes.logand mask) b) ==
(match Lib.IntTypes.v mask = 0 with
| true -> 0
| _ -> Hacl.Spec.Bignum.Definitions.bn_v b)) | {
"end_col": 21,
"end_line": 351,
"start_col": 34,
"start_line": 339
} |
FStar.Pervasives.Lemma | val bn_eval_snoc: #t:limb_t -> #len:size_nat{len + 1 <= max_size_t} -> b:lbignum t len -> e:limb t ->
Lemma (bn_v #t #(len + 1) (Seq.snoc b e) == bn_v b + v e * pow2 (bits t * len)) | [
{
"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_eval_snoc #t #len b e =
let b1 = Seq.snoc b e in
bn_eval_unfold_i #t #(len + 1) b1 (len + 1);
bn_eval_extensionality_j #t #(len+1) #len b1 (slice #_ #(len+1) b1 0 len) len;
eq_intro (sub #_ #(len + 1) b1 0 len) b | val bn_eval_snoc: #t:limb_t -> #len:size_nat{len + 1 <= max_size_t} -> b:lbignum t len -> e:limb t ->
Lemma (bn_v #t #(len + 1) (Seq.snoc b e) == bn_v b + v e * pow2 (bits t * len))
let bn_eval_snoc #t #len b e = | false | null | true | let b1 = Seq.snoc b e in
bn_eval_unfold_i #t #(len + 1) b1 (len + 1);
bn_eval_extensionality_j #t #(len + 1) #len b1 (slice #_ #(len + 1) b1 0 len) len;
eq_intro (sub #_ #(len + 1) b1 0 len) b | {
"checked_file": "Hacl.Spec.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Definitions.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.limb",
"Lib.Sequence.eq_intro",
"Lib.Sequence.sub",
"Prims.unit",
"Hacl.Spec.Bignum.Definitions.bn_eval_extensionality_j",
"Lib.Sequence.slice",
"Hacl.Spec.Bignum.Definitions.bn_eval_unfold_i",
"FStar.Seq.Base.seq",
"FStar.Seq.Properties.snoc"
] | [] | module Hacl.Spec.Bignum.Definitions
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val blocks0: x:size_nat -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks0 x m = if x = 0 then 1 else (x - 1) / m + 1
inline_for_extraction noextract
let limb_t = t:inttype{t = U32 \/ t = U64}
inline_for_extraction noextract
let limb (t:limb_t) = uint_t t SEC
let lbignum (t:limb_t) len = lseq (limb t) len
val eval_: #t:limb_t -> len:size_nat -> s:lbignum t len -> i:nat{i <= len} -> nat
let rec eval_ #t len s i =
if i = 0 then 0
else eval_ #t len s (i - 1) + v s.[i - 1] * pow2 (bits t * (i - 1))
let bn_v (#t:limb_t) (#len:size_nat) (s:lbignum t len) = eval_ #t len s len
///
/// Lemmas
///
#push-options "--fuel 2"
val bn_eval0: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (eval_ len b 0 == 0)
let bn_eval0 #t #len b = ()
val bn_eval1: #t:limb_t -> b:lbignum t 1 -> Lemma (bn_v b == v b.[0])
let bn_eval1 b = ()
val bn_eval_unfold_i: #t:limb_t -> #len:size_pos -> b:lbignum t len -> i:pos{i <= len} ->
Lemma (eval_ len b i == eval_ len b (i - 1) + v b.[i - 1] * pow2 (bits t * (i - 1)))
let bn_eval_unfold_i #t #len b i = ()
#pop-options
val bn_eval_zeroes: #t:limb_t -> len:size_nat -> i:nat{i <= len} ->
Lemma (eval_ len (create len (uint #t 0)) i == 0)
let rec bn_eval_zeroes #t len i =
let b = create len (uint #t 0) in
if i = 0 then
bn_eval0 b
else begin
bn_eval_unfold_i b i;
bn_eval_zeroes #t len (i - 1) end
val bn_eval_create1: #t:limb_t -> c:limb t -> Lemma (bn_v (create 1 c) == v c)
let bn_eval_create1 #t c =
bn_eval1 (create 1 c)
val bn_eval_extensionality_j:
#t:limb_t
-> #len1:size_nat
-> #len2:size_nat
-> b1:lbignum t len1
-> b2:lbignum t len2
-> j:nat{j <= len1 /\ j <= len2} ->
Lemma
(requires sub b1 0 j == sub b2 0 j)
(ensures eval_ len1 b1 j == eval_ len2 b2 j)
(decreases j)
let rec bn_eval_extensionality_j #t #len1 #len2 b1 b2 j =
if j = 0 then begin
bn_eval0 b1;
bn_eval0 b2 end
else begin
bn_eval_unfold_i b1 j;
bn_eval_unfold_i b2 j;
let b1j = slice b1 0 j in
let b2j = slice b2 0 j in
let c1 = slice b1j 0 (j - 1) in
let c2 = slice b2j 0 (j - 1) in
eq_intro c1 c2;
bn_eval_extensionality_j #t #len1 #len2 b1 b2 (j - 1);
Seq.lemma_index_slice b1 0 j (j - 1);
Seq.lemma_index_slice b2 0 j (j - 1);
assert (v b1.[j - 1] == v b2.[j - 1]);
() end
val bn_eval_snoc: #t:limb_t -> #len:size_nat{len + 1 <= max_size_t} -> b:lbignum t len -> e:limb t ->
Lemma (bn_v #t #(len + 1) (Seq.snoc b e) == bn_v b + v e * pow2 (bits t * len)) | false | false | Hacl.Spec.Bignum.Definitions.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_eval_snoc: #t:limb_t -> #len:size_nat{len + 1 <= max_size_t} -> b:lbignum t len -> e:limb t ->
Lemma (bn_v #t #(len + 1) (Seq.snoc b e) == bn_v b + v e * pow2 (bits t * len)) | [] | Hacl.Spec.Bignum.Definitions.bn_eval_snoc | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Definitions.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 -> e: Hacl.Spec.Bignum.Definitions.limb t
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Definitions.bn_v (FStar.Seq.Properties.snoc b e) ==
Hacl.Spec.Bignum.Definitions.bn_v b +
Lib.IntTypes.v e * Prims.pow2 (Lib.IntTypes.bits t * len)) | {
"end_col": 41,
"end_line": 99,
"start_col": 30,
"start_line": 95
} |
FStar.Pervasives.Lemma | val bn_eval_zeroes: #t:limb_t -> len:size_nat -> i:nat{i <= len} ->
Lemma (eval_ len (create len (uint #t 0)) i == 0) | [
{
"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_eval_zeroes #t len i =
let b = create len (uint #t 0) in
if i = 0 then
bn_eval0 b
else begin
bn_eval_unfold_i b i;
bn_eval_zeroes #t len (i - 1) end | val bn_eval_zeroes: #t:limb_t -> len:size_nat -> i:nat{i <= len} ->
Lemma (eval_ len (create len (uint #t 0)) i == 0)
let rec bn_eval_zeroes #t len i = | false | null | true | let b = create len (uint #t 0) in
if i = 0
then bn_eval0 b
else
(bn_eval_unfold_i b i;
bn_eval_zeroes #t len (i - 1)) | {
"checked_file": "Hacl.Spec.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Definitions.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"Hacl.Spec.Bignum.Definitions.bn_eval0",
"Prims.bool",
"Hacl.Spec.Bignum.Definitions.bn_eval_zeroes",
"Prims.op_Subtraction",
"Prims.unit",
"Hacl.Spec.Bignum.Definitions.bn_eval_unfold_i",
"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.l_imp",
"Prims.op_LessThan",
"Lib.Sequence.index",
"Lib.Sequence.create",
"Lib.IntTypes.uint"
] | [] | module Hacl.Spec.Bignum.Definitions
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val blocks0: x:size_nat -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks0 x m = if x = 0 then 1 else (x - 1) / m + 1
inline_for_extraction noextract
let limb_t = t:inttype{t = U32 \/ t = U64}
inline_for_extraction noextract
let limb (t:limb_t) = uint_t t SEC
let lbignum (t:limb_t) len = lseq (limb t) len
val eval_: #t:limb_t -> len:size_nat -> s:lbignum t len -> i:nat{i <= len} -> nat
let rec eval_ #t len s i =
if i = 0 then 0
else eval_ #t len s (i - 1) + v s.[i - 1] * pow2 (bits t * (i - 1))
let bn_v (#t:limb_t) (#len:size_nat) (s:lbignum t len) = eval_ #t len s len
///
/// Lemmas
///
#push-options "--fuel 2"
val bn_eval0: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (eval_ len b 0 == 0)
let bn_eval0 #t #len b = ()
val bn_eval1: #t:limb_t -> b:lbignum t 1 -> Lemma (bn_v b == v b.[0])
let bn_eval1 b = ()
val bn_eval_unfold_i: #t:limb_t -> #len:size_pos -> b:lbignum t len -> i:pos{i <= len} ->
Lemma (eval_ len b i == eval_ len b (i - 1) + v b.[i - 1] * pow2 (bits t * (i - 1)))
let bn_eval_unfold_i #t #len b i = ()
#pop-options
val bn_eval_zeroes: #t:limb_t -> len:size_nat -> i:nat{i <= len} -> | false | false | Hacl.Spec.Bignum.Definitions.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_eval_zeroes: #t:limb_t -> len:size_nat -> i:nat{i <= len} ->
Lemma (eval_ len (create len (uint #t 0)) i == 0) | [
"recursion"
] | Hacl.Spec.Bignum.Definitions.bn_eval_zeroes | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Lib.IntTypes.size_nat -> i: Prims.nat{i <= len}
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Definitions.eval_ len (Lib.Sequence.create len (Lib.IntTypes.uint 0)) i == 0) | {
"end_col": 37,
"end_line": 54,
"start_col": 33,
"start_line": 48
} |
FStar.Pervasives.Lemma | val bn_eval_split_i_aux: p:nat -> a:nat -> b:nat -> c:nat -> i:nat -> Lemma
(requires pow2 p * c == a - b)
(ensures pow2 (p * (i + 1)) * c == pow2 (p * i) * a - pow2 (p * i) * b) | [
{
"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_eval_split_i_aux p a b c i =
calc (==) {
pow2 (p * (i + 1)) * c;
(==) { Math.Lemmas.pow2_plus (p * i) p }
pow2 (p * i) * pow2 p * c;
(==) { Math.Lemmas.paren_mul_right (pow2 (p * i)) (pow2 p) c }
pow2 (p * i) * (pow2 p * c);
(==) { }
pow2 (p * i) * (a - b);
(==) { Math.Lemmas.distributivity_sub_right (pow2 (p * i)) a b }
pow2 (p * i) * a - pow2 (p * i) * b;
} | val bn_eval_split_i_aux: p:nat -> a:nat -> b:nat -> c:nat -> i:nat -> Lemma
(requires pow2 p * c == a - b)
(ensures pow2 (p * (i + 1)) * c == pow2 (p * i) * a - pow2 (p * i) * b)
let bn_eval_split_i_aux p a b c i = | false | null | true | calc ( == ) {
pow2 (p * (i + 1)) * c;
( == ) { Math.Lemmas.pow2_plus (p * i) p }
(pow2 (p * i) * pow2 p) * c;
( == ) { Math.Lemmas.paren_mul_right (pow2 (p * i)) (pow2 p) c }
pow2 (p * i) * (pow2 p * c);
( == ) { () }
pow2 (p * i) * (a - b);
( == ) { Math.Lemmas.distributivity_sub_right (pow2 (p * i)) a b }
pow2 (p * i) * a - pow2 (p * i) * b;
} | {
"checked_file": "Hacl.Spec.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Definitions.fst"
} | [
"lemma"
] | [
"Prims.nat",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.op_Addition",
"Prims.op_Subtraction",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.pow2_plus",
"Prims.squash",
"FStar.Math.Lemmas.paren_mul_right",
"FStar.Math.Lemmas.distributivity_sub_right"
] | [] | module Hacl.Spec.Bignum.Definitions
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val blocks0: x:size_nat -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks0 x m = if x = 0 then 1 else (x - 1) / m + 1
inline_for_extraction noextract
let limb_t = t:inttype{t = U32 \/ t = U64}
inline_for_extraction noextract
let limb (t:limb_t) = uint_t t SEC
let lbignum (t:limb_t) len = lseq (limb t) len
val eval_: #t:limb_t -> len:size_nat -> s:lbignum t len -> i:nat{i <= len} -> nat
let rec eval_ #t len s i =
if i = 0 then 0
else eval_ #t len s (i - 1) + v s.[i - 1] * pow2 (bits t * (i - 1))
let bn_v (#t:limb_t) (#len:size_nat) (s:lbignum t len) = eval_ #t len s len
///
/// Lemmas
///
#push-options "--fuel 2"
val bn_eval0: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (eval_ len b 0 == 0)
let bn_eval0 #t #len b = ()
val bn_eval1: #t:limb_t -> b:lbignum t 1 -> Lemma (bn_v b == v b.[0])
let bn_eval1 b = ()
val bn_eval_unfold_i: #t:limb_t -> #len:size_pos -> b:lbignum t len -> i:pos{i <= len} ->
Lemma (eval_ len b i == eval_ len b (i - 1) + v b.[i - 1] * pow2 (bits t * (i - 1)))
let bn_eval_unfold_i #t #len b i = ()
#pop-options
val bn_eval_zeroes: #t:limb_t -> len:size_nat -> i:nat{i <= len} ->
Lemma (eval_ len (create len (uint #t 0)) i == 0)
let rec bn_eval_zeroes #t len i =
let b = create len (uint #t 0) in
if i = 0 then
bn_eval0 b
else begin
bn_eval_unfold_i b i;
bn_eval_zeroes #t len (i - 1) end
val bn_eval_create1: #t:limb_t -> c:limb t -> Lemma (bn_v (create 1 c) == v c)
let bn_eval_create1 #t c =
bn_eval1 (create 1 c)
val bn_eval_extensionality_j:
#t:limb_t
-> #len1:size_nat
-> #len2:size_nat
-> b1:lbignum t len1
-> b2:lbignum t len2
-> j:nat{j <= len1 /\ j <= len2} ->
Lemma
(requires sub b1 0 j == sub b2 0 j)
(ensures eval_ len1 b1 j == eval_ len2 b2 j)
(decreases j)
let rec bn_eval_extensionality_j #t #len1 #len2 b1 b2 j =
if j = 0 then begin
bn_eval0 b1;
bn_eval0 b2 end
else begin
bn_eval_unfold_i b1 j;
bn_eval_unfold_i b2 j;
let b1j = slice b1 0 j in
let b2j = slice b2 0 j in
let c1 = slice b1j 0 (j - 1) in
let c2 = slice b2j 0 (j - 1) in
eq_intro c1 c2;
bn_eval_extensionality_j #t #len1 #len2 b1 b2 (j - 1);
Seq.lemma_index_slice b1 0 j (j - 1);
Seq.lemma_index_slice b2 0 j (j - 1);
assert (v b1.[j - 1] == v b2.[j - 1]);
() end
val bn_eval_snoc: #t:limb_t -> #len:size_nat{len + 1 <= max_size_t} -> b:lbignum t len -> e:limb t ->
Lemma (bn_v #t #(len + 1) (Seq.snoc b e) == bn_v b + v e * pow2 (bits t * len))
let bn_eval_snoc #t #len b e =
let b1 = Seq.snoc b e in
bn_eval_unfold_i #t #(len + 1) b1 (len + 1);
bn_eval_extensionality_j #t #(len+1) #len b1 (slice #_ #(len+1) b1 0 len) len;
eq_intro (sub #_ #(len + 1) b1 0 len) b
val bn_eval_split_i_aux: p:nat -> a:nat -> b:nat -> c:nat -> i:nat -> Lemma
(requires pow2 p * c == a - b)
(ensures pow2 (p * (i + 1)) * c == pow2 (p * i) * a - pow2 (p * i) * b) | false | false | Hacl.Spec.Bignum.Definitions.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_eval_split_i_aux: p:nat -> a:nat -> b:nat -> c:nat -> i:nat -> Lemma
(requires pow2 p * c == a - b)
(ensures pow2 (p * (i + 1)) * c == pow2 (p * i) * a - pow2 (p * i) * b) | [] | Hacl.Spec.Bignum.Definitions.bn_eval_split_i_aux | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Prims.nat -> a: Prims.nat -> b: Prims.nat -> c: Prims.nat -> i: Prims.nat
-> FStar.Pervasives.Lemma (requires Prims.pow2 p * c == a - b)
(ensures Prims.pow2 (p * (i + 1)) * c == Prims.pow2 (p * i) * a - Prims.pow2 (p * i) * b) | {
"end_col": 3,
"end_line": 117,
"start_col": 2,
"start_line": 107
} |
FStar.Pervasives.Lemma | val bn_upd_eval:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b1:limb t
-> i:nat{i < aLen} ->
Lemma (bn_v (upd a i b1) == bn_v a - v a.[i] * pow2 (bits t * i) + v b1 * pow2 (bits t * i)) | [
{
"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_upd_eval #t #aLen a b1 i =
let b = create 1 b1 in
bn_update_sub_eval a b i;
bn_eval1 (sub a i 1);
bn_eval1 b;
assert (bn_v (update_sub a i 1 b) == bn_v a - v a.[i] * pow2 (bits t * i) + v b1 * pow2 (bits t * i));
eq_intro (update_sub a i 1 b) (upd a i b1) | val bn_upd_eval:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b1:limb t
-> i:nat{i < aLen} ->
Lemma (bn_v (upd a i b1) == bn_v a - v a.[i] * pow2 (bits t * i) + v b1 * pow2 (bits t * i))
let bn_upd_eval #t #aLen a b1 i = | false | null | true | let b = create 1 b1 in
bn_update_sub_eval a b i;
bn_eval1 (sub a i 1);
bn_eval1 b;
assert (bn_v (update_sub a i 1 b) ==
bn_v a - v a.[ i ] * pow2 (bits t * i) + v b1 * pow2 (bits t * i));
eq_intro (update_sub a i 1 b) (upd a i b1) | {
"checked_file": "Hacl.Spec.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Definitions.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.Sequence.eq_intro",
"Lib.Sequence.update_sub",
"Lib.Sequence.upd",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.op_Addition",
"Prims.op_Subtraction",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Lib.Sequence.op_String_Access",
"Prims.pow2",
"Lib.IntTypes.bits",
"Hacl.Spec.Bignum.Definitions.bn_eval1",
"Lib.Sequence.sub",
"Hacl.Spec.Bignum.Definitions.bn_update_sub_eval",
"Lib.Sequence.lseq",
"Prims.l_and",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.create",
"Prims.l_Forall",
"Prims.l_imp",
"Lib.Sequence.index",
"Lib.Sequence.create"
] | [] | module Hacl.Spec.Bignum.Definitions
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val blocks0: x:size_nat -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks0 x m = if x = 0 then 1 else (x - 1) / m + 1
inline_for_extraction noextract
let limb_t = t:inttype{t = U32 \/ t = U64}
inline_for_extraction noextract
let limb (t:limb_t) = uint_t t SEC
let lbignum (t:limb_t) len = lseq (limb t) len
val eval_: #t:limb_t -> len:size_nat -> s:lbignum t len -> i:nat{i <= len} -> nat
let rec eval_ #t len s i =
if i = 0 then 0
else eval_ #t len s (i - 1) + v s.[i - 1] * pow2 (bits t * (i - 1))
let bn_v (#t:limb_t) (#len:size_nat) (s:lbignum t len) = eval_ #t len s len
///
/// Lemmas
///
#push-options "--fuel 2"
val bn_eval0: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (eval_ len b 0 == 0)
let bn_eval0 #t #len b = ()
val bn_eval1: #t:limb_t -> b:lbignum t 1 -> Lemma (bn_v b == v b.[0])
let bn_eval1 b = ()
val bn_eval_unfold_i: #t:limb_t -> #len:size_pos -> b:lbignum t len -> i:pos{i <= len} ->
Lemma (eval_ len b i == eval_ len b (i - 1) + v b.[i - 1] * pow2 (bits t * (i - 1)))
let bn_eval_unfold_i #t #len b i = ()
#pop-options
val bn_eval_zeroes: #t:limb_t -> len:size_nat -> i:nat{i <= len} ->
Lemma (eval_ len (create len (uint #t 0)) i == 0)
let rec bn_eval_zeroes #t len i =
let b = create len (uint #t 0) in
if i = 0 then
bn_eval0 b
else begin
bn_eval_unfold_i b i;
bn_eval_zeroes #t len (i - 1) end
val bn_eval_create1: #t:limb_t -> c:limb t -> Lemma (bn_v (create 1 c) == v c)
let bn_eval_create1 #t c =
bn_eval1 (create 1 c)
val bn_eval_extensionality_j:
#t:limb_t
-> #len1:size_nat
-> #len2:size_nat
-> b1:lbignum t len1
-> b2:lbignum t len2
-> j:nat{j <= len1 /\ j <= len2} ->
Lemma
(requires sub b1 0 j == sub b2 0 j)
(ensures eval_ len1 b1 j == eval_ len2 b2 j)
(decreases j)
let rec bn_eval_extensionality_j #t #len1 #len2 b1 b2 j =
if j = 0 then begin
bn_eval0 b1;
bn_eval0 b2 end
else begin
bn_eval_unfold_i b1 j;
bn_eval_unfold_i b2 j;
let b1j = slice b1 0 j in
let b2j = slice b2 0 j in
let c1 = slice b1j 0 (j - 1) in
let c2 = slice b2j 0 (j - 1) in
eq_intro c1 c2;
bn_eval_extensionality_j #t #len1 #len2 b1 b2 (j - 1);
Seq.lemma_index_slice b1 0 j (j - 1);
Seq.lemma_index_slice b2 0 j (j - 1);
assert (v b1.[j - 1] == v b2.[j - 1]);
() end
val bn_eval_snoc: #t:limb_t -> #len:size_nat{len + 1 <= max_size_t} -> b:lbignum t len -> e:limb t ->
Lemma (bn_v #t #(len + 1) (Seq.snoc b e) == bn_v b + v e * pow2 (bits t * len))
let bn_eval_snoc #t #len b e =
let b1 = Seq.snoc b e in
bn_eval_unfold_i #t #(len + 1) b1 (len + 1);
bn_eval_extensionality_j #t #(len+1) #len b1 (slice #_ #(len+1) b1 0 len) len;
eq_intro (sub #_ #(len + 1) b1 0 len) b
val bn_eval_split_i_aux: p:nat -> a:nat -> b:nat -> c:nat -> i:nat -> Lemma
(requires pow2 p * c == a - b)
(ensures pow2 (p * (i + 1)) * c == pow2 (p * i) * a - pow2 (p * i) * b)
let bn_eval_split_i_aux p a b c i =
calc (==) {
pow2 (p * (i + 1)) * c;
(==) { Math.Lemmas.pow2_plus (p * i) p }
pow2 (p * i) * pow2 p * c;
(==) { Math.Lemmas.paren_mul_right (pow2 (p * i)) (pow2 p) c }
pow2 (p * i) * (pow2 p * c);
(==) { }
pow2 (p * i) * (a - b);
(==) { Math.Lemmas.distributivity_sub_right (pow2 (p * i)) a b }
pow2 (p * i) * a - pow2 (p * i) * b;
}
#restart-solver
val bn_eval_split_i: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i <= len} -> Lemma
(ensures bn_v b == bn_v (slice b 0 i) + pow2 (bits t * i) * bn_v (slice b i len))
(decreases (len - i))
// 20220513 JP: this proof broke somewhere in the calc, but even with --quake
// 3/3 it goes through. Solver inconsistency? The restart solver above fixes it.
let rec bn_eval_split_i #t #len b i =
let pbits = bits t in
if i = 0 then
bn_eval0 (slice b 0 i)
else begin
if len = i then
bn_eval0 (slice b i len)
else begin
let b1 = slice b i len in
bn_eval_split_i b1 1;
bn_eval1 (slice b1 0 1);
assert (bn_v b1 == v b1.[0] + pow2 pbits * bn_v (slice b1 1 (len - i)));
Seq.lemma_index_slice b i len 0;
assert (bn_v b1 == v b.[i] + pow2 pbits * bn_v (slice b (i + 1) len));
calc (==) {
bn_v b;
(==) { bn_eval_split_i b (i + 1) }
bn_v (slice b 0 (i + 1)) + pow2 (pbits * (i + 1)) * bn_v (slice b (i + 1) len);
(==) { bn_eval_split_i_aux pbits (bn_v b1) (v b.[i]) (bn_v (slice b (i + 1) len)) i }
bn_v (slice b 0 (i + 1)) + pow2 (pbits * i) * bn_v b1 - pow2 (pbits * i) * v b.[i];
(==) { bn_eval_unfold_i (slice b 0 (i + 1)) (i + 1)}
eval_ (i + 1) (slice b 0 (i + 1)) i + pow2 (pbits * i) * bn_v b1;
(==) { bn_eval_extensionality_j (slice b 0 (i + 1)) (slice b 0 i) i }
eval_ i (slice b 0 i) i + pow2 (pbits * i) * bn_v b1;
}; () end end
val bn_eval_inj: #t:limb_t -> len:size_nat -> b1:lbignum t len -> b2:lbignum t len -> Lemma
(requires bn_v b1 == bn_v b2)
(ensures equal b1 b2)
(decreases len)
let rec bn_eval_inj #t len b1 b2 =
if len = 0 then ()
else begin
bn_eval_split_i b1 1;
bn_eval_split_i b2 1;
bn_eval1 (slice b1 0 1);
bn_eval1 (slice b2 0 1);
bn_eval_inj (len - 1) (slice b1 1 len) (slice b2 1 len);
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
val bn_eval_bound: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i <= len} ->
Lemma (eval_ len b i < pow2 (bits t * i))
let rec bn_eval_bound #t #len b i =
let pbits = bits t in
if i = 0 then
bn_eval0 b
else begin
bn_eval_unfold_i b i;
assert (eval_ len b i == eval_ len b (i - 1) + pow2 (pbits * (i - 1)) * v b.[i - 1]);
calc (<) {
eval_ len b (i - 1) + pow2 (pbits * (i - 1)) * v b.[i - 1];
(<) { bn_eval_bound #t #len b (i - 1) }
pow2 (pbits * (i - 1)) + pow2 (pbits * (i - 1)) * v b.[i - 1];
(==) { Math.Lemmas.distributivity_add_right (pow2 (pbits * (i - 1))) 1 (v b.[i - 1]) }
pow2 (pbits * (i - 1)) * (1 + v b.[i - 1]);
(<=) { Math.Lemmas.lemma_mult_le_left (pow2 (pbits * (i - 1))) (1 + v b.[i - 1]) (pow2 pbits) }
pow2 (pbits * (i - 1)) * pow2 pbits;
(==) { Math.Lemmas.pow2_plus (pbits * (i - 1)) pbits }
pow2 (pbits * i);
};
assert (eval_ len b i < pow2 (pbits * i))
end
val bn_eval_index: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i < len} ->
Lemma (v b.[i] == bn_v b / pow2 (bits t * i) % pow2 (bits t))
let bn_eval_index #t #len b i =
let pbits = bits t in
calc (==) {
bn_v b / pow2 (pbits * i) % pow2 pbits;
(==) { bn_eval_split_i #t #len b i }
(bn_v (slice b 0 i) + pow2 (pbits * i) * bn_v (slice b i len)) / pow2 (pbits * i) % pow2 pbits;
(==) { Math.Lemmas.division_addition_lemma (bn_v (slice b 0 i)) (pow2 (pbits * i)) (bn_v (slice b i len)) }
(bn_v (slice b 0 i) / pow2 (pbits * i) + bn_v (slice b i len)) % pow2 pbits;
(==) { bn_eval_bound (slice b 0 i) i; Math.Lemmas.small_division_lemma_1 (bn_v (slice b 0 i)) (pow2 (pbits * i)) }
bn_v (slice b i len) % pow2 pbits;
(==) { bn_eval_split_i (slice b i len) 1 }
(bn_v (slice b i (i + 1)) + pow2 pbits * bn_v (slice b (i + 1) len)) % pow2 pbits;
(==) { Math.Lemmas.modulo_addition_lemma (bn_v (slice b i (i + 1))) (pow2 pbits) (bn_v (slice b (i + 1) len)) }
bn_v (slice b i (i + 1)) % pow2 pbits;
(==) { bn_eval1 (slice b i (i + 1)); Seq.lemma_index_slice b i (i + 1) 0 }
v b.[i] % pow2 pbits;
(==) { Math.Lemmas.modulo_lemma (v b.[i]) (pow2 pbits) }
v b.[i];
};
assert (bn_v b / pow2 (pbits * i) % pow2 pbits == v b.[i])
val bn_eval_lt: #t:limb_t -> len:size_nat -> a:lbignum t len -> b:lbignum t len -> k:pos{k <= len} -> Lemma
(requires v a.[k - 1] < v b.[k - 1])
(ensures eval_ len a k < eval_ len b k)
let bn_eval_lt #t len a b k =
let pbits = bits t in
calc (==) {
eval_ len b k - eval_ len a k;
(==) { bn_eval_unfold_i b k }
eval_ len b (k - 1) + v b.[k - 1] * pow2 (pbits * (k - 1)) - eval_ len a k;
(==) { bn_eval_unfold_i a k }
eval_ len b (k - 1) + v b.[k - 1] * pow2 (pbits * (k - 1)) - eval_ len a (k - 1) - v a.[k - 1] * pow2 (pbits * (k - 1));
(==) { Math.Lemmas.distributivity_sub_left (v b.[k - 1]) (v a.[k - 1]) (pow2 (pbits * (k - 1))) }
eval_ len b (k - 1) - eval_ len a (k - 1) + (v b.[k - 1] - v a.[k - 1]) * pow2 (pbits * (k - 1));
};
bn_eval_bound a (k - 1);
bn_eval_bound b (k - 1);
assert (eval_ len b (k - 1) - eval_ len a (k - 1) > - pow2 (pbits * (k - 1)));
assert ((v b.[k - 1] - v a.[k - 1]) * pow2 (pbits * (k - 1)) >= pow2 (pbits * (k - 1)))
val bn_eval_update_sub: #t:limb_t -> len1:size_nat -> b1:lbignum t len1 -> len2:size_nat{len1 <= len2} ->
Lemma (let b2 = create len2 (uint #t 0) in bn_v b1 == bn_v (update_sub b2 0 len1 b1))
let bn_eval_update_sub #t len1 b1 len2 =
let b2 = create len2 (uint #t 0) in
let b2 = update_sub b2 0 len1 b1 in
bn_eval_split_i b2 len1;
assert (bn_v b2 == bn_v b1 + pow2 (bits t * len1) * bn_v (slice b2 len1 len2));
let b_zeroes = create (len2 - len1) (uint #t 0) in
eq_intro b_zeroes (slice b2 len1 len2);
bn_eval_zeroes #t (len2 - len1) (len2 - len1)
val bn_update_sub_eval:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t bLen
-> i:nat{i + bLen <= aLen} ->
Lemma (bn_v (update_sub a i bLen b) == bn_v a - bn_v (sub a i bLen) * pow2 (bits t * i) + bn_v b * pow2 (bits t * i))
let bn_update_sub_eval #t #aLen #bLen a b i =
let pbits = bits t in
let a' = update_sub a i bLen b in
let c = bn_v (sub a i bLen) * pow2 (bits t * i) in
calc (==) {
bn_v a' + c;
(==) { bn_eval_split_i a' i }
bn_v (slice a' 0 i) + pow2 (pbits * i) * bn_v (slice a' i aLen) + c;
(==) { eq_intro (slice a 0 i) (slice a' 0 i) }
bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v (slice a' i aLen) + c;
(==) { bn_eval_split_i (slice a' i aLen) bLen }
bn_v (slice a 0 i) + pow2 (pbits * i) * (bn_v (sub a' i bLen) + pow2 (pbits * bLen) * bn_v (slice a' (i + bLen) aLen)) + c;
(==) { eq_intro (slice a' (i + bLen) aLen) (slice a (i + bLen) aLen) }
bn_v (slice a 0 i) + pow2 (pbits * i) * (bn_v (sub a' i bLen) + pow2 (pbits * bLen) * bn_v (slice a (i + bLen) aLen)) + c;
(==) {eq_intro (sub a' i bLen) b }
bn_v (slice a 0 i) + pow2 (pbits * i) * (bn_v b + pow2 (pbits * bLen) * bn_v (slice a (i + bLen) aLen)) + c;
(==) { Math.Lemmas.distributivity_add_right (pow2 (pbits * i)) (bn_v b) (pow2 (pbits * bLen) * bn_v (slice a (i + bLen) aLen)) }
bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v b + pow2 (pbits * i) * (pow2 (pbits * bLen) * bn_v (slice a (i + bLen) aLen)) + c;
(==) { Math.Lemmas.paren_mul_right (pow2 (pbits * i)) (pow2 (pbits * bLen)) (bn_v (slice a (i + bLen) aLen));
Math.Lemmas.pow2_plus (pbits * i) (pbits * bLen) }
bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v b + pow2 (pbits * (i + bLen)) * bn_v (slice a (i + bLen) aLen) + c;
(==) { bn_eval_split_i (slice a 0 (i + bLen)) i }
bn_v (slice a 0 (i + bLen)) + pow2 (pbits * i) * bn_v b + pow2 (pbits * (i + bLen)) * bn_v (slice a (i + bLen) aLen);
(==) { bn_eval_split_i a (i + bLen) }
bn_v a + pow2 (pbits * i) * bn_v b;
}
val bn_upd_eval:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b1:limb t
-> i:nat{i < aLen} ->
Lemma (bn_v (upd a i b1) == bn_v a - v a.[i] * pow2 (bits t * i) + v b1 * pow2 (bits t * i)) | false | false | Hacl.Spec.Bignum.Definitions.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_upd_eval:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b1:limb t
-> i:nat{i < aLen} ->
Lemma (bn_v (upd a i b1) == bn_v a - v a.[i] * pow2 (bits t * i) + v b1 * pow2 (bits t * i)) | [] | Hacl.Spec.Bignum.Definitions.bn_upd_eval | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Definitions.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 aLen ->
b1: Hacl.Spec.Bignum.Definitions.limb t ->
i: Prims.nat{i < aLen}
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Definitions.bn_v (Lib.Sequence.upd a i b1) ==
Hacl.Spec.Bignum.Definitions.bn_v a -
Lib.IntTypes.v a.[ i ] * Prims.pow2 (Lib.IntTypes.bits t * i) +
Lib.IntTypes.v b1 * Prims.pow2 (Lib.IntTypes.bits t * i)) | {
"end_col": 44,
"end_line": 310,
"start_col": 33,
"start_line": 304
} |
FStar.Pervasives.Lemma | val bn_eval_update_sub: #t:limb_t -> len1:size_nat -> b1:lbignum t len1 -> len2:size_nat{len1 <= len2} ->
Lemma (let b2 = create len2 (uint #t 0) in bn_v b1 == bn_v (update_sub b2 0 len1 b1)) | [
{
"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_eval_update_sub #t len1 b1 len2 =
let b2 = create len2 (uint #t 0) in
let b2 = update_sub b2 0 len1 b1 in
bn_eval_split_i b2 len1;
assert (bn_v b2 == bn_v b1 + pow2 (bits t * len1) * bn_v (slice b2 len1 len2));
let b_zeroes = create (len2 - len1) (uint #t 0) in
eq_intro b_zeroes (slice b2 len1 len2);
bn_eval_zeroes #t (len2 - len1) (len2 - len1) | val bn_eval_update_sub: #t:limb_t -> len1:size_nat -> b1:lbignum t len1 -> len2:size_nat{len1 <= len2} ->
Lemma (let b2 = create len2 (uint #t 0) in bn_v b1 == bn_v (update_sub b2 0 len1 b1))
let bn_eval_update_sub #t len1 b1 len2 = | false | null | true | let b2 = create len2 (uint #t 0) in
let b2 = update_sub b2 0 len1 b1 in
bn_eval_split_i b2 len1;
assert (bn_v b2 == bn_v b1 + pow2 (bits t * len1) * bn_v (slice b2 len1 len2));
let b_zeroes = create (len2 - len1) (uint #t 0) in
eq_intro b_zeroes (slice b2 len1 len2);
bn_eval_zeroes #t (len2 - len1) (len2 - len1) | {
"checked_file": "Hacl.Spec.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Definitions.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Hacl.Spec.Bignum.Definitions.bn_eval_zeroes",
"Prims.op_Subtraction",
"Prims.unit",
"Lib.Sequence.eq_intro",
"Hacl.Spec.Bignum.Definitions.limb",
"Lib.Sequence.slice",
"Lib.Sequence.lseq",
"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.op_LessThan",
"Lib.Sequence.index",
"Lib.Sequence.create",
"Lib.IntTypes.uint",
"Prims._assert",
"Prims.int",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.pow2",
"Lib.IntTypes.bits",
"Hacl.Spec.Bignum.Definitions.bn_eval_split_i",
"Lib.Sequence.sub",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.update_sub"
] | [] | module Hacl.Spec.Bignum.Definitions
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val blocks0: x:size_nat -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks0 x m = if x = 0 then 1 else (x - 1) / m + 1
inline_for_extraction noextract
let limb_t = t:inttype{t = U32 \/ t = U64}
inline_for_extraction noextract
let limb (t:limb_t) = uint_t t SEC
let lbignum (t:limb_t) len = lseq (limb t) len
val eval_: #t:limb_t -> len:size_nat -> s:lbignum t len -> i:nat{i <= len} -> nat
let rec eval_ #t len s i =
if i = 0 then 0
else eval_ #t len s (i - 1) + v s.[i - 1] * pow2 (bits t * (i - 1))
let bn_v (#t:limb_t) (#len:size_nat) (s:lbignum t len) = eval_ #t len s len
///
/// Lemmas
///
#push-options "--fuel 2"
val bn_eval0: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (eval_ len b 0 == 0)
let bn_eval0 #t #len b = ()
val bn_eval1: #t:limb_t -> b:lbignum t 1 -> Lemma (bn_v b == v b.[0])
let bn_eval1 b = ()
val bn_eval_unfold_i: #t:limb_t -> #len:size_pos -> b:lbignum t len -> i:pos{i <= len} ->
Lemma (eval_ len b i == eval_ len b (i - 1) + v b.[i - 1] * pow2 (bits t * (i - 1)))
let bn_eval_unfold_i #t #len b i = ()
#pop-options
val bn_eval_zeroes: #t:limb_t -> len:size_nat -> i:nat{i <= len} ->
Lemma (eval_ len (create len (uint #t 0)) i == 0)
let rec bn_eval_zeroes #t len i =
let b = create len (uint #t 0) in
if i = 0 then
bn_eval0 b
else begin
bn_eval_unfold_i b i;
bn_eval_zeroes #t len (i - 1) end
val bn_eval_create1: #t:limb_t -> c:limb t -> Lemma (bn_v (create 1 c) == v c)
let bn_eval_create1 #t c =
bn_eval1 (create 1 c)
val bn_eval_extensionality_j:
#t:limb_t
-> #len1:size_nat
-> #len2:size_nat
-> b1:lbignum t len1
-> b2:lbignum t len2
-> j:nat{j <= len1 /\ j <= len2} ->
Lemma
(requires sub b1 0 j == sub b2 0 j)
(ensures eval_ len1 b1 j == eval_ len2 b2 j)
(decreases j)
let rec bn_eval_extensionality_j #t #len1 #len2 b1 b2 j =
if j = 0 then begin
bn_eval0 b1;
bn_eval0 b2 end
else begin
bn_eval_unfold_i b1 j;
bn_eval_unfold_i b2 j;
let b1j = slice b1 0 j in
let b2j = slice b2 0 j in
let c1 = slice b1j 0 (j - 1) in
let c2 = slice b2j 0 (j - 1) in
eq_intro c1 c2;
bn_eval_extensionality_j #t #len1 #len2 b1 b2 (j - 1);
Seq.lemma_index_slice b1 0 j (j - 1);
Seq.lemma_index_slice b2 0 j (j - 1);
assert (v b1.[j - 1] == v b2.[j - 1]);
() end
val bn_eval_snoc: #t:limb_t -> #len:size_nat{len + 1 <= max_size_t} -> b:lbignum t len -> e:limb t ->
Lemma (bn_v #t #(len + 1) (Seq.snoc b e) == bn_v b + v e * pow2 (bits t * len))
let bn_eval_snoc #t #len b e =
let b1 = Seq.snoc b e in
bn_eval_unfold_i #t #(len + 1) b1 (len + 1);
bn_eval_extensionality_j #t #(len+1) #len b1 (slice #_ #(len+1) b1 0 len) len;
eq_intro (sub #_ #(len + 1) b1 0 len) b
val bn_eval_split_i_aux: p:nat -> a:nat -> b:nat -> c:nat -> i:nat -> Lemma
(requires pow2 p * c == a - b)
(ensures pow2 (p * (i + 1)) * c == pow2 (p * i) * a - pow2 (p * i) * b)
let bn_eval_split_i_aux p a b c i =
calc (==) {
pow2 (p * (i + 1)) * c;
(==) { Math.Lemmas.pow2_plus (p * i) p }
pow2 (p * i) * pow2 p * c;
(==) { Math.Lemmas.paren_mul_right (pow2 (p * i)) (pow2 p) c }
pow2 (p * i) * (pow2 p * c);
(==) { }
pow2 (p * i) * (a - b);
(==) { Math.Lemmas.distributivity_sub_right (pow2 (p * i)) a b }
pow2 (p * i) * a - pow2 (p * i) * b;
}
#restart-solver
val bn_eval_split_i: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i <= len} -> Lemma
(ensures bn_v b == bn_v (slice b 0 i) + pow2 (bits t * i) * bn_v (slice b i len))
(decreases (len - i))
// 20220513 JP: this proof broke somewhere in the calc, but even with --quake
// 3/3 it goes through. Solver inconsistency? The restart solver above fixes it.
let rec bn_eval_split_i #t #len b i =
let pbits = bits t in
if i = 0 then
bn_eval0 (slice b 0 i)
else begin
if len = i then
bn_eval0 (slice b i len)
else begin
let b1 = slice b i len in
bn_eval_split_i b1 1;
bn_eval1 (slice b1 0 1);
assert (bn_v b1 == v b1.[0] + pow2 pbits * bn_v (slice b1 1 (len - i)));
Seq.lemma_index_slice b i len 0;
assert (bn_v b1 == v b.[i] + pow2 pbits * bn_v (slice b (i + 1) len));
calc (==) {
bn_v b;
(==) { bn_eval_split_i b (i + 1) }
bn_v (slice b 0 (i + 1)) + pow2 (pbits * (i + 1)) * bn_v (slice b (i + 1) len);
(==) { bn_eval_split_i_aux pbits (bn_v b1) (v b.[i]) (bn_v (slice b (i + 1) len)) i }
bn_v (slice b 0 (i + 1)) + pow2 (pbits * i) * bn_v b1 - pow2 (pbits * i) * v b.[i];
(==) { bn_eval_unfold_i (slice b 0 (i + 1)) (i + 1)}
eval_ (i + 1) (slice b 0 (i + 1)) i + pow2 (pbits * i) * bn_v b1;
(==) { bn_eval_extensionality_j (slice b 0 (i + 1)) (slice b 0 i) i }
eval_ i (slice b 0 i) i + pow2 (pbits * i) * bn_v b1;
}; () end end
val bn_eval_inj: #t:limb_t -> len:size_nat -> b1:lbignum t len -> b2:lbignum t len -> Lemma
(requires bn_v b1 == bn_v b2)
(ensures equal b1 b2)
(decreases len)
let rec bn_eval_inj #t len b1 b2 =
if len = 0 then ()
else begin
bn_eval_split_i b1 1;
bn_eval_split_i b2 1;
bn_eval1 (slice b1 0 1);
bn_eval1 (slice b2 0 1);
bn_eval_inj (len - 1) (slice b1 1 len) (slice b2 1 len);
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
val bn_eval_bound: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i <= len} ->
Lemma (eval_ len b i < pow2 (bits t * i))
let rec bn_eval_bound #t #len b i =
let pbits = bits t in
if i = 0 then
bn_eval0 b
else begin
bn_eval_unfold_i b i;
assert (eval_ len b i == eval_ len b (i - 1) + pow2 (pbits * (i - 1)) * v b.[i - 1]);
calc (<) {
eval_ len b (i - 1) + pow2 (pbits * (i - 1)) * v b.[i - 1];
(<) { bn_eval_bound #t #len b (i - 1) }
pow2 (pbits * (i - 1)) + pow2 (pbits * (i - 1)) * v b.[i - 1];
(==) { Math.Lemmas.distributivity_add_right (pow2 (pbits * (i - 1))) 1 (v b.[i - 1]) }
pow2 (pbits * (i - 1)) * (1 + v b.[i - 1]);
(<=) { Math.Lemmas.lemma_mult_le_left (pow2 (pbits * (i - 1))) (1 + v b.[i - 1]) (pow2 pbits) }
pow2 (pbits * (i - 1)) * pow2 pbits;
(==) { Math.Lemmas.pow2_plus (pbits * (i - 1)) pbits }
pow2 (pbits * i);
};
assert (eval_ len b i < pow2 (pbits * i))
end
val bn_eval_index: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i < len} ->
Lemma (v b.[i] == bn_v b / pow2 (bits t * i) % pow2 (bits t))
let bn_eval_index #t #len b i =
let pbits = bits t in
calc (==) {
bn_v b / pow2 (pbits * i) % pow2 pbits;
(==) { bn_eval_split_i #t #len b i }
(bn_v (slice b 0 i) + pow2 (pbits * i) * bn_v (slice b i len)) / pow2 (pbits * i) % pow2 pbits;
(==) { Math.Lemmas.division_addition_lemma (bn_v (slice b 0 i)) (pow2 (pbits * i)) (bn_v (slice b i len)) }
(bn_v (slice b 0 i) / pow2 (pbits * i) + bn_v (slice b i len)) % pow2 pbits;
(==) { bn_eval_bound (slice b 0 i) i; Math.Lemmas.small_division_lemma_1 (bn_v (slice b 0 i)) (pow2 (pbits * i)) }
bn_v (slice b i len) % pow2 pbits;
(==) { bn_eval_split_i (slice b i len) 1 }
(bn_v (slice b i (i + 1)) + pow2 pbits * bn_v (slice b (i + 1) len)) % pow2 pbits;
(==) { Math.Lemmas.modulo_addition_lemma (bn_v (slice b i (i + 1))) (pow2 pbits) (bn_v (slice b (i + 1) len)) }
bn_v (slice b i (i + 1)) % pow2 pbits;
(==) { bn_eval1 (slice b i (i + 1)); Seq.lemma_index_slice b i (i + 1) 0 }
v b.[i] % pow2 pbits;
(==) { Math.Lemmas.modulo_lemma (v b.[i]) (pow2 pbits) }
v b.[i];
};
assert (bn_v b / pow2 (pbits * i) % pow2 pbits == v b.[i])
val bn_eval_lt: #t:limb_t -> len:size_nat -> a:lbignum t len -> b:lbignum t len -> k:pos{k <= len} -> Lemma
(requires v a.[k - 1] < v b.[k - 1])
(ensures eval_ len a k < eval_ len b k)
let bn_eval_lt #t len a b k =
let pbits = bits t in
calc (==) {
eval_ len b k - eval_ len a k;
(==) { bn_eval_unfold_i b k }
eval_ len b (k - 1) + v b.[k - 1] * pow2 (pbits * (k - 1)) - eval_ len a k;
(==) { bn_eval_unfold_i a k }
eval_ len b (k - 1) + v b.[k - 1] * pow2 (pbits * (k - 1)) - eval_ len a (k - 1) - v a.[k - 1] * pow2 (pbits * (k - 1));
(==) { Math.Lemmas.distributivity_sub_left (v b.[k - 1]) (v a.[k - 1]) (pow2 (pbits * (k - 1))) }
eval_ len b (k - 1) - eval_ len a (k - 1) + (v b.[k - 1] - v a.[k - 1]) * pow2 (pbits * (k - 1));
};
bn_eval_bound a (k - 1);
bn_eval_bound b (k - 1);
assert (eval_ len b (k - 1) - eval_ len a (k - 1) > - pow2 (pbits * (k - 1)));
assert ((v b.[k - 1] - v a.[k - 1]) * pow2 (pbits * (k - 1)) >= pow2 (pbits * (k - 1)))
val bn_eval_update_sub: #t:limb_t -> len1:size_nat -> b1:lbignum t len1 -> len2:size_nat{len1 <= len2} ->
Lemma (let b2 = create len2 (uint #t 0) in bn_v b1 == bn_v (update_sub b2 0 len1 b1)) | false | false | Hacl.Spec.Bignum.Definitions.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_eval_update_sub: #t:limb_t -> len1:size_nat -> b1:lbignum t len1 -> len2:size_nat{len1 <= len2} ->
Lemma (let b2 = create len2 (uint #t 0) in bn_v b1 == bn_v (update_sub b2 0 len1 b1)) | [] | Hacl.Spec.Bignum.Definitions.bn_eval_update_sub | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
len1: Lib.IntTypes.size_nat ->
b1: Hacl.Spec.Bignum.Definitions.lbignum t len1 ->
len2: Lib.IntTypes.size_nat{len1 <= len2}
-> FStar.Pervasives.Lemma
(ensures
(let b2 = Lib.Sequence.create len2 (Lib.IntTypes.uint 0) in
Hacl.Spec.Bignum.Definitions.bn_v b1 ==
Hacl.Spec.Bignum.Definitions.bn_v (Lib.Sequence.update_sub b2 0 len1 b1))) | {
"end_col": 47,
"end_line": 255,
"start_col": 40,
"start_line": 248
} |
FStar.Pervasives.Lemma | val bn_concat_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{aLen + bLen <= max_size_t}
-> a:lbignum t aLen
-> b:lbignum t bLen ->
Lemma (bn_v (concat a b) == bn_v a + pow2 (bits t * aLen) * bn_v b) | [
{
"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_concat_lemma #t #aLen #bLen a b =
let pbits = bits t in
let res = concat a b in
calc (==) {
bn_v res;
(==) { bn_eval_split_i res aLen }
bn_v (slice res 0 aLen) + pow2 (pbits * aLen) * bn_v (slice res aLen (aLen + bLen));
(==) { eq_intro (slice res 0 aLen) a }
bn_v a + pow2 (pbits * aLen) * bn_v (slice res aLen (aLen + bLen));
(==) { eq_intro (slice res aLen (aLen + bLen)) b }
bn_v a + pow2 (pbits * aLen) * bn_v b;
} | val bn_concat_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{aLen + bLen <= max_size_t}
-> a:lbignum t aLen
-> b:lbignum t bLen ->
Lemma (bn_v (concat a b) == bn_v a + pow2 (bits t * aLen) * bn_v b)
let bn_concat_lemma #t #aLen #bLen a b = | false | null | true | let pbits = bits t in
let res = concat a b in
calc ( == ) {
bn_v res;
( == ) { bn_eval_split_i res aLen }
bn_v (slice res 0 aLen) + pow2 (pbits * aLen) * bn_v (slice res aLen (aLen + bLen));
( == ) { eq_intro (slice res 0 aLen) a }
bn_v a + pow2 (pbits * aLen) * bn_v (slice res aLen (aLen + bLen));
( == ) { eq_intro (slice res aLen (aLen + bLen)) b }
bn_v a + pow2 (pbits * aLen) * bn_v b;
} | {
"checked_file": "Hacl.Spec.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Definitions.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"FStar.Calc.calc_finish",
"Prims.nat",
"Prims.eq2",
"Hacl.Spec.Bignum.Definitions.bn_v",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"Prims.op_Subtraction",
"Lib.Sequence.slice",
"Hacl.Spec.Bignum.Definitions.limb",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Hacl.Spec.Bignum.Definitions.bn_eval_split_i",
"Prims.squash",
"Lib.Sequence.eq_intro",
"Lib.Sequence.lseq",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.append",
"Lib.Sequence.concat",
"Prims.int",
"Lib.IntTypes.bits"
] | [] | module Hacl.Spec.Bignum.Definitions
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val blocks0: x:size_nat -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks0 x m = if x = 0 then 1 else (x - 1) / m + 1
inline_for_extraction noextract
let limb_t = t:inttype{t = U32 \/ t = U64}
inline_for_extraction noextract
let limb (t:limb_t) = uint_t t SEC
let lbignum (t:limb_t) len = lseq (limb t) len
val eval_: #t:limb_t -> len:size_nat -> s:lbignum t len -> i:nat{i <= len} -> nat
let rec eval_ #t len s i =
if i = 0 then 0
else eval_ #t len s (i - 1) + v s.[i - 1] * pow2 (bits t * (i - 1))
let bn_v (#t:limb_t) (#len:size_nat) (s:lbignum t len) = eval_ #t len s len
///
/// Lemmas
///
#push-options "--fuel 2"
val bn_eval0: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (eval_ len b 0 == 0)
let bn_eval0 #t #len b = ()
val bn_eval1: #t:limb_t -> b:lbignum t 1 -> Lemma (bn_v b == v b.[0])
let bn_eval1 b = ()
val bn_eval_unfold_i: #t:limb_t -> #len:size_pos -> b:lbignum t len -> i:pos{i <= len} ->
Lemma (eval_ len b i == eval_ len b (i - 1) + v b.[i - 1] * pow2 (bits t * (i - 1)))
let bn_eval_unfold_i #t #len b i = ()
#pop-options
val bn_eval_zeroes: #t:limb_t -> len:size_nat -> i:nat{i <= len} ->
Lemma (eval_ len (create len (uint #t 0)) i == 0)
let rec bn_eval_zeroes #t len i =
let b = create len (uint #t 0) in
if i = 0 then
bn_eval0 b
else begin
bn_eval_unfold_i b i;
bn_eval_zeroes #t len (i - 1) end
val bn_eval_create1: #t:limb_t -> c:limb t -> Lemma (bn_v (create 1 c) == v c)
let bn_eval_create1 #t c =
bn_eval1 (create 1 c)
val bn_eval_extensionality_j:
#t:limb_t
-> #len1:size_nat
-> #len2:size_nat
-> b1:lbignum t len1
-> b2:lbignum t len2
-> j:nat{j <= len1 /\ j <= len2} ->
Lemma
(requires sub b1 0 j == sub b2 0 j)
(ensures eval_ len1 b1 j == eval_ len2 b2 j)
(decreases j)
let rec bn_eval_extensionality_j #t #len1 #len2 b1 b2 j =
if j = 0 then begin
bn_eval0 b1;
bn_eval0 b2 end
else begin
bn_eval_unfold_i b1 j;
bn_eval_unfold_i b2 j;
let b1j = slice b1 0 j in
let b2j = slice b2 0 j in
let c1 = slice b1j 0 (j - 1) in
let c2 = slice b2j 0 (j - 1) in
eq_intro c1 c2;
bn_eval_extensionality_j #t #len1 #len2 b1 b2 (j - 1);
Seq.lemma_index_slice b1 0 j (j - 1);
Seq.lemma_index_slice b2 0 j (j - 1);
assert (v b1.[j - 1] == v b2.[j - 1]);
() end
val bn_eval_snoc: #t:limb_t -> #len:size_nat{len + 1 <= max_size_t} -> b:lbignum t len -> e:limb t ->
Lemma (bn_v #t #(len + 1) (Seq.snoc b e) == bn_v b + v e * pow2 (bits t * len))
let bn_eval_snoc #t #len b e =
let b1 = Seq.snoc b e in
bn_eval_unfold_i #t #(len + 1) b1 (len + 1);
bn_eval_extensionality_j #t #(len+1) #len b1 (slice #_ #(len+1) b1 0 len) len;
eq_intro (sub #_ #(len + 1) b1 0 len) b
val bn_eval_split_i_aux: p:nat -> a:nat -> b:nat -> c:nat -> i:nat -> Lemma
(requires pow2 p * c == a - b)
(ensures pow2 (p * (i + 1)) * c == pow2 (p * i) * a - pow2 (p * i) * b)
let bn_eval_split_i_aux p a b c i =
calc (==) {
pow2 (p * (i + 1)) * c;
(==) { Math.Lemmas.pow2_plus (p * i) p }
pow2 (p * i) * pow2 p * c;
(==) { Math.Lemmas.paren_mul_right (pow2 (p * i)) (pow2 p) c }
pow2 (p * i) * (pow2 p * c);
(==) { }
pow2 (p * i) * (a - b);
(==) { Math.Lemmas.distributivity_sub_right (pow2 (p * i)) a b }
pow2 (p * i) * a - pow2 (p * i) * b;
}
#restart-solver
val bn_eval_split_i: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i <= len} -> Lemma
(ensures bn_v b == bn_v (slice b 0 i) + pow2 (bits t * i) * bn_v (slice b i len))
(decreases (len - i))
// 20220513 JP: this proof broke somewhere in the calc, but even with --quake
// 3/3 it goes through. Solver inconsistency? The restart solver above fixes it.
let rec bn_eval_split_i #t #len b i =
let pbits = bits t in
if i = 0 then
bn_eval0 (slice b 0 i)
else begin
if len = i then
bn_eval0 (slice b i len)
else begin
let b1 = slice b i len in
bn_eval_split_i b1 1;
bn_eval1 (slice b1 0 1);
assert (bn_v b1 == v b1.[0] + pow2 pbits * bn_v (slice b1 1 (len - i)));
Seq.lemma_index_slice b i len 0;
assert (bn_v b1 == v b.[i] + pow2 pbits * bn_v (slice b (i + 1) len));
calc (==) {
bn_v b;
(==) { bn_eval_split_i b (i + 1) }
bn_v (slice b 0 (i + 1)) + pow2 (pbits * (i + 1)) * bn_v (slice b (i + 1) len);
(==) { bn_eval_split_i_aux pbits (bn_v b1) (v b.[i]) (bn_v (slice b (i + 1) len)) i }
bn_v (slice b 0 (i + 1)) + pow2 (pbits * i) * bn_v b1 - pow2 (pbits * i) * v b.[i];
(==) { bn_eval_unfold_i (slice b 0 (i + 1)) (i + 1)}
eval_ (i + 1) (slice b 0 (i + 1)) i + pow2 (pbits * i) * bn_v b1;
(==) { bn_eval_extensionality_j (slice b 0 (i + 1)) (slice b 0 i) i }
eval_ i (slice b 0 i) i + pow2 (pbits * i) * bn_v b1;
}; () end end
val bn_eval_inj: #t:limb_t -> len:size_nat -> b1:lbignum t len -> b2:lbignum t len -> Lemma
(requires bn_v b1 == bn_v b2)
(ensures equal b1 b2)
(decreases len)
let rec bn_eval_inj #t len b1 b2 =
if len = 0 then ()
else begin
bn_eval_split_i b1 1;
bn_eval_split_i b2 1;
bn_eval1 (slice b1 0 1);
bn_eval1 (slice b2 0 1);
bn_eval_inj (len - 1) (slice b1 1 len) (slice b2 1 len);
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
val bn_eval_bound: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i <= len} ->
Lemma (eval_ len b i < pow2 (bits t * i))
let rec bn_eval_bound #t #len b i =
let pbits = bits t in
if i = 0 then
bn_eval0 b
else begin
bn_eval_unfold_i b i;
assert (eval_ len b i == eval_ len b (i - 1) + pow2 (pbits * (i - 1)) * v b.[i - 1]);
calc (<) {
eval_ len b (i - 1) + pow2 (pbits * (i - 1)) * v b.[i - 1];
(<) { bn_eval_bound #t #len b (i - 1) }
pow2 (pbits * (i - 1)) + pow2 (pbits * (i - 1)) * v b.[i - 1];
(==) { Math.Lemmas.distributivity_add_right (pow2 (pbits * (i - 1))) 1 (v b.[i - 1]) }
pow2 (pbits * (i - 1)) * (1 + v b.[i - 1]);
(<=) { Math.Lemmas.lemma_mult_le_left (pow2 (pbits * (i - 1))) (1 + v b.[i - 1]) (pow2 pbits) }
pow2 (pbits * (i - 1)) * pow2 pbits;
(==) { Math.Lemmas.pow2_plus (pbits * (i - 1)) pbits }
pow2 (pbits * i);
};
assert (eval_ len b i < pow2 (pbits * i))
end
val bn_eval_index: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i < len} ->
Lemma (v b.[i] == bn_v b / pow2 (bits t * i) % pow2 (bits t))
let bn_eval_index #t #len b i =
let pbits = bits t in
calc (==) {
bn_v b / pow2 (pbits * i) % pow2 pbits;
(==) { bn_eval_split_i #t #len b i }
(bn_v (slice b 0 i) + pow2 (pbits * i) * bn_v (slice b i len)) / pow2 (pbits * i) % pow2 pbits;
(==) { Math.Lemmas.division_addition_lemma (bn_v (slice b 0 i)) (pow2 (pbits * i)) (bn_v (slice b i len)) }
(bn_v (slice b 0 i) / pow2 (pbits * i) + bn_v (slice b i len)) % pow2 pbits;
(==) { bn_eval_bound (slice b 0 i) i; Math.Lemmas.small_division_lemma_1 (bn_v (slice b 0 i)) (pow2 (pbits * i)) }
bn_v (slice b i len) % pow2 pbits;
(==) { bn_eval_split_i (slice b i len) 1 }
(bn_v (slice b i (i + 1)) + pow2 pbits * bn_v (slice b (i + 1) len)) % pow2 pbits;
(==) { Math.Lemmas.modulo_addition_lemma (bn_v (slice b i (i + 1))) (pow2 pbits) (bn_v (slice b (i + 1) len)) }
bn_v (slice b i (i + 1)) % pow2 pbits;
(==) { bn_eval1 (slice b i (i + 1)); Seq.lemma_index_slice b i (i + 1) 0 }
v b.[i] % pow2 pbits;
(==) { Math.Lemmas.modulo_lemma (v b.[i]) (pow2 pbits) }
v b.[i];
};
assert (bn_v b / pow2 (pbits * i) % pow2 pbits == v b.[i])
val bn_eval_lt: #t:limb_t -> len:size_nat -> a:lbignum t len -> b:lbignum t len -> k:pos{k <= len} -> Lemma
(requires v a.[k - 1] < v b.[k - 1])
(ensures eval_ len a k < eval_ len b k)
let bn_eval_lt #t len a b k =
let pbits = bits t in
calc (==) {
eval_ len b k - eval_ len a k;
(==) { bn_eval_unfold_i b k }
eval_ len b (k - 1) + v b.[k - 1] * pow2 (pbits * (k - 1)) - eval_ len a k;
(==) { bn_eval_unfold_i a k }
eval_ len b (k - 1) + v b.[k - 1] * pow2 (pbits * (k - 1)) - eval_ len a (k - 1) - v a.[k - 1] * pow2 (pbits * (k - 1));
(==) { Math.Lemmas.distributivity_sub_left (v b.[k - 1]) (v a.[k - 1]) (pow2 (pbits * (k - 1))) }
eval_ len b (k - 1) - eval_ len a (k - 1) + (v b.[k - 1] - v a.[k - 1]) * pow2 (pbits * (k - 1));
};
bn_eval_bound a (k - 1);
bn_eval_bound b (k - 1);
assert (eval_ len b (k - 1) - eval_ len a (k - 1) > - pow2 (pbits * (k - 1)));
assert ((v b.[k - 1] - v a.[k - 1]) * pow2 (pbits * (k - 1)) >= pow2 (pbits * (k - 1)))
val bn_eval_update_sub: #t:limb_t -> len1:size_nat -> b1:lbignum t len1 -> len2:size_nat{len1 <= len2} ->
Lemma (let b2 = create len2 (uint #t 0) in bn_v b1 == bn_v (update_sub b2 0 len1 b1))
let bn_eval_update_sub #t len1 b1 len2 =
let b2 = create len2 (uint #t 0) in
let b2 = update_sub b2 0 len1 b1 in
bn_eval_split_i b2 len1;
assert (bn_v b2 == bn_v b1 + pow2 (bits t * len1) * bn_v (slice b2 len1 len2));
let b_zeroes = create (len2 - len1) (uint #t 0) in
eq_intro b_zeroes (slice b2 len1 len2);
bn_eval_zeroes #t (len2 - len1) (len2 - len1)
val bn_update_sub_eval:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t bLen
-> i:nat{i + bLen <= aLen} ->
Lemma (bn_v (update_sub a i bLen b) == bn_v a - bn_v (sub a i bLen) * pow2 (bits t * i) + bn_v b * pow2 (bits t * i))
let bn_update_sub_eval #t #aLen #bLen a b i =
let pbits = bits t in
let a' = update_sub a i bLen b in
let c = bn_v (sub a i bLen) * pow2 (bits t * i) in
calc (==) {
bn_v a' + c;
(==) { bn_eval_split_i a' i }
bn_v (slice a' 0 i) + pow2 (pbits * i) * bn_v (slice a' i aLen) + c;
(==) { eq_intro (slice a 0 i) (slice a' 0 i) }
bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v (slice a' i aLen) + c;
(==) { bn_eval_split_i (slice a' i aLen) bLen }
bn_v (slice a 0 i) + pow2 (pbits * i) * (bn_v (sub a' i bLen) + pow2 (pbits * bLen) * bn_v (slice a' (i + bLen) aLen)) + c;
(==) { eq_intro (slice a' (i + bLen) aLen) (slice a (i + bLen) aLen) }
bn_v (slice a 0 i) + pow2 (pbits * i) * (bn_v (sub a' i bLen) + pow2 (pbits * bLen) * bn_v (slice a (i + bLen) aLen)) + c;
(==) {eq_intro (sub a' i bLen) b }
bn_v (slice a 0 i) + pow2 (pbits * i) * (bn_v b + pow2 (pbits * bLen) * bn_v (slice a (i + bLen) aLen)) + c;
(==) { Math.Lemmas.distributivity_add_right (pow2 (pbits * i)) (bn_v b) (pow2 (pbits * bLen) * bn_v (slice a (i + bLen) aLen)) }
bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v b + pow2 (pbits * i) * (pow2 (pbits * bLen) * bn_v (slice a (i + bLen) aLen)) + c;
(==) { Math.Lemmas.paren_mul_right (pow2 (pbits * i)) (pow2 (pbits * bLen)) (bn_v (slice a (i + bLen) aLen));
Math.Lemmas.pow2_plus (pbits * i) (pbits * bLen) }
bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v b + pow2 (pbits * (i + bLen)) * bn_v (slice a (i + bLen) aLen) + c;
(==) { bn_eval_split_i (slice a 0 (i + bLen)) i }
bn_v (slice a 0 (i + bLen)) + pow2 (pbits * i) * bn_v b + pow2 (pbits * (i + bLen)) * bn_v (slice a (i + bLen) aLen);
(==) { bn_eval_split_i a (i + bLen) }
bn_v a + pow2 (pbits * i) * bn_v b;
}
val bn_upd_eval:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b1:limb t
-> i:nat{i < aLen} ->
Lemma (bn_v (upd a i b1) == bn_v a - v a.[i] * pow2 (bits t * i) + v b1 * pow2 (bits t * i))
let bn_upd_eval #t #aLen a b1 i =
let b = create 1 b1 in
bn_update_sub_eval a b i;
bn_eval1 (sub a i 1);
bn_eval1 b;
assert (bn_v (update_sub a i 1 b) == bn_v a - v a.[i] * pow2 (bits t * i) + v b1 * pow2 (bits t * i));
eq_intro (update_sub a i 1 b) (upd a i b1)
val bn_concat_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{aLen + bLen <= max_size_t}
-> a:lbignum t aLen
-> b:lbignum t bLen ->
Lemma (bn_v (concat a b) == bn_v a + pow2 (bits t * aLen) * bn_v b) | false | false | Hacl.Spec.Bignum.Definitions.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_concat_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{aLen + bLen <= max_size_t}
-> a:lbignum t aLen
-> b:lbignum t bLen ->
Lemma (bn_v (concat a b) == bn_v a + pow2 (bits t * aLen) * bn_v b) | [] | Hacl.Spec.Bignum.Definitions.bn_concat_lemma | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Definitions.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 aLen -> b: Hacl.Spec.Bignum.Definitions.lbignum t bLen
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Definitions.bn_v (Lib.Sequence.concat a b) ==
Hacl.Spec.Bignum.Definitions.bn_v a +
Prims.pow2 (Lib.IntTypes.bits t * aLen) * Hacl.Spec.Bignum.Definitions.bn_v b) | {
"end_col": 5,
"end_line": 332,
"start_col": 40,
"start_line": 321
} |
FStar.Pervasives.Lemma | val bn_eval_lt: #t:limb_t -> len:size_nat -> a:lbignum t len -> b:lbignum t len -> k:pos{k <= len} -> Lemma
(requires v a.[k - 1] < v b.[k - 1])
(ensures eval_ len a k < eval_ len b k) | [
{
"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_eval_lt #t len a b k =
let pbits = bits t in
calc (==) {
eval_ len b k - eval_ len a k;
(==) { bn_eval_unfold_i b k }
eval_ len b (k - 1) + v b.[k - 1] * pow2 (pbits * (k - 1)) - eval_ len a k;
(==) { bn_eval_unfold_i a k }
eval_ len b (k - 1) + v b.[k - 1] * pow2 (pbits * (k - 1)) - eval_ len a (k - 1) - v a.[k - 1] * pow2 (pbits * (k - 1));
(==) { Math.Lemmas.distributivity_sub_left (v b.[k - 1]) (v a.[k - 1]) (pow2 (pbits * (k - 1))) }
eval_ len b (k - 1) - eval_ len a (k - 1) + (v b.[k - 1] - v a.[k - 1]) * pow2 (pbits * (k - 1));
};
bn_eval_bound a (k - 1);
bn_eval_bound b (k - 1);
assert (eval_ len b (k - 1) - eval_ len a (k - 1) > - pow2 (pbits * (k - 1)));
assert ((v b.[k - 1] - v a.[k - 1]) * pow2 (pbits * (k - 1)) >= pow2 (pbits * (k - 1))) | val bn_eval_lt: #t:limb_t -> len:size_nat -> a:lbignum t len -> b:lbignum t len -> k:pos{k <= len} -> Lemma
(requires v a.[k - 1] < v b.[k - 1])
(ensures eval_ len a k < eval_ len b k)
let bn_eval_lt #t len a b k = | false | null | true | let pbits = bits t in
calc ( == ) {
eval_ len b k - eval_ len a k;
( == ) { bn_eval_unfold_i b k }
eval_ len b (k - 1) + v b.[ k - 1 ] * pow2 (pbits * (k - 1)) - eval_ len a k;
( == ) { bn_eval_unfold_i a k }
eval_ len b (k - 1) + v b.[ k - 1 ] * pow2 (pbits * (k - 1)) - eval_ len a (k - 1) -
v a.[ k - 1 ] * pow2 (pbits * (k - 1));
( == ) { Math.Lemmas.distributivity_sub_left (v b.[ k - 1 ])
(v a.[ k - 1 ])
(pow2 (pbits * (k - 1))) }
eval_ len b (k - 1) - eval_ len a (k - 1) +
(v b.[ k - 1 ] - v a.[ k - 1 ]) * pow2 (pbits * (k - 1));
};
bn_eval_bound a (k - 1);
bn_eval_bound b (k - 1);
assert (eval_ len b (k - 1) - eval_ len a (k - 1) > - pow2 (pbits * (k - 1)));
assert ((v b.[ k - 1 ] - v a.[ k - 1 ]) * pow2 (pbits * (k - 1)) >= pow2 (pbits * (k - 1))) | {
"checked_file": "Hacl.Spec.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Definitions.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims._assert",
"Prims.op_GreaterThanOrEqual",
"FStar.Mul.op_Star",
"Prims.op_Subtraction",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.pow2",
"Prims.unit",
"Prims.op_GreaterThan",
"Hacl.Spec.Bignum.Definitions.eval_",
"Prims.op_Minus",
"Hacl.Spec.Bignum.Definitions.bn_eval_bound",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Addition",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Hacl.Spec.Bignum.Definitions.bn_eval_unfold_i",
"Prims.squash",
"FStar.Math.Lemmas.distributivity_sub_left",
"Lib.IntTypes.bits"
] | [] | module Hacl.Spec.Bignum.Definitions
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val blocks0: x:size_nat -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks0 x m = if x = 0 then 1 else (x - 1) / m + 1
inline_for_extraction noextract
let limb_t = t:inttype{t = U32 \/ t = U64}
inline_for_extraction noextract
let limb (t:limb_t) = uint_t t SEC
let lbignum (t:limb_t) len = lseq (limb t) len
val eval_: #t:limb_t -> len:size_nat -> s:lbignum t len -> i:nat{i <= len} -> nat
let rec eval_ #t len s i =
if i = 0 then 0
else eval_ #t len s (i - 1) + v s.[i - 1] * pow2 (bits t * (i - 1))
let bn_v (#t:limb_t) (#len:size_nat) (s:lbignum t len) = eval_ #t len s len
///
/// Lemmas
///
#push-options "--fuel 2"
val bn_eval0: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (eval_ len b 0 == 0)
let bn_eval0 #t #len b = ()
val bn_eval1: #t:limb_t -> b:lbignum t 1 -> Lemma (bn_v b == v b.[0])
let bn_eval1 b = ()
val bn_eval_unfold_i: #t:limb_t -> #len:size_pos -> b:lbignum t len -> i:pos{i <= len} ->
Lemma (eval_ len b i == eval_ len b (i - 1) + v b.[i - 1] * pow2 (bits t * (i - 1)))
let bn_eval_unfold_i #t #len b i = ()
#pop-options
val bn_eval_zeroes: #t:limb_t -> len:size_nat -> i:nat{i <= len} ->
Lemma (eval_ len (create len (uint #t 0)) i == 0)
let rec bn_eval_zeroes #t len i =
let b = create len (uint #t 0) in
if i = 0 then
bn_eval0 b
else begin
bn_eval_unfold_i b i;
bn_eval_zeroes #t len (i - 1) end
val bn_eval_create1: #t:limb_t -> c:limb t -> Lemma (bn_v (create 1 c) == v c)
let bn_eval_create1 #t c =
bn_eval1 (create 1 c)
val bn_eval_extensionality_j:
#t:limb_t
-> #len1:size_nat
-> #len2:size_nat
-> b1:lbignum t len1
-> b2:lbignum t len2
-> j:nat{j <= len1 /\ j <= len2} ->
Lemma
(requires sub b1 0 j == sub b2 0 j)
(ensures eval_ len1 b1 j == eval_ len2 b2 j)
(decreases j)
let rec bn_eval_extensionality_j #t #len1 #len2 b1 b2 j =
if j = 0 then begin
bn_eval0 b1;
bn_eval0 b2 end
else begin
bn_eval_unfold_i b1 j;
bn_eval_unfold_i b2 j;
let b1j = slice b1 0 j in
let b2j = slice b2 0 j in
let c1 = slice b1j 0 (j - 1) in
let c2 = slice b2j 0 (j - 1) in
eq_intro c1 c2;
bn_eval_extensionality_j #t #len1 #len2 b1 b2 (j - 1);
Seq.lemma_index_slice b1 0 j (j - 1);
Seq.lemma_index_slice b2 0 j (j - 1);
assert (v b1.[j - 1] == v b2.[j - 1]);
() end
val bn_eval_snoc: #t:limb_t -> #len:size_nat{len + 1 <= max_size_t} -> b:lbignum t len -> e:limb t ->
Lemma (bn_v #t #(len + 1) (Seq.snoc b e) == bn_v b + v e * pow2 (bits t * len))
let bn_eval_snoc #t #len b e =
let b1 = Seq.snoc b e in
bn_eval_unfold_i #t #(len + 1) b1 (len + 1);
bn_eval_extensionality_j #t #(len+1) #len b1 (slice #_ #(len+1) b1 0 len) len;
eq_intro (sub #_ #(len + 1) b1 0 len) b
val bn_eval_split_i_aux: p:nat -> a:nat -> b:nat -> c:nat -> i:nat -> Lemma
(requires pow2 p * c == a - b)
(ensures pow2 (p * (i + 1)) * c == pow2 (p * i) * a - pow2 (p * i) * b)
let bn_eval_split_i_aux p a b c i =
calc (==) {
pow2 (p * (i + 1)) * c;
(==) { Math.Lemmas.pow2_plus (p * i) p }
pow2 (p * i) * pow2 p * c;
(==) { Math.Lemmas.paren_mul_right (pow2 (p * i)) (pow2 p) c }
pow2 (p * i) * (pow2 p * c);
(==) { }
pow2 (p * i) * (a - b);
(==) { Math.Lemmas.distributivity_sub_right (pow2 (p * i)) a b }
pow2 (p * i) * a - pow2 (p * i) * b;
}
#restart-solver
val bn_eval_split_i: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i <= len} -> Lemma
(ensures bn_v b == bn_v (slice b 0 i) + pow2 (bits t * i) * bn_v (slice b i len))
(decreases (len - i))
// 20220513 JP: this proof broke somewhere in the calc, but even with --quake
// 3/3 it goes through. Solver inconsistency? The restart solver above fixes it.
let rec bn_eval_split_i #t #len b i =
let pbits = bits t in
if i = 0 then
bn_eval0 (slice b 0 i)
else begin
if len = i then
bn_eval0 (slice b i len)
else begin
let b1 = slice b i len in
bn_eval_split_i b1 1;
bn_eval1 (slice b1 0 1);
assert (bn_v b1 == v b1.[0] + pow2 pbits * bn_v (slice b1 1 (len - i)));
Seq.lemma_index_slice b i len 0;
assert (bn_v b1 == v b.[i] + pow2 pbits * bn_v (slice b (i + 1) len));
calc (==) {
bn_v b;
(==) { bn_eval_split_i b (i + 1) }
bn_v (slice b 0 (i + 1)) + pow2 (pbits * (i + 1)) * bn_v (slice b (i + 1) len);
(==) { bn_eval_split_i_aux pbits (bn_v b1) (v b.[i]) (bn_v (slice b (i + 1) len)) i }
bn_v (slice b 0 (i + 1)) + pow2 (pbits * i) * bn_v b1 - pow2 (pbits * i) * v b.[i];
(==) { bn_eval_unfold_i (slice b 0 (i + 1)) (i + 1)}
eval_ (i + 1) (slice b 0 (i + 1)) i + pow2 (pbits * i) * bn_v b1;
(==) { bn_eval_extensionality_j (slice b 0 (i + 1)) (slice b 0 i) i }
eval_ i (slice b 0 i) i + pow2 (pbits * i) * bn_v b1;
}; () end end
val bn_eval_inj: #t:limb_t -> len:size_nat -> b1:lbignum t len -> b2:lbignum t len -> Lemma
(requires bn_v b1 == bn_v b2)
(ensures equal b1 b2)
(decreases len)
let rec bn_eval_inj #t len b1 b2 =
if len = 0 then ()
else begin
bn_eval_split_i b1 1;
bn_eval_split_i b2 1;
bn_eval1 (slice b1 0 1);
bn_eval1 (slice b2 0 1);
bn_eval_inj (len - 1) (slice b1 1 len) (slice b2 1 len);
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
val bn_eval_bound: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i <= len} ->
Lemma (eval_ len b i < pow2 (bits t * i))
let rec bn_eval_bound #t #len b i =
let pbits = bits t in
if i = 0 then
bn_eval0 b
else begin
bn_eval_unfold_i b i;
assert (eval_ len b i == eval_ len b (i - 1) + pow2 (pbits * (i - 1)) * v b.[i - 1]);
calc (<) {
eval_ len b (i - 1) + pow2 (pbits * (i - 1)) * v b.[i - 1];
(<) { bn_eval_bound #t #len b (i - 1) }
pow2 (pbits * (i - 1)) + pow2 (pbits * (i - 1)) * v b.[i - 1];
(==) { Math.Lemmas.distributivity_add_right (pow2 (pbits * (i - 1))) 1 (v b.[i - 1]) }
pow2 (pbits * (i - 1)) * (1 + v b.[i - 1]);
(<=) { Math.Lemmas.lemma_mult_le_left (pow2 (pbits * (i - 1))) (1 + v b.[i - 1]) (pow2 pbits) }
pow2 (pbits * (i - 1)) * pow2 pbits;
(==) { Math.Lemmas.pow2_plus (pbits * (i - 1)) pbits }
pow2 (pbits * i);
};
assert (eval_ len b i < pow2 (pbits * i))
end
val bn_eval_index: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i < len} ->
Lemma (v b.[i] == bn_v b / pow2 (bits t * i) % pow2 (bits t))
let bn_eval_index #t #len b i =
let pbits = bits t in
calc (==) {
bn_v b / pow2 (pbits * i) % pow2 pbits;
(==) { bn_eval_split_i #t #len b i }
(bn_v (slice b 0 i) + pow2 (pbits * i) * bn_v (slice b i len)) / pow2 (pbits * i) % pow2 pbits;
(==) { Math.Lemmas.division_addition_lemma (bn_v (slice b 0 i)) (pow2 (pbits * i)) (bn_v (slice b i len)) }
(bn_v (slice b 0 i) / pow2 (pbits * i) + bn_v (slice b i len)) % pow2 pbits;
(==) { bn_eval_bound (slice b 0 i) i; Math.Lemmas.small_division_lemma_1 (bn_v (slice b 0 i)) (pow2 (pbits * i)) }
bn_v (slice b i len) % pow2 pbits;
(==) { bn_eval_split_i (slice b i len) 1 }
(bn_v (slice b i (i + 1)) + pow2 pbits * bn_v (slice b (i + 1) len)) % pow2 pbits;
(==) { Math.Lemmas.modulo_addition_lemma (bn_v (slice b i (i + 1))) (pow2 pbits) (bn_v (slice b (i + 1) len)) }
bn_v (slice b i (i + 1)) % pow2 pbits;
(==) { bn_eval1 (slice b i (i + 1)); Seq.lemma_index_slice b i (i + 1) 0 }
v b.[i] % pow2 pbits;
(==) { Math.Lemmas.modulo_lemma (v b.[i]) (pow2 pbits) }
v b.[i];
};
assert (bn_v b / pow2 (pbits * i) % pow2 pbits == v b.[i])
val bn_eval_lt: #t:limb_t -> len:size_nat -> a:lbignum t len -> b:lbignum t len -> k:pos{k <= len} -> Lemma
(requires v a.[k - 1] < v b.[k - 1])
(ensures eval_ len a k < eval_ len b k) | false | false | Hacl.Spec.Bignum.Definitions.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_eval_lt: #t:limb_t -> len:size_nat -> a:lbignum t len -> b:lbignum t len -> k:pos{k <= len} -> Lemma
(requires v a.[k - 1] < v b.[k - 1])
(ensures eval_ len a k < eval_ len b k) | [] | Hacl.Spec.Bignum.Definitions.bn_eval_lt | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
len: Lib.IntTypes.size_nat ->
a: Hacl.Spec.Bignum.Definitions.lbignum t len ->
b: Hacl.Spec.Bignum.Definitions.lbignum t len ->
k: Prims.pos{k <= len}
-> FStar.Pervasives.Lemma (requires Lib.IntTypes.v a.[ k - 1 ] < Lib.IntTypes.v b.[ k - 1 ])
(ensures
Hacl.Spec.Bignum.Definitions.eval_ len a k < Hacl.Spec.Bignum.Definitions.eval_ len b k) | {
"end_col": 89,
"end_line": 242,
"start_col": 29,
"start_line": 227
} |
FStar.Pervasives.Lemma | val bn_eval_bound: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i <= len} ->
Lemma (eval_ len b i < pow2 (bits t * i)) | [
{
"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_eval_bound #t #len b i =
let pbits = bits t in
if i = 0 then
bn_eval0 b
else begin
bn_eval_unfold_i b i;
assert (eval_ len b i == eval_ len b (i - 1) + pow2 (pbits * (i - 1)) * v b.[i - 1]);
calc (<) {
eval_ len b (i - 1) + pow2 (pbits * (i - 1)) * v b.[i - 1];
(<) { bn_eval_bound #t #len b (i - 1) }
pow2 (pbits * (i - 1)) + pow2 (pbits * (i - 1)) * v b.[i - 1];
(==) { Math.Lemmas.distributivity_add_right (pow2 (pbits * (i - 1))) 1 (v b.[i - 1]) }
pow2 (pbits * (i - 1)) * (1 + v b.[i - 1]);
(<=) { Math.Lemmas.lemma_mult_le_left (pow2 (pbits * (i - 1))) (1 + v b.[i - 1]) (pow2 pbits) }
pow2 (pbits * (i - 1)) * pow2 pbits;
(==) { Math.Lemmas.pow2_plus (pbits * (i - 1)) pbits }
pow2 (pbits * i);
};
assert (eval_ len b i < pow2 (pbits * i))
end | val bn_eval_bound: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i <= len} ->
Lemma (eval_ len b i < pow2 (bits t * i))
let rec bn_eval_bound #t #len b i = | false | null | true | let pbits = bits t in
if i = 0
then bn_eval0 b
else
(bn_eval_unfold_i b i;
assert (eval_ len b i == eval_ len b (i - 1) + pow2 (pbits * (i - 1)) * v b.[ i - 1 ]);
calc ( < ) {
eval_ len b (i - 1) + pow2 (pbits * (i - 1)) * v b.[ i - 1 ];
( < ) { bn_eval_bound #t #len b (i - 1) }
pow2 (pbits * (i - 1)) + pow2 (pbits * (i - 1)) * v b.[ i - 1 ];
( == ) { Math.Lemmas.distributivity_add_right (pow2 (pbits * (i - 1))) 1 (v b.[ i - 1 ]) }
pow2 (pbits * (i - 1)) * (1 + v b.[ i - 1 ]);
( <= ) { Math.Lemmas.lemma_mult_le_left (pow2 (pbits * (i - 1)))
(1 + v b.[ i - 1 ])
(pow2 pbits) }
pow2 (pbits * (i - 1)) * pow2 pbits;
( == ) { Math.Lemmas.pow2_plus (pbits * (i - 1)) pbits }
pow2 (pbits * i);
};
assert (eval_ len b i < pow2 (pbits * i))) | {
"checked_file": "Hacl.Spec.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Definitions.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.bool",
"Prims._assert",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.eval_",
"Prims.pow2",
"FStar.Mul.op_Star",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.op_Addition",
"Prims.op_Subtraction",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.eq2",
"Prims.Nil",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Hacl.Spec.Bignum.Definitions.bn_eval_bound",
"Prims.squash",
"FStar.Math.Lemmas.distributivity_add_right",
"FStar.Math.Lemmas.lemma_mult_le_left",
"FStar.Math.Lemmas.pow2_plus",
"Hacl.Spec.Bignum.Definitions.bn_eval_unfold_i",
"Lib.IntTypes.bits"
] | [] | module Hacl.Spec.Bignum.Definitions
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val blocks0: x:size_nat -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks0 x m = if x = 0 then 1 else (x - 1) / m + 1
inline_for_extraction noextract
let limb_t = t:inttype{t = U32 \/ t = U64}
inline_for_extraction noextract
let limb (t:limb_t) = uint_t t SEC
let lbignum (t:limb_t) len = lseq (limb t) len
val eval_: #t:limb_t -> len:size_nat -> s:lbignum t len -> i:nat{i <= len} -> nat
let rec eval_ #t len s i =
if i = 0 then 0
else eval_ #t len s (i - 1) + v s.[i - 1] * pow2 (bits t * (i - 1))
let bn_v (#t:limb_t) (#len:size_nat) (s:lbignum t len) = eval_ #t len s len
///
/// Lemmas
///
#push-options "--fuel 2"
val bn_eval0: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (eval_ len b 0 == 0)
let bn_eval0 #t #len b = ()
val bn_eval1: #t:limb_t -> b:lbignum t 1 -> Lemma (bn_v b == v b.[0])
let bn_eval1 b = ()
val bn_eval_unfold_i: #t:limb_t -> #len:size_pos -> b:lbignum t len -> i:pos{i <= len} ->
Lemma (eval_ len b i == eval_ len b (i - 1) + v b.[i - 1] * pow2 (bits t * (i - 1)))
let bn_eval_unfold_i #t #len b i = ()
#pop-options
val bn_eval_zeroes: #t:limb_t -> len:size_nat -> i:nat{i <= len} ->
Lemma (eval_ len (create len (uint #t 0)) i == 0)
let rec bn_eval_zeroes #t len i =
let b = create len (uint #t 0) in
if i = 0 then
bn_eval0 b
else begin
bn_eval_unfold_i b i;
bn_eval_zeroes #t len (i - 1) end
val bn_eval_create1: #t:limb_t -> c:limb t -> Lemma (bn_v (create 1 c) == v c)
let bn_eval_create1 #t c =
bn_eval1 (create 1 c)
val bn_eval_extensionality_j:
#t:limb_t
-> #len1:size_nat
-> #len2:size_nat
-> b1:lbignum t len1
-> b2:lbignum t len2
-> j:nat{j <= len1 /\ j <= len2} ->
Lemma
(requires sub b1 0 j == sub b2 0 j)
(ensures eval_ len1 b1 j == eval_ len2 b2 j)
(decreases j)
let rec bn_eval_extensionality_j #t #len1 #len2 b1 b2 j =
if j = 0 then begin
bn_eval0 b1;
bn_eval0 b2 end
else begin
bn_eval_unfold_i b1 j;
bn_eval_unfold_i b2 j;
let b1j = slice b1 0 j in
let b2j = slice b2 0 j in
let c1 = slice b1j 0 (j - 1) in
let c2 = slice b2j 0 (j - 1) in
eq_intro c1 c2;
bn_eval_extensionality_j #t #len1 #len2 b1 b2 (j - 1);
Seq.lemma_index_slice b1 0 j (j - 1);
Seq.lemma_index_slice b2 0 j (j - 1);
assert (v b1.[j - 1] == v b2.[j - 1]);
() end
val bn_eval_snoc: #t:limb_t -> #len:size_nat{len + 1 <= max_size_t} -> b:lbignum t len -> e:limb t ->
Lemma (bn_v #t #(len + 1) (Seq.snoc b e) == bn_v b + v e * pow2 (bits t * len))
let bn_eval_snoc #t #len b e =
let b1 = Seq.snoc b e in
bn_eval_unfold_i #t #(len + 1) b1 (len + 1);
bn_eval_extensionality_j #t #(len+1) #len b1 (slice #_ #(len+1) b1 0 len) len;
eq_intro (sub #_ #(len + 1) b1 0 len) b
val bn_eval_split_i_aux: p:nat -> a:nat -> b:nat -> c:nat -> i:nat -> Lemma
(requires pow2 p * c == a - b)
(ensures pow2 (p * (i + 1)) * c == pow2 (p * i) * a - pow2 (p * i) * b)
let bn_eval_split_i_aux p a b c i =
calc (==) {
pow2 (p * (i + 1)) * c;
(==) { Math.Lemmas.pow2_plus (p * i) p }
pow2 (p * i) * pow2 p * c;
(==) { Math.Lemmas.paren_mul_right (pow2 (p * i)) (pow2 p) c }
pow2 (p * i) * (pow2 p * c);
(==) { }
pow2 (p * i) * (a - b);
(==) { Math.Lemmas.distributivity_sub_right (pow2 (p * i)) a b }
pow2 (p * i) * a - pow2 (p * i) * b;
}
#restart-solver
val bn_eval_split_i: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i <= len} -> Lemma
(ensures bn_v b == bn_v (slice b 0 i) + pow2 (bits t * i) * bn_v (slice b i len))
(decreases (len - i))
// 20220513 JP: this proof broke somewhere in the calc, but even with --quake
// 3/3 it goes through. Solver inconsistency? The restart solver above fixes it.
let rec bn_eval_split_i #t #len b i =
let pbits = bits t in
if i = 0 then
bn_eval0 (slice b 0 i)
else begin
if len = i then
bn_eval0 (slice b i len)
else begin
let b1 = slice b i len in
bn_eval_split_i b1 1;
bn_eval1 (slice b1 0 1);
assert (bn_v b1 == v b1.[0] + pow2 pbits * bn_v (slice b1 1 (len - i)));
Seq.lemma_index_slice b i len 0;
assert (bn_v b1 == v b.[i] + pow2 pbits * bn_v (slice b (i + 1) len));
calc (==) {
bn_v b;
(==) { bn_eval_split_i b (i + 1) }
bn_v (slice b 0 (i + 1)) + pow2 (pbits * (i + 1)) * bn_v (slice b (i + 1) len);
(==) { bn_eval_split_i_aux pbits (bn_v b1) (v b.[i]) (bn_v (slice b (i + 1) len)) i }
bn_v (slice b 0 (i + 1)) + pow2 (pbits * i) * bn_v b1 - pow2 (pbits * i) * v b.[i];
(==) { bn_eval_unfold_i (slice b 0 (i + 1)) (i + 1)}
eval_ (i + 1) (slice b 0 (i + 1)) i + pow2 (pbits * i) * bn_v b1;
(==) { bn_eval_extensionality_j (slice b 0 (i + 1)) (slice b 0 i) i }
eval_ i (slice b 0 i) i + pow2 (pbits * i) * bn_v b1;
}; () end end
val bn_eval_inj: #t:limb_t -> len:size_nat -> b1:lbignum t len -> b2:lbignum t len -> Lemma
(requires bn_v b1 == bn_v b2)
(ensures equal b1 b2)
(decreases len)
let rec bn_eval_inj #t len b1 b2 =
if len = 0 then ()
else begin
bn_eval_split_i b1 1;
bn_eval_split_i b2 1;
bn_eval1 (slice b1 0 1);
bn_eval1 (slice b2 0 1);
bn_eval_inj (len - 1) (slice b1 1 len) (slice b2 1 len);
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
val bn_eval_bound: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i <= len} ->
Lemma (eval_ len b i < pow2 (bits t * i)) | false | false | Hacl.Spec.Bignum.Definitions.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_eval_bound: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i <= len} ->
Lemma (eval_ len b i < pow2 (bits t * i)) | [
"recursion"
] | Hacl.Spec.Bignum.Definitions.bn_eval_bound | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Definitions.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 -> i: Prims.nat{i <= len}
-> FStar.Pervasives.Lemma
(ensures Hacl.Spec.Bignum.Definitions.eval_ len b i < Prims.pow2 (Lib.IntTypes.bits t * i)) | {
"end_col": 7,
"end_line": 193,
"start_col": 35,
"start_line": 174
} |
FStar.Pervasives.Lemma | val bn_eval_extensionality_j:
#t:limb_t
-> #len1:size_nat
-> #len2:size_nat
-> b1:lbignum t len1
-> b2:lbignum t len2
-> j:nat{j <= len1 /\ j <= len2} ->
Lemma
(requires sub b1 0 j == sub b2 0 j)
(ensures eval_ len1 b1 j == eval_ len2 b2 j)
(decreases j) | [
{
"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_eval_extensionality_j #t #len1 #len2 b1 b2 j =
if j = 0 then begin
bn_eval0 b1;
bn_eval0 b2 end
else begin
bn_eval_unfold_i b1 j;
bn_eval_unfold_i b2 j;
let b1j = slice b1 0 j in
let b2j = slice b2 0 j in
let c1 = slice b1j 0 (j - 1) in
let c2 = slice b2j 0 (j - 1) in
eq_intro c1 c2;
bn_eval_extensionality_j #t #len1 #len2 b1 b2 (j - 1);
Seq.lemma_index_slice b1 0 j (j - 1);
Seq.lemma_index_slice b2 0 j (j - 1);
assert (v b1.[j - 1] == v b2.[j - 1]);
() end | val bn_eval_extensionality_j:
#t:limb_t
-> #len1:size_nat
-> #len2:size_nat
-> b1:lbignum t len1
-> b2:lbignum t len2
-> j:nat{j <= len1 /\ j <= len2} ->
Lemma
(requires sub b1 0 j == sub b2 0 j)
(ensures eval_ len1 b1 j == eval_ len2 b2 j)
(decreases j)
let rec bn_eval_extensionality_j #t #len1 #len2 b1 b2 j = | false | null | true | if j = 0
then
(bn_eval0 b1;
bn_eval0 b2)
else
(bn_eval_unfold_i b1 j;
bn_eval_unfold_i b2 j;
let b1j = slice b1 0 j in
let b2j = slice b2 0 j in
let c1 = slice b1j 0 (j - 1) in
let c2 = slice b2j 0 (j - 1) in
eq_intro c1 c2;
bn_eval_extensionality_j #t #len1 #len2 b1 b2 (j - 1);
Seq.lemma_index_slice b1 0 j (j - 1);
Seq.lemma_index_slice b2 0 j (j - 1);
assert (v b1.[ j - 1 ] == v b2.[ j - 1 ]);
()) | {
"checked_file": "Hacl.Spec.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Definitions.fst"
} | [
"lemma",
""
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"Hacl.Spec.Bignum.Definitions.bn_eval0",
"Prims.unit",
"Prims.bool",
"Prims._assert",
"Prims.eq2",
"Lib.IntTypes.range_t",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.op_Subtraction",
"FStar.Seq.Base.lemma_index_slice",
"Hacl.Spec.Bignum.Definitions.bn_eval_extensionality_j",
"Lib.Sequence.eq_intro",
"Lib.Sequence.lseq",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"Prims.l_Forall",
"Prims.op_LessThan",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Lib.Sequence.slice",
"Hacl.Spec.Bignum.Definitions.bn_eval_unfold_i"
] | [] | module Hacl.Spec.Bignum.Definitions
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val blocks0: x:size_nat -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks0 x m = if x = 0 then 1 else (x - 1) / m + 1
inline_for_extraction noextract
let limb_t = t:inttype{t = U32 \/ t = U64}
inline_for_extraction noextract
let limb (t:limb_t) = uint_t t SEC
let lbignum (t:limb_t) len = lseq (limb t) len
val eval_: #t:limb_t -> len:size_nat -> s:lbignum t len -> i:nat{i <= len} -> nat
let rec eval_ #t len s i =
if i = 0 then 0
else eval_ #t len s (i - 1) + v s.[i - 1] * pow2 (bits t * (i - 1))
let bn_v (#t:limb_t) (#len:size_nat) (s:lbignum t len) = eval_ #t len s len
///
/// Lemmas
///
#push-options "--fuel 2"
val bn_eval0: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (eval_ len b 0 == 0)
let bn_eval0 #t #len b = ()
val bn_eval1: #t:limb_t -> b:lbignum t 1 -> Lemma (bn_v b == v b.[0])
let bn_eval1 b = ()
val bn_eval_unfold_i: #t:limb_t -> #len:size_pos -> b:lbignum t len -> i:pos{i <= len} ->
Lemma (eval_ len b i == eval_ len b (i - 1) + v b.[i - 1] * pow2 (bits t * (i - 1)))
let bn_eval_unfold_i #t #len b i = ()
#pop-options
val bn_eval_zeroes: #t:limb_t -> len:size_nat -> i:nat{i <= len} ->
Lemma (eval_ len (create len (uint #t 0)) i == 0)
let rec bn_eval_zeroes #t len i =
let b = create len (uint #t 0) in
if i = 0 then
bn_eval0 b
else begin
bn_eval_unfold_i b i;
bn_eval_zeroes #t len (i - 1) end
val bn_eval_create1: #t:limb_t -> c:limb t -> Lemma (bn_v (create 1 c) == v c)
let bn_eval_create1 #t c =
bn_eval1 (create 1 c)
val bn_eval_extensionality_j:
#t:limb_t
-> #len1:size_nat
-> #len2:size_nat
-> b1:lbignum t len1
-> b2:lbignum t len2
-> j:nat{j <= len1 /\ j <= len2} ->
Lemma
(requires sub b1 0 j == sub b2 0 j)
(ensures eval_ len1 b1 j == eval_ len2 b2 j)
(decreases j) | false | false | Hacl.Spec.Bignum.Definitions.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_eval_extensionality_j:
#t:limb_t
-> #len1:size_nat
-> #len2:size_nat
-> b1:lbignum t len1
-> b2:lbignum t len2
-> j:nat{j <= len1 /\ j <= len2} ->
Lemma
(requires sub b1 0 j == sub b2 0 j)
(ensures eval_ len1 b1 j == eval_ len2 b2 j)
(decreases j) | [
"recursion"
] | Hacl.Spec.Bignum.Definitions.bn_eval_extensionality_j | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
b1: Hacl.Spec.Bignum.Definitions.lbignum t len1 ->
b2: Hacl.Spec.Bignum.Definitions.lbignum t len2 ->
j: Prims.nat{j <= len1 /\ j <= len2}
-> FStar.Pervasives.Lemma (requires Lib.Sequence.sub b1 0 j == Lib.Sequence.sub b2 0 j)
(ensures
Hacl.Spec.Bignum.Definitions.eval_ len1 b1 j == Hacl.Spec.Bignum.Definitions.eval_ len2 b2 j
)
(decreases j) | {
"end_col": 10,
"end_line": 89,
"start_col": 2,
"start_line": 74
} |
FStar.Pervasives.Lemma | val bn_eval_split_i: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i <= len} -> Lemma
(ensures bn_v b == bn_v (slice b 0 i) + pow2 (bits t * i) * bn_v (slice b i len))
(decreases (len - i)) | [
{
"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_eval_split_i #t #len b i =
let pbits = bits t in
if i = 0 then
bn_eval0 (slice b 0 i)
else begin
if len = i then
bn_eval0 (slice b i len)
else begin
let b1 = slice b i len in
bn_eval_split_i b1 1;
bn_eval1 (slice b1 0 1);
assert (bn_v b1 == v b1.[0] + pow2 pbits * bn_v (slice b1 1 (len - i)));
Seq.lemma_index_slice b i len 0;
assert (bn_v b1 == v b.[i] + pow2 pbits * bn_v (slice b (i + 1) len));
calc (==) {
bn_v b;
(==) { bn_eval_split_i b (i + 1) }
bn_v (slice b 0 (i + 1)) + pow2 (pbits * (i + 1)) * bn_v (slice b (i + 1) len);
(==) { bn_eval_split_i_aux pbits (bn_v b1) (v b.[i]) (bn_v (slice b (i + 1) len)) i }
bn_v (slice b 0 (i + 1)) + pow2 (pbits * i) * bn_v b1 - pow2 (pbits * i) * v b.[i];
(==) { bn_eval_unfold_i (slice b 0 (i + 1)) (i + 1)}
eval_ (i + 1) (slice b 0 (i + 1)) i + pow2 (pbits * i) * bn_v b1;
(==) { bn_eval_extensionality_j (slice b 0 (i + 1)) (slice b 0 i) i }
eval_ i (slice b 0 i) i + pow2 (pbits * i) * bn_v b1;
}; () end end | val bn_eval_split_i: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i <= len} -> Lemma
(ensures bn_v b == bn_v (slice b 0 i) + pow2 (bits t * i) * bn_v (slice b i len))
(decreases (len - i))
let rec bn_eval_split_i #t #len b i = | false | null | true | let pbits = bits t in
if i = 0
then bn_eval0 (slice b 0 i)
else
if len = i
then bn_eval0 (slice b i len)
else
let b1 = slice b i len in
bn_eval_split_i b1 1;
bn_eval1 (slice b1 0 1);
assert (bn_v b1 == v b1.[ 0 ] + pow2 pbits * bn_v (slice b1 1 (len - i)));
Seq.lemma_index_slice b i len 0;
assert (bn_v b1 == v b.[ i ] + pow2 pbits * bn_v (slice b (i + 1) len));
calc ( == ) {
bn_v b;
( == ) { bn_eval_split_i b (i + 1) }
bn_v (slice b 0 (i + 1)) + pow2 (pbits * (i + 1)) * bn_v (slice b (i + 1) len);
( == ) { bn_eval_split_i_aux pbits (bn_v b1) (v b.[ i ]) (bn_v (slice b (i + 1) len)) i }
bn_v (slice b 0 (i + 1)) + pow2 (pbits * i) * bn_v b1 - pow2 (pbits * i) * v b.[ i ];
( == ) { bn_eval_unfold_i (slice b 0 (i + 1)) (i + 1) }
eval_ (i + 1) (slice b 0 (i + 1)) i + pow2 (pbits * i) * bn_v b1;
( == ) { bn_eval_extensionality_j (slice b 0 (i + 1)) (slice b 0 i) i }
eval_ i (slice b 0 i) i + pow2 (pbits * i) * bn_v b1;
};
() | {
"checked_file": "Hacl.Spec.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Definitions.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.op_Subtraction",
"Lib.Sequence.slice",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.bool",
"Prims.l_or",
"Lib.IntTypes.max_size_t",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.op_Addition",
"Hacl.Spec.Bignum.Definitions.eval_",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Lib.Sequence.op_String_Access",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Hacl.Spec.Bignum.Definitions.bn_eval_split_i",
"Prims.squash",
"Hacl.Spec.Bignum.Definitions.bn_eval_split_i_aux",
"Hacl.Spec.Bignum.Definitions.bn_eval_unfold_i",
"Hacl.Spec.Bignum.Definitions.bn_eval_extensionality_j",
"Prims._assert",
"FStar.Seq.Base.lemma_index_slice",
"Hacl.Spec.Bignum.Definitions.bn_eval1",
"Lib.Sequence.lseq",
"Prims.l_and",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.l_Forall",
"Prims.op_LessThan",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Lib.IntTypes.bits"
] | [] | module Hacl.Spec.Bignum.Definitions
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val blocks0: x:size_nat -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks0 x m = if x = 0 then 1 else (x - 1) / m + 1
inline_for_extraction noextract
let limb_t = t:inttype{t = U32 \/ t = U64}
inline_for_extraction noextract
let limb (t:limb_t) = uint_t t SEC
let lbignum (t:limb_t) len = lseq (limb t) len
val eval_: #t:limb_t -> len:size_nat -> s:lbignum t len -> i:nat{i <= len} -> nat
let rec eval_ #t len s i =
if i = 0 then 0
else eval_ #t len s (i - 1) + v s.[i - 1] * pow2 (bits t * (i - 1))
let bn_v (#t:limb_t) (#len:size_nat) (s:lbignum t len) = eval_ #t len s len
///
/// Lemmas
///
#push-options "--fuel 2"
val bn_eval0: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (eval_ len b 0 == 0)
let bn_eval0 #t #len b = ()
val bn_eval1: #t:limb_t -> b:lbignum t 1 -> Lemma (bn_v b == v b.[0])
let bn_eval1 b = ()
val bn_eval_unfold_i: #t:limb_t -> #len:size_pos -> b:lbignum t len -> i:pos{i <= len} ->
Lemma (eval_ len b i == eval_ len b (i - 1) + v b.[i - 1] * pow2 (bits t * (i - 1)))
let bn_eval_unfold_i #t #len b i = ()
#pop-options
val bn_eval_zeroes: #t:limb_t -> len:size_nat -> i:nat{i <= len} ->
Lemma (eval_ len (create len (uint #t 0)) i == 0)
let rec bn_eval_zeroes #t len i =
let b = create len (uint #t 0) in
if i = 0 then
bn_eval0 b
else begin
bn_eval_unfold_i b i;
bn_eval_zeroes #t len (i - 1) end
val bn_eval_create1: #t:limb_t -> c:limb t -> Lemma (bn_v (create 1 c) == v c)
let bn_eval_create1 #t c =
bn_eval1 (create 1 c)
val bn_eval_extensionality_j:
#t:limb_t
-> #len1:size_nat
-> #len2:size_nat
-> b1:lbignum t len1
-> b2:lbignum t len2
-> j:nat{j <= len1 /\ j <= len2} ->
Lemma
(requires sub b1 0 j == sub b2 0 j)
(ensures eval_ len1 b1 j == eval_ len2 b2 j)
(decreases j)
let rec bn_eval_extensionality_j #t #len1 #len2 b1 b2 j =
if j = 0 then begin
bn_eval0 b1;
bn_eval0 b2 end
else begin
bn_eval_unfold_i b1 j;
bn_eval_unfold_i b2 j;
let b1j = slice b1 0 j in
let b2j = slice b2 0 j in
let c1 = slice b1j 0 (j - 1) in
let c2 = slice b2j 0 (j - 1) in
eq_intro c1 c2;
bn_eval_extensionality_j #t #len1 #len2 b1 b2 (j - 1);
Seq.lemma_index_slice b1 0 j (j - 1);
Seq.lemma_index_slice b2 0 j (j - 1);
assert (v b1.[j - 1] == v b2.[j - 1]);
() end
val bn_eval_snoc: #t:limb_t -> #len:size_nat{len + 1 <= max_size_t} -> b:lbignum t len -> e:limb t ->
Lemma (bn_v #t #(len + 1) (Seq.snoc b e) == bn_v b + v e * pow2 (bits t * len))
let bn_eval_snoc #t #len b e =
let b1 = Seq.snoc b e in
bn_eval_unfold_i #t #(len + 1) b1 (len + 1);
bn_eval_extensionality_j #t #(len+1) #len b1 (slice #_ #(len+1) b1 0 len) len;
eq_intro (sub #_ #(len + 1) b1 0 len) b
val bn_eval_split_i_aux: p:nat -> a:nat -> b:nat -> c:nat -> i:nat -> Lemma
(requires pow2 p * c == a - b)
(ensures pow2 (p * (i + 1)) * c == pow2 (p * i) * a - pow2 (p * i) * b)
let bn_eval_split_i_aux p a b c i =
calc (==) {
pow2 (p * (i + 1)) * c;
(==) { Math.Lemmas.pow2_plus (p * i) p }
pow2 (p * i) * pow2 p * c;
(==) { Math.Lemmas.paren_mul_right (pow2 (p * i)) (pow2 p) c }
pow2 (p * i) * (pow2 p * c);
(==) { }
pow2 (p * i) * (a - b);
(==) { Math.Lemmas.distributivity_sub_right (pow2 (p * i)) a b }
pow2 (p * i) * a - pow2 (p * i) * b;
}
#restart-solver
val bn_eval_split_i: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i <= len} -> Lemma
(ensures bn_v b == bn_v (slice b 0 i) + pow2 (bits t * i) * bn_v (slice b i len))
(decreases (len - i))
// 20220513 JP: this proof broke somewhere in the calc, but even with --quake | false | false | Hacl.Spec.Bignum.Definitions.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_eval_split_i: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i <= len} -> Lemma
(ensures bn_v b == bn_v (slice b 0 i) + pow2 (bits t * i) * bn_v (slice b i len))
(decreases (len - i)) | [
"recursion"
] | Hacl.Spec.Bignum.Definitions.bn_eval_split_i | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Definitions.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 -> i: Prims.nat{i <= len}
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Definitions.bn_v b ==
Hacl.Spec.Bignum.Definitions.bn_v (Lib.Sequence.slice b 0 i) +
Prims.pow2 (Lib.IntTypes.bits t * i) *
Hacl.Spec.Bignum.Definitions.bn_v (Lib.Sequence.slice b i len)) (decreases len - i) | {
"end_col": 19,
"end_line": 151,
"start_col": 37,
"start_line": 127
} |
FStar.Pervasives.Lemma | val bn_eval_index: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i < len} ->
Lemma (v b.[i] == bn_v b / pow2 (bits t * i) % pow2 (bits t)) | [
{
"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_eval_index #t #len b i =
let pbits = bits t in
calc (==) {
bn_v b / pow2 (pbits * i) % pow2 pbits;
(==) { bn_eval_split_i #t #len b i }
(bn_v (slice b 0 i) + pow2 (pbits * i) * bn_v (slice b i len)) / pow2 (pbits * i) % pow2 pbits;
(==) { Math.Lemmas.division_addition_lemma (bn_v (slice b 0 i)) (pow2 (pbits * i)) (bn_v (slice b i len)) }
(bn_v (slice b 0 i) / pow2 (pbits * i) + bn_v (slice b i len)) % pow2 pbits;
(==) { bn_eval_bound (slice b 0 i) i; Math.Lemmas.small_division_lemma_1 (bn_v (slice b 0 i)) (pow2 (pbits * i)) }
bn_v (slice b i len) % pow2 pbits;
(==) { bn_eval_split_i (slice b i len) 1 }
(bn_v (slice b i (i + 1)) + pow2 pbits * bn_v (slice b (i + 1) len)) % pow2 pbits;
(==) { Math.Lemmas.modulo_addition_lemma (bn_v (slice b i (i + 1))) (pow2 pbits) (bn_v (slice b (i + 1) len)) }
bn_v (slice b i (i + 1)) % pow2 pbits;
(==) { bn_eval1 (slice b i (i + 1)); Seq.lemma_index_slice b i (i + 1) 0 }
v b.[i] % pow2 pbits;
(==) { Math.Lemmas.modulo_lemma (v b.[i]) (pow2 pbits) }
v b.[i];
};
assert (bn_v b / pow2 (pbits * i) % pow2 pbits == v b.[i]) | val bn_eval_index: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i < len} ->
Lemma (v b.[i] == bn_v b / pow2 (bits t * i) % pow2 (bits t))
let bn_eval_index #t #len b i = | false | null | true | let pbits = bits t in
calc ( == ) {
bn_v b / pow2 (pbits * i) % pow2 pbits;
( == ) { bn_eval_split_i #t #len b i }
(bn_v (slice b 0 i) + pow2 (pbits * i) * bn_v (slice b i len)) / pow2 (pbits * i) % pow2 pbits;
( == ) { Math.Lemmas.division_addition_lemma (bn_v (slice b 0 i))
(pow2 (pbits * i))
(bn_v (slice b i len)) }
(bn_v (slice b 0 i) / pow2 (pbits * i) + bn_v (slice b i len)) % pow2 pbits;
( == ) { (bn_eval_bound (slice b 0 i) i;
Math.Lemmas.small_division_lemma_1 (bn_v (slice b 0 i)) (pow2 (pbits * i))) }
bn_v (slice b i len) % pow2 pbits;
( == ) { bn_eval_split_i (slice b i len) 1 }
(bn_v (slice b i (i + 1)) + pow2 pbits * bn_v (slice b (i + 1) len)) % pow2 pbits;
( == ) { Math.Lemmas.modulo_addition_lemma (bn_v (slice b i (i + 1)))
(pow2 pbits)
(bn_v (slice b (i + 1) len)) }
bn_v (slice b i (i + 1)) % pow2 pbits;
( == ) { (bn_eval1 (slice b i (i + 1));
Seq.lemma_index_slice b i (i + 1) 0) }
v b.[ i ] % pow2 pbits;
( == ) { Math.Lemmas.modulo_lemma (v b.[ i ]) (pow2 pbits) }
v b.[ i ];
};
assert (bn_v b / pow2 (pbits * i) % pow2 pbits == v b.[ i ]) | {
"checked_file": "Hacl.Spec.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Definitions.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"Prims.op_Division",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.pow2",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"Prims.op_Subtraction",
"Prims.op_Addition",
"Lib.Sequence.slice",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Hacl.Spec.Bignum.Definitions.bn_eval_split_i",
"Prims.squash",
"FStar.Math.Lemmas.division_addition_lemma",
"FStar.Math.Lemmas.small_division_lemma_1",
"Hacl.Spec.Bignum.Definitions.bn_eval_bound",
"FStar.Math.Lemmas.modulo_addition_lemma",
"FStar.Seq.Base.lemma_index_slice",
"Hacl.Spec.Bignum.Definitions.bn_eval1",
"FStar.Math.Lemmas.modulo_lemma",
"Lib.IntTypes.bits"
] | [] | module Hacl.Spec.Bignum.Definitions
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val blocks0: x:size_nat -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks0 x m = if x = 0 then 1 else (x - 1) / m + 1
inline_for_extraction noextract
let limb_t = t:inttype{t = U32 \/ t = U64}
inline_for_extraction noextract
let limb (t:limb_t) = uint_t t SEC
let lbignum (t:limb_t) len = lseq (limb t) len
val eval_: #t:limb_t -> len:size_nat -> s:lbignum t len -> i:nat{i <= len} -> nat
let rec eval_ #t len s i =
if i = 0 then 0
else eval_ #t len s (i - 1) + v s.[i - 1] * pow2 (bits t * (i - 1))
let bn_v (#t:limb_t) (#len:size_nat) (s:lbignum t len) = eval_ #t len s len
///
/// Lemmas
///
#push-options "--fuel 2"
val bn_eval0: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (eval_ len b 0 == 0)
let bn_eval0 #t #len b = ()
val bn_eval1: #t:limb_t -> b:lbignum t 1 -> Lemma (bn_v b == v b.[0])
let bn_eval1 b = ()
val bn_eval_unfold_i: #t:limb_t -> #len:size_pos -> b:lbignum t len -> i:pos{i <= len} ->
Lemma (eval_ len b i == eval_ len b (i - 1) + v b.[i - 1] * pow2 (bits t * (i - 1)))
let bn_eval_unfold_i #t #len b i = ()
#pop-options
val bn_eval_zeroes: #t:limb_t -> len:size_nat -> i:nat{i <= len} ->
Lemma (eval_ len (create len (uint #t 0)) i == 0)
let rec bn_eval_zeroes #t len i =
let b = create len (uint #t 0) in
if i = 0 then
bn_eval0 b
else begin
bn_eval_unfold_i b i;
bn_eval_zeroes #t len (i - 1) end
val bn_eval_create1: #t:limb_t -> c:limb t -> Lemma (bn_v (create 1 c) == v c)
let bn_eval_create1 #t c =
bn_eval1 (create 1 c)
val bn_eval_extensionality_j:
#t:limb_t
-> #len1:size_nat
-> #len2:size_nat
-> b1:lbignum t len1
-> b2:lbignum t len2
-> j:nat{j <= len1 /\ j <= len2} ->
Lemma
(requires sub b1 0 j == sub b2 0 j)
(ensures eval_ len1 b1 j == eval_ len2 b2 j)
(decreases j)
let rec bn_eval_extensionality_j #t #len1 #len2 b1 b2 j =
if j = 0 then begin
bn_eval0 b1;
bn_eval0 b2 end
else begin
bn_eval_unfold_i b1 j;
bn_eval_unfold_i b2 j;
let b1j = slice b1 0 j in
let b2j = slice b2 0 j in
let c1 = slice b1j 0 (j - 1) in
let c2 = slice b2j 0 (j - 1) in
eq_intro c1 c2;
bn_eval_extensionality_j #t #len1 #len2 b1 b2 (j - 1);
Seq.lemma_index_slice b1 0 j (j - 1);
Seq.lemma_index_slice b2 0 j (j - 1);
assert (v b1.[j - 1] == v b2.[j - 1]);
() end
val bn_eval_snoc: #t:limb_t -> #len:size_nat{len + 1 <= max_size_t} -> b:lbignum t len -> e:limb t ->
Lemma (bn_v #t #(len + 1) (Seq.snoc b e) == bn_v b + v e * pow2 (bits t * len))
let bn_eval_snoc #t #len b e =
let b1 = Seq.snoc b e in
bn_eval_unfold_i #t #(len + 1) b1 (len + 1);
bn_eval_extensionality_j #t #(len+1) #len b1 (slice #_ #(len+1) b1 0 len) len;
eq_intro (sub #_ #(len + 1) b1 0 len) b
val bn_eval_split_i_aux: p:nat -> a:nat -> b:nat -> c:nat -> i:nat -> Lemma
(requires pow2 p * c == a - b)
(ensures pow2 (p * (i + 1)) * c == pow2 (p * i) * a - pow2 (p * i) * b)
let bn_eval_split_i_aux p a b c i =
calc (==) {
pow2 (p * (i + 1)) * c;
(==) { Math.Lemmas.pow2_plus (p * i) p }
pow2 (p * i) * pow2 p * c;
(==) { Math.Lemmas.paren_mul_right (pow2 (p * i)) (pow2 p) c }
pow2 (p * i) * (pow2 p * c);
(==) { }
pow2 (p * i) * (a - b);
(==) { Math.Lemmas.distributivity_sub_right (pow2 (p * i)) a b }
pow2 (p * i) * a - pow2 (p * i) * b;
}
#restart-solver
val bn_eval_split_i: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i <= len} -> Lemma
(ensures bn_v b == bn_v (slice b 0 i) + pow2 (bits t * i) * bn_v (slice b i len))
(decreases (len - i))
// 20220513 JP: this proof broke somewhere in the calc, but even with --quake
// 3/3 it goes through. Solver inconsistency? The restart solver above fixes it.
let rec bn_eval_split_i #t #len b i =
let pbits = bits t in
if i = 0 then
bn_eval0 (slice b 0 i)
else begin
if len = i then
bn_eval0 (slice b i len)
else begin
let b1 = slice b i len in
bn_eval_split_i b1 1;
bn_eval1 (slice b1 0 1);
assert (bn_v b1 == v b1.[0] + pow2 pbits * bn_v (slice b1 1 (len - i)));
Seq.lemma_index_slice b i len 0;
assert (bn_v b1 == v b.[i] + pow2 pbits * bn_v (slice b (i + 1) len));
calc (==) {
bn_v b;
(==) { bn_eval_split_i b (i + 1) }
bn_v (slice b 0 (i + 1)) + pow2 (pbits * (i + 1)) * bn_v (slice b (i + 1) len);
(==) { bn_eval_split_i_aux pbits (bn_v b1) (v b.[i]) (bn_v (slice b (i + 1) len)) i }
bn_v (slice b 0 (i + 1)) + pow2 (pbits * i) * bn_v b1 - pow2 (pbits * i) * v b.[i];
(==) { bn_eval_unfold_i (slice b 0 (i + 1)) (i + 1)}
eval_ (i + 1) (slice b 0 (i + 1)) i + pow2 (pbits * i) * bn_v b1;
(==) { bn_eval_extensionality_j (slice b 0 (i + 1)) (slice b 0 i) i }
eval_ i (slice b 0 i) i + pow2 (pbits * i) * bn_v b1;
}; () end end
val bn_eval_inj: #t:limb_t -> len:size_nat -> b1:lbignum t len -> b2:lbignum t len -> Lemma
(requires bn_v b1 == bn_v b2)
(ensures equal b1 b2)
(decreases len)
let rec bn_eval_inj #t len b1 b2 =
if len = 0 then ()
else begin
bn_eval_split_i b1 1;
bn_eval_split_i b2 1;
bn_eval1 (slice b1 0 1);
bn_eval1 (slice b2 0 1);
bn_eval_inj (len - 1) (slice b1 1 len) (slice b2 1 len);
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
val bn_eval_bound: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i <= len} ->
Lemma (eval_ len b i < pow2 (bits t * i))
let rec bn_eval_bound #t #len b i =
let pbits = bits t in
if i = 0 then
bn_eval0 b
else begin
bn_eval_unfold_i b i;
assert (eval_ len b i == eval_ len b (i - 1) + pow2 (pbits * (i - 1)) * v b.[i - 1]);
calc (<) {
eval_ len b (i - 1) + pow2 (pbits * (i - 1)) * v b.[i - 1];
(<) { bn_eval_bound #t #len b (i - 1) }
pow2 (pbits * (i - 1)) + pow2 (pbits * (i - 1)) * v b.[i - 1];
(==) { Math.Lemmas.distributivity_add_right (pow2 (pbits * (i - 1))) 1 (v b.[i - 1]) }
pow2 (pbits * (i - 1)) * (1 + v b.[i - 1]);
(<=) { Math.Lemmas.lemma_mult_le_left (pow2 (pbits * (i - 1))) (1 + v b.[i - 1]) (pow2 pbits) }
pow2 (pbits * (i - 1)) * pow2 pbits;
(==) { Math.Lemmas.pow2_plus (pbits * (i - 1)) pbits }
pow2 (pbits * i);
};
assert (eval_ len b i < pow2 (pbits * i))
end
val bn_eval_index: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i < len} ->
Lemma (v b.[i] == bn_v b / pow2 (bits t * i) % pow2 (bits t)) | false | false | Hacl.Spec.Bignum.Definitions.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_eval_index: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i < len} ->
Lemma (v b.[i] == bn_v b / pow2 (bits t * i) % pow2 (bits t)) | [] | Hacl.Spec.Bignum.Definitions.bn_eval_index | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Definitions.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 -> i: Prims.nat{i < len}
-> FStar.Pervasives.Lemma
(ensures
Lib.IntTypes.v b.[ i ] ==
Hacl.Spec.Bignum.Definitions.bn_v b / Prims.pow2 (Lib.IntTypes.bits t * i) %
Prims.pow2 (Lib.IntTypes.bits t)) | {
"end_col": 60,
"end_line": 219,
"start_col": 31,
"start_line": 199
} |
FStar.Pervasives.Lemma | val bn_update_sub_eval:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t bLen
-> i:nat{i + bLen <= aLen} ->
Lemma (bn_v (update_sub a i bLen b) == bn_v a - bn_v (sub a i bLen) * pow2 (bits t * i) + bn_v b * pow2 (bits t * i)) | [
{
"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_update_sub_eval #t #aLen #bLen a b i =
let pbits = bits t in
let a' = update_sub a i bLen b in
let c = bn_v (sub a i bLen) * pow2 (bits t * i) in
calc (==) {
bn_v a' + c;
(==) { bn_eval_split_i a' i }
bn_v (slice a' 0 i) + pow2 (pbits * i) * bn_v (slice a' i aLen) + c;
(==) { eq_intro (slice a 0 i) (slice a' 0 i) }
bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v (slice a' i aLen) + c;
(==) { bn_eval_split_i (slice a' i aLen) bLen }
bn_v (slice a 0 i) + pow2 (pbits * i) * (bn_v (sub a' i bLen) + pow2 (pbits * bLen) * bn_v (slice a' (i + bLen) aLen)) + c;
(==) { eq_intro (slice a' (i + bLen) aLen) (slice a (i + bLen) aLen) }
bn_v (slice a 0 i) + pow2 (pbits * i) * (bn_v (sub a' i bLen) + pow2 (pbits * bLen) * bn_v (slice a (i + bLen) aLen)) + c;
(==) {eq_intro (sub a' i bLen) b }
bn_v (slice a 0 i) + pow2 (pbits * i) * (bn_v b + pow2 (pbits * bLen) * bn_v (slice a (i + bLen) aLen)) + c;
(==) { Math.Lemmas.distributivity_add_right (pow2 (pbits * i)) (bn_v b) (pow2 (pbits * bLen) * bn_v (slice a (i + bLen) aLen)) }
bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v b + pow2 (pbits * i) * (pow2 (pbits * bLen) * bn_v (slice a (i + bLen) aLen)) + c;
(==) { Math.Lemmas.paren_mul_right (pow2 (pbits * i)) (pow2 (pbits * bLen)) (bn_v (slice a (i + bLen) aLen));
Math.Lemmas.pow2_plus (pbits * i) (pbits * bLen) }
bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v b + pow2 (pbits * (i + bLen)) * bn_v (slice a (i + bLen) aLen) + c;
(==) { bn_eval_split_i (slice a 0 (i + bLen)) i }
bn_v (slice a 0 (i + bLen)) + pow2 (pbits * i) * bn_v b + pow2 (pbits * (i + bLen)) * bn_v (slice a (i + bLen) aLen);
(==) { bn_eval_split_i a (i + bLen) }
bn_v a + pow2 (pbits * i) * bn_v b;
} | val bn_update_sub_eval:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t bLen
-> i:nat{i + bLen <= aLen} ->
Lemma (bn_v (update_sub a i bLen b) == bn_v a - bn_v (sub a i bLen) * pow2 (bits t * i) + bn_v b * pow2 (bits t * i))
let bn_update_sub_eval #t #aLen #bLen a b i = | false | null | true | let pbits = bits t in
let a' = update_sub a i bLen b in
let c = bn_v (sub a i bLen) * pow2 (bits t * i) in
calc ( == ) {
bn_v a' + c;
( == ) { bn_eval_split_i a' i }
bn_v (slice a' 0 i) + pow2 (pbits * i) * bn_v (slice a' i aLen) + c;
( == ) { eq_intro (slice a 0 i) (slice a' 0 i) }
bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v (slice a' i aLen) + c;
( == ) { bn_eval_split_i (slice a' i aLen) bLen }
bn_v (slice a 0 i) +
pow2 (pbits * i) * (bn_v (sub a' i bLen) + pow2 (pbits * bLen) * bn_v (slice a' (i + bLen) aLen)) +
c;
( == ) { eq_intro (slice a' (i + bLen) aLen) (slice a (i + bLen) aLen) }
bn_v (slice a 0 i) +
pow2 (pbits * i) * (bn_v (sub a' i bLen) + pow2 (pbits * bLen) * bn_v (slice a (i + bLen) aLen)) +
c;
( == ) { eq_intro (sub a' i bLen) b }
bn_v (slice a 0 i) +
pow2 (pbits * i) * (bn_v b + pow2 (pbits * bLen) * bn_v (slice a (i + bLen) aLen)) +
c;
( == ) { Math.Lemmas.distributivity_add_right (pow2 (pbits * i))
(bn_v b)
(pow2 (pbits * bLen) * bn_v (slice a (i + bLen) aLen)) }
bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v b +
pow2 (pbits * i) * (pow2 (pbits * bLen) * bn_v (slice a (i + bLen) aLen)) +
c;
( == ) { (Math.Lemmas.paren_mul_right (pow2 (pbits * i))
(pow2 (pbits * bLen))
(bn_v (slice a (i + bLen) aLen));
Math.Lemmas.pow2_plus (pbits * i) (pbits * bLen)) }
bn_v (slice a 0 i) + pow2 (pbits * i) * bn_v b +
pow2 (pbits * (i + bLen)) * bn_v (slice a (i + bLen) aLen) +
c;
( == ) { bn_eval_split_i (slice a 0 (i + bLen)) i }
bn_v (slice a 0 (i + bLen)) + pow2 (pbits * i) * bn_v b +
pow2 (pbits * (i + bLen)) * bn_v (slice a (i + bLen) aLen);
( == ) { bn_eval_split_i a (i + bLen) }
bn_v a + pow2 (pbits * i) * bn_v b;
} | {
"checked_file": "Hacl.Spec.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Definitions.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_Addition",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Hacl.Spec.Bignum.Definitions.bn_v",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"Prims.op_Subtraction",
"Lib.Sequence.slice",
"Hacl.Spec.Bignum.Definitions.limb",
"Lib.Sequence.sub",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Hacl.Spec.Bignum.Definitions.bn_eval_split_i",
"Prims.squash",
"Lib.Sequence.eq_intro",
"FStar.Math.Lemmas.distributivity_add_right",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.paren_mul_right",
"Lib.IntTypes.bits",
"Lib.Sequence.lseq",
"Prims.l_and",
"Prims.l_Forall",
"Prims.l_or",
"Prims.op_LessThan",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.index",
"Lib.Sequence.update_sub"
] | [] | module Hacl.Spec.Bignum.Definitions
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val blocks0: x:size_nat -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks0 x m = if x = 0 then 1 else (x - 1) / m + 1
inline_for_extraction noextract
let limb_t = t:inttype{t = U32 \/ t = U64}
inline_for_extraction noextract
let limb (t:limb_t) = uint_t t SEC
let lbignum (t:limb_t) len = lseq (limb t) len
val eval_: #t:limb_t -> len:size_nat -> s:lbignum t len -> i:nat{i <= len} -> nat
let rec eval_ #t len s i =
if i = 0 then 0
else eval_ #t len s (i - 1) + v s.[i - 1] * pow2 (bits t * (i - 1))
let bn_v (#t:limb_t) (#len:size_nat) (s:lbignum t len) = eval_ #t len s len
///
/// Lemmas
///
#push-options "--fuel 2"
val bn_eval0: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (eval_ len b 0 == 0)
let bn_eval0 #t #len b = ()
val bn_eval1: #t:limb_t -> b:lbignum t 1 -> Lemma (bn_v b == v b.[0])
let bn_eval1 b = ()
val bn_eval_unfold_i: #t:limb_t -> #len:size_pos -> b:lbignum t len -> i:pos{i <= len} ->
Lemma (eval_ len b i == eval_ len b (i - 1) + v b.[i - 1] * pow2 (bits t * (i - 1)))
let bn_eval_unfold_i #t #len b i = ()
#pop-options
val bn_eval_zeroes: #t:limb_t -> len:size_nat -> i:nat{i <= len} ->
Lemma (eval_ len (create len (uint #t 0)) i == 0)
let rec bn_eval_zeroes #t len i =
let b = create len (uint #t 0) in
if i = 0 then
bn_eval0 b
else begin
bn_eval_unfold_i b i;
bn_eval_zeroes #t len (i - 1) end
val bn_eval_create1: #t:limb_t -> c:limb t -> Lemma (bn_v (create 1 c) == v c)
let bn_eval_create1 #t c =
bn_eval1 (create 1 c)
val bn_eval_extensionality_j:
#t:limb_t
-> #len1:size_nat
-> #len2:size_nat
-> b1:lbignum t len1
-> b2:lbignum t len2
-> j:nat{j <= len1 /\ j <= len2} ->
Lemma
(requires sub b1 0 j == sub b2 0 j)
(ensures eval_ len1 b1 j == eval_ len2 b2 j)
(decreases j)
let rec bn_eval_extensionality_j #t #len1 #len2 b1 b2 j =
if j = 0 then begin
bn_eval0 b1;
bn_eval0 b2 end
else begin
bn_eval_unfold_i b1 j;
bn_eval_unfold_i b2 j;
let b1j = slice b1 0 j in
let b2j = slice b2 0 j in
let c1 = slice b1j 0 (j - 1) in
let c2 = slice b2j 0 (j - 1) in
eq_intro c1 c2;
bn_eval_extensionality_j #t #len1 #len2 b1 b2 (j - 1);
Seq.lemma_index_slice b1 0 j (j - 1);
Seq.lemma_index_slice b2 0 j (j - 1);
assert (v b1.[j - 1] == v b2.[j - 1]);
() end
val bn_eval_snoc: #t:limb_t -> #len:size_nat{len + 1 <= max_size_t} -> b:lbignum t len -> e:limb t ->
Lemma (bn_v #t #(len + 1) (Seq.snoc b e) == bn_v b + v e * pow2 (bits t * len))
let bn_eval_snoc #t #len b e =
let b1 = Seq.snoc b e in
bn_eval_unfold_i #t #(len + 1) b1 (len + 1);
bn_eval_extensionality_j #t #(len+1) #len b1 (slice #_ #(len+1) b1 0 len) len;
eq_intro (sub #_ #(len + 1) b1 0 len) b
val bn_eval_split_i_aux: p:nat -> a:nat -> b:nat -> c:nat -> i:nat -> Lemma
(requires pow2 p * c == a - b)
(ensures pow2 (p * (i + 1)) * c == pow2 (p * i) * a - pow2 (p * i) * b)
let bn_eval_split_i_aux p a b c i =
calc (==) {
pow2 (p * (i + 1)) * c;
(==) { Math.Lemmas.pow2_plus (p * i) p }
pow2 (p * i) * pow2 p * c;
(==) { Math.Lemmas.paren_mul_right (pow2 (p * i)) (pow2 p) c }
pow2 (p * i) * (pow2 p * c);
(==) { }
pow2 (p * i) * (a - b);
(==) { Math.Lemmas.distributivity_sub_right (pow2 (p * i)) a b }
pow2 (p * i) * a - pow2 (p * i) * b;
}
#restart-solver
val bn_eval_split_i: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i <= len} -> Lemma
(ensures bn_v b == bn_v (slice b 0 i) + pow2 (bits t * i) * bn_v (slice b i len))
(decreases (len - i))
// 20220513 JP: this proof broke somewhere in the calc, but even with --quake
// 3/3 it goes through. Solver inconsistency? The restart solver above fixes it.
let rec bn_eval_split_i #t #len b i =
let pbits = bits t in
if i = 0 then
bn_eval0 (slice b 0 i)
else begin
if len = i then
bn_eval0 (slice b i len)
else begin
let b1 = slice b i len in
bn_eval_split_i b1 1;
bn_eval1 (slice b1 0 1);
assert (bn_v b1 == v b1.[0] + pow2 pbits * bn_v (slice b1 1 (len - i)));
Seq.lemma_index_slice b i len 0;
assert (bn_v b1 == v b.[i] + pow2 pbits * bn_v (slice b (i + 1) len));
calc (==) {
bn_v b;
(==) { bn_eval_split_i b (i + 1) }
bn_v (slice b 0 (i + 1)) + pow2 (pbits * (i + 1)) * bn_v (slice b (i + 1) len);
(==) { bn_eval_split_i_aux pbits (bn_v b1) (v b.[i]) (bn_v (slice b (i + 1) len)) i }
bn_v (slice b 0 (i + 1)) + pow2 (pbits * i) * bn_v b1 - pow2 (pbits * i) * v b.[i];
(==) { bn_eval_unfold_i (slice b 0 (i + 1)) (i + 1)}
eval_ (i + 1) (slice b 0 (i + 1)) i + pow2 (pbits * i) * bn_v b1;
(==) { bn_eval_extensionality_j (slice b 0 (i + 1)) (slice b 0 i) i }
eval_ i (slice b 0 i) i + pow2 (pbits * i) * bn_v b1;
}; () end end
val bn_eval_inj: #t:limb_t -> len:size_nat -> b1:lbignum t len -> b2:lbignum t len -> Lemma
(requires bn_v b1 == bn_v b2)
(ensures equal b1 b2)
(decreases len)
let rec bn_eval_inj #t len b1 b2 =
if len = 0 then ()
else begin
bn_eval_split_i b1 1;
bn_eval_split_i b2 1;
bn_eval1 (slice b1 0 1);
bn_eval1 (slice b2 0 1);
bn_eval_inj (len - 1) (slice b1 1 len) (slice b2 1 len);
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
val bn_eval_bound: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i <= len} ->
Lemma (eval_ len b i < pow2 (bits t * i))
let rec bn_eval_bound #t #len b i =
let pbits = bits t in
if i = 0 then
bn_eval0 b
else begin
bn_eval_unfold_i b i;
assert (eval_ len b i == eval_ len b (i - 1) + pow2 (pbits * (i - 1)) * v b.[i - 1]);
calc (<) {
eval_ len b (i - 1) + pow2 (pbits * (i - 1)) * v b.[i - 1];
(<) { bn_eval_bound #t #len b (i - 1) }
pow2 (pbits * (i - 1)) + pow2 (pbits * (i - 1)) * v b.[i - 1];
(==) { Math.Lemmas.distributivity_add_right (pow2 (pbits * (i - 1))) 1 (v b.[i - 1]) }
pow2 (pbits * (i - 1)) * (1 + v b.[i - 1]);
(<=) { Math.Lemmas.lemma_mult_le_left (pow2 (pbits * (i - 1))) (1 + v b.[i - 1]) (pow2 pbits) }
pow2 (pbits * (i - 1)) * pow2 pbits;
(==) { Math.Lemmas.pow2_plus (pbits * (i - 1)) pbits }
pow2 (pbits * i);
};
assert (eval_ len b i < pow2 (pbits * i))
end
val bn_eval_index: #t:limb_t -> #len:size_nat -> b:lbignum t len -> i:nat{i < len} ->
Lemma (v b.[i] == bn_v b / pow2 (bits t * i) % pow2 (bits t))
let bn_eval_index #t #len b i =
let pbits = bits t in
calc (==) {
bn_v b / pow2 (pbits * i) % pow2 pbits;
(==) { bn_eval_split_i #t #len b i }
(bn_v (slice b 0 i) + pow2 (pbits * i) * bn_v (slice b i len)) / pow2 (pbits * i) % pow2 pbits;
(==) { Math.Lemmas.division_addition_lemma (bn_v (slice b 0 i)) (pow2 (pbits * i)) (bn_v (slice b i len)) }
(bn_v (slice b 0 i) / pow2 (pbits * i) + bn_v (slice b i len)) % pow2 pbits;
(==) { bn_eval_bound (slice b 0 i) i; Math.Lemmas.small_division_lemma_1 (bn_v (slice b 0 i)) (pow2 (pbits * i)) }
bn_v (slice b i len) % pow2 pbits;
(==) { bn_eval_split_i (slice b i len) 1 }
(bn_v (slice b i (i + 1)) + pow2 pbits * bn_v (slice b (i + 1) len)) % pow2 pbits;
(==) { Math.Lemmas.modulo_addition_lemma (bn_v (slice b i (i + 1))) (pow2 pbits) (bn_v (slice b (i + 1) len)) }
bn_v (slice b i (i + 1)) % pow2 pbits;
(==) { bn_eval1 (slice b i (i + 1)); Seq.lemma_index_slice b i (i + 1) 0 }
v b.[i] % pow2 pbits;
(==) { Math.Lemmas.modulo_lemma (v b.[i]) (pow2 pbits) }
v b.[i];
};
assert (bn_v b / pow2 (pbits * i) % pow2 pbits == v b.[i])
val bn_eval_lt: #t:limb_t -> len:size_nat -> a:lbignum t len -> b:lbignum t len -> k:pos{k <= len} -> Lemma
(requires v a.[k - 1] < v b.[k - 1])
(ensures eval_ len a k < eval_ len b k)
let bn_eval_lt #t len a b k =
let pbits = bits t in
calc (==) {
eval_ len b k - eval_ len a k;
(==) { bn_eval_unfold_i b k }
eval_ len b (k - 1) + v b.[k - 1] * pow2 (pbits * (k - 1)) - eval_ len a k;
(==) { bn_eval_unfold_i a k }
eval_ len b (k - 1) + v b.[k - 1] * pow2 (pbits * (k - 1)) - eval_ len a (k - 1) - v a.[k - 1] * pow2 (pbits * (k - 1));
(==) { Math.Lemmas.distributivity_sub_left (v b.[k - 1]) (v a.[k - 1]) (pow2 (pbits * (k - 1))) }
eval_ len b (k - 1) - eval_ len a (k - 1) + (v b.[k - 1] - v a.[k - 1]) * pow2 (pbits * (k - 1));
};
bn_eval_bound a (k - 1);
bn_eval_bound b (k - 1);
assert (eval_ len b (k - 1) - eval_ len a (k - 1) > - pow2 (pbits * (k - 1)));
assert ((v b.[k - 1] - v a.[k - 1]) * pow2 (pbits * (k - 1)) >= pow2 (pbits * (k - 1)))
val bn_eval_update_sub: #t:limb_t -> len1:size_nat -> b1:lbignum t len1 -> len2:size_nat{len1 <= len2} ->
Lemma (let b2 = create len2 (uint #t 0) in bn_v b1 == bn_v (update_sub b2 0 len1 b1))
let bn_eval_update_sub #t len1 b1 len2 =
let b2 = create len2 (uint #t 0) in
let b2 = update_sub b2 0 len1 b1 in
bn_eval_split_i b2 len1;
assert (bn_v b2 == bn_v b1 + pow2 (bits t * len1) * bn_v (slice b2 len1 len2));
let b_zeroes = create (len2 - len1) (uint #t 0) in
eq_intro b_zeroes (slice b2 len1 len2);
bn_eval_zeroes #t (len2 - len1) (len2 - len1)
val bn_update_sub_eval:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t bLen
-> i:nat{i + bLen <= aLen} ->
Lemma (bn_v (update_sub a i bLen b) == bn_v a - bn_v (sub a i bLen) * pow2 (bits t * i) + bn_v b * pow2 (bits t * i)) | false | false | Hacl.Spec.Bignum.Definitions.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_update_sub_eval:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t bLen
-> i:nat{i + bLen <= aLen} ->
Lemma (bn_v (update_sub a i bLen b) == bn_v a - bn_v (sub a i bLen) * pow2 (bits t * i) + bn_v b * pow2 (bits t * i)) | [] | Hacl.Spec.Bignum.Definitions.bn_update_sub_eval | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Definitions.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 aLen ->
b: Hacl.Spec.Bignum.Definitions.lbignum t bLen ->
i: Prims.nat{i + bLen <= aLen}
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Definitions.bn_v (Lib.Sequence.update_sub a i bLen b) ==
Hacl.Spec.Bignum.Definitions.bn_v a -
Hacl.Spec.Bignum.Definitions.bn_v (Lib.Sequence.sub a i bLen) *
Prims.pow2 (Lib.IntTypes.bits t * i) +
Hacl.Spec.Bignum.Definitions.bn_v b * Prims.pow2 (Lib.IntTypes.bits t * i)) | {
"end_col": 5,
"end_line": 293,
"start_col": 45,
"start_line": 267
} |
Prims.Tot | val va_wp_Callee_save_registers (win: bool) (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.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"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.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"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.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"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.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let va_wp_Callee_save_registers (win:bool) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) :
Type0 =
(va_get_ok va_s0 /\ va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
sse_enabled /\ (forall (va_x_stack:vale_stack) (va_x_rsp:nat64) (va_x_rax:nat64)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_reg64 rRax
va_x_rax (va_upd_reg64 rRsp va_x_rsp (va_upd_stack va_x_stack va_s0))) in va_get_ok va_sM /\
(forall i . Vale.X64.Stack_i.valid_src_stack64 i (va_get_stack va_s0) /\ va_get_reg64 rRsp
va_sM + va_if win (fun _ -> 224) (fun _ -> 64) <= i ==> Vale.X64.Stack_i.load_stack64 i
(va_get_stack va_sM) == Vale.X64.Stack_i.load_stack64 i (va_get_stack va_s0)) /\ va_get_reg64
rRbx va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM) (va_get_stack va_sM) /\
va_get_reg64 rRbp va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 8)
(va_get_stack va_sM) /\ va_get_reg64 rRdi va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64
rRsp va_sM + 16) (va_get_stack va_sM) /\ va_get_reg64 rRsi va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 24) (va_get_stack va_sM) /\
va_get_reg64 rR12 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 32)
(va_get_stack va_sM) /\ va_get_reg64 rR13 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64
rRsp va_sM + 40) (va_get_stack va_sM) /\ va_get_reg64 rR14 va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 48) (va_get_stack va_sM) /\
va_get_reg64 rR15 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 56)
(va_get_stack va_sM) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 6 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 64) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 6 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 72) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 7 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 80) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 7 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 88) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 8 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 96) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 8 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 104) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 9 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 112) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 9 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 120) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 10 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 128) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 10 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 136) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 11 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 144) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 11 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 152) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 12 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 160) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 12 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 168) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 13 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 176) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 13 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 184) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 14 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 192) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 14 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 200) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 15 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 208) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 15 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 216) (va_get_stack va_sM)) ==> va_k va_sM (()))) | val va_wp_Callee_save_registers (win: bool) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Callee_save_registers (win: bool) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_get_ok va_s0 /\ va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
sse_enabled /\
(forall (va_x_stack: vale_stack) (va_x_rsp: nat64) (va_x_rax: nat64) (va_x_stackTaint: memtaint).
let va_sM =
va_upd_stackTaint va_x_stackTaint
(va_upd_reg64 rRax va_x_rax (va_upd_reg64 rRsp va_x_rsp (va_upd_stack va_x_stack va_s0)))
in
va_get_ok va_sM /\
(forall i.
Vale.X64.Stack_i.valid_src_stack64 i (va_get_stack va_s0) /\
va_get_reg64 rRsp va_sM + va_if win (fun _ -> 224) (fun _ -> 64) <= i ==>
Vale.X64.Stack_i.load_stack64 i (va_get_stack va_sM) ==
Vale.X64.Stack_i.load_stack64 i (va_get_stack va_s0)) /\
va_get_reg64 rRbx va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM) (va_get_stack va_sM) /\
va_get_reg64 rRbp va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 8) (va_get_stack va_sM) /\
va_get_reg64 rRdi va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 16) (va_get_stack va_sM) /\
va_get_reg64 rRsi va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 24) (va_get_stack va_sM) /\
va_get_reg64 rR12 va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 32) (va_get_stack va_sM) /\
va_get_reg64 rR13 va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 40) (va_get_stack va_sM) /\
va_get_reg64 rR14 va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 48) (va_get_stack va_sM) /\
va_get_reg64 rR15 va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 56) (va_get_stack va_sM) /\
(win ==>
Vale.Arch.Types.hi64 (va_get_xmm 6 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 64) (va_get_stack va_sM)) /\
(win ==>
Vale.Arch.Types.lo64 (va_get_xmm 6 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 72) (va_get_stack va_sM)) /\
(win ==>
Vale.Arch.Types.hi64 (va_get_xmm 7 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 80) (va_get_stack va_sM)) /\
(win ==>
Vale.Arch.Types.lo64 (va_get_xmm 7 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 88) (va_get_stack va_sM)) /\
(win ==>
Vale.Arch.Types.hi64 (va_get_xmm 8 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 96) (va_get_stack va_sM)) /\
(win ==>
Vale.Arch.Types.lo64 (va_get_xmm 8 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 104) (va_get_stack va_sM)) /\
(win ==>
Vale.Arch.Types.hi64 (va_get_xmm 9 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 112) (va_get_stack va_sM)) /\
(win ==>
Vale.Arch.Types.lo64 (va_get_xmm 9 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 120) (va_get_stack va_sM)) /\
(win ==>
Vale.Arch.Types.hi64 (va_get_xmm 10 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 128) (va_get_stack va_sM)) /\
(win ==>
Vale.Arch.Types.lo64 (va_get_xmm 10 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 136) (va_get_stack va_sM)) /\
(win ==>
Vale.Arch.Types.hi64 (va_get_xmm 11 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 144) (va_get_stack va_sM)) /\
(win ==>
Vale.Arch.Types.lo64 (va_get_xmm 11 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 152) (va_get_stack va_sM)) /\
(win ==>
Vale.Arch.Types.hi64 (va_get_xmm 12 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 160) (va_get_stack va_sM)) /\
(win ==>
Vale.Arch.Types.lo64 (va_get_xmm 12 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 168) (va_get_stack va_sM)) /\
(win ==>
Vale.Arch.Types.hi64 (va_get_xmm 13 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 176) (va_get_stack va_sM)) /\
(win ==>
Vale.Arch.Types.lo64 (va_get_xmm 13 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 184) (va_get_stack va_sM)) /\
(win ==>
Vale.Arch.Types.hi64 (va_get_xmm 14 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 192) (va_get_stack va_sM)) /\
(win ==>
Vale.Arch.Types.lo64 (va_get_xmm 14 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 200) (va_get_stack va_sM)) /\
(win ==>
Vale.Arch.Types.hi64 (va_get_xmm 15 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 208) (va_get_stack va_sM)) /\
(win ==>
Vale.Arch.Types.lo64 (va_get_xmm 15 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 216) (va_get_stack va_sM)) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.X64.Stack.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.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.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Stack.fsti"
} | [
"total"
] | [
"Prims.bool",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Prims.eq2",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.Stack_i.init_rsp",
"Vale.X64.Decls.va_get_stack",
"Vale.X64.CPU_Features_s.sse_enabled",
"Prims.l_Forall",
"Vale.X64.InsBasic.vale_stack",
"Vale.X64.Memory.nat64",
"Vale.X64.Memory.memtaint",
"Prims.l_imp",
"Prims.int",
"Vale.X64.Stack_i.valid_src_stack64",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Vale.X64.Decls.va_if",
"Prims.l_not",
"Vale.X64.Stack_i.load_stack64",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rRbp",
"Vale.X64.Machine_s.rRdi",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rR12",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rR14",
"Vale.X64.Machine_s.rR15",
"Vale.Arch.Types.hi64",
"Vale.X64.Decls.va_get_xmm",
"Vale.Arch.Types.lo64",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_stackTaint",
"Vale.X64.Decls.va_upd_reg64",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Decls.va_upd_stack"
] | [] | module Vale.X64.Stack
//open Vale.Def.Opaque_s
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
open Vale.Arch.Types
//open Vale.AES.GCM_helpers
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.InsVector
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
#reset-options "--z3rlimit 30"
//-- Callee_save_registers
val va_code_Callee_save_registers : win:bool -> Tot va_code
val va_codegen_success_Callee_save_registers : win:bool -> Tot va_pbool
val va_lemma_Callee_save_registers : va_b0:va_code -> va_s0:va_state -> win:bool
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Callee_save_registers win) va_s0 /\ va_get_ok va_s0 /\
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ sse_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(forall i . Vale.X64.Stack_i.valid_src_stack64 i (va_get_stack va_s0) /\ va_get_reg64 rRsp
va_sM + (if win then 224 else 64) <= i ==> Vale.X64.Stack_i.load_stack64 i (va_get_stack va_sM)
== Vale.X64.Stack_i.load_stack64 i (va_get_stack va_s0)) /\ va_get_reg64 rRbx va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM) (va_get_stack va_sM) /\ va_get_reg64
rRbp va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 8) (va_get_stack va_sM)
/\ va_get_reg64 rRdi va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 16)
(va_get_stack va_sM) /\ va_get_reg64 rRsi va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64
rRsp va_sM + 24) (va_get_stack va_sM) /\ va_get_reg64 rR12 va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 32) (va_get_stack va_sM) /\
va_get_reg64 rR13 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 40)
(va_get_stack va_sM) /\ va_get_reg64 rR14 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64
rRsp va_sM + 48) (va_get_stack va_sM) /\ va_get_reg64 rR15 va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 56) (va_get_stack va_sM) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 6 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 64) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 6 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 72) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 7 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 80) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 7 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 88) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 8 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 96) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 8 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 104) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 9 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 112) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 9 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 120) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 10 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 128) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 10 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 136) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 11 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 144) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 11 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 152) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 12 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 160) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 12 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 168) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 13 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 176) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 13 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 184) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 14 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 192) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 14 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 200) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 15 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 208) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 15 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 216) (va_get_stack va_sM)) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_reg64 rRax va_sM (va_update_reg64 rRsp
va_sM (va_update_stack va_sM (va_update_ok va_sM va_s0)))))))
[@ va_qattr]
let va_wp_Callee_save_registers (win:bool) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : | false | true | Vale.X64.Stack.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": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Callee_save_registers (win: bool) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.X64.Stack.va_wp_Callee_save_registers | {
"file_name": "obj/Vale.X64.Stack.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
win: Prims.bool ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 60,
"end_line": 128,
"start_col": 2,
"start_line": 81
} |
Prims.Tot | val va_wp_Callee_restore_registers
(win: bool)
(old_xmm6 old_xmm7 old_xmm8 old_xmm9 old_xmm10 old_xmm11 old_xmm12 old_xmm13 old_xmm14 old_xmm15:
quad32)
(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.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"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.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"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.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"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.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let va_wp_Callee_restore_registers (win:bool) (old_xmm6:quad32) (old_xmm7:quad32) (old_xmm8:quad32)
(old_xmm9:quad32) (old_xmm10:quad32) (old_xmm11:quad32) (old_xmm12:quad32) (old_xmm13:quad32)
(old_xmm14:quad32) (old_xmm15:quad32) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0
=
(va_get_ok va_s0 /\ sse_enabled /\ (forall i . va_get_reg64 rRsp va_s0 <= i /\ i <= va_get_reg64
rRsp va_s0 + va_if win (fun _ -> 216) (fun _ -> 56) ==> Vale.X64.Stack_i.valid_stack_slot64 i
(va_get_stack va_s0) Public (va_get_stackTaint va_s0)) /\ va_get_reg64 rRsp va_s0 >=
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) - 4096 /\ va_get_reg64 rRsp va_s0 + va_if win
(fun _ -> 224) (fun _ -> 64) <= Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ (win ==>
Vale.Arch.Types.hi64 old_xmm6 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 64)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.lo64 old_xmm6 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 72) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.hi64 old_xmm7 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 80)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.lo64 old_xmm7 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 88) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.hi64 old_xmm8 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 96)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.lo64 old_xmm8 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 104) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.hi64 old_xmm9 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 112)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.lo64 old_xmm9 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 120) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.hi64 old_xmm10 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 128)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.lo64 old_xmm10 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 136) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.hi64 old_xmm11 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 144)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.lo64 old_xmm11 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 152) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.hi64 old_xmm12 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 160)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.lo64 old_xmm12 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 168) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.hi64 old_xmm13 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 176)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.lo64 old_xmm13 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 184) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.hi64 old_xmm14 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 192)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.lo64 old_xmm14 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 200) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.hi64 old_xmm15 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 208)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.lo64 old_xmm15 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 216) (va_get_stack va_s0)) /\ (forall
(va_x_rax:nat64) (va_x_rbx:nat64) (va_x_rbp:nat64) (va_x_rdi:nat64) (va_x_rsi:nat64)
(va_x_r12:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_xmm6:quad32)
(va_x_xmm7:quad32) (va_x_xmm8:quad32) (va_x_xmm9:quad32) (va_x_xmm10:quad32)
(va_x_xmm11:quad32) (va_x_xmm12:quad32) (va_x_xmm13:quad32) (va_x_xmm14:quad32)
(va_x_xmm15:quad32) (va_x_rsp:nat64) (va_x_stack:vale_stack) . let va_sM = va_upd_stack
va_x_stack (va_upd_reg64 rRsp va_x_rsp (va_upd_xmm 15 va_x_xmm15 (va_upd_xmm 14 va_x_xmm14
(va_upd_xmm 13 va_x_xmm13 (va_upd_xmm 12 va_x_xmm12 (va_upd_xmm 11 va_x_xmm11 (va_upd_xmm 10
va_x_xmm10 (va_upd_xmm 9 va_x_xmm9 (va_upd_xmm 8 va_x_xmm8 (va_upd_xmm 7 va_x_xmm7 (va_upd_xmm
6 va_x_xmm6 (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR12 va_x_r12 (va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ va_get_reg64 rRbx va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0) (va_get_stack va_s0) /\ va_get_reg64
rRbp va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 8) (va_get_stack va_s0)
/\ va_get_reg64 rRdi va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 16)
(va_get_stack va_s0) /\ va_get_reg64 rRsi va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64
rRsp va_s0 + 24) (va_get_stack va_s0) /\ va_get_reg64 rR12 va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 32) (va_get_stack va_s0) /\
va_get_reg64 rR13 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 40)
(va_get_stack va_s0) /\ va_get_reg64 rR14 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64
rRsp va_s0 + 48) (va_get_stack va_s0) /\ va_get_reg64 rR15 va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 56) (va_get_stack va_s0) /\ (win ==>
va_get_xmm 6 va_sM == old_xmm6) /\ (win ==> va_get_xmm 7 va_sM == old_xmm7) /\ (win ==>
va_get_xmm 8 va_sM == old_xmm8) /\ (win ==> va_get_xmm 9 va_sM == old_xmm9) /\ (win ==>
va_get_xmm 10 va_sM == old_xmm10) /\ (win ==> va_get_xmm 11 va_sM == old_xmm11) /\ (win ==>
va_get_xmm 12 va_sM == old_xmm12) /\ (win ==> va_get_xmm 13 va_sM == old_xmm13) /\ (win ==>
va_get_xmm 14 va_sM == old_xmm14) /\ (win ==> va_get_xmm 15 va_sM == old_xmm15) /\ va_get_reg64
rRsp va_sM == va_get_reg64 rRsp va_s0 + va_if win (fun _ -> 224) (fun _ -> 64) /\ va_get_stack
va_sM == Vale.X64.Stack_i.free_stack64 (va_get_reg64 rRsp va_s0) (va_get_reg64 rRsp va_s0 +
va_if win (fun _ -> 224) (fun _ -> 64)) (va_get_stack va_s0) ==> va_k va_sM (()))) | val va_wp_Callee_restore_registers
(win: bool)
(old_xmm6 old_xmm7 old_xmm8 old_xmm9 old_xmm10 old_xmm11 old_xmm12 old_xmm13 old_xmm14 old_xmm15:
quad32)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Callee_restore_registers
(win: bool)
(old_xmm6 old_xmm7 old_xmm8 old_xmm9 old_xmm10 old_xmm11 old_xmm12 old_xmm13 old_xmm14 old_xmm15:
quad32)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_get_ok va_s0 /\ sse_enabled /\
(forall i.
va_get_reg64 rRsp va_s0 <= i /\
i <= va_get_reg64 rRsp va_s0 + va_if win (fun _ -> 216) (fun _ -> 56) ==>
Vale.X64.Stack_i.valid_stack_slot64 i (va_get_stack va_s0) Public (va_get_stackTaint va_s0)) /\
va_get_reg64 rRsp va_s0 >= Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) - 4096 /\
va_get_reg64 rRsp va_s0 + va_if win (fun _ -> 224) (fun _ -> 64) <=
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
(win ==>
Vale.Arch.Types.hi64 old_xmm6 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 64) (va_get_stack va_s0)) /\
(win ==>
Vale.Arch.Types.lo64 old_xmm6 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 72) (va_get_stack va_s0)) /\
(win ==>
Vale.Arch.Types.hi64 old_xmm7 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 80) (va_get_stack va_s0)) /\
(win ==>
Vale.Arch.Types.lo64 old_xmm7 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 88) (va_get_stack va_s0)) /\
(win ==>
Vale.Arch.Types.hi64 old_xmm8 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 96) (va_get_stack va_s0)) /\
(win ==>
Vale.Arch.Types.lo64 old_xmm8 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 104) (va_get_stack va_s0)) /\
(win ==>
Vale.Arch.Types.hi64 old_xmm9 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 112) (va_get_stack va_s0)) /\
(win ==>
Vale.Arch.Types.lo64 old_xmm9 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 120) (va_get_stack va_s0)) /\
(win ==>
Vale.Arch.Types.hi64 old_xmm10 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 128) (va_get_stack va_s0)) /\
(win ==>
Vale.Arch.Types.lo64 old_xmm10 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 136) (va_get_stack va_s0)) /\
(win ==>
Vale.Arch.Types.hi64 old_xmm11 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 144) (va_get_stack va_s0)) /\
(win ==>
Vale.Arch.Types.lo64 old_xmm11 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 152) (va_get_stack va_s0)) /\
(win ==>
Vale.Arch.Types.hi64 old_xmm12 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 160) (va_get_stack va_s0)) /\
(win ==>
Vale.Arch.Types.lo64 old_xmm12 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 168) (va_get_stack va_s0)) /\
(win ==>
Vale.Arch.Types.hi64 old_xmm13 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 176) (va_get_stack va_s0)) /\
(win ==>
Vale.Arch.Types.lo64 old_xmm13 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 184) (va_get_stack va_s0)) /\
(win ==>
Vale.Arch.Types.hi64 old_xmm14 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 192) (va_get_stack va_s0)) /\
(win ==>
Vale.Arch.Types.lo64 old_xmm14 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 200) (va_get_stack va_s0)) /\
(win ==>
Vale.Arch.Types.hi64 old_xmm15 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 208) (va_get_stack va_s0)) /\
(win ==>
Vale.Arch.Types.lo64 old_xmm15 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 216) (va_get_stack va_s0)) /\
(forall (va_x_rax: nat64) (va_x_rbx: nat64) (va_x_rbp: nat64) (va_x_rdi: nat64) (va_x_rsi: nat64)
(va_x_r12: nat64) (va_x_r13: nat64) (va_x_r14: nat64) (va_x_r15: nat64) (va_x_xmm6: quad32)
(va_x_xmm7: quad32) (va_x_xmm8: quad32) (va_x_xmm9: quad32) (va_x_xmm10: quad32)
(va_x_xmm11: quad32) (va_x_xmm12: quad32) (va_x_xmm13: quad32) (va_x_xmm14: quad32)
(va_x_xmm15: quad32) (va_x_rsp: nat64) (va_x_stack: vale_stack).
let va_sM =
va_upd_stack va_x_stack
(va_upd_reg64 rRsp
va_x_rsp
(va_upd_xmm 15
va_x_xmm15
(va_upd_xmm 14
va_x_xmm14
(va_upd_xmm 13
va_x_xmm13
(va_upd_xmm 12
va_x_xmm12
(va_upd_xmm 11
va_x_xmm11
(va_upd_xmm 10
va_x_xmm10
(va_upd_xmm 9
va_x_xmm9
(va_upd_xmm 8
va_x_xmm8
(va_upd_xmm 7
va_x_xmm7
(va_upd_xmm 6
va_x_xmm6
(va_upd_reg64 rR15
va_x_r15
(va_upd_reg64 rR14
va_x_r14
(va_upd_reg64 rR13
va_x_r13
(va_upd_reg64 rR12
va_x_r12
(va_upd_reg64 rRsi
va_x_rsi
(va_upd_reg64 rRdi
va_x_rdi
(va_upd_reg64 rRbp
va_x_rbp
(va_upd_reg64 rRbx
va_x_rbx
(va_upd_reg64 rRax
va_x_rax
va_s0)))))
)))))))))))))))
in
va_get_ok va_sM /\
va_get_reg64 rRbx va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0) (va_get_stack va_s0) /\
va_get_reg64 rRbp va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 8) (va_get_stack va_s0) /\
va_get_reg64 rRdi va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 16) (va_get_stack va_s0) /\
va_get_reg64 rRsi va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 24) (va_get_stack va_s0) /\
va_get_reg64 rR12 va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 32) (va_get_stack va_s0) /\
va_get_reg64 rR13 va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 40) (va_get_stack va_s0) /\
va_get_reg64 rR14 va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 48) (va_get_stack va_s0) /\
va_get_reg64 rR15 va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 56) (va_get_stack va_s0) /\
(win ==> va_get_xmm 6 va_sM == old_xmm6) /\ (win ==> va_get_xmm 7 va_sM == old_xmm7) /\
(win ==> va_get_xmm 8 va_sM == old_xmm8) /\ (win ==> va_get_xmm 9 va_sM == old_xmm9) /\
(win ==> va_get_xmm 10 va_sM == old_xmm10) /\ (win ==> va_get_xmm 11 va_sM == old_xmm11) /\
(win ==> va_get_xmm 12 va_sM == old_xmm12) /\ (win ==> va_get_xmm 13 va_sM == old_xmm13) /\
(win ==> va_get_xmm 14 va_sM == old_xmm14) /\ (win ==> va_get_xmm 15 va_sM == old_xmm15) /\
va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0 + va_if win (fun _ -> 224) (fun _ -> 64) /\
va_get_stack va_sM ==
Vale.X64.Stack_i.free_stack64 (va_get_reg64 rRsp va_s0)
(va_get_reg64 rRsp va_s0 + va_if win (fun _ -> 224) (fun _ -> 64))
(va_get_stack va_s0) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.X64.Stack.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.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.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Stack.fsti"
} | [
"total"
] | [
"Prims.bool",
"Vale.X64.Decls.quad32",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.sse_enabled",
"Prims.l_Forall",
"Prims.int",
"Prims.l_imp",
"Prims.op_LessThanOrEqual",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRsp",
"Prims.op_Addition",
"Vale.X64.Decls.va_if",
"Prims.l_not",
"Vale.X64.Stack_i.valid_stack_slot64",
"Vale.X64.Decls.va_get_stack",
"Vale.Arch.HeapTypes_s.Public",
"Vale.X64.Decls.va_get_stackTaint",
"Prims.op_GreaterThanOrEqual",
"Prims.op_Subtraction",
"Vale.X64.Stack_i.init_rsp",
"Prims.eq2",
"Vale.Def.Words_s.nat64",
"Vale.Arch.Types.hi64",
"Vale.X64.Stack_i.load_stack64",
"Vale.Arch.Types.lo64",
"Vale.X64.Memory.nat64",
"Vale.X64.InsBasic.vale_stack",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rRbp",
"Vale.X64.Machine_s.rRdi",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rR12",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rR14",
"Vale.X64.Machine_s.rR15",
"Vale.X64.Decls.va_get_xmm",
"Vale.X64.Stack_i.vale_stack",
"Vale.X64.Stack_i.free_stack64",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_stack",
"Vale.X64.Decls.va_upd_reg64",
"Vale.X64.Decls.va_upd_xmm",
"Vale.X64.Machine_s.rRax"
] | [] | module Vale.X64.Stack
//open Vale.Def.Opaque_s
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
open Vale.Arch.Types
//open Vale.AES.GCM_helpers
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.InsVector
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
#reset-options "--z3rlimit 30"
//-- Callee_save_registers
val va_code_Callee_save_registers : win:bool -> Tot va_code
val va_codegen_success_Callee_save_registers : win:bool -> Tot va_pbool
val va_lemma_Callee_save_registers : va_b0:va_code -> va_s0:va_state -> win:bool
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Callee_save_registers win) va_s0 /\ va_get_ok va_s0 /\
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ sse_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(forall i . Vale.X64.Stack_i.valid_src_stack64 i (va_get_stack va_s0) /\ va_get_reg64 rRsp
va_sM + (if win then 224 else 64) <= i ==> Vale.X64.Stack_i.load_stack64 i (va_get_stack va_sM)
== Vale.X64.Stack_i.load_stack64 i (va_get_stack va_s0)) /\ va_get_reg64 rRbx va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM) (va_get_stack va_sM) /\ va_get_reg64
rRbp va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 8) (va_get_stack va_sM)
/\ va_get_reg64 rRdi va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 16)
(va_get_stack va_sM) /\ va_get_reg64 rRsi va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64
rRsp va_sM + 24) (va_get_stack va_sM) /\ va_get_reg64 rR12 va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 32) (va_get_stack va_sM) /\
va_get_reg64 rR13 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 40)
(va_get_stack va_sM) /\ va_get_reg64 rR14 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64
rRsp va_sM + 48) (va_get_stack va_sM) /\ va_get_reg64 rR15 va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 56) (va_get_stack va_sM) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 6 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 64) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 6 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 72) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 7 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 80) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 7 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 88) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 8 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 96) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 8 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 104) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 9 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 112) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 9 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 120) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 10 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 128) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 10 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 136) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 11 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 144) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 11 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 152) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 12 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 160) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 12 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 168) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 13 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 176) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 13 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 184) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 14 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 192) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 14 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 200) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 15 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 208) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 15 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 216) (va_get_stack va_sM)) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_reg64 rRax va_sM (va_update_reg64 rRsp
va_sM (va_update_stack va_sM (va_update_ok va_sM va_s0)))))))
[@ va_qattr]
let va_wp_Callee_save_registers (win:bool) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) :
Type0 =
(va_get_ok va_s0 /\ va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
sse_enabled /\ (forall (va_x_stack:vale_stack) (va_x_rsp:nat64) (va_x_rax:nat64)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_reg64 rRax
va_x_rax (va_upd_reg64 rRsp va_x_rsp (va_upd_stack va_x_stack va_s0))) in va_get_ok va_sM /\
(forall i . Vale.X64.Stack_i.valid_src_stack64 i (va_get_stack va_s0) /\ va_get_reg64 rRsp
va_sM + va_if win (fun _ -> 224) (fun _ -> 64) <= i ==> Vale.X64.Stack_i.load_stack64 i
(va_get_stack va_sM) == Vale.X64.Stack_i.load_stack64 i (va_get_stack va_s0)) /\ va_get_reg64
rRbx va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM) (va_get_stack va_sM) /\
va_get_reg64 rRbp va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 8)
(va_get_stack va_sM) /\ va_get_reg64 rRdi va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64
rRsp va_sM + 16) (va_get_stack va_sM) /\ va_get_reg64 rRsi va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 24) (va_get_stack va_sM) /\
va_get_reg64 rR12 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 32)
(va_get_stack va_sM) /\ va_get_reg64 rR13 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64
rRsp va_sM + 40) (va_get_stack va_sM) /\ va_get_reg64 rR14 va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 48) (va_get_stack va_sM) /\
va_get_reg64 rR15 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 56)
(va_get_stack va_sM) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 6 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 64) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 6 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 72) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 7 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 80) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 7 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 88) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 8 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 96) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 8 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 104) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 9 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 112) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 9 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 120) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 10 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 128) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 10 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 136) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 11 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 144) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 11 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 152) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 12 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 160) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 12 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 168) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 13 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 176) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 13 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 184) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 14 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 192) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 14 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 200) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 15 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 208) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 15 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 216) (va_get_stack va_sM)) ==> va_k va_sM (())))
val va_wpProof_Callee_save_registers : win:bool -> va_s0:va_state -> va_k:(va_state -> unit ->
Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Callee_save_registers win va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Callee_save_registers win)
([va_Mod_stackTaint; va_Mod_reg64 rRax; va_Mod_reg64 rRsp; va_Mod_stack]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Callee_save_registers (win:bool) : (va_quickCode unit (va_code_Callee_save_registers
win)) =
(va_QProc (va_code_Callee_save_registers win) ([va_Mod_stackTaint; va_Mod_reg64 rRax;
va_Mod_reg64 rRsp; va_Mod_stack]) (va_wp_Callee_save_registers win)
(va_wpProof_Callee_save_registers win))
//--
//-- Callee_restore_registers
val va_code_Callee_restore_registers : win:bool -> Tot va_code
val va_codegen_success_Callee_restore_registers : win:bool -> Tot va_pbool
val va_lemma_Callee_restore_registers : va_b0:va_code -> va_s0:va_state -> win:bool ->
old_xmm6:quad32 -> old_xmm7:quad32 -> old_xmm8:quad32 -> old_xmm9:quad32 -> old_xmm10:quad32 ->
old_xmm11:quad32 -> old_xmm12:quad32 -> old_xmm13:quad32 -> old_xmm14:quad32 -> old_xmm15:quad32
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Callee_restore_registers win) va_s0 /\ va_get_ok va_s0
/\ sse_enabled /\ (forall i . va_get_reg64 rRsp va_s0 <= i /\ i <= va_get_reg64 rRsp va_s0 +
(if win then 216 else 56) ==> Vale.X64.Stack_i.valid_stack_slot64 i (va_get_stack va_s0) Public
(va_get_stackTaint va_s0)) /\ va_get_reg64 rRsp va_s0 >= Vale.X64.Stack_i.init_rsp
(va_get_stack va_s0) - 4096 /\ va_get_reg64 rRsp va_s0 + (if win then 224 else 64) <=
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ (win ==> Vale.Arch.Types.hi64 old_xmm6 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 64) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.lo64 old_xmm6 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 72)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.hi64 old_xmm7 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 80) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.lo64 old_xmm7 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 88)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.hi64 old_xmm8 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 96) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.lo64 old_xmm8 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 104)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.hi64 old_xmm9 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 112) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.lo64 old_xmm9 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 120)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.hi64 old_xmm10 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 128) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.lo64 old_xmm10 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 136)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.hi64 old_xmm11 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 144) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.lo64 old_xmm11 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 152)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.hi64 old_xmm12 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 160) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.lo64 old_xmm12 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 168)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.hi64 old_xmm13 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 176) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.lo64 old_xmm13 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 184)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.hi64 old_xmm14 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 192) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.lo64 old_xmm14 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 200)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.hi64 old_xmm15 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 208) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.lo64 old_xmm15 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 216)
(va_get_stack va_s0))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_get_reg64 rRbx va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0)
(va_get_stack va_s0) /\ va_get_reg64 rRbp va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64
rRsp va_s0 + 8) (va_get_stack va_s0) /\ va_get_reg64 rRdi va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 16) (va_get_stack va_s0) /\
va_get_reg64 rRsi va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 24)
(va_get_stack va_s0) /\ va_get_reg64 rR12 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64
rRsp va_s0 + 32) (va_get_stack va_s0) /\ va_get_reg64 rR13 va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 40) (va_get_stack va_s0) /\
va_get_reg64 rR14 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 48)
(va_get_stack va_s0) /\ va_get_reg64 rR15 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64
rRsp va_s0 + 56) (va_get_stack va_s0) /\ (win ==> va_get_xmm 6 va_sM == old_xmm6) /\ (win ==>
va_get_xmm 7 va_sM == old_xmm7) /\ (win ==> va_get_xmm 8 va_sM == old_xmm8) /\ (win ==>
va_get_xmm 9 va_sM == old_xmm9) /\ (win ==> va_get_xmm 10 va_sM == old_xmm10) /\ (win ==>
va_get_xmm 11 va_sM == old_xmm11) /\ (win ==> va_get_xmm 12 va_sM == old_xmm12) /\ (win ==>
va_get_xmm 13 va_sM == old_xmm13) /\ (win ==> va_get_xmm 14 va_sM == old_xmm14) /\ (win ==>
va_get_xmm 15 va_sM == old_xmm15) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0 + (if
win then 224 else 64) /\ va_get_stack va_sM == Vale.X64.Stack_i.free_stack64 (va_get_reg64 rRsp
va_s0) (va_get_reg64 rRsp va_s0 + (if win then 224 else 64)) (va_get_stack va_s0) /\
va_state_eq va_sM (va_update_stack va_sM (va_update_reg64 rRsp va_sM (va_update_xmm 15 va_sM
(va_update_xmm 14 va_sM (va_update_xmm 13 va_sM (va_update_xmm 12 va_sM (va_update_xmm 11 va_sM
(va_update_xmm 10 va_sM (va_update_xmm 9 va_sM (va_update_xmm 8 va_sM (va_update_xmm 7 va_sM
(va_update_xmm 6 va_sM (va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64
rR13 va_sM (va_update_reg64 rR12 va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRbp va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Callee_restore_registers (win:bool) (old_xmm6:quad32) (old_xmm7:quad32) (old_xmm8:quad32)
(old_xmm9:quad32) (old_xmm10:quad32) (old_xmm11:quad32) (old_xmm12:quad32) (old_xmm13:quad32)
(old_xmm14:quad32) (old_xmm15:quad32) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 | false | true | Vale.X64.Stack.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": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_Callee_restore_registers
(win: bool)
(old_xmm6 old_xmm7 old_xmm8 old_xmm9 old_xmm10 old_xmm11 old_xmm12 old_xmm13 old_xmm14 old_xmm15:
quad32)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.X64.Stack.va_wp_Callee_restore_registers | {
"file_name": "obj/Vale.X64.Stack.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
win: Prims.bool ->
old_xmm6: Vale.X64.Decls.quad32 ->
old_xmm7: Vale.X64.Decls.quad32 ->
old_xmm8: Vale.X64.Decls.quad32 ->
old_xmm9: Vale.X64.Decls.quad32 ->
old_xmm10: Vale.X64.Decls.quad32 ->
old_xmm11: Vale.X64.Decls.quad32 ->
old_xmm12: Vale.X64.Decls.quad32 ->
old_xmm13: Vale.X64.Decls.quad32 ->
old_xmm14: Vale.X64.Decls.quad32 ->
old_xmm15: Vale.X64.Decls.quad32 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 86,
"end_line": 285,
"start_col": 2,
"start_line": 221
} |
Prims.Tot | val va_quick_Callee_save_registers (win: bool)
: (va_quickCode unit (va_code_Callee_save_registers win)) | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"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.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"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.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"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.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"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.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let va_quick_Callee_save_registers (win:bool) : (va_quickCode unit (va_code_Callee_save_registers
win)) =
(va_QProc (va_code_Callee_save_registers win) ([va_Mod_stackTaint; va_Mod_reg64 rRax;
va_Mod_reg64 rRsp; va_Mod_stack]) (va_wp_Callee_save_registers win)
(va_wpProof_Callee_save_registers win)) | val va_quick_Callee_save_registers (win: bool)
: (va_quickCode unit (va_code_Callee_save_registers win))
let va_quick_Callee_save_registers (win: bool)
: (va_quickCode unit (va_code_Callee_save_registers win)) = | false | null | false | (va_QProc (va_code_Callee_save_registers win)
([va_Mod_stackTaint; va_Mod_reg64 rRax; va_Mod_reg64 rRsp; va_Mod_stack])
(va_wp_Callee_save_registers win)
(va_wpProof_Callee_save_registers win)) | {
"checked_file": "Vale.X64.Stack.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.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.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Stack.fsti"
} | [
"total"
] | [
"Prims.bool",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.X64.Stack.va_code_Callee_save_registers",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_stackTaint",
"Vale.X64.QuickCode.va_Mod_reg64",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.QuickCode.va_Mod_stack",
"Prims.Nil",
"Vale.X64.Stack.va_wp_Callee_save_registers",
"Vale.X64.Stack.va_wpProof_Callee_save_registers",
"Vale.X64.QuickCode.va_quickCode"
] | [] | module Vale.X64.Stack
//open Vale.Def.Opaque_s
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
open Vale.Arch.Types
//open Vale.AES.GCM_helpers
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.InsVector
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
#reset-options "--z3rlimit 30"
//-- Callee_save_registers
val va_code_Callee_save_registers : win:bool -> Tot va_code
val va_codegen_success_Callee_save_registers : win:bool -> Tot va_pbool
val va_lemma_Callee_save_registers : va_b0:va_code -> va_s0:va_state -> win:bool
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Callee_save_registers win) va_s0 /\ va_get_ok va_s0 /\
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ sse_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(forall i . Vale.X64.Stack_i.valid_src_stack64 i (va_get_stack va_s0) /\ va_get_reg64 rRsp
va_sM + (if win then 224 else 64) <= i ==> Vale.X64.Stack_i.load_stack64 i (va_get_stack va_sM)
== Vale.X64.Stack_i.load_stack64 i (va_get_stack va_s0)) /\ va_get_reg64 rRbx va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM) (va_get_stack va_sM) /\ va_get_reg64
rRbp va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 8) (va_get_stack va_sM)
/\ va_get_reg64 rRdi va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 16)
(va_get_stack va_sM) /\ va_get_reg64 rRsi va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64
rRsp va_sM + 24) (va_get_stack va_sM) /\ va_get_reg64 rR12 va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 32) (va_get_stack va_sM) /\
va_get_reg64 rR13 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 40)
(va_get_stack va_sM) /\ va_get_reg64 rR14 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64
rRsp va_sM + 48) (va_get_stack va_sM) /\ va_get_reg64 rR15 va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 56) (va_get_stack va_sM) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 6 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 64) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 6 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 72) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 7 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 80) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 7 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 88) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 8 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 96) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 8 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 104) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 9 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 112) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 9 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 120) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 10 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 128) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 10 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 136) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 11 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 144) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 11 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 152) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 12 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 160) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 12 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 168) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 13 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 176) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 13 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 184) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 14 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 192) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 14 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 200) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 15 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 208) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 15 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 216) (va_get_stack va_sM)) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_reg64 rRax va_sM (va_update_reg64 rRsp
va_sM (va_update_stack va_sM (va_update_ok va_sM va_s0)))))))
[@ va_qattr]
let va_wp_Callee_save_registers (win:bool) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) :
Type0 =
(va_get_ok va_s0 /\ va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
sse_enabled /\ (forall (va_x_stack:vale_stack) (va_x_rsp:nat64) (va_x_rax:nat64)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_reg64 rRax
va_x_rax (va_upd_reg64 rRsp va_x_rsp (va_upd_stack va_x_stack va_s0))) in va_get_ok va_sM /\
(forall i . Vale.X64.Stack_i.valid_src_stack64 i (va_get_stack va_s0) /\ va_get_reg64 rRsp
va_sM + va_if win (fun _ -> 224) (fun _ -> 64) <= i ==> Vale.X64.Stack_i.load_stack64 i
(va_get_stack va_sM) == Vale.X64.Stack_i.load_stack64 i (va_get_stack va_s0)) /\ va_get_reg64
rRbx va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM) (va_get_stack va_sM) /\
va_get_reg64 rRbp va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 8)
(va_get_stack va_sM) /\ va_get_reg64 rRdi va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64
rRsp va_sM + 16) (va_get_stack va_sM) /\ va_get_reg64 rRsi va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 24) (va_get_stack va_sM) /\
va_get_reg64 rR12 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 32)
(va_get_stack va_sM) /\ va_get_reg64 rR13 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64
rRsp va_sM + 40) (va_get_stack va_sM) /\ va_get_reg64 rR14 va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 48) (va_get_stack va_sM) /\
va_get_reg64 rR15 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 56)
(va_get_stack va_sM) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 6 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 64) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 6 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 72) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 7 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 80) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 7 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 88) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 8 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 96) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 8 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 104) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 9 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 112) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 9 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 120) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 10 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 128) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 10 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 136) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 11 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 144) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 11 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 152) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 12 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 160) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 12 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 168) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 13 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 176) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 13 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 184) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 14 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 192) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 14 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 200) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 15 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 208) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 15 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 216) (va_get_stack va_sM)) ==> va_k va_sM (())))
val va_wpProof_Callee_save_registers : win:bool -> va_s0:va_state -> va_k:(va_state -> unit ->
Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Callee_save_registers win va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Callee_save_registers win)
([va_Mod_stackTaint; va_Mod_reg64 rRax; va_Mod_reg64 rRsp; va_Mod_stack]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Callee_save_registers (win:bool) : (va_quickCode unit (va_code_Callee_save_registers | false | false | Vale.X64.Stack.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": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Callee_save_registers (win: bool)
: (va_quickCode unit (va_code_Callee_save_registers win)) | [] | Vale.X64.Stack.va_quick_Callee_save_registers | {
"file_name": "obj/Vale.X64.Stack.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | win: Prims.bool
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.X64.Stack.va_code_Callee_save_registers win) | {
"end_col": 43,
"end_line": 142,
"start_col": 2,
"start_line": 140
} |
Prims.Tot | val va_quick_Callee_restore_registers
(win: bool)
(old_xmm6 old_xmm7 old_xmm8 old_xmm9 old_xmm10 old_xmm11 old_xmm12 old_xmm13 old_xmm14 old_xmm15:
quad32)
: (va_quickCode unit (va_code_Callee_restore_registers win)) | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"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.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"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.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"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.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsStack",
"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.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let va_quick_Callee_restore_registers (win:bool) (old_xmm6:quad32) (old_xmm7:quad32)
(old_xmm8:quad32) (old_xmm9:quad32) (old_xmm10:quad32) (old_xmm11:quad32) (old_xmm12:quad32)
(old_xmm13:quad32) (old_xmm14:quad32) (old_xmm15:quad32) : (va_quickCode unit
(va_code_Callee_restore_registers win)) =
(va_QProc (va_code_Callee_restore_registers win) ([va_Mod_stack; va_Mod_reg64 rRsp; va_Mod_xmm
15; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12; va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9;
va_Mod_xmm 8; va_Mod_xmm 7; va_Mod_xmm 6; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64
rR13; va_Mod_reg64 rR12; va_Mod_reg64 rRsi; va_Mod_reg64 rRdi; va_Mod_reg64 rRbp; va_Mod_reg64
rRbx; va_Mod_reg64 rRax]) (va_wp_Callee_restore_registers win old_xmm6 old_xmm7 old_xmm8
old_xmm9 old_xmm10 old_xmm11 old_xmm12 old_xmm13 old_xmm14 old_xmm15)
(va_wpProof_Callee_restore_registers win old_xmm6 old_xmm7 old_xmm8 old_xmm9 old_xmm10
old_xmm11 old_xmm12 old_xmm13 old_xmm14 old_xmm15)) | val va_quick_Callee_restore_registers
(win: bool)
(old_xmm6 old_xmm7 old_xmm8 old_xmm9 old_xmm10 old_xmm11 old_xmm12 old_xmm13 old_xmm14 old_xmm15:
quad32)
: (va_quickCode unit (va_code_Callee_restore_registers win))
let va_quick_Callee_restore_registers
(win: bool)
(old_xmm6 old_xmm7 old_xmm8 old_xmm9 old_xmm10 old_xmm11 old_xmm12 old_xmm13 old_xmm14 old_xmm15:
quad32)
: (va_quickCode unit (va_code_Callee_restore_registers win)) = | false | null | false | (va_QProc (va_code_Callee_restore_registers win)
([
va_Mod_stack; va_Mod_reg64 rRsp; va_Mod_xmm 15; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12;
va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_xmm 8; va_Mod_xmm 7; va_Mod_xmm 6;
va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR12;
va_Mod_reg64 rRsi; va_Mod_reg64 rRdi; va_Mod_reg64 rRbp; va_Mod_reg64 rRbx;
va_Mod_reg64 rRax
])
(va_wp_Callee_restore_registers win old_xmm6 old_xmm7 old_xmm8 old_xmm9 old_xmm10 old_xmm11
old_xmm12 old_xmm13 old_xmm14 old_xmm15)
(va_wpProof_Callee_restore_registers win old_xmm6 old_xmm7 old_xmm8 old_xmm9 old_xmm10 old_xmm11
old_xmm12 old_xmm13 old_xmm14 old_xmm15)) | {
"checked_file": "Vale.X64.Stack.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.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.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Stack.fsti"
} | [
"total"
] | [
"Prims.bool",
"Vale.X64.Decls.quad32",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.X64.Stack.va_code_Callee_restore_registers",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_stack",
"Vale.X64.QuickCode.va_Mod_reg64",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.QuickCode.va_Mod_xmm",
"Vale.X64.Machine_s.rR15",
"Vale.X64.Machine_s.rR14",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rR12",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRdi",
"Vale.X64.Machine_s.rRbp",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rRax",
"Prims.Nil",
"Vale.X64.Stack.va_wp_Callee_restore_registers",
"Vale.X64.Stack.va_wpProof_Callee_restore_registers",
"Vale.X64.QuickCode.va_quickCode"
] | [] | module Vale.X64.Stack
//open Vale.Def.Opaque_s
open FStar.Seq
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
open Vale.Arch.Types
//open Vale.AES.GCM_helpers
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.InsVector
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
#reset-options "--z3rlimit 30"
//-- Callee_save_registers
val va_code_Callee_save_registers : win:bool -> Tot va_code
val va_codegen_success_Callee_save_registers : win:bool -> Tot va_pbool
val va_lemma_Callee_save_registers : va_b0:va_code -> va_s0:va_state -> win:bool
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Callee_save_registers win) va_s0 /\ va_get_ok va_s0 /\
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ sse_enabled))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(forall i . Vale.X64.Stack_i.valid_src_stack64 i (va_get_stack va_s0) /\ va_get_reg64 rRsp
va_sM + (if win then 224 else 64) <= i ==> Vale.X64.Stack_i.load_stack64 i (va_get_stack va_sM)
== Vale.X64.Stack_i.load_stack64 i (va_get_stack va_s0)) /\ va_get_reg64 rRbx va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM) (va_get_stack va_sM) /\ va_get_reg64
rRbp va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 8) (va_get_stack va_sM)
/\ va_get_reg64 rRdi va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 16)
(va_get_stack va_sM) /\ va_get_reg64 rRsi va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64
rRsp va_sM + 24) (va_get_stack va_sM) /\ va_get_reg64 rR12 va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 32) (va_get_stack va_sM) /\
va_get_reg64 rR13 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 40)
(va_get_stack va_sM) /\ va_get_reg64 rR14 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64
rRsp va_sM + 48) (va_get_stack va_sM) /\ va_get_reg64 rR15 va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 56) (va_get_stack va_sM) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 6 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 64) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 6 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 72) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 7 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 80) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 7 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 88) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 8 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 96) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 8 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 104) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 9 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 112) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 9 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 120) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 10 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 128) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 10 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 136) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 11 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 144) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 11 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 152) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 12 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 160) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 12 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 168) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 13 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 176) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 13 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 184) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 14 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 192) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 14 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 200) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.hi64 (va_get_xmm 15 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 208) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.lo64 (va_get_xmm 15 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 216) (va_get_stack va_sM)) /\
va_state_eq va_sM (va_update_stackTaint va_sM (va_update_reg64 rRax va_sM (va_update_reg64 rRsp
va_sM (va_update_stack va_sM (va_update_ok va_sM va_s0)))))))
[@ va_qattr]
let va_wp_Callee_save_registers (win:bool) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) :
Type0 =
(va_get_ok va_s0 /\ va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
sse_enabled /\ (forall (va_x_stack:vale_stack) (va_x_rsp:nat64) (va_x_rax:nat64)
(va_x_stackTaint:memtaint) . let va_sM = va_upd_stackTaint va_x_stackTaint (va_upd_reg64 rRax
va_x_rax (va_upd_reg64 rRsp va_x_rsp (va_upd_stack va_x_stack va_s0))) in va_get_ok va_sM /\
(forall i . Vale.X64.Stack_i.valid_src_stack64 i (va_get_stack va_s0) /\ va_get_reg64 rRsp
va_sM + va_if win (fun _ -> 224) (fun _ -> 64) <= i ==> Vale.X64.Stack_i.load_stack64 i
(va_get_stack va_sM) == Vale.X64.Stack_i.load_stack64 i (va_get_stack va_s0)) /\ va_get_reg64
rRbx va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM) (va_get_stack va_sM) /\
va_get_reg64 rRbp va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 8)
(va_get_stack va_sM) /\ va_get_reg64 rRdi va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64
rRsp va_sM + 16) (va_get_stack va_sM) /\ va_get_reg64 rRsi va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 24) (va_get_stack va_sM) /\
va_get_reg64 rR12 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 32)
(va_get_stack va_sM) /\ va_get_reg64 rR13 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64
rRsp va_sM + 40) (va_get_stack va_sM) /\ va_get_reg64 rR14 va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 48) (va_get_stack va_sM) /\
va_get_reg64 rR15 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 56)
(va_get_stack va_sM) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 6 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 64) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 6 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 72) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 7 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 80) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 7 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 88) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 8 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 96) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 8 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 104) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 9 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 112) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 9 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 120) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 10 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 128) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 10 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 136) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 11 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 144) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 11 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 152) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 12 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 160) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 12 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 168) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 13 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 176) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 13 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 184) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 14 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 192) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 14 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 200) (va_get_stack va_sM)) /\ (win ==> Vale.Arch.Types.hi64 (va_get_xmm 15 va_sM) ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_sM + 208) (va_get_stack va_sM)) /\ (win ==>
Vale.Arch.Types.lo64 (va_get_xmm 15 va_sM) == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp
va_sM + 216) (va_get_stack va_sM)) ==> va_k va_sM (())))
val va_wpProof_Callee_save_registers : win:bool -> va_s0:va_state -> va_k:(va_state -> unit ->
Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Callee_save_registers win va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Callee_save_registers win)
([va_Mod_stackTaint; va_Mod_reg64 rRax; va_Mod_reg64 rRsp; va_Mod_stack]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Callee_save_registers (win:bool) : (va_quickCode unit (va_code_Callee_save_registers
win)) =
(va_QProc (va_code_Callee_save_registers win) ([va_Mod_stackTaint; va_Mod_reg64 rRax;
va_Mod_reg64 rRsp; va_Mod_stack]) (va_wp_Callee_save_registers win)
(va_wpProof_Callee_save_registers win))
//--
//-- Callee_restore_registers
val va_code_Callee_restore_registers : win:bool -> Tot va_code
val va_codegen_success_Callee_restore_registers : win:bool -> Tot va_pbool
val va_lemma_Callee_restore_registers : va_b0:va_code -> va_s0:va_state -> win:bool ->
old_xmm6:quad32 -> old_xmm7:quad32 -> old_xmm8:quad32 -> old_xmm9:quad32 -> old_xmm10:quad32 ->
old_xmm11:quad32 -> old_xmm12:quad32 -> old_xmm13:quad32 -> old_xmm14:quad32 -> old_xmm15:quad32
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Callee_restore_registers win) va_s0 /\ va_get_ok va_s0
/\ sse_enabled /\ (forall i . va_get_reg64 rRsp va_s0 <= i /\ i <= va_get_reg64 rRsp va_s0 +
(if win then 216 else 56) ==> Vale.X64.Stack_i.valid_stack_slot64 i (va_get_stack va_s0) Public
(va_get_stackTaint va_s0)) /\ va_get_reg64 rRsp va_s0 >= Vale.X64.Stack_i.init_rsp
(va_get_stack va_s0) - 4096 /\ va_get_reg64 rRsp va_s0 + (if win then 224 else 64) <=
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ (win ==> Vale.Arch.Types.hi64 old_xmm6 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 64) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.lo64 old_xmm6 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 72)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.hi64 old_xmm7 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 80) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.lo64 old_xmm7 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 88)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.hi64 old_xmm8 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 96) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.lo64 old_xmm8 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 104)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.hi64 old_xmm9 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 112) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.lo64 old_xmm9 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 120)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.hi64 old_xmm10 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 128) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.lo64 old_xmm10 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 136)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.hi64 old_xmm11 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 144) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.lo64 old_xmm11 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 152)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.hi64 old_xmm12 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 160) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.lo64 old_xmm12 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 168)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.hi64 old_xmm13 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 176) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.lo64 old_xmm13 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 184)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.hi64 old_xmm14 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 192) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.lo64 old_xmm14 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 200)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.hi64 old_xmm15 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 208) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.lo64 old_xmm15 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 216)
(va_get_stack va_s0))))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_get_reg64 rRbx va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0)
(va_get_stack va_s0) /\ va_get_reg64 rRbp va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64
rRsp va_s0 + 8) (va_get_stack va_s0) /\ va_get_reg64 rRdi va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 16) (va_get_stack va_s0) /\
va_get_reg64 rRsi va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 24)
(va_get_stack va_s0) /\ va_get_reg64 rR12 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64
rRsp va_s0 + 32) (va_get_stack va_s0) /\ va_get_reg64 rR13 va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 40) (va_get_stack va_s0) /\
va_get_reg64 rR14 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 48)
(va_get_stack va_s0) /\ va_get_reg64 rR15 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64
rRsp va_s0 + 56) (va_get_stack va_s0) /\ (win ==> va_get_xmm 6 va_sM == old_xmm6) /\ (win ==>
va_get_xmm 7 va_sM == old_xmm7) /\ (win ==> va_get_xmm 8 va_sM == old_xmm8) /\ (win ==>
va_get_xmm 9 va_sM == old_xmm9) /\ (win ==> va_get_xmm 10 va_sM == old_xmm10) /\ (win ==>
va_get_xmm 11 va_sM == old_xmm11) /\ (win ==> va_get_xmm 12 va_sM == old_xmm12) /\ (win ==>
va_get_xmm 13 va_sM == old_xmm13) /\ (win ==> va_get_xmm 14 va_sM == old_xmm14) /\ (win ==>
va_get_xmm 15 va_sM == old_xmm15) /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0 + (if
win then 224 else 64) /\ va_get_stack va_sM == Vale.X64.Stack_i.free_stack64 (va_get_reg64 rRsp
va_s0) (va_get_reg64 rRsp va_s0 + (if win then 224 else 64)) (va_get_stack va_s0) /\
va_state_eq va_sM (va_update_stack va_sM (va_update_reg64 rRsp va_sM (va_update_xmm 15 va_sM
(va_update_xmm 14 va_sM (va_update_xmm 13 va_sM (va_update_xmm 12 va_sM (va_update_xmm 11 va_sM
(va_update_xmm 10 va_sM (va_update_xmm 9 va_sM (va_update_xmm 8 va_sM (va_update_xmm 7 va_sM
(va_update_xmm 6 va_sM (va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64
rR13 va_sM (va_update_reg64 rR12 va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRbp va_sM (va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM
(va_update_ok va_sM va_s0))))))))))))))))))))))))
[@ va_qattr]
let va_wp_Callee_restore_registers (win:bool) (old_xmm6:quad32) (old_xmm7:quad32) (old_xmm8:quad32)
(old_xmm9:quad32) (old_xmm10:quad32) (old_xmm11:quad32) (old_xmm12:quad32) (old_xmm13:quad32)
(old_xmm14:quad32) (old_xmm15:quad32) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0
=
(va_get_ok va_s0 /\ sse_enabled /\ (forall i . va_get_reg64 rRsp va_s0 <= i /\ i <= va_get_reg64
rRsp va_s0 + va_if win (fun _ -> 216) (fun _ -> 56) ==> Vale.X64.Stack_i.valid_stack_slot64 i
(va_get_stack va_s0) Public (va_get_stackTaint va_s0)) /\ va_get_reg64 rRsp va_s0 >=
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) - 4096 /\ va_get_reg64 rRsp va_s0 + va_if win
(fun _ -> 224) (fun _ -> 64) <= Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ (win ==>
Vale.Arch.Types.hi64 old_xmm6 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 64)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.lo64 old_xmm6 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 72) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.hi64 old_xmm7 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 80)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.lo64 old_xmm7 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 88) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.hi64 old_xmm8 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 96)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.lo64 old_xmm8 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 104) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.hi64 old_xmm9 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 112)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.lo64 old_xmm9 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 120) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.hi64 old_xmm10 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 128)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.lo64 old_xmm10 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 136) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.hi64 old_xmm11 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 144)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.lo64 old_xmm11 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 152) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.hi64 old_xmm12 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 160)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.lo64 old_xmm12 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 168) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.hi64 old_xmm13 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 176)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.lo64 old_xmm13 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 184) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.hi64 old_xmm14 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 192)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.lo64 old_xmm14 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 200) (va_get_stack va_s0)) /\ (win ==>
Vale.Arch.Types.hi64 old_xmm15 == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 208)
(va_get_stack va_s0)) /\ (win ==> Vale.Arch.Types.lo64 old_xmm15 ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 216) (va_get_stack va_s0)) /\ (forall
(va_x_rax:nat64) (va_x_rbx:nat64) (va_x_rbp:nat64) (va_x_rdi:nat64) (va_x_rsi:nat64)
(va_x_r12:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_xmm6:quad32)
(va_x_xmm7:quad32) (va_x_xmm8:quad32) (va_x_xmm9:quad32) (va_x_xmm10:quad32)
(va_x_xmm11:quad32) (va_x_xmm12:quad32) (va_x_xmm13:quad32) (va_x_xmm14:quad32)
(va_x_xmm15:quad32) (va_x_rsp:nat64) (va_x_stack:vale_stack) . let va_sM = va_upd_stack
va_x_stack (va_upd_reg64 rRsp va_x_rsp (va_upd_xmm 15 va_x_xmm15 (va_upd_xmm 14 va_x_xmm14
(va_upd_xmm 13 va_x_xmm13 (va_upd_xmm 12 va_x_xmm12 (va_upd_xmm 11 va_x_xmm11 (va_upd_xmm 10
va_x_xmm10 (va_upd_xmm 9 va_x_xmm9 (va_upd_xmm 8 va_x_xmm8 (va_upd_xmm 7 va_x_xmm7 (va_upd_xmm
6 va_x_xmm6 (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR12 va_x_r12 (va_upd_reg64 rRsi va_x_rsi (va_upd_reg64 rRdi va_x_rdi
(va_upd_reg64 rRbp va_x_rbp (va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax
va_s0)))))))))))))))))))) in va_get_ok va_sM /\ va_get_reg64 rRbx va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0) (va_get_stack va_s0) /\ va_get_reg64
rRbp va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 8) (va_get_stack va_s0)
/\ va_get_reg64 rRdi va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 16)
(va_get_stack va_s0) /\ va_get_reg64 rRsi va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64
rRsp va_s0 + 24) (va_get_stack va_s0) /\ va_get_reg64 rR12 va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 32) (va_get_stack va_s0) /\
va_get_reg64 rR13 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 40)
(va_get_stack va_s0) /\ va_get_reg64 rR14 va_sM == Vale.X64.Stack_i.load_stack64 (va_get_reg64
rRsp va_s0 + 48) (va_get_stack va_s0) /\ va_get_reg64 rR15 va_sM ==
Vale.X64.Stack_i.load_stack64 (va_get_reg64 rRsp va_s0 + 56) (va_get_stack va_s0) /\ (win ==>
va_get_xmm 6 va_sM == old_xmm6) /\ (win ==> va_get_xmm 7 va_sM == old_xmm7) /\ (win ==>
va_get_xmm 8 va_sM == old_xmm8) /\ (win ==> va_get_xmm 9 va_sM == old_xmm9) /\ (win ==>
va_get_xmm 10 va_sM == old_xmm10) /\ (win ==> va_get_xmm 11 va_sM == old_xmm11) /\ (win ==>
va_get_xmm 12 va_sM == old_xmm12) /\ (win ==> va_get_xmm 13 va_sM == old_xmm13) /\ (win ==>
va_get_xmm 14 va_sM == old_xmm14) /\ (win ==> va_get_xmm 15 va_sM == old_xmm15) /\ va_get_reg64
rRsp va_sM == va_get_reg64 rRsp va_s0 + va_if win (fun _ -> 224) (fun _ -> 64) /\ va_get_stack
va_sM == Vale.X64.Stack_i.free_stack64 (va_get_reg64 rRsp va_s0) (va_get_reg64 rRsp va_s0 +
va_if win (fun _ -> 224) (fun _ -> 64)) (va_get_stack va_s0) ==> va_k va_sM (())))
val va_wpProof_Callee_restore_registers : win:bool -> old_xmm6:quad32 -> old_xmm7:quad32 ->
old_xmm8:quad32 -> old_xmm9:quad32 -> old_xmm10:quad32 -> old_xmm11:quad32 -> old_xmm12:quad32 ->
old_xmm13:quad32 -> old_xmm14:quad32 -> old_xmm15:quad32 -> va_s0:va_state -> va_k:(va_state ->
unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Callee_restore_registers win old_xmm6 old_xmm7 old_xmm8
old_xmm9 old_xmm10 old_xmm11 old_xmm12 old_xmm13 old_xmm14 old_xmm15 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Callee_restore_registers win)
([va_Mod_stack; va_Mod_reg64 rRsp; va_Mod_xmm 15; va_Mod_xmm 14; va_Mod_xmm 13; va_Mod_xmm 12;
va_Mod_xmm 11; va_Mod_xmm 10; va_Mod_xmm 9; va_Mod_xmm 8; va_Mod_xmm 7; va_Mod_xmm 6;
va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR12; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdi; va_Mod_reg64 rRbp; va_Mod_reg64 rRbx; va_Mod_reg64 rRax]) va_s0 va_k
((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Callee_restore_registers (win:bool) (old_xmm6:quad32) (old_xmm7:quad32)
(old_xmm8:quad32) (old_xmm9:quad32) (old_xmm10:quad32) (old_xmm11:quad32) (old_xmm12:quad32)
(old_xmm13:quad32) (old_xmm14:quad32) (old_xmm15:quad32) : (va_quickCode unit | false | false | Vale.X64.Stack.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": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_Callee_restore_registers
(win: bool)
(old_xmm6 old_xmm7 old_xmm8 old_xmm9 old_xmm10 old_xmm11 old_xmm12 old_xmm13 old_xmm14 old_xmm15:
quad32)
: (va_quickCode unit (va_code_Callee_restore_registers win)) | [] | Vale.X64.Stack.va_quick_Callee_restore_registers | {
"file_name": "obj/Vale.X64.Stack.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
win: Prims.bool ->
old_xmm6: Vale.X64.Decls.quad32 ->
old_xmm7: Vale.X64.Decls.quad32 ->
old_xmm8: Vale.X64.Decls.quad32 ->
old_xmm9: Vale.X64.Decls.quad32 ->
old_xmm10: Vale.X64.Decls.quad32 ->
old_xmm11: Vale.X64.Decls.quad32 ->
old_xmm12: Vale.X64.Decls.quad32 ->
old_xmm13: Vale.X64.Decls.quad32 ->
old_xmm14: Vale.X64.Decls.quad32 ->
old_xmm15: Vale.X64.Decls.quad32
-> Vale.X64.QuickCode.va_quickCode Prims.unit
(Vale.X64.Stack.va_code_Callee_restore_registers win) | {
"end_col": 55,
"end_line": 312,
"start_col": 2,
"start_line": 305
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Lowstarize",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": 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 siggen_vectors512_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_512 | let siggen_vectors512_tmp = | false | null | false | List.Tot.map (fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_512 | {
"checked_file": "Hacl.Test.ECDSA.fst.checked",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.P256.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int32.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"C.String.fsti.checked",
"C.Loops.fst.checked",
"C.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Test.ECDSA.fst"
} | [
"total"
] | [
"FStar.List.Tot.Base.map",
"Spec.ECDSA.Test.Vectors.vec_SigGen",
"FStar.Pervasives.Native.tuple7",
"Test.Lowstarize.hex_encoded",
"FStar.Pervasives.Native.Mktuple7",
"Test.Lowstarize.h",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigGen__item__msg'",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigGen__item__d",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigGen__item__qx'",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigGen__item__qy'",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigGen__item__k",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigGen__item__r'",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigGen__item__s'",
"Spec.ECDSA.Test.Vectors.siggen_vectors_sha2_512"
] | [] | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
noextract
let sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_256
noextract
let sigver_vectors384_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_384
noextract
let sigver_vectors512_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_512
noextract
let siggen_vectors256_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_256
noextract
let siggen_vectors384_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_384 | false | true | Hacl.Test.ECDSA.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": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val siggen_vectors512_tmp : Prims.list ((((((Test.Lowstarize.hex_encoded * Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) | [] | Hacl.Test.ECDSA.siggen_vectors512_tmp | {
"file_name": "code/tests/Hacl.Test.ECDSA.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.list ((((((Test.Lowstarize.hex_encoded * Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) | {
"end_col": 25,
"end_line": 46,
"start_col": 28,
"start_line": 44
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Lowstarize",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": 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 sigver_vectors384_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_384 | let sigver_vectors384_tmp = | false | null | false | List.Tot.map (fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result) sigver_vectors_sha2_384 | {
"checked_file": "Hacl.Test.ECDSA.fst.checked",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.P256.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int32.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"C.String.fsti.checked",
"C.Loops.fst.checked",
"C.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Test.ECDSA.fst"
} | [
"total"
] | [
"FStar.List.Tot.Base.map",
"Spec.ECDSA.Test.Vectors.vec_SigVer",
"FStar.Pervasives.Native.tuple6",
"Test.Lowstarize.hex_encoded",
"Prims.bool",
"FStar.Pervasives.Native.Mktuple6",
"Test.Lowstarize.h",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigVer__item__msg",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigVer__item__qx",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigVer__item__qy",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigVer__item__r",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigVer__item__s",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigVer__item__result",
"Spec.ECDSA.Test.Vectors.sigver_vectors_sha2_384"
] | [] | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
noextract
let sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_256 | false | true | Hacl.Test.ECDSA.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": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val sigver_vectors384_tmp : Prims.list (((((Test.Lowstarize.hex_encoded * Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Prims.bool) | [] | Hacl.Test.ECDSA.sigver_vectors384_tmp | {
"file_name": "code/tests/Hacl.Test.ECDSA.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.list (((((Test.Lowstarize.hex_encoded * Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Prims.bool) | {
"end_col": 25,
"end_line": 25,
"start_col": 28,
"start_line": 23
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Lowstarize",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": 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 sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_256 | let sigver_vectors256_tmp = | false | null | false | List.Tot.map (fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result) sigver_vectors_sha2_256 | {
"checked_file": "Hacl.Test.ECDSA.fst.checked",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.P256.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int32.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"C.String.fsti.checked",
"C.Loops.fst.checked",
"C.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Test.ECDSA.fst"
} | [
"total"
] | [
"FStar.List.Tot.Base.map",
"Spec.ECDSA.Test.Vectors.vec_SigVer",
"FStar.Pervasives.Native.tuple6",
"Test.Lowstarize.hex_encoded",
"Prims.bool",
"FStar.Pervasives.Native.Mktuple6",
"Test.Lowstarize.h",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigVer__item__msg",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigVer__item__qx",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigVer__item__qy",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigVer__item__r",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigVer__item__s",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigVer__item__result",
"Spec.ECDSA.Test.Vectors.sigver_vectors_sha2_256"
] | [] | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100" | false | true | Hacl.Test.ECDSA.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": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val sigver_vectors256_tmp : Prims.list (((((Test.Lowstarize.hex_encoded * Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Prims.bool) | [] | Hacl.Test.ECDSA.sigver_vectors256_tmp | {
"file_name": "code/tests/Hacl.Test.ECDSA.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.list (((((Test.Lowstarize.hex_encoded * Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Prims.bool) | {
"end_col": 25,
"end_line": 20,
"start_col": 28,
"start_line": 18
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Lowstarize",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": 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 siggen_vectors384_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_384 | let siggen_vectors384_tmp = | false | null | false | List.Tot.map (fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_384 | {
"checked_file": "Hacl.Test.ECDSA.fst.checked",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.P256.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int32.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"C.String.fsti.checked",
"C.Loops.fst.checked",
"C.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Test.ECDSA.fst"
} | [
"total"
] | [
"FStar.List.Tot.Base.map",
"Spec.ECDSA.Test.Vectors.vec_SigGen",
"FStar.Pervasives.Native.tuple7",
"Test.Lowstarize.hex_encoded",
"FStar.Pervasives.Native.Mktuple7",
"Test.Lowstarize.h",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigGen__item__msg'",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigGen__item__d",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigGen__item__qx'",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigGen__item__qy'",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigGen__item__k",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigGen__item__r'",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigGen__item__s'",
"Spec.ECDSA.Test.Vectors.siggen_vectors_sha2_384"
] | [] | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
noextract
let sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_256
noextract
let sigver_vectors384_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_384
noextract
let sigver_vectors512_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_512
noextract
let siggen_vectors256_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_256 | false | true | Hacl.Test.ECDSA.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": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val siggen_vectors384_tmp : Prims.list ((((((Test.Lowstarize.hex_encoded * Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) | [] | Hacl.Test.ECDSA.siggen_vectors384_tmp | {
"file_name": "code/tests/Hacl.Test.ECDSA.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.list ((((((Test.Lowstarize.hex_encoded * Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) | {
"end_col": 25,
"end_line": 41,
"start_col": 28,
"start_line": 39
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Lowstarize",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": 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 sigver_vectors512_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_512 | let sigver_vectors512_tmp = | false | null | false | List.Tot.map (fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result) sigver_vectors_sha2_512 | {
"checked_file": "Hacl.Test.ECDSA.fst.checked",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.P256.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int32.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"C.String.fsti.checked",
"C.Loops.fst.checked",
"C.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Test.ECDSA.fst"
} | [
"total"
] | [
"FStar.List.Tot.Base.map",
"Spec.ECDSA.Test.Vectors.vec_SigVer",
"FStar.Pervasives.Native.tuple6",
"Test.Lowstarize.hex_encoded",
"Prims.bool",
"FStar.Pervasives.Native.Mktuple6",
"Test.Lowstarize.h",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigVer__item__msg",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigVer__item__qx",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigVer__item__qy",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigVer__item__r",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigVer__item__s",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigVer__item__result",
"Spec.ECDSA.Test.Vectors.sigver_vectors_sha2_512"
] | [] | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
noextract
let sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_256
noextract
let sigver_vectors384_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_384 | false | true | Hacl.Test.ECDSA.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": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val sigver_vectors512_tmp : Prims.list (((((Test.Lowstarize.hex_encoded * Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Prims.bool) | [] | Hacl.Test.ECDSA.sigver_vectors512_tmp | {
"file_name": "code/tests/Hacl.Test.ECDSA.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.list (((((Test.Lowstarize.hex_encoded * Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Prims.bool) | {
"end_col": 25,
"end_line": 30,
"start_col": 28,
"start_line": 28
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Lowstarize",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": 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 siggen_vectors256_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_256 | let siggen_vectors256_tmp = | false | null | false | List.Tot.map (fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_256 | {
"checked_file": "Hacl.Test.ECDSA.fst.checked",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.P256.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int32.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"C.String.fsti.checked",
"C.Loops.fst.checked",
"C.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Test.ECDSA.fst"
} | [
"total"
] | [
"FStar.List.Tot.Base.map",
"Spec.ECDSA.Test.Vectors.vec_SigGen",
"FStar.Pervasives.Native.tuple7",
"Test.Lowstarize.hex_encoded",
"FStar.Pervasives.Native.Mktuple7",
"Test.Lowstarize.h",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigGen__item__msg'",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigGen__item__d",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigGen__item__qx'",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigGen__item__qy'",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigGen__item__k",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigGen__item__r'",
"Spec.ECDSA.Test.Vectors.__proj__Mkvec_SigGen__item__s'",
"Spec.ECDSA.Test.Vectors.siggen_vectors_sha2_256"
] | [] | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
noextract
let sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_256
noextract
let sigver_vectors384_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_384
noextract
let sigver_vectors512_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_512 | false | true | Hacl.Test.ECDSA.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": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val siggen_vectors256_tmp : Prims.list ((((((Test.Lowstarize.hex_encoded * Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) | [] | Hacl.Test.ECDSA.siggen_vectors256_tmp | {
"file_name": "code/tests/Hacl.Test.ECDSA.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.list ((((((Test.Lowstarize.hex_encoded * Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) *
Test.Lowstarize.hex_encoded) | {
"end_col": 25,
"end_line": 36,
"start_col": 28,
"start_line": 34
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Lowstarize",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": 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 siggen_vector = vec8 & vec8 & vec8 & vec8 & vec8 & vec8 & vec8 | let siggen_vector = | false | null | false | vec8 & vec8 & vec8 & vec8 & vec8 & vec8 & vec8 | {
"checked_file": "Hacl.Test.ECDSA.fst.checked",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.P256.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int32.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"C.String.fsti.checked",
"C.Loops.fst.checked",
"C.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Test.ECDSA.fst"
} | [
"total"
] | [
"FStar.Pervasives.Native.tuple7",
"Hacl.Test.ECDSA.vec8"
] | [] | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
noextract
let sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_256
noextract
let sigver_vectors384_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_384
noextract
let sigver_vectors512_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_512
noextract
let siggen_vectors256_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_256
noextract
let siggen_vectors384_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_384
noextract
let siggen_vectors512_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_512
%splice[sigver_vectors256_low]
(lowstarize_toplevel "sigver_vectors256_tmp" "sigver_vectors256_low")
%splice[sigver_vectors384_low]
(lowstarize_toplevel "sigver_vectors384_tmp" "sigver_vectors384_low")
%splice[sigver_vectors512_low]
(lowstarize_toplevel "sigver_vectors512_tmp" "sigver_vectors512_low")
%splice[siggen_vectors256_low]
(lowstarize_toplevel "siggen_vectors256_tmp" "siggen_vectors256_low")
%splice[siggen_vectors384_low]
(lowstarize_toplevel "siggen_vectors384_tmp" "siggen_vectors384_low")
%splice[siggen_vectors512_low]
(lowstarize_toplevel "siggen_vectors512_tmp" "siggen_vectors512_low")
// Cheap alternative to friend Lib.IntTypes needed because Test.Lowstarize uses UInt8.t
assume val declassify_uint8: squash (uint8 == UInt8.t)
let vec8 = L.lbuffer UInt8.t
let sigver_vector = vec8 & vec8 & vec8 & vec8 & vec8 & bool | false | true | Hacl.Test.ECDSA.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": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val siggen_vector : Type0 | [] | Hacl.Test.ECDSA.siggen_vector | {
"file_name": "code/tests/Hacl.Test.ECDSA.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 66,
"end_line": 78,
"start_col": 20,
"start_line": 78
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Lowstarize",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": 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 sigver_vector = vec8 & vec8 & vec8 & vec8 & vec8 & bool | let sigver_vector = | false | null | false | vec8 & vec8 & vec8 & vec8 & vec8 & bool | {
"checked_file": "Hacl.Test.ECDSA.fst.checked",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.P256.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int32.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"C.String.fsti.checked",
"C.Loops.fst.checked",
"C.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Test.ECDSA.fst"
} | [
"total"
] | [
"FStar.Pervasives.Native.tuple6",
"Hacl.Test.ECDSA.vec8",
"Prims.bool"
] | [] | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
noextract
let sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_256
noextract
let sigver_vectors384_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_384
noextract
let sigver_vectors512_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_512
noextract
let siggen_vectors256_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_256
noextract
let siggen_vectors384_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_384
noextract
let siggen_vectors512_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_512
%splice[sigver_vectors256_low]
(lowstarize_toplevel "sigver_vectors256_tmp" "sigver_vectors256_low")
%splice[sigver_vectors384_low]
(lowstarize_toplevel "sigver_vectors384_tmp" "sigver_vectors384_low")
%splice[sigver_vectors512_low]
(lowstarize_toplevel "sigver_vectors512_tmp" "sigver_vectors512_low")
%splice[siggen_vectors256_low]
(lowstarize_toplevel "siggen_vectors256_tmp" "siggen_vectors256_low")
%splice[siggen_vectors384_low]
(lowstarize_toplevel "siggen_vectors384_tmp" "siggen_vectors384_low")
%splice[siggen_vectors512_low]
(lowstarize_toplevel "siggen_vectors512_tmp" "siggen_vectors512_low")
// Cheap alternative to friend Lib.IntTypes needed because Test.Lowstarize uses UInt8.t
assume val declassify_uint8: squash (uint8 == UInt8.t)
let vec8 = L.lbuffer UInt8.t | false | true | Hacl.Test.ECDSA.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": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val sigver_vector : Type0 | [] | Hacl.Test.ECDSA.sigver_vector | {
"file_name": "code/tests/Hacl.Test.ECDSA.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 59,
"end_line": 76,
"start_col": 20,
"start_line": 76
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Lowstarize",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": 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 vec8 = L.lbuffer UInt8.t | let vec8 = | false | null | false | L.lbuffer UInt8.t | {
"checked_file": "Hacl.Test.ECDSA.fst.checked",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.P256.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int32.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"C.String.fsti.checked",
"C.Loops.fst.checked",
"C.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Test.ECDSA.fst"
} | [
"total"
] | [
"Test.Lowstarize.lbuffer",
"FStar.UInt8.t"
] | [] | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
noextract
let sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_256
noextract
let sigver_vectors384_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_384
noextract
let sigver_vectors512_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_512
noextract
let siggen_vectors256_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_256
noextract
let siggen_vectors384_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_384
noextract
let siggen_vectors512_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_512
%splice[sigver_vectors256_low]
(lowstarize_toplevel "sigver_vectors256_tmp" "sigver_vectors256_low")
%splice[sigver_vectors384_low]
(lowstarize_toplevel "sigver_vectors384_tmp" "sigver_vectors384_low")
%splice[sigver_vectors512_low]
(lowstarize_toplevel "sigver_vectors512_tmp" "sigver_vectors512_low")
%splice[siggen_vectors256_low]
(lowstarize_toplevel "siggen_vectors256_tmp" "siggen_vectors256_low")
%splice[siggen_vectors384_low]
(lowstarize_toplevel "siggen_vectors384_tmp" "siggen_vectors384_low")
%splice[siggen_vectors512_low]
(lowstarize_toplevel "siggen_vectors512_tmp" "siggen_vectors512_low")
// Cheap alternative to friend Lib.IntTypes needed because Test.Lowstarize uses UInt8.t
assume val declassify_uint8: squash (uint8 == UInt8.t) | false | true | Hacl.Test.ECDSA.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": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val vec8 : Type0 | [] | Hacl.Test.ECDSA.vec8 | {
"file_name": "code/tests/Hacl.Test.ECDSA.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 28,
"end_line": 74,
"start_col": 11,
"start_line": 74
} |
|
FStar.HyperStack.ST.STATE | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Lowstarize",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": 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 test_many #a (label:C.String.t)
(f:a -> Stack unit (fun _ -> True) (fun _ _ _ -> True)) (vec: L.lbuffer a)
=
C.String.print label;
C.String.(print !$"\n");
let L.LB len vs = vec in
let f (i:UInt32.t{0 <= v i /\ v i < v len}): Stack unit
(requires fun h -> True)
(ensures fun h0 _ h1 -> True)
=
let open LowStar.BufferOps in
B.recall vs;
LowStar.Printf.(printf "ECDSA Test %ul/%ul\n" (i +! 1ul) len done);
f vs.(i)
in
C.Loops.for 0ul len (fun _ _ -> True) f | let test_many
#a
(label: C.String.t)
(f: (a -> Stack unit (fun _ -> True) (fun _ _ _ -> True)))
(vec: L.lbuffer a)
= | true | null | false | C.String.print label;
(let open C.String in print !$"\n");
let L.LB len vs = vec in
let f (i: UInt32.t{0 <= v i /\ v i < v len})
: Stack unit (requires fun h -> True) (ensures fun h0 _ h1 -> True) =
let open LowStar.BufferOps in
B.recall vs;
(let open LowStar.Printf in printf "ECDSA Test %ul/%ul\n" (i +! 1ul) len done);
f vs.(i)
in
C.Loops.for 0ul len (fun _ _ -> True) f | {
"checked_file": "Hacl.Test.ECDSA.fst.checked",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.P256.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int32.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"C.String.fsti.checked",
"C.Loops.fst.checked",
"C.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Test.ECDSA.fst"
} | [] | [
"C.String.t",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_True",
"Test.Lowstarize.lbuffer",
"FStar.UInt32.t",
"LowStar.Buffer.buffer",
"Prims.l_and",
"Prims.eq2",
"LowStar.Monotonic.Buffer.len",
"LowStar.Buffer.trivial_preorder",
"LowStar.Monotonic.Buffer.recallable",
"C.Loops.for",
"FStar.UInt32.__uint_to_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.op_LessThan",
"LowStar.BufferOps.op_Array_Access",
"LowStar.Printf.printf",
"Lib.IntTypes.op_Plus_Bang",
"LowStar.Printf.done",
"LowStar.Monotonic.Buffer.recall",
"C.String.print",
"C.String.op_Bang_Dollar"
] | [] | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
noextract
let sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_256
noextract
let sigver_vectors384_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_384
noextract
let sigver_vectors512_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_512
noextract
let siggen_vectors256_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_256
noextract
let siggen_vectors384_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_384
noextract
let siggen_vectors512_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_512
%splice[sigver_vectors256_low]
(lowstarize_toplevel "sigver_vectors256_tmp" "sigver_vectors256_low")
%splice[sigver_vectors384_low]
(lowstarize_toplevel "sigver_vectors384_tmp" "sigver_vectors384_low")
%splice[sigver_vectors512_low]
(lowstarize_toplevel "sigver_vectors512_tmp" "sigver_vectors512_low")
%splice[siggen_vectors256_low]
(lowstarize_toplevel "siggen_vectors256_tmp" "siggen_vectors256_low")
%splice[siggen_vectors384_low]
(lowstarize_toplevel "siggen_vectors384_tmp" "siggen_vectors384_low")
%splice[siggen_vectors512_low]
(lowstarize_toplevel "siggen_vectors512_tmp" "siggen_vectors512_low")
// Cheap alternative to friend Lib.IntTypes needed because Test.Lowstarize uses UInt8.t
assume val declassify_uint8: squash (uint8 == UInt8.t)
let vec8 = L.lbuffer UInt8.t
let sigver_vector = vec8 & vec8 & vec8 & vec8 & vec8 & bool
let siggen_vector = vec8 & vec8 & vec8 & vec8 & vec8 & vec8 & vec8
// This could replace TestLib.compare_and_print
val compare_and_print: b1:B.buffer UInt8.t -> b2:B.buffer UInt8.t -> len:UInt32.t
-> Stack bool
(requires fun h0 -> B.live h0 b1 /\ B.live h0 b2 /\ B.length b1 == v len /\ B.length b2 == v len)
(ensures fun h0 _ h1 -> B.modifies B.loc_none h0 h1)
let compare_and_print b1 b2 len =
push_frame();
LowStar.Printf.(printf "Expected: %xuy\n" len b1 done);
LowStar.Printf.(printf "Computed: %xuy\n" len b2 done);
let b = Lib.ByteBuffer.lbytes_eq #len b1 b2 in
if b then
LowStar.Printf.(printf "PASS\n" done)
else
LowStar.Printf.(printf "FAIL\n" done);
pop_frame();
b
let test_sigver256 (vec:sigver_vector) : Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
let max_msg_len = 0 in
let LB msg_len msg,
LB qx_len qx,
LB qy_len qy,
LB r_len r,
LB s_len s,
result = vec
in
B.recall msg;
B.recall qx;
B.recall qy;
B.recall r;
B.recall s;
// We need to check this at runtime because Low*-ized vectors don't carry any refinements
if not (qx_len = 32ul && qy_len = 32ul && r_len = 32ul && s_len = 32ul)
then C.exit (-1l)
else
begin
push_frame();
let qxy = B.alloca (u8 0) 64ul in
B.blit qx 0ul qxy 0ul 32ul;
B.blit qy 0ul qxy 32ul 32ul;
let result' = ecdsa_verif_p256_sha2 msg_len msg qxy r s in
if result' = result then ()
else
begin
LowStar.Printf.(printf "FAIL\n" done);
C.exit 1l
end;
pop_frame()
end
let test_sigver384 (vec:sigver_vector) : Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
let max_msg_len = 0 in
let LB msg_len msg,
LB qx_len qx,
LB qy_len qy,
LB r_len r,
LB s_len s,
result = vec
in
B.recall msg;
B.recall qx;
B.recall qy;
B.recall r;
B.recall s;
// We need to check this at runtime because Low*-ized vectors don't carry any refinements
if not (qx_len = 32ul && qy_len = 32ul && r_len = 32ul && s_len = 32ul)
then C.exit (-1l)
else
begin
push_frame();
let qxy = B.alloca (u8 0) 64ul in
B.blit qx 0ul qxy 0ul 32ul;
B.blit qy 0ul qxy 32ul 32ul;
let result' = ecdsa_verif_p256_sha384 msg_len msg qxy r s in
if result' = result then ()
else
begin
LowStar.Printf.(printf "FAIL\n" done);
C.exit 1l
end;
pop_frame()
end
let test_sigver512 (vec:sigver_vector) : Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
let max_msg_len = 0 in
let LB msg_len msg,
LB qx_len qx,
LB qy_len qy,
LB r_len r,
LB s_len s,
result = vec
in
B.recall msg;
B.recall qx;
B.recall qy;
B.recall r;
B.recall s;
// We need to check this at runtime because Low*-ized vectors don't carry any refinements
if not (qx_len = 32ul && qy_len = 32ul && r_len = 32ul && s_len = 32ul)
then C.exit (-1l)
else
begin
push_frame();
let qxy = B.alloca (u8 0) 64ul in
B.blit qx 0ul qxy 0ul 32ul;
B.blit qy 0ul qxy 32ul 32ul;
let result' = ecdsa_verif_p256_sha512 msg_len msg qxy r s in
if result' = result then ()
else
begin
LowStar.Printf.(printf "FAIL\n" done);
C.exit 1l
end;
pop_frame()
end
#push-options "--fuel 1 --ifuel 1 --z3rlimit 200"
val check_bound: b:Lib.Buffer.lbuffer uint8 32ul -> Stack bool
(requires fun h -> Lib.Buffer.live h b)
(ensures fun h0 r h1 ->
h0 == h1 /\
r ==
(
(Lib.ByteSequence.nat_from_bytes_be (Lib.Buffer.as_seq h0 b) > 0) &&
(Lib.ByteSequence.nat_from_bytes_be (Lib.Buffer.as_seq h0 b) <
Spec.P256.order)))
let check_bound b =
let open FStar.Mul in
let open Lib.ByteSequence in
let open Spec.P256 in
[@inline_let]
let q1 = normalize_term (order % pow2 64) in
[@inline_let]
let q2 = normalize_term ((order / pow2 64) % pow2 64) in
[@inline_let]
let q3 = normalize_term ((order / pow2 128) % pow2 64) in
[@inline_let]
let q4 = normalize_term (((order / pow2 128) / pow2 64) % pow2 64) in
assert_norm (pow2 128 * pow2 64 == pow2 192);
assert (order == q1 + pow2 64 * q2 + pow2 128 * q3 + pow2 192 * q4);
let zero = mk_int #U64 #PUB 0 in
let q1 = mk_int #U64 #PUB q1 in
let q2 = mk_int #U64 #PUB q2 in
let q3 = mk_int #U64 #PUB q3 in
let q4 = mk_int #U64 #PUB q4 in
let h0 = get () in
let x1 = Lib.ByteBuffer.uint_from_bytes_be #U64 (Lib.Buffer.sub b 0ul 8ul) in
let x2 = Lib.ByteBuffer.uint_from_bytes_be #U64 (Lib.Buffer.sub b 8ul 8ul) in
let x3 = Lib.ByteBuffer.uint_from_bytes_be #U64 (Lib.Buffer.sub b 16ul 8ul) in
let x4 = Lib.ByteBuffer.uint_from_bytes_be #U64 (Lib.Buffer.sub b 24ul 8ul) in
nat_from_intseq_be_slice_lemma (Lib.Buffer.as_seq h0 b) 8;
lemma_reveal_uint_to_bytes_be #U64 (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 0 8);
nat_from_intseq_be_slice_lemma (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 8 32) 8;
lemma_reveal_uint_to_bytes_be #U64 (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 8 16);
nat_from_intseq_be_slice_lemma (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 16 32) 8;
lemma_reveal_uint_to_bytes_be #U64 (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 16 24);
nat_from_intseq_be_slice_lemma (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 24 32) 8;
lemma_reveal_uint_to_bytes_be #U64 (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 24 32);
let x1 = Lib.RawIntTypes.u64_to_UInt64 x1 in
let x2 = Lib.RawIntTypes.u64_to_UInt64 x2 in
let x3 = Lib.RawIntTypes.u64_to_UInt64 x3 in
let x4 = Lib.RawIntTypes.u64_to_UInt64 x4 in
let r = x1 <. q4 || (x1 =. q4 &&
(x2 <. q3 || (x2 =. q3 &&
(x3 <. q2 || (x3 =. q2 && x4 <. q1))))) in
let r1 = x1 = zero && x2 = zero && x3 = zero && x4 = zero in
r && not r1
#push-options " --ifuel 1 --fuel 1"
let test_siggen_256 (vec:siggen_vector) : Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
let max_msg_len = 0 in
let LB msg_len msg,
LB d_len d,
LB qx_len qx,
LB qy_len qy,
LB k_len k,
LB r_len r,
LB s_len s = vec
in
B.recall msg;
B.recall d;
B.recall qx;
B.recall qy;
B.recall k;
B.recall r;
B.recall s;
if not (k_len = 32ul && d_len = 32ul) then
C.exit (-1l);
let bound_k = check_bound k in
let bound_d = check_bound d in
// We need to check this at runtime because Low*-ized vectors don't carry any refinements
if not (bound_k && bound_d &&
qx_len = 32ul && qy_len = 32ul && r_len = 32ul && s_len = 32ul)
then C.exit (-1l)
else
begin
push_frame();
let rs = B.alloca (u8 0) 64ul in
let qxy = B.alloca (u8 0) 64ul in
B.blit qx 0ul qxy 0ul 32ul;
B.blit qy 0ul qxy 32ul 32ul;
let flag = ecdsa_sign_p256_sha2 rs msg_len msg d k in
if flag then
begin
let okr = compare_and_print (B.sub rs 0ul 32ul) r 32ul in
let oks = compare_and_print (B.sub rs 32ul 32ul) s 32ul in
if okr && oks then
begin
let result = ecdsa_verif_p256_sha2 msg_len msg qxy r s in
if not result then
begin
LowStar.Printf.(printf "FAIL: verification\n" done);
C.exit 1l
end
end
else
begin
LowStar.Printf.(printf "FAIL: signing\n" done);
C.exit 1l
end
end
else
begin
LowStar.Printf.(printf "FAIL: signing\n" done);
C.exit 1l
end;
pop_frame()
end
let test_siggen_384 (vec:siggen_vector) : Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
let max_msg_len = 0 in
let LB msg_len msg,
LB d_len d,
LB qx_len qx,
LB qy_len qy,
LB k_len k,
LB r_len r,
LB s_len s = vec
in
B.recall msg;
B.recall d;
B.recall qx;
B.recall qy;
B.recall k;
B.recall r;
B.recall s;
if not (k_len = 32ul && d_len = 32ul) then
C.exit (-1l);
let bound_k = check_bound k in
let bound_d = check_bound d in
// We need to check this at runtime because Low*-ized vectors don't carry any refinements
if not (bound_k && bound_d &&
qx_len = 32ul && qy_len = 32ul && r_len = 32ul && s_len = 32ul)
then C.exit (-1l)
else
begin
push_frame();
let rs = B.alloca (u8 0) 64ul in
let qxy = B.alloca (u8 0) 64ul in
B.blit qx 0ul qxy 0ul 32ul;
B.blit qy 0ul qxy 32ul 32ul;
let flag = ecdsa_sign_p256_sha384 rs msg_len msg d k in
if flag then
begin
let okr = compare_and_print (B.sub rs 0ul 32ul) r 32ul in
let oks = compare_and_print (B.sub rs 32ul 32ul) s 32ul in
if okr && oks then
begin
let result = ecdsa_verif_p256_sha384 msg_len msg qxy r s in
if not result then
begin
LowStar.Printf.(printf "FAIL: verification\n" done);
C.exit 1l
end
end
else
begin
LowStar.Printf.(printf "FAIL: signing\n" done);
C.exit 1l
end
end
else
begin
LowStar.Printf.(printf "FAIL: signing\n" done);
C.exit 1l
end;
pop_frame()
end
let test_siggen_512 (vec:siggen_vector) : Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
let max_msg_len = 0 in
let LB msg_len msg,
LB d_len d,
LB qx_len qx,
LB qy_len qy,
LB k_len k,
LB r_len r,
LB s_len s = vec
in
B.recall msg;
B.recall d;
B.recall qx;
B.recall qy;
B.recall k;
B.recall r;
B.recall s;
if not (k_len = 32ul && d_len = 32ul) then
C.exit (-1l);
let bound_k = check_bound k in
let bound_d = check_bound d in
// We need to check this at runtime because Low*-ized vectors don't carry any refinements
if not (bound_k && bound_d &&
qx_len = 32ul && qy_len = 32ul && r_len = 32ul && s_len = 32ul)
then C.exit (-1l)
else
begin
push_frame();
let rs = B.alloca (u8 0) 64ul in
let qxy = B.alloca (u8 0) 64ul in
B.blit qx 0ul qxy 0ul 32ul;
B.blit qy 0ul qxy 32ul 32ul;
let flag = ecdsa_sign_p256_sha512 rs msg_len msg d k in
if flag then
begin
let okr = compare_and_print (B.sub rs 0ul 32ul) r 32ul in
let oks = compare_and_print (B.sub rs 32ul 32ul) s 32ul in
if okr && oks then
begin
let result = ecdsa_verif_p256_sha512 msg_len msg qxy r s in
if not result then
begin
LowStar.Printf.(printf "FAIL: verification\n" done);
C.exit 1l
end
end
else
begin
LowStar.Printf.(printf "FAIL: signing\n" done);
C.exit 1l
end
end
else
begin
LowStar.Printf.(printf "FAIL: signing\n" done);
C.exit 1l
end;
pop_frame()
end
inline_for_extraction noextract
let test_many #a (label:C.String.t)
(f:a -> Stack unit (fun _ -> True) (fun _ _ _ -> True)) (vec: L.lbuffer a) | false | false | Hacl.Test.ECDSA.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": 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": 200,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val test_many : label: C.String.t ->
f: (_: a -> FStar.HyperStack.ST.Stack Prims.unit) ->
vec: Test.Lowstarize.lbuffer a
-> FStar.HyperStack.ST.STATE Prims.unit | [] | Hacl.Test.ECDSA.test_many | {
"file_name": "code/tests/Hacl.Test.ECDSA.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
label: C.String.t ->
f: (_: a -> FStar.HyperStack.ST.Stack Prims.unit) ->
vec: Test.Lowstarize.lbuffer a
-> FStar.HyperStack.ST.STATE Prims.unit | {
"end_col": 41,
"end_line": 479,
"start_col": 2,
"start_line": 467
} |
|
FStar.HyperStack.ST.St | val main: Prims.unit -> St C.exit_code | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Lowstarize",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": 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 main () : St C.exit_code =
test_many C.String.(!$"[ECDSA SigVer]") test_sigver256 sigver_vectors256_low;
test_many C.String.(!$"[ECDSA SigGen]") test_siggen_256 siggen_vectors256_low;
test_many C.String.(!$"[ECDSA SigVer - SHA384]") test_sigver384 sigver_vectors384_low;
test_many C.String.(!$"[ECDSA SigGen - SHA384]") test_siggen_384 siggen_vectors384_low;
test_many C.String.(!$"[ECDSA SigVer - SHA512]") test_sigver512 sigver_vectors512_low;
test_many C.String.(!$"[ECDSA SigGen - SHA512]") test_siggen_512 siggen_vectors512_low;
C.EXIT_SUCCESS | val main: Prims.unit -> St C.exit_code
let main () : St C.exit_code = | true | null | false | test_many C.String.(!$"[ECDSA SigVer]") test_sigver256 sigver_vectors256_low;
test_many C.String.(!$"[ECDSA SigGen]") test_siggen_256 siggen_vectors256_low;
test_many C.String.(!$"[ECDSA SigVer - SHA384]") test_sigver384 sigver_vectors384_low;
test_many C.String.(!$"[ECDSA SigGen - SHA384]") test_siggen_384 siggen_vectors384_low;
test_many C.String.(!$"[ECDSA SigVer - SHA512]") test_sigver512 sigver_vectors512_low;
test_many C.String.(!$"[ECDSA SigGen - SHA512]") test_siggen_512 siggen_vectors512_low;
C.EXIT_SUCCESS | {
"checked_file": "Hacl.Test.ECDSA.fst.checked",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.P256.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int32.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"C.String.fsti.checked",
"C.Loops.fst.checked",
"C.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Test.ECDSA.fst"
} | [] | [
"Prims.unit",
"C.EXIT_SUCCESS",
"C.exit_code",
"Hacl.Test.ECDSA.test_many",
"FStar.Pervasives.Native.tuple7",
"Test.Lowstarize.lbuffer",
"FStar.UInt8.t",
"C.String.op_Bang_Dollar",
"Hacl.Test.ECDSA.test_siggen_512",
"Hacl.Test.ECDSA.siggen_vectors512_low",
"FStar.Pervasives.Native.tuple6",
"Prims.bool",
"Hacl.Test.ECDSA.test_sigver512",
"Hacl.Test.ECDSA.sigver_vectors512_low",
"Hacl.Test.ECDSA.test_siggen_384",
"Hacl.Test.ECDSA.siggen_vectors384_low",
"Hacl.Test.ECDSA.test_sigver384",
"Hacl.Test.ECDSA.sigver_vectors384_low",
"Hacl.Test.ECDSA.test_siggen_256",
"Hacl.Test.ECDSA.siggen_vectors256_low",
"Hacl.Test.ECDSA.test_sigver256",
"Hacl.Test.ECDSA.sigver_vectors256_low"
] | [] | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
noextract
let sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_256
noextract
let sigver_vectors384_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_384
noextract
let sigver_vectors512_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_512
noextract
let siggen_vectors256_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_256
noextract
let siggen_vectors384_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_384
noextract
let siggen_vectors512_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_512
%splice[sigver_vectors256_low]
(lowstarize_toplevel "sigver_vectors256_tmp" "sigver_vectors256_low")
%splice[sigver_vectors384_low]
(lowstarize_toplevel "sigver_vectors384_tmp" "sigver_vectors384_low")
%splice[sigver_vectors512_low]
(lowstarize_toplevel "sigver_vectors512_tmp" "sigver_vectors512_low")
%splice[siggen_vectors256_low]
(lowstarize_toplevel "siggen_vectors256_tmp" "siggen_vectors256_low")
%splice[siggen_vectors384_low]
(lowstarize_toplevel "siggen_vectors384_tmp" "siggen_vectors384_low")
%splice[siggen_vectors512_low]
(lowstarize_toplevel "siggen_vectors512_tmp" "siggen_vectors512_low")
// Cheap alternative to friend Lib.IntTypes needed because Test.Lowstarize uses UInt8.t
assume val declassify_uint8: squash (uint8 == UInt8.t)
let vec8 = L.lbuffer UInt8.t
let sigver_vector = vec8 & vec8 & vec8 & vec8 & vec8 & bool
let siggen_vector = vec8 & vec8 & vec8 & vec8 & vec8 & vec8 & vec8
// This could replace TestLib.compare_and_print
val compare_and_print: b1:B.buffer UInt8.t -> b2:B.buffer UInt8.t -> len:UInt32.t
-> Stack bool
(requires fun h0 -> B.live h0 b1 /\ B.live h0 b2 /\ B.length b1 == v len /\ B.length b2 == v len)
(ensures fun h0 _ h1 -> B.modifies B.loc_none h0 h1)
let compare_and_print b1 b2 len =
push_frame();
LowStar.Printf.(printf "Expected: %xuy\n" len b1 done);
LowStar.Printf.(printf "Computed: %xuy\n" len b2 done);
let b = Lib.ByteBuffer.lbytes_eq #len b1 b2 in
if b then
LowStar.Printf.(printf "PASS\n" done)
else
LowStar.Printf.(printf "FAIL\n" done);
pop_frame();
b
let test_sigver256 (vec:sigver_vector) : Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
let max_msg_len = 0 in
let LB msg_len msg,
LB qx_len qx,
LB qy_len qy,
LB r_len r,
LB s_len s,
result = vec
in
B.recall msg;
B.recall qx;
B.recall qy;
B.recall r;
B.recall s;
// We need to check this at runtime because Low*-ized vectors don't carry any refinements
if not (qx_len = 32ul && qy_len = 32ul && r_len = 32ul && s_len = 32ul)
then C.exit (-1l)
else
begin
push_frame();
let qxy = B.alloca (u8 0) 64ul in
B.blit qx 0ul qxy 0ul 32ul;
B.blit qy 0ul qxy 32ul 32ul;
let result' = ecdsa_verif_p256_sha2 msg_len msg qxy r s in
if result' = result then ()
else
begin
LowStar.Printf.(printf "FAIL\n" done);
C.exit 1l
end;
pop_frame()
end
let test_sigver384 (vec:sigver_vector) : Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
let max_msg_len = 0 in
let LB msg_len msg,
LB qx_len qx,
LB qy_len qy,
LB r_len r,
LB s_len s,
result = vec
in
B.recall msg;
B.recall qx;
B.recall qy;
B.recall r;
B.recall s;
// We need to check this at runtime because Low*-ized vectors don't carry any refinements
if not (qx_len = 32ul && qy_len = 32ul && r_len = 32ul && s_len = 32ul)
then C.exit (-1l)
else
begin
push_frame();
let qxy = B.alloca (u8 0) 64ul in
B.blit qx 0ul qxy 0ul 32ul;
B.blit qy 0ul qxy 32ul 32ul;
let result' = ecdsa_verif_p256_sha384 msg_len msg qxy r s in
if result' = result then ()
else
begin
LowStar.Printf.(printf "FAIL\n" done);
C.exit 1l
end;
pop_frame()
end
let test_sigver512 (vec:sigver_vector) : Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
let max_msg_len = 0 in
let LB msg_len msg,
LB qx_len qx,
LB qy_len qy,
LB r_len r,
LB s_len s,
result = vec
in
B.recall msg;
B.recall qx;
B.recall qy;
B.recall r;
B.recall s;
// We need to check this at runtime because Low*-ized vectors don't carry any refinements
if not (qx_len = 32ul && qy_len = 32ul && r_len = 32ul && s_len = 32ul)
then C.exit (-1l)
else
begin
push_frame();
let qxy = B.alloca (u8 0) 64ul in
B.blit qx 0ul qxy 0ul 32ul;
B.blit qy 0ul qxy 32ul 32ul;
let result' = ecdsa_verif_p256_sha512 msg_len msg qxy r s in
if result' = result then ()
else
begin
LowStar.Printf.(printf "FAIL\n" done);
C.exit 1l
end;
pop_frame()
end
#push-options "--fuel 1 --ifuel 1 --z3rlimit 200"
val check_bound: b:Lib.Buffer.lbuffer uint8 32ul -> Stack bool
(requires fun h -> Lib.Buffer.live h b)
(ensures fun h0 r h1 ->
h0 == h1 /\
r ==
(
(Lib.ByteSequence.nat_from_bytes_be (Lib.Buffer.as_seq h0 b) > 0) &&
(Lib.ByteSequence.nat_from_bytes_be (Lib.Buffer.as_seq h0 b) <
Spec.P256.order)))
let check_bound b =
let open FStar.Mul in
let open Lib.ByteSequence in
let open Spec.P256 in
[@inline_let]
let q1 = normalize_term (order % pow2 64) in
[@inline_let]
let q2 = normalize_term ((order / pow2 64) % pow2 64) in
[@inline_let]
let q3 = normalize_term ((order / pow2 128) % pow2 64) in
[@inline_let]
let q4 = normalize_term (((order / pow2 128) / pow2 64) % pow2 64) in
assert_norm (pow2 128 * pow2 64 == pow2 192);
assert (order == q1 + pow2 64 * q2 + pow2 128 * q3 + pow2 192 * q4);
let zero = mk_int #U64 #PUB 0 in
let q1 = mk_int #U64 #PUB q1 in
let q2 = mk_int #U64 #PUB q2 in
let q3 = mk_int #U64 #PUB q3 in
let q4 = mk_int #U64 #PUB q4 in
let h0 = get () in
let x1 = Lib.ByteBuffer.uint_from_bytes_be #U64 (Lib.Buffer.sub b 0ul 8ul) in
let x2 = Lib.ByteBuffer.uint_from_bytes_be #U64 (Lib.Buffer.sub b 8ul 8ul) in
let x3 = Lib.ByteBuffer.uint_from_bytes_be #U64 (Lib.Buffer.sub b 16ul 8ul) in
let x4 = Lib.ByteBuffer.uint_from_bytes_be #U64 (Lib.Buffer.sub b 24ul 8ul) in
nat_from_intseq_be_slice_lemma (Lib.Buffer.as_seq h0 b) 8;
lemma_reveal_uint_to_bytes_be #U64 (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 0 8);
nat_from_intseq_be_slice_lemma (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 8 32) 8;
lemma_reveal_uint_to_bytes_be #U64 (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 8 16);
nat_from_intseq_be_slice_lemma (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 16 32) 8;
lemma_reveal_uint_to_bytes_be #U64 (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 16 24);
nat_from_intseq_be_slice_lemma (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 24 32) 8;
lemma_reveal_uint_to_bytes_be #U64 (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 24 32);
let x1 = Lib.RawIntTypes.u64_to_UInt64 x1 in
let x2 = Lib.RawIntTypes.u64_to_UInt64 x2 in
let x3 = Lib.RawIntTypes.u64_to_UInt64 x3 in
let x4 = Lib.RawIntTypes.u64_to_UInt64 x4 in
let r = x1 <. q4 || (x1 =. q4 &&
(x2 <. q3 || (x2 =. q3 &&
(x3 <. q2 || (x3 =. q2 && x4 <. q1))))) in
let r1 = x1 = zero && x2 = zero && x3 = zero && x4 = zero in
r && not r1
#push-options " --ifuel 1 --fuel 1"
let test_siggen_256 (vec:siggen_vector) : Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
let max_msg_len = 0 in
let LB msg_len msg,
LB d_len d,
LB qx_len qx,
LB qy_len qy,
LB k_len k,
LB r_len r,
LB s_len s = vec
in
B.recall msg;
B.recall d;
B.recall qx;
B.recall qy;
B.recall k;
B.recall r;
B.recall s;
if not (k_len = 32ul && d_len = 32ul) then
C.exit (-1l);
let bound_k = check_bound k in
let bound_d = check_bound d in
// We need to check this at runtime because Low*-ized vectors don't carry any refinements
if not (bound_k && bound_d &&
qx_len = 32ul && qy_len = 32ul && r_len = 32ul && s_len = 32ul)
then C.exit (-1l)
else
begin
push_frame();
let rs = B.alloca (u8 0) 64ul in
let qxy = B.alloca (u8 0) 64ul in
B.blit qx 0ul qxy 0ul 32ul;
B.blit qy 0ul qxy 32ul 32ul;
let flag = ecdsa_sign_p256_sha2 rs msg_len msg d k in
if flag then
begin
let okr = compare_and_print (B.sub rs 0ul 32ul) r 32ul in
let oks = compare_and_print (B.sub rs 32ul 32ul) s 32ul in
if okr && oks then
begin
let result = ecdsa_verif_p256_sha2 msg_len msg qxy r s in
if not result then
begin
LowStar.Printf.(printf "FAIL: verification\n" done);
C.exit 1l
end
end
else
begin
LowStar.Printf.(printf "FAIL: signing\n" done);
C.exit 1l
end
end
else
begin
LowStar.Printf.(printf "FAIL: signing\n" done);
C.exit 1l
end;
pop_frame()
end
let test_siggen_384 (vec:siggen_vector) : Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
let max_msg_len = 0 in
let LB msg_len msg,
LB d_len d,
LB qx_len qx,
LB qy_len qy,
LB k_len k,
LB r_len r,
LB s_len s = vec
in
B.recall msg;
B.recall d;
B.recall qx;
B.recall qy;
B.recall k;
B.recall r;
B.recall s;
if not (k_len = 32ul && d_len = 32ul) then
C.exit (-1l);
let bound_k = check_bound k in
let bound_d = check_bound d in
// We need to check this at runtime because Low*-ized vectors don't carry any refinements
if not (bound_k && bound_d &&
qx_len = 32ul && qy_len = 32ul && r_len = 32ul && s_len = 32ul)
then C.exit (-1l)
else
begin
push_frame();
let rs = B.alloca (u8 0) 64ul in
let qxy = B.alloca (u8 0) 64ul in
B.blit qx 0ul qxy 0ul 32ul;
B.blit qy 0ul qxy 32ul 32ul;
let flag = ecdsa_sign_p256_sha384 rs msg_len msg d k in
if flag then
begin
let okr = compare_and_print (B.sub rs 0ul 32ul) r 32ul in
let oks = compare_and_print (B.sub rs 32ul 32ul) s 32ul in
if okr && oks then
begin
let result = ecdsa_verif_p256_sha384 msg_len msg qxy r s in
if not result then
begin
LowStar.Printf.(printf "FAIL: verification\n" done);
C.exit 1l
end
end
else
begin
LowStar.Printf.(printf "FAIL: signing\n" done);
C.exit 1l
end
end
else
begin
LowStar.Printf.(printf "FAIL: signing\n" done);
C.exit 1l
end;
pop_frame()
end
let test_siggen_512 (vec:siggen_vector) : Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
let max_msg_len = 0 in
let LB msg_len msg,
LB d_len d,
LB qx_len qx,
LB qy_len qy,
LB k_len k,
LB r_len r,
LB s_len s = vec
in
B.recall msg;
B.recall d;
B.recall qx;
B.recall qy;
B.recall k;
B.recall r;
B.recall s;
if not (k_len = 32ul && d_len = 32ul) then
C.exit (-1l);
let bound_k = check_bound k in
let bound_d = check_bound d in
// We need to check this at runtime because Low*-ized vectors don't carry any refinements
if not (bound_k && bound_d &&
qx_len = 32ul && qy_len = 32ul && r_len = 32ul && s_len = 32ul)
then C.exit (-1l)
else
begin
push_frame();
let rs = B.alloca (u8 0) 64ul in
let qxy = B.alloca (u8 0) 64ul in
B.blit qx 0ul qxy 0ul 32ul;
B.blit qy 0ul qxy 32ul 32ul;
let flag = ecdsa_sign_p256_sha512 rs msg_len msg d k in
if flag then
begin
let okr = compare_and_print (B.sub rs 0ul 32ul) r 32ul in
let oks = compare_and_print (B.sub rs 32ul 32ul) s 32ul in
if okr && oks then
begin
let result = ecdsa_verif_p256_sha512 msg_len msg qxy r s in
if not result then
begin
LowStar.Printf.(printf "FAIL: verification\n" done);
C.exit 1l
end
end
else
begin
LowStar.Printf.(printf "FAIL: signing\n" done);
C.exit 1l
end
end
else
begin
LowStar.Printf.(printf "FAIL: signing\n" done);
C.exit 1l
end;
pop_frame()
end
inline_for_extraction noextract
let test_many #a (label:C.String.t)
(f:a -> Stack unit (fun _ -> True) (fun _ _ _ -> True)) (vec: L.lbuffer a)
=
C.String.print label;
C.String.(print !$"\n");
let L.LB len vs = vec in
let f (i:UInt32.t{0 <= v i /\ v i < v len}): Stack unit
(requires fun h -> True)
(ensures fun h0 _ h1 -> True)
=
let open LowStar.BufferOps in
B.recall vs;
LowStar.Printf.(printf "ECDSA Test %ul/%ul\n" (i +! 1ul) len done);
f vs.(i)
in
C.Loops.for 0ul len (fun _ _ -> True) f | false | false | Hacl.Test.ECDSA.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": 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": 200,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val main: Prims.unit -> St C.exit_code | [] | Hacl.Test.ECDSA.main | {
"file_name": "code/tests/Hacl.Test.ECDSA.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.unit -> FStar.HyperStack.ST.St C.exit_code | {
"end_col": 16,
"end_line": 492,
"start_col": 2,
"start_line": 483
} |
FStar.HyperStack.ST.Stack | val test_sigver384 (vec: sigver_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Lowstarize",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": 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 test_sigver384 (vec:sigver_vector) : Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
let max_msg_len = 0 in
let LB msg_len msg,
LB qx_len qx,
LB qy_len qy,
LB r_len r,
LB s_len s,
result = vec
in
B.recall msg;
B.recall qx;
B.recall qy;
B.recall r;
B.recall s;
// We need to check this at runtime because Low*-ized vectors don't carry any refinements
if not (qx_len = 32ul && qy_len = 32ul && r_len = 32ul && s_len = 32ul)
then C.exit (-1l)
else
begin
push_frame();
let qxy = B.alloca (u8 0) 64ul in
B.blit qx 0ul qxy 0ul 32ul;
B.blit qy 0ul qxy 32ul 32ul;
let result' = ecdsa_verif_p256_sha384 msg_len msg qxy r s in
if result' = result then ()
else
begin
LowStar.Printf.(printf "FAIL\n" done);
C.exit 1l
end;
pop_frame()
end | val test_sigver384 (vec: sigver_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True)
let test_sigver384 (vec: sigver_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) = | true | null | false | let max_msg_len = 0 in
let LB msg_len msg, LB qx_len qx, LB qy_len qy, LB r_len r, LB s_len s, result = vec in
B.recall msg;
B.recall qx;
B.recall qy;
B.recall r;
B.recall s;
if not (qx_len = 32ul && qy_len = 32ul && r_len = 32ul && s_len = 32ul)
then C.exit (-1l)
else
(push_frame ();
let qxy = B.alloca (u8 0) 64ul in
B.blit qx 0ul qxy 0ul 32ul;
B.blit qy 0ul qxy 32ul 32ul;
let result' = ecdsa_verif_p256_sha384 msg_len msg qxy r s in
if result' = result
then ()
else
((let open LowStar.Printf in printf "FAIL\n" done);
C.exit 1l);
pop_frame ()) | {
"checked_file": "Hacl.Test.ECDSA.fst.checked",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.P256.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int32.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"C.String.fsti.checked",
"C.Loops.fst.checked",
"C.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Test.ECDSA.fst"
} | [] | [
"Hacl.Test.ECDSA.sigver_vector",
"FStar.UInt32.t",
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"Prims.l_and",
"Prims.eq2",
"LowStar.Monotonic.Buffer.len",
"LowStar.Buffer.trivial_preorder",
"LowStar.Monotonic.Buffer.recallable",
"Prims.bool",
"Prims.op_Negation",
"Prims.op_AmpAmp",
"Prims.op_Equality",
"FStar.UInt32.__uint_to_t",
"C.exit",
"FStar.Int32.__int_to_t",
"Prims.unit",
"FStar.HyperStack.ST.pop_frame",
"LowStar.Printf.printf",
"LowStar.Printf.done",
"Hacl.P256.ecdsa_verif_p256_sha384",
"LowStar.Monotonic.Buffer.blit",
"LowStar.Monotonic.Buffer.mbuffer",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.UInt32.v",
"FStar.UInt32.uint_to_t",
"Prims.b2t",
"LowStar.Monotonic.Buffer.g_is_null",
"LowStar.Buffer.alloca",
"Lib.IntTypes.u8",
"FStar.HyperStack.ST.push_frame",
"LowStar.Monotonic.Buffer.recall",
"Prims.int",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_True"
] | [] | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
noextract
let sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_256
noextract
let sigver_vectors384_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_384
noextract
let sigver_vectors512_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_512
noextract
let siggen_vectors256_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_256
noextract
let siggen_vectors384_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_384
noextract
let siggen_vectors512_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_512
%splice[sigver_vectors256_low]
(lowstarize_toplevel "sigver_vectors256_tmp" "sigver_vectors256_low")
%splice[sigver_vectors384_low]
(lowstarize_toplevel "sigver_vectors384_tmp" "sigver_vectors384_low")
%splice[sigver_vectors512_low]
(lowstarize_toplevel "sigver_vectors512_tmp" "sigver_vectors512_low")
%splice[siggen_vectors256_low]
(lowstarize_toplevel "siggen_vectors256_tmp" "siggen_vectors256_low")
%splice[siggen_vectors384_low]
(lowstarize_toplevel "siggen_vectors384_tmp" "siggen_vectors384_low")
%splice[siggen_vectors512_low]
(lowstarize_toplevel "siggen_vectors512_tmp" "siggen_vectors512_low")
// Cheap alternative to friend Lib.IntTypes needed because Test.Lowstarize uses UInt8.t
assume val declassify_uint8: squash (uint8 == UInt8.t)
let vec8 = L.lbuffer UInt8.t
let sigver_vector = vec8 & vec8 & vec8 & vec8 & vec8 & bool
let siggen_vector = vec8 & vec8 & vec8 & vec8 & vec8 & vec8 & vec8
// This could replace TestLib.compare_and_print
val compare_and_print: b1:B.buffer UInt8.t -> b2:B.buffer UInt8.t -> len:UInt32.t
-> Stack bool
(requires fun h0 -> B.live h0 b1 /\ B.live h0 b2 /\ B.length b1 == v len /\ B.length b2 == v len)
(ensures fun h0 _ h1 -> B.modifies B.loc_none h0 h1)
let compare_and_print b1 b2 len =
push_frame();
LowStar.Printf.(printf "Expected: %xuy\n" len b1 done);
LowStar.Printf.(printf "Computed: %xuy\n" len b2 done);
let b = Lib.ByteBuffer.lbytes_eq #len b1 b2 in
if b then
LowStar.Printf.(printf "PASS\n" done)
else
LowStar.Printf.(printf "FAIL\n" done);
pop_frame();
b
let test_sigver256 (vec:sigver_vector) : Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
let max_msg_len = 0 in
let LB msg_len msg,
LB qx_len qx,
LB qy_len qy,
LB r_len r,
LB s_len s,
result = vec
in
B.recall msg;
B.recall qx;
B.recall qy;
B.recall r;
B.recall s;
// We need to check this at runtime because Low*-ized vectors don't carry any refinements
if not (qx_len = 32ul && qy_len = 32ul && r_len = 32ul && s_len = 32ul)
then C.exit (-1l)
else
begin
push_frame();
let qxy = B.alloca (u8 0) 64ul in
B.blit qx 0ul qxy 0ul 32ul;
B.blit qy 0ul qxy 32ul 32ul;
let result' = ecdsa_verif_p256_sha2 msg_len msg qxy r s in
if result' = result then ()
else
begin
LowStar.Printf.(printf "FAIL\n" done);
C.exit 1l
end;
pop_frame()
end | false | false | Hacl.Test.ECDSA.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": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val test_sigver384 (vec: sigver_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) | [] | Hacl.Test.ECDSA.test_sigver384 | {
"file_name": "code/tests/Hacl.Test.ECDSA.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | vec: Hacl.Test.ECDSA.sigver_vector -> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 7,
"end_line": 162,
"start_col": 106,
"start_line": 131
} |
FStar.HyperStack.ST.Stack | val test_sigver512 (vec: sigver_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Lowstarize",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": 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 test_sigver512 (vec:sigver_vector) : Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
let max_msg_len = 0 in
let LB msg_len msg,
LB qx_len qx,
LB qy_len qy,
LB r_len r,
LB s_len s,
result = vec
in
B.recall msg;
B.recall qx;
B.recall qy;
B.recall r;
B.recall s;
// We need to check this at runtime because Low*-ized vectors don't carry any refinements
if not (qx_len = 32ul && qy_len = 32ul && r_len = 32ul && s_len = 32ul)
then C.exit (-1l)
else
begin
push_frame();
let qxy = B.alloca (u8 0) 64ul in
B.blit qx 0ul qxy 0ul 32ul;
B.blit qy 0ul qxy 32ul 32ul;
let result' = ecdsa_verif_p256_sha512 msg_len msg qxy r s in
if result' = result then ()
else
begin
LowStar.Printf.(printf "FAIL\n" done);
C.exit 1l
end;
pop_frame()
end | val test_sigver512 (vec: sigver_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True)
let test_sigver512 (vec: sigver_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) = | true | null | false | let max_msg_len = 0 in
let LB msg_len msg, LB qx_len qx, LB qy_len qy, LB r_len r, LB s_len s, result = vec in
B.recall msg;
B.recall qx;
B.recall qy;
B.recall r;
B.recall s;
if not (qx_len = 32ul && qy_len = 32ul && r_len = 32ul && s_len = 32ul)
then C.exit (-1l)
else
(push_frame ();
let qxy = B.alloca (u8 0) 64ul in
B.blit qx 0ul qxy 0ul 32ul;
B.blit qy 0ul qxy 32ul 32ul;
let result' = ecdsa_verif_p256_sha512 msg_len msg qxy r s in
if result' = result
then ()
else
((let open LowStar.Printf in printf "FAIL\n" done);
C.exit 1l);
pop_frame ()) | {
"checked_file": "Hacl.Test.ECDSA.fst.checked",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.P256.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int32.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"C.String.fsti.checked",
"C.Loops.fst.checked",
"C.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Test.ECDSA.fst"
} | [] | [
"Hacl.Test.ECDSA.sigver_vector",
"FStar.UInt32.t",
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"Prims.l_and",
"Prims.eq2",
"LowStar.Monotonic.Buffer.len",
"LowStar.Buffer.trivial_preorder",
"LowStar.Monotonic.Buffer.recallable",
"Prims.bool",
"Prims.op_Negation",
"Prims.op_AmpAmp",
"Prims.op_Equality",
"FStar.UInt32.__uint_to_t",
"C.exit",
"FStar.Int32.__int_to_t",
"Prims.unit",
"FStar.HyperStack.ST.pop_frame",
"LowStar.Printf.printf",
"LowStar.Printf.done",
"Hacl.P256.ecdsa_verif_p256_sha512",
"LowStar.Monotonic.Buffer.blit",
"LowStar.Monotonic.Buffer.mbuffer",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.UInt32.v",
"FStar.UInt32.uint_to_t",
"Prims.b2t",
"LowStar.Monotonic.Buffer.g_is_null",
"LowStar.Buffer.alloca",
"Lib.IntTypes.u8",
"FStar.HyperStack.ST.push_frame",
"LowStar.Monotonic.Buffer.recall",
"Prims.int",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_True"
] | [] | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
noextract
let sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_256
noextract
let sigver_vectors384_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_384
noextract
let sigver_vectors512_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_512
noextract
let siggen_vectors256_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_256
noextract
let siggen_vectors384_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_384
noextract
let siggen_vectors512_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_512
%splice[sigver_vectors256_low]
(lowstarize_toplevel "sigver_vectors256_tmp" "sigver_vectors256_low")
%splice[sigver_vectors384_low]
(lowstarize_toplevel "sigver_vectors384_tmp" "sigver_vectors384_low")
%splice[sigver_vectors512_low]
(lowstarize_toplevel "sigver_vectors512_tmp" "sigver_vectors512_low")
%splice[siggen_vectors256_low]
(lowstarize_toplevel "siggen_vectors256_tmp" "siggen_vectors256_low")
%splice[siggen_vectors384_low]
(lowstarize_toplevel "siggen_vectors384_tmp" "siggen_vectors384_low")
%splice[siggen_vectors512_low]
(lowstarize_toplevel "siggen_vectors512_tmp" "siggen_vectors512_low")
// Cheap alternative to friend Lib.IntTypes needed because Test.Lowstarize uses UInt8.t
assume val declassify_uint8: squash (uint8 == UInt8.t)
let vec8 = L.lbuffer UInt8.t
let sigver_vector = vec8 & vec8 & vec8 & vec8 & vec8 & bool
let siggen_vector = vec8 & vec8 & vec8 & vec8 & vec8 & vec8 & vec8
// This could replace TestLib.compare_and_print
val compare_and_print: b1:B.buffer UInt8.t -> b2:B.buffer UInt8.t -> len:UInt32.t
-> Stack bool
(requires fun h0 -> B.live h0 b1 /\ B.live h0 b2 /\ B.length b1 == v len /\ B.length b2 == v len)
(ensures fun h0 _ h1 -> B.modifies B.loc_none h0 h1)
let compare_and_print b1 b2 len =
push_frame();
LowStar.Printf.(printf "Expected: %xuy\n" len b1 done);
LowStar.Printf.(printf "Computed: %xuy\n" len b2 done);
let b = Lib.ByteBuffer.lbytes_eq #len b1 b2 in
if b then
LowStar.Printf.(printf "PASS\n" done)
else
LowStar.Printf.(printf "FAIL\n" done);
pop_frame();
b
let test_sigver256 (vec:sigver_vector) : Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
let max_msg_len = 0 in
let LB msg_len msg,
LB qx_len qx,
LB qy_len qy,
LB r_len r,
LB s_len s,
result = vec
in
B.recall msg;
B.recall qx;
B.recall qy;
B.recall r;
B.recall s;
// We need to check this at runtime because Low*-ized vectors don't carry any refinements
if not (qx_len = 32ul && qy_len = 32ul && r_len = 32ul && s_len = 32ul)
then C.exit (-1l)
else
begin
push_frame();
let qxy = B.alloca (u8 0) 64ul in
B.blit qx 0ul qxy 0ul 32ul;
B.blit qy 0ul qxy 32ul 32ul;
let result' = ecdsa_verif_p256_sha2 msg_len msg qxy r s in
if result' = result then ()
else
begin
LowStar.Printf.(printf "FAIL\n" done);
C.exit 1l
end;
pop_frame()
end
let test_sigver384 (vec:sigver_vector) : Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
let max_msg_len = 0 in
let LB msg_len msg,
LB qx_len qx,
LB qy_len qy,
LB r_len r,
LB s_len s,
result = vec
in
B.recall msg;
B.recall qx;
B.recall qy;
B.recall r;
B.recall s;
// We need to check this at runtime because Low*-ized vectors don't carry any refinements
if not (qx_len = 32ul && qy_len = 32ul && r_len = 32ul && s_len = 32ul)
then C.exit (-1l)
else
begin
push_frame();
let qxy = B.alloca (u8 0) 64ul in
B.blit qx 0ul qxy 0ul 32ul;
B.blit qy 0ul qxy 32ul 32ul;
let result' = ecdsa_verif_p256_sha384 msg_len msg qxy r s in
if result' = result then ()
else
begin
LowStar.Printf.(printf "FAIL\n" done);
C.exit 1l
end;
pop_frame()
end | false | false | Hacl.Test.ECDSA.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": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val test_sigver512 (vec: sigver_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) | [] | Hacl.Test.ECDSA.test_sigver512 | {
"file_name": "code/tests/Hacl.Test.ECDSA.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | vec: Hacl.Test.ECDSA.sigver_vector -> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 7,
"end_line": 196,
"start_col": 106,
"start_line": 165
} |
FStar.HyperStack.ST.Stack | val test_sigver256 (vec: sigver_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Lowstarize",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": 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 test_sigver256 (vec:sigver_vector) : Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
let max_msg_len = 0 in
let LB msg_len msg,
LB qx_len qx,
LB qy_len qy,
LB r_len r,
LB s_len s,
result = vec
in
B.recall msg;
B.recall qx;
B.recall qy;
B.recall r;
B.recall s;
// We need to check this at runtime because Low*-ized vectors don't carry any refinements
if not (qx_len = 32ul && qy_len = 32ul && r_len = 32ul && s_len = 32ul)
then C.exit (-1l)
else
begin
push_frame();
let qxy = B.alloca (u8 0) 64ul in
B.blit qx 0ul qxy 0ul 32ul;
B.blit qy 0ul qxy 32ul 32ul;
let result' = ecdsa_verif_p256_sha2 msg_len msg qxy r s in
if result' = result then ()
else
begin
LowStar.Printf.(printf "FAIL\n" done);
C.exit 1l
end;
pop_frame()
end | val test_sigver256 (vec: sigver_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True)
let test_sigver256 (vec: sigver_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) = | true | null | false | let max_msg_len = 0 in
let LB msg_len msg, LB qx_len qx, LB qy_len qy, LB r_len r, LB s_len s, result = vec in
B.recall msg;
B.recall qx;
B.recall qy;
B.recall r;
B.recall s;
if not (qx_len = 32ul && qy_len = 32ul && r_len = 32ul && s_len = 32ul)
then C.exit (-1l)
else
(push_frame ();
let qxy = B.alloca (u8 0) 64ul in
B.blit qx 0ul qxy 0ul 32ul;
B.blit qy 0ul qxy 32ul 32ul;
let result' = ecdsa_verif_p256_sha2 msg_len msg qxy r s in
if result' = result
then ()
else
((let open LowStar.Printf in printf "FAIL\n" done);
C.exit 1l);
pop_frame ()) | {
"checked_file": "Hacl.Test.ECDSA.fst.checked",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.P256.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int32.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"C.String.fsti.checked",
"C.Loops.fst.checked",
"C.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Test.ECDSA.fst"
} | [] | [
"Hacl.Test.ECDSA.sigver_vector",
"FStar.UInt32.t",
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"Prims.l_and",
"Prims.eq2",
"LowStar.Monotonic.Buffer.len",
"LowStar.Buffer.trivial_preorder",
"LowStar.Monotonic.Buffer.recallable",
"Prims.bool",
"Prims.op_Negation",
"Prims.op_AmpAmp",
"Prims.op_Equality",
"FStar.UInt32.__uint_to_t",
"C.exit",
"FStar.Int32.__int_to_t",
"Prims.unit",
"FStar.HyperStack.ST.pop_frame",
"LowStar.Printf.printf",
"LowStar.Printf.done",
"Hacl.P256.ecdsa_verif_p256_sha2",
"LowStar.Monotonic.Buffer.blit",
"LowStar.Monotonic.Buffer.mbuffer",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.UInt32.v",
"FStar.UInt32.uint_to_t",
"Prims.b2t",
"LowStar.Monotonic.Buffer.g_is_null",
"LowStar.Buffer.alloca",
"Lib.IntTypes.u8",
"FStar.HyperStack.ST.push_frame",
"LowStar.Monotonic.Buffer.recall",
"Prims.int",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_True"
] | [] | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
noextract
let sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_256
noextract
let sigver_vectors384_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_384
noextract
let sigver_vectors512_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_512
noextract
let siggen_vectors256_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_256
noextract
let siggen_vectors384_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_384
noextract
let siggen_vectors512_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_512
%splice[sigver_vectors256_low]
(lowstarize_toplevel "sigver_vectors256_tmp" "sigver_vectors256_low")
%splice[sigver_vectors384_low]
(lowstarize_toplevel "sigver_vectors384_tmp" "sigver_vectors384_low")
%splice[sigver_vectors512_low]
(lowstarize_toplevel "sigver_vectors512_tmp" "sigver_vectors512_low")
%splice[siggen_vectors256_low]
(lowstarize_toplevel "siggen_vectors256_tmp" "siggen_vectors256_low")
%splice[siggen_vectors384_low]
(lowstarize_toplevel "siggen_vectors384_tmp" "siggen_vectors384_low")
%splice[siggen_vectors512_low]
(lowstarize_toplevel "siggen_vectors512_tmp" "siggen_vectors512_low")
// Cheap alternative to friend Lib.IntTypes needed because Test.Lowstarize uses UInt8.t
assume val declassify_uint8: squash (uint8 == UInt8.t)
let vec8 = L.lbuffer UInt8.t
let sigver_vector = vec8 & vec8 & vec8 & vec8 & vec8 & bool
let siggen_vector = vec8 & vec8 & vec8 & vec8 & vec8 & vec8 & vec8
// This could replace TestLib.compare_and_print
val compare_and_print: b1:B.buffer UInt8.t -> b2:B.buffer UInt8.t -> len:UInt32.t
-> Stack bool
(requires fun h0 -> B.live h0 b1 /\ B.live h0 b2 /\ B.length b1 == v len /\ B.length b2 == v len)
(ensures fun h0 _ h1 -> B.modifies B.loc_none h0 h1)
let compare_and_print b1 b2 len =
push_frame();
LowStar.Printf.(printf "Expected: %xuy\n" len b1 done);
LowStar.Printf.(printf "Computed: %xuy\n" len b2 done);
let b = Lib.ByteBuffer.lbytes_eq #len b1 b2 in
if b then
LowStar.Printf.(printf "PASS\n" done)
else
LowStar.Printf.(printf "FAIL\n" done);
pop_frame();
b | false | false | Hacl.Test.ECDSA.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": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val test_sigver256 (vec: sigver_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) | [] | Hacl.Test.ECDSA.test_sigver256 | {
"file_name": "code/tests/Hacl.Test.ECDSA.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | vec: Hacl.Test.ECDSA.sigver_vector -> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 7,
"end_line": 128,
"start_col": 106,
"start_line": 97
} |
FStar.HyperStack.ST.Stack | val compare_and_print: b1:B.buffer UInt8.t -> b2:B.buffer UInt8.t -> len:UInt32.t
-> Stack bool
(requires fun h0 -> B.live h0 b1 /\ B.live h0 b2 /\ B.length b1 == v len /\ B.length b2 == v len)
(ensures fun h0 _ h1 -> B.modifies B.loc_none h0 h1) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Lowstarize",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": 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 compare_and_print b1 b2 len =
push_frame();
LowStar.Printf.(printf "Expected: %xuy\n" len b1 done);
LowStar.Printf.(printf "Computed: %xuy\n" len b2 done);
let b = Lib.ByteBuffer.lbytes_eq #len b1 b2 in
if b then
LowStar.Printf.(printf "PASS\n" done)
else
LowStar.Printf.(printf "FAIL\n" done);
pop_frame();
b | val compare_and_print: b1:B.buffer UInt8.t -> b2:B.buffer UInt8.t -> len:UInt32.t
-> Stack bool
(requires fun h0 -> B.live h0 b1 /\ B.live h0 b2 /\ B.length b1 == v len /\ B.length b2 == v len)
(ensures fun h0 _ h1 -> B.modifies B.loc_none h0 h1)
let compare_and_print b1 b2 len = | true | null | false | push_frame ();
(let open LowStar.Printf in printf "Expected: %xuy\n" len b1 done);
(let open LowStar.Printf in printf "Computed: %xuy\n" len b2 done);
let b = Lib.ByteBuffer.lbytes_eq #len b1 b2 in
if b
then let open LowStar.Printf in printf "PASS\n" done
else (let open LowStar.Printf in printf "FAIL\n" done);
pop_frame ();
b | {
"checked_file": "Hacl.Test.ECDSA.fst.checked",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.P256.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int32.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"C.String.fsti.checked",
"C.Loops.fst.checked",
"C.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Test.ECDSA.fst"
} | [] | [
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"FStar.UInt32.t",
"Prims.bool",
"Prims.unit",
"FStar.HyperStack.ST.pop_frame",
"LowStar.Printf.printf",
"LowStar.Printf.done",
"Lib.ByteBuffer.lbytes_eq",
"LowStar.Buffer.trivial_preorder",
"FStar.HyperStack.ST.push_frame"
] | [] | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
noextract
let sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_256
noextract
let sigver_vectors384_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_384
noextract
let sigver_vectors512_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_512
noextract
let siggen_vectors256_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_256
noextract
let siggen_vectors384_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_384
noextract
let siggen_vectors512_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_512
%splice[sigver_vectors256_low]
(lowstarize_toplevel "sigver_vectors256_tmp" "sigver_vectors256_low")
%splice[sigver_vectors384_low]
(lowstarize_toplevel "sigver_vectors384_tmp" "sigver_vectors384_low")
%splice[sigver_vectors512_low]
(lowstarize_toplevel "sigver_vectors512_tmp" "sigver_vectors512_low")
%splice[siggen_vectors256_low]
(lowstarize_toplevel "siggen_vectors256_tmp" "siggen_vectors256_low")
%splice[siggen_vectors384_low]
(lowstarize_toplevel "siggen_vectors384_tmp" "siggen_vectors384_low")
%splice[siggen_vectors512_low]
(lowstarize_toplevel "siggen_vectors512_tmp" "siggen_vectors512_low")
// Cheap alternative to friend Lib.IntTypes needed because Test.Lowstarize uses UInt8.t
assume val declassify_uint8: squash (uint8 == UInt8.t)
let vec8 = L.lbuffer UInt8.t
let sigver_vector = vec8 & vec8 & vec8 & vec8 & vec8 & bool
let siggen_vector = vec8 & vec8 & vec8 & vec8 & vec8 & vec8 & vec8
// This could replace TestLib.compare_and_print
val compare_and_print: b1:B.buffer UInt8.t -> b2:B.buffer UInt8.t -> len:UInt32.t
-> Stack bool
(requires fun h0 -> B.live h0 b1 /\ B.live h0 b2 /\ B.length b1 == v len /\ B.length b2 == v len)
(ensures fun h0 _ h1 -> B.modifies B.loc_none h0 h1) | false | false | Hacl.Test.ECDSA.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": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val compare_and_print: b1:B.buffer UInt8.t -> b2:B.buffer UInt8.t -> len:UInt32.t
-> Stack bool
(requires fun h0 -> B.live h0 b1 /\ B.live h0 b2 /\ B.length b1 == v len /\ B.length b2 == v len)
(ensures fun h0 _ h1 -> B.modifies B.loc_none h0 h1) | [] | Hacl.Test.ECDSA.compare_and_print | {
"file_name": "code/tests/Hacl.Test.ECDSA.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
b1: LowStar.Buffer.buffer FStar.UInt8.t ->
b2: LowStar.Buffer.buffer FStar.UInt8.t ->
len: FStar.UInt32.t
-> FStar.HyperStack.ST.Stack Prims.bool | {
"end_col": 3,
"end_line": 95,
"start_col": 2,
"start_line": 86
} |
FStar.HyperStack.ST.Stack | val check_bound: b:Lib.Buffer.lbuffer uint8 32ul -> Stack bool
(requires fun h -> Lib.Buffer.live h b)
(ensures fun h0 r h1 ->
h0 == h1 /\
r ==
(
(Lib.ByteSequence.nat_from_bytes_be (Lib.Buffer.as_seq h0 b) > 0) &&
(Lib.ByteSequence.nat_from_bytes_be (Lib.Buffer.as_seq h0 b) <
Spec.P256.order))) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Lowstarize",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Test",
"short_module": null
},
{
"abbrev": 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 check_bound b =
let open FStar.Mul in
let open Lib.ByteSequence in
let open Spec.P256 in
[@inline_let]
let q1 = normalize_term (order % pow2 64) in
[@inline_let]
let q2 = normalize_term ((order / pow2 64) % pow2 64) in
[@inline_let]
let q3 = normalize_term ((order / pow2 128) % pow2 64) in
[@inline_let]
let q4 = normalize_term (((order / pow2 128) / pow2 64) % pow2 64) in
assert_norm (pow2 128 * pow2 64 == pow2 192);
assert (order == q1 + pow2 64 * q2 + pow2 128 * q3 + pow2 192 * q4);
let zero = mk_int #U64 #PUB 0 in
let q1 = mk_int #U64 #PUB q1 in
let q2 = mk_int #U64 #PUB q2 in
let q3 = mk_int #U64 #PUB q3 in
let q4 = mk_int #U64 #PUB q4 in
let h0 = get () in
let x1 = Lib.ByteBuffer.uint_from_bytes_be #U64 (Lib.Buffer.sub b 0ul 8ul) in
let x2 = Lib.ByteBuffer.uint_from_bytes_be #U64 (Lib.Buffer.sub b 8ul 8ul) in
let x3 = Lib.ByteBuffer.uint_from_bytes_be #U64 (Lib.Buffer.sub b 16ul 8ul) in
let x4 = Lib.ByteBuffer.uint_from_bytes_be #U64 (Lib.Buffer.sub b 24ul 8ul) in
nat_from_intseq_be_slice_lemma (Lib.Buffer.as_seq h0 b) 8;
lemma_reveal_uint_to_bytes_be #U64 (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 0 8);
nat_from_intseq_be_slice_lemma (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 8 32) 8;
lemma_reveal_uint_to_bytes_be #U64 (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 8 16);
nat_from_intseq_be_slice_lemma (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 16 32) 8;
lemma_reveal_uint_to_bytes_be #U64 (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 16 24);
nat_from_intseq_be_slice_lemma (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 24 32) 8;
lemma_reveal_uint_to_bytes_be #U64 (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 24 32);
let x1 = Lib.RawIntTypes.u64_to_UInt64 x1 in
let x2 = Lib.RawIntTypes.u64_to_UInt64 x2 in
let x3 = Lib.RawIntTypes.u64_to_UInt64 x3 in
let x4 = Lib.RawIntTypes.u64_to_UInt64 x4 in
let r = x1 <. q4 || (x1 =. q4 &&
(x2 <. q3 || (x2 =. q3 &&
(x3 <. q2 || (x3 =. q2 && x4 <. q1))))) in
let r1 = x1 = zero && x2 = zero && x3 = zero && x4 = zero in
r && not r1 | val check_bound: b:Lib.Buffer.lbuffer uint8 32ul -> Stack bool
(requires fun h -> Lib.Buffer.live h b)
(ensures fun h0 r h1 ->
h0 == h1 /\
r ==
(
(Lib.ByteSequence.nat_from_bytes_be (Lib.Buffer.as_seq h0 b) > 0) &&
(Lib.ByteSequence.nat_from_bytes_be (Lib.Buffer.as_seq h0 b) <
Spec.P256.order)))
let check_bound b = | true | null | false | let open FStar.Mul in
let open Lib.ByteSequence in
let open Spec.P256 in
[@@ inline_let ]let q1 = normalize_term (order % pow2 64) in
[@@ inline_let ]let q2 = normalize_term ((order / pow2 64) % pow2 64) in
[@@ inline_let ]let q3 = normalize_term ((order / pow2 128) % pow2 64) in
[@@ inline_let ]let q4 = normalize_term (((order / pow2 128) / pow2 64) % pow2 64) in
assert_norm (pow2 128 * pow2 64 == pow2 192);
assert (order == q1 + pow2 64 * q2 + pow2 128 * q3 + pow2 192 * q4);
let zero = mk_int #U64 #PUB 0 in
let q1 = mk_int #U64 #PUB q1 in
let q2 = mk_int #U64 #PUB q2 in
let q3 = mk_int #U64 #PUB q3 in
let q4 = mk_int #U64 #PUB q4 in
let h0 = get () in
let x1 = Lib.ByteBuffer.uint_from_bytes_be #U64 (Lib.Buffer.sub b 0ul 8ul) in
let x2 = Lib.ByteBuffer.uint_from_bytes_be #U64 (Lib.Buffer.sub b 8ul 8ul) in
let x3 = Lib.ByteBuffer.uint_from_bytes_be #U64 (Lib.Buffer.sub b 16ul 8ul) in
let x4 = Lib.ByteBuffer.uint_from_bytes_be #U64 (Lib.Buffer.sub b 24ul 8ul) in
nat_from_intseq_be_slice_lemma (Lib.Buffer.as_seq h0 b) 8;
lemma_reveal_uint_to_bytes_be #U64 (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 0 8);
nat_from_intseq_be_slice_lemma (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 8 32) 8;
lemma_reveal_uint_to_bytes_be #U64 (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 8 16);
nat_from_intseq_be_slice_lemma (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 16 32) 8;
lemma_reveal_uint_to_bytes_be #U64 (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 16 24);
nat_from_intseq_be_slice_lemma (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 24 32) 8;
lemma_reveal_uint_to_bytes_be #U64 (Lib.Sequence.slice (Lib.Buffer.as_seq h0 b) 24 32);
let x1 = Lib.RawIntTypes.u64_to_UInt64 x1 in
let x2 = Lib.RawIntTypes.u64_to_UInt64 x2 in
let x3 = Lib.RawIntTypes.u64_to_UInt64 x3 in
let x4 = Lib.RawIntTypes.u64_to_UInt64 x4 in
let r =
x1 <. q4 || (x1 =. q4 && (x2 <. q3 || (x2 =. q3 && (x3 <. q2 || (x3 =. q2 && x4 <. q1)))))
in
let r1 = x1 = zero && x2 = zero && x3 = zero && x4 = zero in
r && not r1 | {
"checked_file": "Hacl.Test.ECDSA.fst.checked",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.P256.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Int32.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"C.String.fsti.checked",
"C.Loops.fst.checked",
"C.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Test.ECDSA.fst"
} | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Prims.op_AmpAmp",
"Prims.op_Negation",
"Prims.bool",
"Prims.op_Equality",
"FStar.UInt64.t",
"Prims.l_or",
"Prims.b2t",
"Prims.int",
"Lib.IntTypes.range",
"Lib.IntTypes.U64",
"FStar.UInt.size",
"FStar.UInt64.n",
"Lib.IntTypes.uint_v",
"Lib.IntTypes.SEC",
"FStar.UInt64.v",
"Prims.eq2",
"Lib.IntTypes.range_t",
"Lib.IntTypes.v",
"Lib.IntTypes.PUB",
"Prims.op_BarBar",
"Lib.IntTypes.op_Less_Dot",
"Lib.IntTypes.op_Equals_Dot",
"Lib.RawIntTypes.u64_to_UInt64",
"Prims.unit",
"Lib.ByteSequence.lemma_reveal_uint_to_bytes_be",
"Lib.Sequence.slice",
"Lib.IntTypes.U32",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Lib.ByteSequence.nat_from_intseq_be_slice_lemma",
"Lib.IntTypes.U8",
"Prims.op_Subtraction",
"Lib.IntTypes.int_t",
"Lib.ByteBuffer.uint_from_bytes_be",
"Lib.IntTypes.uint_t",
"Lib.Buffer.lbuffer_t",
"Lib.IntTypes.mk_int",
"Lib.Buffer.sub",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Prims._assert",
"Spec.P256.PointOps.order",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.pow2",
"FStar.Pervasives.assert_norm",
"FStar.Pervasives.normalize_term",
"Prims.op_Modulus",
"Prims.op_Division"
] | [] | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
noextract
let sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_256
noextract
let sigver_vectors384_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_384
noextract
let sigver_vectors512_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, h x.qy, h x.r, h x.s, x.result)
sigver_vectors_sha2_512
noextract
let siggen_vectors256_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_256
noextract
let siggen_vectors384_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_384
noextract
let siggen_vectors512_tmp = List.Tot.map
(fun x -> h x.msg', h x.d, h x.qx', h x.qy', h x.k, h x.r', h x.s')
siggen_vectors_sha2_512
%splice[sigver_vectors256_low]
(lowstarize_toplevel "sigver_vectors256_tmp" "sigver_vectors256_low")
%splice[sigver_vectors384_low]
(lowstarize_toplevel "sigver_vectors384_tmp" "sigver_vectors384_low")
%splice[sigver_vectors512_low]
(lowstarize_toplevel "sigver_vectors512_tmp" "sigver_vectors512_low")
%splice[siggen_vectors256_low]
(lowstarize_toplevel "siggen_vectors256_tmp" "siggen_vectors256_low")
%splice[siggen_vectors384_low]
(lowstarize_toplevel "siggen_vectors384_tmp" "siggen_vectors384_low")
%splice[siggen_vectors512_low]
(lowstarize_toplevel "siggen_vectors512_tmp" "siggen_vectors512_low")
// Cheap alternative to friend Lib.IntTypes needed because Test.Lowstarize uses UInt8.t
assume val declassify_uint8: squash (uint8 == UInt8.t)
let vec8 = L.lbuffer UInt8.t
let sigver_vector = vec8 & vec8 & vec8 & vec8 & vec8 & bool
let siggen_vector = vec8 & vec8 & vec8 & vec8 & vec8 & vec8 & vec8
// This could replace TestLib.compare_and_print
val compare_and_print: b1:B.buffer UInt8.t -> b2:B.buffer UInt8.t -> len:UInt32.t
-> Stack bool
(requires fun h0 -> B.live h0 b1 /\ B.live h0 b2 /\ B.length b1 == v len /\ B.length b2 == v len)
(ensures fun h0 _ h1 -> B.modifies B.loc_none h0 h1)
let compare_and_print b1 b2 len =
push_frame();
LowStar.Printf.(printf "Expected: %xuy\n" len b1 done);
LowStar.Printf.(printf "Computed: %xuy\n" len b2 done);
let b = Lib.ByteBuffer.lbytes_eq #len b1 b2 in
if b then
LowStar.Printf.(printf "PASS\n" done)
else
LowStar.Printf.(printf "FAIL\n" done);
pop_frame();
b
let test_sigver256 (vec:sigver_vector) : Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
let max_msg_len = 0 in
let LB msg_len msg,
LB qx_len qx,
LB qy_len qy,
LB r_len r,
LB s_len s,
result = vec
in
B.recall msg;
B.recall qx;
B.recall qy;
B.recall r;
B.recall s;
// We need to check this at runtime because Low*-ized vectors don't carry any refinements
if not (qx_len = 32ul && qy_len = 32ul && r_len = 32ul && s_len = 32ul)
then C.exit (-1l)
else
begin
push_frame();
let qxy = B.alloca (u8 0) 64ul in
B.blit qx 0ul qxy 0ul 32ul;
B.blit qy 0ul qxy 32ul 32ul;
let result' = ecdsa_verif_p256_sha2 msg_len msg qxy r s in
if result' = result then ()
else
begin
LowStar.Printf.(printf "FAIL\n" done);
C.exit 1l
end;
pop_frame()
end
let test_sigver384 (vec:sigver_vector) : Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
let max_msg_len = 0 in
let LB msg_len msg,
LB qx_len qx,
LB qy_len qy,
LB r_len r,
LB s_len s,
result = vec
in
B.recall msg;
B.recall qx;
B.recall qy;
B.recall r;
B.recall s;
// We need to check this at runtime because Low*-ized vectors don't carry any refinements
if not (qx_len = 32ul && qy_len = 32ul && r_len = 32ul && s_len = 32ul)
then C.exit (-1l)
else
begin
push_frame();
let qxy = B.alloca (u8 0) 64ul in
B.blit qx 0ul qxy 0ul 32ul;
B.blit qy 0ul qxy 32ul 32ul;
let result' = ecdsa_verif_p256_sha384 msg_len msg qxy r s in
if result' = result then ()
else
begin
LowStar.Printf.(printf "FAIL\n" done);
C.exit 1l
end;
pop_frame()
end
let test_sigver512 (vec:sigver_vector) : Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
let max_msg_len = 0 in
let LB msg_len msg,
LB qx_len qx,
LB qy_len qy,
LB r_len r,
LB s_len s,
result = vec
in
B.recall msg;
B.recall qx;
B.recall qy;
B.recall r;
B.recall s;
// We need to check this at runtime because Low*-ized vectors don't carry any refinements
if not (qx_len = 32ul && qy_len = 32ul && r_len = 32ul && s_len = 32ul)
then C.exit (-1l)
else
begin
push_frame();
let qxy = B.alloca (u8 0) 64ul in
B.blit qx 0ul qxy 0ul 32ul;
B.blit qy 0ul qxy 32ul 32ul;
let result' = ecdsa_verif_p256_sha512 msg_len msg qxy r s in
if result' = result then ()
else
begin
LowStar.Printf.(printf "FAIL\n" done);
C.exit 1l
end;
pop_frame()
end
#push-options "--fuel 1 --ifuel 1 --z3rlimit 200"
val check_bound: b:Lib.Buffer.lbuffer uint8 32ul -> Stack bool
(requires fun h -> Lib.Buffer.live h b)
(ensures fun h0 r h1 ->
h0 == h1 /\
r ==
(
(Lib.ByteSequence.nat_from_bytes_be (Lib.Buffer.as_seq h0 b) > 0) &&
(Lib.ByteSequence.nat_from_bytes_be (Lib.Buffer.as_seq h0 b) <
Spec.P256.order))) | false | false | Hacl.Test.ECDSA.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": 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": 200,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val check_bound: b:Lib.Buffer.lbuffer uint8 32ul -> Stack bool
(requires fun h -> Lib.Buffer.live h b)
(ensures fun h0 r h1 ->
h0 == h1 /\
r ==
(
(Lib.ByteSequence.nat_from_bytes_be (Lib.Buffer.as_seq h0 b) > 0) &&
(Lib.ByteSequence.nat_from_bytes_be (Lib.Buffer.as_seq h0 b) <
Spec.P256.order))) | [] | Hacl.Test.ECDSA.check_bound | {
"file_name": "code/tests/Hacl.Test.ECDSA.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 32ul -> FStar.HyperStack.ST.Stack Prims.bool | {
"end_col": 13,
"end_line": 262,
"start_col": 2,
"start_line": 213
} |
Prims.Tot | val va_quick_Fast_sqr (offset: nat) (dst_b inA_b: buffer64)
: (va_quickCode unit (va_code_Fast_sqr offset)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.Defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastSqr_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"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.InsStack",
"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.Arch.Types",
"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.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"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.InsStack",
"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.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.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_Fast_sqr (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Fast_sqr offset)) =
(va_QProc (va_code_Fast_sqr offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax;
va_Mod_mem]) (va_wp_Fast_sqr offset dst_b inA_b) (va_wpProof_Fast_sqr offset dst_b inA_b)) | val va_quick_Fast_sqr (offset: nat) (dst_b inA_b: buffer64)
: (va_quickCode unit (va_code_Fast_sqr offset))
let va_quick_Fast_sqr (offset: nat) (dst_b inA_b: buffer64)
: (va_quickCode unit (va_code_Fast_sqr offset)) = | false | null | false | (va_QProc (va_code_Fast_sqr offset)
([
va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx;
va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem
])
(va_wp_Fast_sqr offset dst_b inA_b)
(va_wpProof_Fast_sqr offset dst_b inA_b)) | {
"checked_file": "Vale.Curve25519.X64.FastSqr.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.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.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastSqr.fsti"
} | [
"total"
] | [
"Prims.nat",
"Vale.X64.Memory.buffer64",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.Curve25519.X64.FastSqr.va_code_Fast_sqr",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_Mod_mem_heaplet",
"Vale.X64.QuickCode.va_Mod_reg64",
"Vale.X64.Machine_s.rR15",
"Vale.X64.Machine_s.rR14",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rRax",
"Vale.X64.QuickCode.va_Mod_mem",
"Prims.Nil",
"Vale.Curve25519.X64.FastSqr.va_wp_Fast_sqr",
"Vale.Curve25519.X64.FastSqr.va_wpProof_Fast_sqr",
"Vale.X64.QuickCode.va_quickCode"
] | [] | module Vale.Curve25519.X64.FastSqr
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Fast_sqr
val va_code_Fast_sqr : offset:nat -> Tot va_code
val va_codegen_success_Fast_sqr : offset:nat -> Tot va_pbool
val va_lemma_Fast_sqr : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_sqr offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset) (va_get_mem_heaplet 0 va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1
a2 a3 in adx_enabled /\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\
Vale.X64.Decls.buffers_disjoint dst_b inA_b /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0)
(va_get_reg64 rRsi va_s0) inA_b (4 + offset) (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 (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset) (va_get_mem_heaplet 0 va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1
a2 a3 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset
`op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2
+ offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read
dst_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d4 =
Vale.X64.Decls.buffer64_read dst_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in
let d5 = Vale.X64.Decls.buffer64_read dst_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0
va_sM) in let d6 = Vale.X64.Decls.buffer64_read dst_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM) in let d7 = Vale.X64.Decls.buffer64_read dst_b (7 + offset
`op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_eight
d0 d1 d2 d3 d4 d5 d6 d7 in d == va_mul_nat a a /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset `op_Multiply` 2) (8 +
offset `op_Multiply` 2 - 1)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet
0 va_sM (va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))
[@ va_qattr]
let va_wp_Fast_sqr (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled /\ (offset == 0
\/ offset == 4) /\ Vale.X64.Decls.buffers_disjoint dst_b inA_b /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (4 + offset) (va_get_mem_layout
va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rbx:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRbx va_x_rbx
(va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0))))))))))))) in va_get_ok va_sM /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset) (va_get_mem_heaplet 0 va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1
a2 a3 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset
`op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2
+ offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read
dst_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d4 =
Vale.X64.Decls.buffer64_read dst_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in
let d5 = Vale.X64.Decls.buffer64_read dst_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0
va_sM) in let d6 = Vale.X64.Decls.buffer64_read dst_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM) in let d7 = Vale.X64.Decls.buffer64_read dst_b (7 + offset
`op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_eight
d0 d1 d2 d3 d4 d5 d6 d7 in d == va_mul_nat a a /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset `op_Multiply` 2) (8 +
offset `op_Multiply` 2 - 1)) ==> va_k va_sM (())))
val va_wpProof_Fast_sqr : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_sqr offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_sqr offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_sqr (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit | false | false | Vale.Curve25519.X64.FastSqr.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 va_quick_Fast_sqr (offset: nat) (dst_b inA_b: buffer64)
: (va_quickCode unit (va_code_Fast_sqr offset)) | [] | Vale.Curve25519.X64.FastSqr.va_quick_Fast_sqr | {
"file_name": "obj/Vale.Curve25519.X64.FastSqr.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | offset: Prims.nat -> dst_b: Vale.X64.Memory.buffer64 -> inA_b: Vale.X64.Memory.buffer64
-> Vale.X64.QuickCode.va_quickCode Prims.unit
(Vale.Curve25519.X64.FastSqr.va_code_Fast_sqr offset) | {
"end_col": 94,
"end_line": 122,
"start_col": 2,
"start_line": 119
} |
Prims.Tot | val va_quick_Fast_sqr_stdcall (win: bool) (dst_b inA_b: buffer64)
: (va_quickCode unit (va_code_Fast_sqr_stdcall win)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.Defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastSqr_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"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.InsStack",
"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.Arch.Types",
"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.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"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.InsStack",
"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.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.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_Fast_sqr_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Fast_sqr_stdcall win)) =
(va_QProc (va_code_Fast_sqr_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_heaplet 0;
va_Mod_flags; va_Mod_reg64 rRsp; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax;
va_Mod_mem]) (va_wp_Fast_sqr_stdcall win dst_b inA_b) (va_wpProof_Fast_sqr_stdcall win dst_b
inA_b)) | val va_quick_Fast_sqr_stdcall (win: bool) (dst_b inA_b: buffer64)
: (va_quickCode unit (va_code_Fast_sqr_stdcall win))
let va_quick_Fast_sqr_stdcall (win: bool) (dst_b inA_b: buffer64)
: (va_quickCode unit (va_code_Fast_sqr_stdcall win)) = | false | null | false | (va_QProc (va_code_Fast_sqr_stdcall win)
([
va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rRsp;
va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11;
va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsi; va_Mod_reg64 rRdi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem
])
(va_wp_Fast_sqr_stdcall win dst_b inA_b)
(va_wpProof_Fast_sqr_stdcall win dst_b inA_b)) | {
"checked_file": "Vale.Curve25519.X64.FastSqr.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.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.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastSqr.fsti"
} | [
"total"
] | [
"Prims.bool",
"Vale.X64.Memory.buffer64",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.Curve25519.X64.FastSqr.va_code_Fast_sqr_stdcall",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_stackTaint",
"Vale.X64.QuickCode.va_Mod_stack",
"Vale.X64.QuickCode.va_Mod_mem_heaplet",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_Mod_reg64",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.Machine_s.rR15",
"Vale.X64.Machine_s.rR14",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRdi",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rRax",
"Vale.X64.QuickCode.va_Mod_mem",
"Prims.Nil",
"Vale.Curve25519.X64.FastSqr.va_wp_Fast_sqr_stdcall",
"Vale.Curve25519.X64.FastSqr.va_wpProof_Fast_sqr_stdcall",
"Vale.X64.QuickCode.va_quickCode"
] | [] | module Vale.Curve25519.X64.FastSqr
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Fast_sqr
val va_code_Fast_sqr : offset:nat -> Tot va_code
val va_codegen_success_Fast_sqr : offset:nat -> Tot va_pbool
val va_lemma_Fast_sqr : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_sqr offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset) (va_get_mem_heaplet 0 va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1
a2 a3 in adx_enabled /\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\
Vale.X64.Decls.buffers_disjoint dst_b inA_b /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0)
(va_get_reg64 rRsi va_s0) inA_b (4 + offset) (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 (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset) (va_get_mem_heaplet 0 va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1
a2 a3 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset
`op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2
+ offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read
dst_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d4 =
Vale.X64.Decls.buffer64_read dst_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in
let d5 = Vale.X64.Decls.buffer64_read dst_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0
va_sM) in let d6 = Vale.X64.Decls.buffer64_read dst_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM) in let d7 = Vale.X64.Decls.buffer64_read dst_b (7 + offset
`op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_eight
d0 d1 d2 d3 d4 d5 d6 d7 in d == va_mul_nat a a /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset `op_Multiply` 2) (8 +
offset `op_Multiply` 2 - 1)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet
0 va_sM (va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))
[@ va_qattr]
let va_wp_Fast_sqr (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled /\ (offset == 0
\/ offset == 4) /\ Vale.X64.Decls.buffers_disjoint dst_b inA_b /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (4 + offset) (va_get_mem_layout
va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rbx:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRbx va_x_rbx
(va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0))))))))))))) in va_get_ok va_sM /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset) (va_get_mem_heaplet 0 va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1
a2 a3 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset
`op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2
+ offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read
dst_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d4 =
Vale.X64.Decls.buffer64_read dst_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in
let d5 = Vale.X64.Decls.buffer64_read dst_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0
va_sM) in let d6 = Vale.X64.Decls.buffer64_read dst_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM) in let d7 = Vale.X64.Decls.buffer64_read dst_b (7 + offset
`op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_eight
d0 d1 d2 d3 d4 d5 d6 d7 in d == va_mul_nat a a /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset `op_Multiply` 2) (8 +
offset `op_Multiply` 2 - 1)) ==> va_k va_sM (())))
val va_wpProof_Fast_sqr : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_sqr offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_sqr offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_sqr (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Fast_sqr offset)) =
(va_QProc (va_code_Fast_sqr offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax;
va_Mod_mem]) (va_wp_Fast_sqr offset dst_b inA_b) (va_wpProof_Fast_sqr offset dst_b inA_b))
//--
//-- Fast_sqr_stdcall
val va_code_Fast_sqr_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fast_sqr_stdcall : win:bool -> Tot va_pbool
val va_lemma_Fast_sqr_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_sqr_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
Vale.X64.Decls.buffers_disjoint dst_b inA_b /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem_heaplet 0 va_s0) dst_in dst_b 8 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) inA_in inA_b 4 (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 (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let a0 = Vale.X64.Decls.buffer64_read
inA_b 0 (va_get_mem_heaplet 0 va_s0) in let a1 = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem_heaplet 0 va_s0) in let a2 = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem_heaplet 0 va_s0) in let a3 = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem_heaplet 0 va_s0) in let d0 = Vale.X64.Decls.buffer64_read dst_b 0
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b 2
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b 3
(va_get_mem_heaplet 0 va_sM) in let d4 = Vale.X64.Decls.buffer64_read dst_b 4
(va_get_mem_heaplet 0 va_sM) in let d5 = Vale.X64.Decls.buffer64_read dst_b 5
(va_get_mem_heaplet 0 va_sM) in let d6 = Vale.X64.Decls.buffer64_read dst_b 6
(va_get_mem_heaplet 0 va_sM) in let d7 = Vale.X64.Decls.buffer64_read dst_b 7
(va_get_mem_heaplet 0 va_sM) in let a = a0 + va_mul_nat pow2_64 a1 + va_mul_nat pow2_128 a2 +
va_mul_nat pow2_192 a3 in let d = d0 + va_mul_nat pow2_64 d1 + va_mul_nat pow2_128 d2 +
va_mul_nat pow2_192 d3 + va_mul_nat pow2_256 d4 + va_mul_nat pow2_320 d5 + va_mul_nat pow2_384
d6 + va_mul_nat pow2_448 d7 in d == va_mul_nat a a /\ Vale.X64.Decls.modifies_buffer dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) dst_in dst_b 8 (va_get_mem_layout va_sM) Secret /\ va_get_reg64
rRbx va_sM == va_get_reg64 rRbx va_s0 /\ va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0 /\
va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0 /\ va_get_reg64 rR14 va_sM == va_get_reg64
rR14 va_s0 /\ va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0 /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rRsp va_sM
(va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fast_sqr_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
(adx_enabled /\ bmi2_enabled) /\ Vale.X64.Decls.buffers_disjoint dst_b inA_b /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) dst_in dst_b 8 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) inA_in inA_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rdi:nat64) (va_x_rsi:nat64)
(va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64) (va_x_r13:nat64)
(va_x_r14:nat64) (va_x_r15:nat64) (va_x_rsp:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_stack:vale_stack) (va_x_stackTaint:memtaint) . let va_sM =
va_upd_stackTaint va_x_stackTaint (va_upd_stack va_x_stack (va_upd_mem_heaplet 0 va_x_heap0
(va_upd_flags va_x_efl (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64
rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRsi va_x_rsi
(va_upd_reg64 rRdi va_x_rdi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let a0 =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem_heaplet 0 va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem_heaplet 0 va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem_heaplet 0 va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem_heaplet 0 va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem_heaplet 0 va_sM) in let d4 =
Vale.X64.Decls.buffer64_read dst_b 4 (va_get_mem_heaplet 0 va_sM) in let d5 =
Vale.X64.Decls.buffer64_read dst_b 5 (va_get_mem_heaplet 0 va_sM) in let d6 =
Vale.X64.Decls.buffer64_read dst_b 6 (va_get_mem_heaplet 0 va_sM) in let d7 =
Vale.X64.Decls.buffer64_read dst_b 7 (va_get_mem_heaplet 0 va_sM) in let a = a0 + va_mul_nat
pow2_64 a1 + va_mul_nat pow2_128 a2 + va_mul_nat pow2_192 a3 in let d = d0 + va_mul_nat pow2_64
d1 + va_mul_nat pow2_128 d2 + va_mul_nat pow2_192 d3 + va_mul_nat pow2_256 d4 + va_mul_nat
pow2_320 d5 + va_mul_nat pow2_384 d6 + va_mul_nat pow2_448 d7 in d == va_mul_nat a a /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM)
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) dst_in dst_b 8
(va_get_mem_layout va_sM) Secret /\ va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0 /\
va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0 /\ va_get_reg64 rR13 va_sM == va_get_reg64
rR13 va_s0 /\ va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0 /\ va_get_reg64 rR15 va_sM ==
va_get_reg64 rR15 va_s0 /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==> va_k va_sM
(())))
val va_wpProof_Fast_sqr_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_sqr_stdcall win dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_sqr_stdcall win)
([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rRsp;
va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10;
va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsi; va_Mod_reg64 rRdi; va_Mod_reg64 rRdx;
va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_sqr_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit | false | false | Vale.Curve25519.X64.FastSqr.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 va_quick_Fast_sqr_stdcall (win: bool) (dst_b inA_b: buffer64)
: (va_quickCode unit (va_code_Fast_sqr_stdcall win)) | [] | Vale.Curve25519.X64.FastSqr.va_quick_Fast_sqr_stdcall | {
"file_name": "obj/Vale.Curve25519.X64.FastSqr.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | win: Prims.bool -> dst_b: Vale.X64.Memory.buffer64 -> inA_b: Vale.X64.Memory.buffer64
-> Vale.X64.QuickCode.va_quickCode Prims.unit
(Vale.Curve25519.X64.FastSqr.va_code_Fast_sqr_stdcall win) | {
"end_col": 11,
"end_line": 239,
"start_col": 2,
"start_line": 234
} |
Prims.Tot | val va_quick_Sqr2_stdcall (win: bool) (dst_b inA_b: buffer64)
: (va_quickCode unit (va_code_Sqr2_stdcall win)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.Defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastSqr_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"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.InsStack",
"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.Arch.Types",
"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.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"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.InsStack",
"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.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.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_Sqr2_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Sqr2_stdcall win)) =
(va_QProc (va_code_Sqr2_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_heaplet 0;
va_Mod_flags; va_Mod_reg64 rRsp; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax;
va_Mod_mem]) (va_wp_Sqr2_stdcall win dst_b inA_b) (va_wpProof_Sqr2_stdcall win dst_b inA_b)) | val va_quick_Sqr2_stdcall (win: bool) (dst_b inA_b: buffer64)
: (va_quickCode unit (va_code_Sqr2_stdcall win))
let va_quick_Sqr2_stdcall (win: bool) (dst_b inA_b: buffer64)
: (va_quickCode unit (va_code_Sqr2_stdcall win)) = | false | null | false | (va_QProc (va_code_Sqr2_stdcall win)
([
va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rRsp;
va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11;
va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsi; va_Mod_reg64 rRdi;
va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem
])
(va_wp_Sqr2_stdcall win dst_b inA_b)
(va_wpProof_Sqr2_stdcall win dst_b inA_b)) | {
"checked_file": "Vale.Curve25519.X64.FastSqr.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.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.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastSqr.fsti"
} | [
"total"
] | [
"Prims.bool",
"Vale.X64.Memory.buffer64",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.Curve25519.X64.FastSqr.va_code_Sqr2_stdcall",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_stackTaint",
"Vale.X64.QuickCode.va_Mod_stack",
"Vale.X64.QuickCode.va_Mod_mem_heaplet",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_Mod_reg64",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.Machine_s.rR15",
"Vale.X64.Machine_s.rR14",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRdi",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rRax",
"Vale.X64.QuickCode.va_Mod_mem",
"Prims.Nil",
"Vale.Curve25519.X64.FastSqr.va_wp_Sqr2_stdcall",
"Vale.Curve25519.X64.FastSqr.va_wpProof_Sqr2_stdcall",
"Vale.X64.QuickCode.va_quickCode"
] | [] | module Vale.Curve25519.X64.FastSqr
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Fast_sqr
val va_code_Fast_sqr : offset:nat -> Tot va_code
val va_codegen_success_Fast_sqr : offset:nat -> Tot va_pbool
val va_lemma_Fast_sqr : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_sqr offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset) (va_get_mem_heaplet 0 va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1
a2 a3 in adx_enabled /\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\
Vale.X64.Decls.buffers_disjoint dst_b inA_b /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0)
(va_get_reg64 rRsi va_s0) inA_b (4 + offset) (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 (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset) (va_get_mem_heaplet 0 va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1
a2 a3 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset
`op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2
+ offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read
dst_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d4 =
Vale.X64.Decls.buffer64_read dst_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in
let d5 = Vale.X64.Decls.buffer64_read dst_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0
va_sM) in let d6 = Vale.X64.Decls.buffer64_read dst_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM) in let d7 = Vale.X64.Decls.buffer64_read dst_b (7 + offset
`op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_eight
d0 d1 d2 d3 d4 d5 d6 d7 in d == va_mul_nat a a /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset `op_Multiply` 2) (8 +
offset `op_Multiply` 2 - 1)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet
0 va_sM (va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))
[@ va_qattr]
let va_wp_Fast_sqr (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled /\ (offset == 0
\/ offset == 4) /\ Vale.X64.Decls.buffers_disjoint dst_b inA_b /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (4 + offset) (va_get_mem_layout
va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rbx:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRbx va_x_rbx
(va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0))))))))))))) in va_get_ok va_sM /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset) (va_get_mem_heaplet 0 va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1
a2 a3 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset
`op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2
+ offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read
dst_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d4 =
Vale.X64.Decls.buffer64_read dst_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in
let d5 = Vale.X64.Decls.buffer64_read dst_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0
va_sM) in let d6 = Vale.X64.Decls.buffer64_read dst_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM) in let d7 = Vale.X64.Decls.buffer64_read dst_b (7 + offset
`op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_eight
d0 d1 d2 d3 d4 d5 d6 d7 in d == va_mul_nat a a /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset `op_Multiply` 2) (8 +
offset `op_Multiply` 2 - 1)) ==> va_k va_sM (())))
val va_wpProof_Fast_sqr : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_sqr offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_sqr offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_sqr (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Fast_sqr offset)) =
(va_QProc (va_code_Fast_sqr offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax;
va_Mod_mem]) (va_wp_Fast_sqr offset dst_b inA_b) (va_wpProof_Fast_sqr offset dst_b inA_b))
//--
//-- Fast_sqr_stdcall
val va_code_Fast_sqr_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fast_sqr_stdcall : win:bool -> Tot va_pbool
val va_lemma_Fast_sqr_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_sqr_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
Vale.X64.Decls.buffers_disjoint dst_b inA_b /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem_heaplet 0 va_s0) dst_in dst_b 8 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) inA_in inA_b 4 (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 (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let a0 = Vale.X64.Decls.buffer64_read
inA_b 0 (va_get_mem_heaplet 0 va_s0) in let a1 = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem_heaplet 0 va_s0) in let a2 = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem_heaplet 0 va_s0) in let a3 = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem_heaplet 0 va_s0) in let d0 = Vale.X64.Decls.buffer64_read dst_b 0
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b 2
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b 3
(va_get_mem_heaplet 0 va_sM) in let d4 = Vale.X64.Decls.buffer64_read dst_b 4
(va_get_mem_heaplet 0 va_sM) in let d5 = Vale.X64.Decls.buffer64_read dst_b 5
(va_get_mem_heaplet 0 va_sM) in let d6 = Vale.X64.Decls.buffer64_read dst_b 6
(va_get_mem_heaplet 0 va_sM) in let d7 = Vale.X64.Decls.buffer64_read dst_b 7
(va_get_mem_heaplet 0 va_sM) in let a = a0 + va_mul_nat pow2_64 a1 + va_mul_nat pow2_128 a2 +
va_mul_nat pow2_192 a3 in let d = d0 + va_mul_nat pow2_64 d1 + va_mul_nat pow2_128 d2 +
va_mul_nat pow2_192 d3 + va_mul_nat pow2_256 d4 + va_mul_nat pow2_320 d5 + va_mul_nat pow2_384
d6 + va_mul_nat pow2_448 d7 in d == va_mul_nat a a /\ Vale.X64.Decls.modifies_buffer dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) dst_in dst_b 8 (va_get_mem_layout va_sM) Secret /\ va_get_reg64
rRbx va_sM == va_get_reg64 rRbx va_s0 /\ va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0 /\
va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0 /\ va_get_reg64 rR14 va_sM == va_get_reg64
rR14 va_s0 /\ va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0 /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rRsp va_sM
(va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fast_sqr_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
(adx_enabled /\ bmi2_enabled) /\ Vale.X64.Decls.buffers_disjoint dst_b inA_b /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) dst_in dst_b 8 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) inA_in inA_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rdi:nat64) (va_x_rsi:nat64)
(va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64) (va_x_r13:nat64)
(va_x_r14:nat64) (va_x_r15:nat64) (va_x_rsp:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_stack:vale_stack) (va_x_stackTaint:memtaint) . let va_sM =
va_upd_stackTaint va_x_stackTaint (va_upd_stack va_x_stack (va_upd_mem_heaplet 0 va_x_heap0
(va_upd_flags va_x_efl (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64
rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRsi va_x_rsi
(va_upd_reg64 rRdi va_x_rdi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let a0 =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem_heaplet 0 va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem_heaplet 0 va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem_heaplet 0 va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem_heaplet 0 va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem_heaplet 0 va_sM) in let d4 =
Vale.X64.Decls.buffer64_read dst_b 4 (va_get_mem_heaplet 0 va_sM) in let d5 =
Vale.X64.Decls.buffer64_read dst_b 5 (va_get_mem_heaplet 0 va_sM) in let d6 =
Vale.X64.Decls.buffer64_read dst_b 6 (va_get_mem_heaplet 0 va_sM) in let d7 =
Vale.X64.Decls.buffer64_read dst_b 7 (va_get_mem_heaplet 0 va_sM) in let a = a0 + va_mul_nat
pow2_64 a1 + va_mul_nat pow2_128 a2 + va_mul_nat pow2_192 a3 in let d = d0 + va_mul_nat pow2_64
d1 + va_mul_nat pow2_128 d2 + va_mul_nat pow2_192 d3 + va_mul_nat pow2_256 d4 + va_mul_nat
pow2_320 d5 + va_mul_nat pow2_384 d6 + va_mul_nat pow2_448 d7 in d == va_mul_nat a a /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM)
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) dst_in dst_b 8
(va_get_mem_layout va_sM) Secret /\ va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0 /\
va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0 /\ va_get_reg64 rR13 va_sM == va_get_reg64
rR13 va_s0 /\ va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0 /\ va_get_reg64 rR15 va_sM ==
va_get_reg64 rR15 va_s0 /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==> va_k va_sM
(())))
val va_wpProof_Fast_sqr_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_sqr_stdcall win dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_sqr_stdcall win)
([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rRsp;
va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10;
va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsi; va_Mod_reg64 rRdi; va_Mod_reg64 rRdx;
va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_sqr_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Fast_sqr_stdcall win)) =
(va_QProc (va_code_Fast_sqr_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_heaplet 0;
va_Mod_flags; va_Mod_reg64 rRsp; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax;
va_Mod_mem]) (va_wp_Fast_sqr_stdcall win dst_b inA_b) (va_wpProof_Fast_sqr_stdcall win dst_b
inA_b))
//--
//-- Sqr2_stdcall
val va_code_Sqr2_stdcall : win:bool -> Tot va_code
val va_codegen_success_Sqr2_stdcall : win:bool -> Tot va_pbool
val va_lemma_Sqr2_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Sqr2_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
Vale.X64.Decls.buffers_disjoint dst_b inA_b /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem_heaplet 0 va_s0) dst_in dst_b 16 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) inA_in inA_b 8 (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 (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let a0 = Vale.X64.Decls.buffer64_read
inA_b 0 (va_get_mem_heaplet 0 va_s0) in let a1 = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem_heaplet 0 va_s0) in let a2 = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem_heaplet 0 va_s0) in let a3 = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem_heaplet 0 va_s0) in let d0 = Vale.X64.Decls.buffer64_read dst_b 0
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b 2
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b 3
(va_get_mem_heaplet 0 va_sM) in let d4 = Vale.X64.Decls.buffer64_read dst_b 4
(va_get_mem_heaplet 0 va_sM) in let d5 = Vale.X64.Decls.buffer64_read dst_b 5
(va_get_mem_heaplet 0 va_sM) in let d6 = Vale.X64.Decls.buffer64_read dst_b 6
(va_get_mem_heaplet 0 va_sM) in let d7 = Vale.X64.Decls.buffer64_read dst_b 7
(va_get_mem_heaplet 0 va_sM) in let a = a0 + va_mul_nat pow2_64 a1 + va_mul_nat pow2_128 a2 +
va_mul_nat pow2_192 a3 in let d = d0 + va_mul_nat pow2_64 d1 + va_mul_nat pow2_128 d2 +
va_mul_nat pow2_192 d3 + va_mul_nat pow2_256 d4 + va_mul_nat pow2_320 d5 + va_mul_nat pow2_384
d6 + va_mul_nat pow2_448 d7 in d == va_mul_nat a a /\ Vale.X64.Decls.modifies_buffer dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) dst_in dst_b 16 (va_get_mem_layout va_sM) Secret /\ va_get_reg64
rRbx va_sM == va_get_reg64 rRbx va_s0 /\ va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0 /\
va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0 /\ va_get_reg64 rR14 va_sM == va_get_reg64
rR14 va_s0 /\ va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0 /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rRsp va_sM
(va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))))))))))
[@ va_qattr]
let va_wp_Sqr2_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
(adx_enabled /\ bmi2_enabled) /\ Vale.X64.Decls.buffers_disjoint dst_b inA_b /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) dst_in dst_b 16 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) inA_in inA_b 8
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rdi:nat64) (va_x_rsi:nat64)
(va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64) (va_x_r13:nat64)
(va_x_r14:nat64) (va_x_r15:nat64) (va_x_rsp:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_stack:vale_stack) (va_x_stackTaint:memtaint) . let va_sM =
va_upd_stackTaint va_x_stackTaint (va_upd_stack va_x_stack (va_upd_mem_heaplet 0 va_x_heap0
(va_upd_flags va_x_efl (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64
rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRsi va_x_rsi
(va_upd_reg64 rRdi va_x_rdi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let a0 =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem_heaplet 0 va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem_heaplet 0 va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem_heaplet 0 va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem_heaplet 0 va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem_heaplet 0 va_sM) in let d4 =
Vale.X64.Decls.buffer64_read dst_b 4 (va_get_mem_heaplet 0 va_sM) in let d5 =
Vale.X64.Decls.buffer64_read dst_b 5 (va_get_mem_heaplet 0 va_sM) in let d6 =
Vale.X64.Decls.buffer64_read dst_b 6 (va_get_mem_heaplet 0 va_sM) in let d7 =
Vale.X64.Decls.buffer64_read dst_b 7 (va_get_mem_heaplet 0 va_sM) in let a = a0 + va_mul_nat
pow2_64 a1 + va_mul_nat pow2_128 a2 + va_mul_nat pow2_192 a3 in let d = d0 + va_mul_nat pow2_64
d1 + va_mul_nat pow2_128 d2 + va_mul_nat pow2_192 d3 + va_mul_nat pow2_256 d4 + va_mul_nat
pow2_320 d5 + va_mul_nat pow2_384 d6 + va_mul_nat pow2_448 d7 in d == va_mul_nat a a /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM)
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) dst_in dst_b 16
(va_get_mem_layout va_sM) Secret /\ va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0 /\
va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0 /\ va_get_reg64 rR13 va_sM == va_get_reg64
rR13 va_s0 /\ va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0 /\ va_get_reg64 rR15 va_sM ==
va_get_reg64 rR15 va_s0 /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==> va_k va_sM
(())))
val va_wpProof_Sqr2_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Sqr2_stdcall win dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Sqr2_stdcall win) ([va_Mod_stackTaint;
va_Mod_stack; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rRsp; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRsi; va_Mod_reg64 rRdi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx;
va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Sqr2_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit | false | false | Vale.Curve25519.X64.FastSqr.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 va_quick_Sqr2_stdcall (win: bool) (dst_b inA_b: buffer64)
: (va_quickCode unit (va_code_Sqr2_stdcall win)) | [] | Vale.Curve25519.X64.FastSqr.va_quick_Sqr2_stdcall | {
"file_name": "obj/Vale.Curve25519.X64.FastSqr.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | win: Prims.bool -> dst_b: Vale.X64.Memory.buffer64 -> inA_b: Vale.X64.Memory.buffer64
-> Vale.X64.QuickCode.va_quickCode Prims.unit
(Vale.Curve25519.X64.FastSqr.va_code_Sqr2_stdcall win) | {
"end_col": 96,
"end_line": 354,
"start_col": 2,
"start_line": 350
} |
Prims.Tot | val va_wp_Fast_sqr
(offset: nat)
(dst_b inA_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.Defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastSqr_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"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.InsStack",
"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.Arch.Types",
"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.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"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.InsStack",
"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.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.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_Fast_sqr (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled /\ (offset == 0
\/ offset == 4) /\ Vale.X64.Decls.buffers_disjoint dst_b inA_b /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (4 + offset) (va_get_mem_layout
va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rbx:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRbx va_x_rbx
(va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0))))))))))))) in va_get_ok va_sM /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset) (va_get_mem_heaplet 0 va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1
a2 a3 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset
`op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2
+ offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read
dst_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d4 =
Vale.X64.Decls.buffer64_read dst_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in
let d5 = Vale.X64.Decls.buffer64_read dst_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0
va_sM) in let d6 = Vale.X64.Decls.buffer64_read dst_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM) in let d7 = Vale.X64.Decls.buffer64_read dst_b (7 + offset
`op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_eight
d0 d1 d2 d3 d4 d5 d6 d7 in d == va_mul_nat a a /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset `op_Multiply` 2) (8 +
offset `op_Multiply` 2 - 1)) ==> va_k va_sM (()))) | val va_wp_Fast_sqr
(offset: nat)
(dst_b inA_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Fast_sqr
(offset: nat)
(dst_b inA_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_get_ok va_s0 /\
(let a0:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read inA_b (0 + offset) (va_get_mem_heaplet 0 va_s0)
in
let a1:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read inA_b (1 + offset) (va_get_mem_heaplet 0 va_s0)
in
let a2:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read inA_b (2 + offset) (va_get_mem_heaplet 0 va_s0)
in
let a3:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read inA_b (3 + offset) (va_get_mem_heaplet 0 va_s0)
in
let a:Prims.nat = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
adx_enabled /\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\
Vale.X64.Decls.buffers_disjoint dst_b inA_b /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0)
(va_get_reg64 rRdi va_s0)
dst_b
(8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0)
(va_get_reg64 rRsi va_s0)
inA_b
(4 + offset)
(va_get_mem_layout va_s0)
Secret) /\
(forall (va_x_mem: vale_heap) (va_x_rax: nat64) (va_x_rbx: nat64) (va_x_rcx: nat64)
(va_x_rdx: nat64) (va_x_r8: nat64) (va_x_r9: nat64) (va_x_r10: nat64) (va_x_r11: nat64)
(va_x_r13: nat64) (va_x_r14: nat64) (va_x_r15: nat64) (va_x_heap0: vale_heap)
(va_x_efl: Vale.X64.Flags.t).
let va_sM =
va_upd_flags va_x_efl
(va_upd_mem_heaplet 0
va_x_heap0
(va_upd_reg64 rR15
va_x_r15
(va_upd_reg64 rR14
va_x_r14
(va_upd_reg64 rR13
va_x_r13
(va_upd_reg64 rR11
va_x_r11
(va_upd_reg64 rR10
va_x_r10
(va_upd_reg64 rR9
va_x_r9
(va_upd_reg64 rR8
va_x_r8
(va_upd_reg64 rRdx
va_x_rdx
(va_upd_reg64 rRcx
va_x_rcx
(va_upd_reg64 rRbx
va_x_rbx
(va_upd_reg64 rRax
va_x_rax
(va_upd_mem va_x_mem va_s0)))))))))))))
in
va_get_ok va_sM /\
(let a0:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read inA_b (0 + offset) (va_get_mem_heaplet 0 va_s0)
in
let a1:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read inA_b (1 + offset) (va_get_mem_heaplet 0 va_s0)
in
let a2:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read inA_b (2 + offset) (va_get_mem_heaplet 0 va_s0)
in
let a3:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read inA_b (3 + offset) (va_get_mem_heaplet 0 va_s0)
in
let a:Prims.nat = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in
let d0 =
Vale.X64.Decls.buffer64_read dst_b
(0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM)
in
let d1 =
Vale.X64.Decls.buffer64_read dst_b
(1 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM)
in
let d2 =
Vale.X64.Decls.buffer64_read dst_b
(2 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM)
in
let d3 =
Vale.X64.Decls.buffer64_read dst_b
(3 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM)
in
let d4 =
Vale.X64.Decls.buffer64_read dst_b
(4 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM)
in
let d5 =
Vale.X64.Decls.buffer64_read dst_b
(5 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM)
in
let d6 =
Vale.X64.Decls.buffer64_read dst_b
(6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM)
in
let d7 =
Vale.X64.Decls.buffer64_read dst_b
(7 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM)
in
let d = Vale.Curve25519.Fast_defs.pow2_eight d0 d1 d2 d3 d4 d5 d6 d7 in
d == va_mul_nat a a /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM)
(va_get_reg64 rRdi va_sM)
dst_b
(8 + offset `op_Multiply` 2)
(va_get_mem_layout va_sM)
Secret /\
Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM)
(0 + offset `op_Multiply` 2)
(8 + offset `op_Multiply` 2 - 1)) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.Curve25519.X64.FastSqr.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.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.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastSqr.fsti"
} | [
"total"
] | [
"Prims.nat",
"Vale.X64.Memory.buffer64",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.adx_enabled",
"Vale.X64.CPU_Features_s.bmi2_enabled",
"Prims.l_or",
"Prims.eq2",
"Prims.int",
"Vale.X64.Decls.buffers_disjoint",
"Vale.X64.Decls.validDstAddrs64",
"Vale.X64.Decls.va_get_mem_heaplet",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRdi",
"Prims.op_Addition",
"Prims.op_Multiply",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.validSrcAddrs64",
"Vale.X64.Machine_s.rRsi",
"Vale.Curve25519.Fast_defs.pow2_four",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.buffer64_read",
"Prims.l_Forall",
"Vale.X64.InsBasic.vale_heap",
"Vale.X64.Memory.nat64",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Vale.X64.Decls.va_mul_nat",
"Vale.X64.Decls.modifies_buffer_specific",
"Prims.op_Subtraction",
"Vale.Curve25519.Fast_defs.pow2_eight",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_mem_heaplet",
"Vale.X64.Decls.va_upd_reg64",
"Vale.X64.Machine_s.rR15",
"Vale.X64.Machine_s.rR14",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Decls.va_upd_mem"
] | [] | module Vale.Curve25519.X64.FastSqr
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Fast_sqr
val va_code_Fast_sqr : offset:nat -> Tot va_code
val va_codegen_success_Fast_sqr : offset:nat -> Tot va_pbool
val va_lemma_Fast_sqr : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_sqr offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset) (va_get_mem_heaplet 0 va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1
a2 a3 in adx_enabled /\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\
Vale.X64.Decls.buffers_disjoint dst_b inA_b /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0)
(va_get_reg64 rRsi va_s0) inA_b (4 + offset) (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 (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset) (va_get_mem_heaplet 0 va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1
a2 a3 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset
`op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2
+ offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read
dst_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d4 =
Vale.X64.Decls.buffer64_read dst_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in
let d5 = Vale.X64.Decls.buffer64_read dst_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0
va_sM) in let d6 = Vale.X64.Decls.buffer64_read dst_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM) in let d7 = Vale.X64.Decls.buffer64_read dst_b (7 + offset
`op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_eight
d0 d1 d2 d3 d4 d5 d6 d7 in d == va_mul_nat a a /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset `op_Multiply` 2) (8 +
offset `op_Multiply` 2 - 1)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet
0 va_sM (va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))
[@ va_qattr]
let va_wp_Fast_sqr (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state) (va_k:(va_state | false | true | Vale.Curve25519.X64.FastSqr.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 va_wp_Fast_sqr
(offset: nat)
(dst_b inA_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.Curve25519.X64.FastSqr.va_wp_Fast_sqr | {
"file_name": "obj/Vale.Curve25519.X64.FastSqr.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
offset: Prims.nat ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 54,
"end_line": 106,
"start_col": 2,
"start_line": 67
} |
Prims.Tot | val va_wp_Fast_sqr_stdcall
(win: bool)
(dst_b inA_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.Defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastSqr_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"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.InsStack",
"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.Arch.Types",
"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.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"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.InsStack",
"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.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.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_Fast_sqr_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
(adx_enabled /\ bmi2_enabled) /\ Vale.X64.Decls.buffers_disjoint dst_b inA_b /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) dst_in dst_b 8 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) inA_in inA_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rdi:nat64) (va_x_rsi:nat64)
(va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64) (va_x_r13:nat64)
(va_x_r14:nat64) (va_x_r15:nat64) (va_x_rsp:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_stack:vale_stack) (va_x_stackTaint:memtaint) . let va_sM =
va_upd_stackTaint va_x_stackTaint (va_upd_stack va_x_stack (va_upd_mem_heaplet 0 va_x_heap0
(va_upd_flags va_x_efl (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64
rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRsi va_x_rsi
(va_upd_reg64 rRdi va_x_rdi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let a0 =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem_heaplet 0 va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem_heaplet 0 va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem_heaplet 0 va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem_heaplet 0 va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem_heaplet 0 va_sM) in let d4 =
Vale.X64.Decls.buffer64_read dst_b 4 (va_get_mem_heaplet 0 va_sM) in let d5 =
Vale.X64.Decls.buffer64_read dst_b 5 (va_get_mem_heaplet 0 va_sM) in let d6 =
Vale.X64.Decls.buffer64_read dst_b 6 (va_get_mem_heaplet 0 va_sM) in let d7 =
Vale.X64.Decls.buffer64_read dst_b 7 (va_get_mem_heaplet 0 va_sM) in let a = a0 + va_mul_nat
pow2_64 a1 + va_mul_nat pow2_128 a2 + va_mul_nat pow2_192 a3 in let d = d0 + va_mul_nat pow2_64
d1 + va_mul_nat pow2_128 d2 + va_mul_nat pow2_192 d3 + va_mul_nat pow2_256 d4 + va_mul_nat
pow2_320 d5 + va_mul_nat pow2_384 d6 + va_mul_nat pow2_448 d7 in d == va_mul_nat a a /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM)
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) dst_in dst_b 8
(va_get_mem_layout va_sM) Secret /\ va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0 /\
va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0 /\ va_get_reg64 rR13 va_sM == va_get_reg64
rR13 va_s0 /\ va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0 /\ va_get_reg64 rR15 va_sM ==
va_get_reg64 rR15 va_s0 /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==> va_k va_sM
(()))) | val va_wp_Fast_sqr_stdcall
(win: bool)
(dst_b inA_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Fast_sqr_stdcall
(win: bool)
(dst_b inA_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_get_ok va_s0 /\
(let dst_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0)
in
let inA_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0)
in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
(adx_enabled /\ bmi2_enabled) /\ Vale.X64.Decls.buffers_disjoint dst_b inA_b /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0)
dst_in
dst_b
8
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0)
inA_in
inA_b
4
(va_get_mem_layout va_s0)
Secret) /\
(forall (va_x_mem: vale_heap) (va_x_rax: nat64) (va_x_rbx: nat64) (va_x_rcx: nat64)
(va_x_rdx: nat64) (va_x_rdi: nat64) (va_x_rsi: nat64) (va_x_r8: nat64) (va_x_r9: nat64)
(va_x_r10: nat64) (va_x_r11: nat64) (va_x_r13: nat64) (va_x_r14: nat64) (va_x_r15: nat64)
(va_x_rsp: nat64) (va_x_efl: Vale.X64.Flags.t) (va_x_heap0: vale_heap)
(va_x_stack: vale_stack) (va_x_stackTaint: memtaint).
let va_sM =
va_upd_stackTaint va_x_stackTaint
(va_upd_stack va_x_stack
(va_upd_mem_heaplet 0
va_x_heap0
(va_upd_flags va_x_efl
(va_upd_reg64 rRsp
va_x_rsp
(va_upd_reg64 rR15
va_x_r15
(va_upd_reg64 rR14
va_x_r14
(va_upd_reg64 rR13
va_x_r13
(va_upd_reg64 rR11
va_x_r11
(va_upd_reg64 rR10
va_x_r10
(va_upd_reg64 rR9
va_x_r9
(va_upd_reg64 rR8
va_x_r8
(va_upd_reg64 rRsi
va_x_rsi
(va_upd_reg64 rRdi
va_x_rdi
(va_upd_reg64 rRdx
va_x_rdx
(va_upd_reg64 rRcx
va_x_rcx
(va_upd_reg64 rRbx
va_x_rbx
(va_upd_reg64 rRax
va_x_rax
(va_upd_mem va_x_mem
va_s0)))))))))))))
)))))
in
va_get_ok va_sM /\
(let dst_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0)
in
let inA_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0)
in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem_heaplet 0 va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem_heaplet 0 va_s0) in
let a2 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem_heaplet 0 va_s0) in
let a3 = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem_heaplet 0 va_s0) in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem_heaplet 0 va_sM) in
let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem_heaplet 0 va_sM) in
let d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem_heaplet 0 va_sM) in
let d3 = Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem_heaplet 0 va_sM) in
let d4 = Vale.X64.Decls.buffer64_read dst_b 4 (va_get_mem_heaplet 0 va_sM) in
let d5 = Vale.X64.Decls.buffer64_read dst_b 5 (va_get_mem_heaplet 0 va_sM) in
let d6 = Vale.X64.Decls.buffer64_read dst_b 6 (va_get_mem_heaplet 0 va_sM) in
let d7 = Vale.X64.Decls.buffer64_read dst_b 7 (va_get_mem_heaplet 0 va_sM) in
let a = a0 + va_mul_nat pow2_64 a1 + va_mul_nat pow2_128 a2 + va_mul_nat pow2_192 a3 in
let d =
d0 + va_mul_nat pow2_64 d1 + va_mul_nat pow2_128 d2 + va_mul_nat pow2_192 d3 +
va_mul_nat pow2_256 d4 +
va_mul_nat pow2_320 d5 +
va_mul_nat pow2_384 d6 +
va_mul_nat pow2_448 d7
in
d == va_mul_nat a a /\
Vale.X64.Decls.modifies_buffer dst_b
(va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM)
dst_in
dst_b
8
(va_get_mem_layout va_sM)
Secret /\ va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0 /\
va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0 /\
va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0 /\
va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0 /\
va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0 /\
va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.Curve25519.X64.FastSqr.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.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.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastSqr.fsti"
} | [
"total"
] | [
"Prims.bool",
"Vale.X64.Memory.buffer64",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Prims.eq2",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.Stack_i.init_rsp",
"Vale.X64.Decls.va_get_stack",
"Vale.X64.CPU_Features_s.adx_enabled",
"Vale.X64.CPU_Features_s.bmi2_enabled",
"Vale.X64.Decls.buffers_disjoint",
"Vale.X64.Decls.validDstAddrs64",
"Vale.X64.Decls.va_get_mem_heaplet",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.validSrcAddrs64",
"Vale.X64.Decls.va_int_range",
"Vale.X64.Decls.va_if",
"Vale.Def.Types_s.nat64",
"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.Flags.t",
"Vale.X64.InsBasic.vale_stack",
"Vale.X64.Memory.memtaint",
"Prims.l_imp",
"Prims.int",
"Vale.X64.Decls.va_mul_nat",
"Vale.X64.Decls.modifies_buffer",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rR14",
"Vale.X64.Machine_s.rR15",
"Prims.op_Addition",
"Vale.X64.Machine_s.pow2_64",
"Vale.X64.Machine_s.pow2_128",
"Vale.Curve25519.Fast_defs.pow2_192",
"Vale.Curve25519.Fast_defs.pow2_256",
"Vale.Curve25519.Fast_defs.pow2_320",
"Vale.Curve25519.Fast_defs.pow2_384",
"Vale.Curve25519.Fast_defs.pow2_448",
"Vale.X64.Decls.buffer64_read",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_stackTaint",
"Vale.X64.Decls.va_upd_stack",
"Vale.X64.Decls.va_upd_mem_heaplet",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_reg64",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Decls.va_upd_mem"
] | [] | module Vale.Curve25519.X64.FastSqr
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Fast_sqr
val va_code_Fast_sqr : offset:nat -> Tot va_code
val va_codegen_success_Fast_sqr : offset:nat -> Tot va_pbool
val va_lemma_Fast_sqr : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_sqr offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset) (va_get_mem_heaplet 0 va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1
a2 a3 in adx_enabled /\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\
Vale.X64.Decls.buffers_disjoint dst_b inA_b /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0)
(va_get_reg64 rRsi va_s0) inA_b (4 + offset) (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 (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset) (va_get_mem_heaplet 0 va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1
a2 a3 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset
`op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2
+ offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read
dst_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d4 =
Vale.X64.Decls.buffer64_read dst_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in
let d5 = Vale.X64.Decls.buffer64_read dst_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0
va_sM) in let d6 = Vale.X64.Decls.buffer64_read dst_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM) in let d7 = Vale.X64.Decls.buffer64_read dst_b (7 + offset
`op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_eight
d0 d1 d2 d3 d4 d5 d6 d7 in d == va_mul_nat a a /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset `op_Multiply` 2) (8 +
offset `op_Multiply` 2 - 1)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet
0 va_sM (va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))
[@ va_qattr]
let va_wp_Fast_sqr (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled /\ (offset == 0
\/ offset == 4) /\ Vale.X64.Decls.buffers_disjoint dst_b inA_b /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (4 + offset) (va_get_mem_layout
va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rbx:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRbx va_x_rbx
(va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0))))))))))))) in va_get_ok va_sM /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset) (va_get_mem_heaplet 0 va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1
a2 a3 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset
`op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2
+ offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read
dst_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d4 =
Vale.X64.Decls.buffer64_read dst_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in
let d5 = Vale.X64.Decls.buffer64_read dst_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0
va_sM) in let d6 = Vale.X64.Decls.buffer64_read dst_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM) in let d7 = Vale.X64.Decls.buffer64_read dst_b (7 + offset
`op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_eight
d0 d1 d2 d3 d4 d5 d6 d7 in d == va_mul_nat a a /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset `op_Multiply` 2) (8 +
offset `op_Multiply` 2 - 1)) ==> va_k va_sM (())))
val va_wpProof_Fast_sqr : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_sqr offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_sqr offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_sqr (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Fast_sqr offset)) =
(va_QProc (va_code_Fast_sqr offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax;
va_Mod_mem]) (va_wp_Fast_sqr offset dst_b inA_b) (va_wpProof_Fast_sqr offset dst_b inA_b))
//--
//-- Fast_sqr_stdcall
val va_code_Fast_sqr_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fast_sqr_stdcall : win:bool -> Tot va_pbool
val va_lemma_Fast_sqr_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_sqr_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
Vale.X64.Decls.buffers_disjoint dst_b inA_b /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem_heaplet 0 va_s0) dst_in dst_b 8 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) inA_in inA_b 4 (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 (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let a0 = Vale.X64.Decls.buffer64_read
inA_b 0 (va_get_mem_heaplet 0 va_s0) in let a1 = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem_heaplet 0 va_s0) in let a2 = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem_heaplet 0 va_s0) in let a3 = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem_heaplet 0 va_s0) in let d0 = Vale.X64.Decls.buffer64_read dst_b 0
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b 2
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b 3
(va_get_mem_heaplet 0 va_sM) in let d4 = Vale.X64.Decls.buffer64_read dst_b 4
(va_get_mem_heaplet 0 va_sM) in let d5 = Vale.X64.Decls.buffer64_read dst_b 5
(va_get_mem_heaplet 0 va_sM) in let d6 = Vale.X64.Decls.buffer64_read dst_b 6
(va_get_mem_heaplet 0 va_sM) in let d7 = Vale.X64.Decls.buffer64_read dst_b 7
(va_get_mem_heaplet 0 va_sM) in let a = a0 + va_mul_nat pow2_64 a1 + va_mul_nat pow2_128 a2 +
va_mul_nat pow2_192 a3 in let d = d0 + va_mul_nat pow2_64 d1 + va_mul_nat pow2_128 d2 +
va_mul_nat pow2_192 d3 + va_mul_nat pow2_256 d4 + va_mul_nat pow2_320 d5 + va_mul_nat pow2_384
d6 + va_mul_nat pow2_448 d7 in d == va_mul_nat a a /\ Vale.X64.Decls.modifies_buffer dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) dst_in dst_b 8 (va_get_mem_layout va_sM) Secret /\ va_get_reg64
rRbx va_sM == va_get_reg64 rRbx va_s0 /\ va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0 /\
va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0 /\ va_get_reg64 rR14 va_sM == va_get_reg64
rR14 va_s0 /\ va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0 /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rRsp va_sM
(va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fast_sqr_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state) | false | true | Vale.Curve25519.X64.FastSqr.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 va_wp_Fast_sqr_stdcall
(win: bool)
(dst_b inA_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.Curve25519.X64.FastSqr.va_wp_Fast_sqr_stdcall | {
"file_name": "obj/Vale.Curve25519.X64.FastSqr.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
win: Prims.bool ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 10,
"end_line": 219,
"start_col": 2,
"start_line": 176
} |
Prims.Tot | val va_wp_Sqr2_stdcall
(win: bool)
(dst_b inA_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Bignum.Defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastSqr_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"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.InsStack",
"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.Arch.Types",
"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.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"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.InsStack",
"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.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.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_Sqr2_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
(adx_enabled /\ bmi2_enabled) /\ Vale.X64.Decls.buffers_disjoint dst_b inA_b /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) dst_in dst_b 16 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) inA_in inA_b 8
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rdi:nat64) (va_x_rsi:nat64)
(va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64) (va_x_r13:nat64)
(va_x_r14:nat64) (va_x_r15:nat64) (va_x_rsp:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_stack:vale_stack) (va_x_stackTaint:memtaint) . let va_sM =
va_upd_stackTaint va_x_stackTaint (va_upd_stack va_x_stack (va_upd_mem_heaplet 0 va_x_heap0
(va_upd_flags va_x_efl (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64
rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRsi va_x_rsi
(va_upd_reg64 rRdi va_x_rdi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let a0 =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem_heaplet 0 va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem_heaplet 0 va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem_heaplet 0 va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem_heaplet 0 va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem_heaplet 0 va_sM) in let d4 =
Vale.X64.Decls.buffer64_read dst_b 4 (va_get_mem_heaplet 0 va_sM) in let d5 =
Vale.X64.Decls.buffer64_read dst_b 5 (va_get_mem_heaplet 0 va_sM) in let d6 =
Vale.X64.Decls.buffer64_read dst_b 6 (va_get_mem_heaplet 0 va_sM) in let d7 =
Vale.X64.Decls.buffer64_read dst_b 7 (va_get_mem_heaplet 0 va_sM) in let a = a0 + va_mul_nat
pow2_64 a1 + va_mul_nat pow2_128 a2 + va_mul_nat pow2_192 a3 in let d = d0 + va_mul_nat pow2_64
d1 + va_mul_nat pow2_128 d2 + va_mul_nat pow2_192 d3 + va_mul_nat pow2_256 d4 + va_mul_nat
pow2_320 d5 + va_mul_nat pow2_384 d6 + va_mul_nat pow2_448 d7 in d == va_mul_nat a a /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM)
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) dst_in dst_b 16
(va_get_mem_layout va_sM) Secret /\ va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0 /\
va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0 /\ va_get_reg64 rR13 va_sM == va_get_reg64
rR13 va_s0 /\ va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0 /\ va_get_reg64 rR15 va_sM ==
va_get_reg64 rR15 va_s0 /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==> va_k va_sM
(()))) | val va_wp_Sqr2_stdcall
(win: bool)
(dst_b inA_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Sqr2_stdcall
(win: bool)
(dst_b inA_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_get_ok va_s0 /\
(let dst_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0)
in
let inA_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0)
in
va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
(adx_enabled /\ bmi2_enabled) /\ Vale.X64.Decls.buffers_disjoint dst_b inA_b /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0)
dst_in
dst_b
16
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0)
inA_in
inA_b
8
(va_get_mem_layout va_s0)
Secret) /\
(forall (va_x_mem: vale_heap) (va_x_rax: nat64) (va_x_rbx: nat64) (va_x_rcx: nat64)
(va_x_rdx: nat64) (va_x_rdi: nat64) (va_x_rsi: nat64) (va_x_r8: nat64) (va_x_r9: nat64)
(va_x_r10: nat64) (va_x_r11: nat64) (va_x_r13: nat64) (va_x_r14: nat64) (va_x_r15: nat64)
(va_x_rsp: nat64) (va_x_efl: Vale.X64.Flags.t) (va_x_heap0: vale_heap)
(va_x_stack: vale_stack) (va_x_stackTaint: memtaint).
let va_sM =
va_upd_stackTaint va_x_stackTaint
(va_upd_stack va_x_stack
(va_upd_mem_heaplet 0
va_x_heap0
(va_upd_flags va_x_efl
(va_upd_reg64 rRsp
va_x_rsp
(va_upd_reg64 rR15
va_x_r15
(va_upd_reg64 rR14
va_x_r14
(va_upd_reg64 rR13
va_x_r13
(va_upd_reg64 rR11
va_x_r11
(va_upd_reg64 rR10
va_x_r10
(va_upd_reg64 rR9
va_x_r9
(va_upd_reg64 rR8
va_x_r8
(va_upd_reg64 rRsi
va_x_rsi
(va_upd_reg64 rRdi
va_x_rdi
(va_upd_reg64 rRdx
va_x_rdx
(va_upd_reg64 rRcx
va_x_rcx
(va_upd_reg64 rRbx
va_x_rbx
(va_upd_reg64 rRax
va_x_rax
(va_upd_mem va_x_mem
va_s0)))))))))))))
)))))
in
va_get_ok va_sM /\
(let dst_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0)
in
let inA_in:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0)
in
let a0 = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem_heaplet 0 va_s0) in
let a1 = Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem_heaplet 0 va_s0) in
let a2 = Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem_heaplet 0 va_s0) in
let a3 = Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem_heaplet 0 va_s0) in
let d0 = Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem_heaplet 0 va_sM) in
let d1 = Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem_heaplet 0 va_sM) in
let d2 = Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem_heaplet 0 va_sM) in
let d3 = Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem_heaplet 0 va_sM) in
let d4 = Vale.X64.Decls.buffer64_read dst_b 4 (va_get_mem_heaplet 0 va_sM) in
let d5 = Vale.X64.Decls.buffer64_read dst_b 5 (va_get_mem_heaplet 0 va_sM) in
let d6 = Vale.X64.Decls.buffer64_read dst_b 6 (va_get_mem_heaplet 0 va_sM) in
let d7 = Vale.X64.Decls.buffer64_read dst_b 7 (va_get_mem_heaplet 0 va_sM) in
let a = a0 + va_mul_nat pow2_64 a1 + va_mul_nat pow2_128 a2 + va_mul_nat pow2_192 a3 in
let d =
d0 + va_mul_nat pow2_64 d1 + va_mul_nat pow2_128 d2 + va_mul_nat pow2_192 d3 +
va_mul_nat pow2_256 d4 +
va_mul_nat pow2_320 d5 +
va_mul_nat pow2_384 d6 +
va_mul_nat pow2_448 d7
in
d == va_mul_nat a a /\
Vale.X64.Decls.modifies_buffer dst_b
(va_get_mem_heaplet 0 va_s0)
(va_get_mem_heaplet 0 va_sM) /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM)
dst_in
dst_b
16
(va_get_mem_layout va_sM)
Secret /\ va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0 /\
va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0 /\
va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0 /\
va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0 /\
va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0 /\
va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.Curve25519.X64.FastSqr.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.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.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.X64.FastSqr.fsti"
} | [
"total"
] | [
"Prims.bool",
"Vale.X64.Memory.buffer64",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Prims.eq2",
"Vale.Def.Words_s.nat64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRsp",
"Vale.X64.Stack_i.init_rsp",
"Vale.X64.Decls.va_get_stack",
"Vale.X64.CPU_Features_s.adx_enabled",
"Vale.X64.CPU_Features_s.bmi2_enabled",
"Vale.X64.Decls.buffers_disjoint",
"Vale.X64.Decls.validDstAddrs64",
"Vale.X64.Decls.va_get_mem_heaplet",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.validSrcAddrs64",
"Vale.X64.Decls.va_int_range",
"Vale.X64.Decls.va_if",
"Vale.Def.Types_s.nat64",
"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.Flags.t",
"Vale.X64.InsBasic.vale_stack",
"Vale.X64.Memory.memtaint",
"Prims.l_imp",
"Prims.int",
"Vale.X64.Decls.va_mul_nat",
"Vale.X64.Decls.modifies_buffer",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.Machine_s.rR13",
"Vale.X64.Machine_s.rR14",
"Vale.X64.Machine_s.rR15",
"Prims.op_Addition",
"Vale.X64.Machine_s.pow2_64",
"Vale.X64.Machine_s.pow2_128",
"Vale.Curve25519.Fast_defs.pow2_192",
"Vale.Curve25519.Fast_defs.pow2_256",
"Vale.Curve25519.Fast_defs.pow2_320",
"Vale.Curve25519.Fast_defs.pow2_384",
"Vale.Curve25519.Fast_defs.pow2_448",
"Vale.X64.Decls.buffer64_read",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_stackTaint",
"Vale.X64.Decls.va_upd_stack",
"Vale.X64.Decls.va_upd_mem_heaplet",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_reg64",
"Vale.X64.Machine_s.rR11",
"Vale.X64.Machine_s.rR10",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Decls.va_upd_mem"
] | [] | module Vale.Curve25519.X64.FastSqr
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Curve25519.Fast_defs
open Vale.X64.CPU_Features_s
//-- Fast_sqr
val va_code_Fast_sqr : offset:nat -> Tot va_code
val va_codegen_success_Fast_sqr : offset:nat -> Tot va_pbool
val va_lemma_Fast_sqr : va_b0:va_code -> va_s0:va_state -> offset:nat -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_sqr offset) va_s0 /\ va_get_ok va_s0 /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset) (va_get_mem_heaplet 0 va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1
a2 a3 in adx_enabled /\ bmi2_enabled /\ (offset == 0 \/ offset == 4) /\
Vale.X64.Decls.buffers_disjoint dst_b inA_b /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0)
(va_get_reg64 rRsi va_s0) inA_b (4 + offset) (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 (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset) (va_get_mem_heaplet 0 va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1
a2 a3 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset
`op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2
+ offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read
dst_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d4 =
Vale.X64.Decls.buffer64_read dst_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in
let d5 = Vale.X64.Decls.buffer64_read dst_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0
va_sM) in let d6 = Vale.X64.Decls.buffer64_read dst_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM) in let d7 = Vale.X64.Decls.buffer64_read dst_b (7 + offset
`op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_eight
d0 d1 d2 d3 d4 d5 d6 d7 in d == va_mul_nat a a /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset `op_Multiply` 2) (8 +
offset `op_Multiply` 2 - 1)) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_mem_heaplet
0 va_sM (va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRbx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))
[@ va_qattr]
let va_wp_Fast_sqr (offset:nat) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 +
offset) (va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (1 + offset) (va_get_mem_heaplet 0 va_s0) in let
(a2:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (2 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (3 + offset) (va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) =
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 in adx_enabled /\ bmi2_enabled /\ (offset == 0
\/ offset == 4) /\ Vale.X64.Decls.buffers_disjoint dst_b inA_b /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRdi va_s0) dst_b (8
+ offset `op_Multiply` 2) (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_s0) (va_get_reg64 rRsi va_s0) inA_b (4 + offset) (va_get_mem_layout
va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rbx:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64)
(va_x_r11:nat64) (va_x_r13:nat64) (va_x_r14:nat64) (va_x_r15:nat64) (va_x_heap0:vale_heap)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_mem_heaplet 0
va_x_heap0 (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64 rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13
(va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10 va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64
rR8 va_x_r8 (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRbx va_x_rbx
(va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0))))))))))))) in va_get_ok va_sM /\ (let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (0 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a1:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read
inA_b (1 + offset) (va_get_mem_heaplet 0 va_s0) in let (a2:Vale.Def.Types_s.nat64) =
Vale.X64.Decls.buffer64_read inA_b (2 + offset) (va_get_mem_heaplet 0 va_s0) in let
(a3:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b (3 + offset)
(va_get_mem_heaplet 0 va_s0) in let (a:Prims.nat) = Vale.Curve25519.Fast_defs.pow2_four a0 a1
a2 a3 in let d0 = Vale.X64.Decls.buffer64_read dst_b (0 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b (1 + offset
`op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b (2
+ offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read
dst_b (3 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d4 =
Vale.X64.Decls.buffer64_read dst_b (4 + offset `op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in
let d5 = Vale.X64.Decls.buffer64_read dst_b (5 + offset `op_Multiply` 2) (va_get_mem_heaplet 0
va_sM) in let d6 = Vale.X64.Decls.buffer64_read dst_b (6 + offset `op_Multiply` 2)
(va_get_mem_heaplet 0 va_sM) in let d7 = Vale.X64.Decls.buffer64_read dst_b (7 + offset
`op_Multiply` 2) (va_get_mem_heaplet 0 va_sM) in let d = Vale.Curve25519.Fast_defs.pow2_eight
d0 d1 d2 d3 d4 d5 d6 d7 in d == va_mul_nat a a /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) (va_get_reg64 rRdi va_sM) dst_b (8 + offset `op_Multiply` 2)
(va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer_specific dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) (0 + offset `op_Multiply` 2) (8 +
offset `op_Multiply` 2 - 1)) ==> va_k va_sM (())))
val va_wpProof_Fast_sqr : offset:nat -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_sqr offset dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_sqr offset) ([va_Mod_flags;
va_Mod_mem_heaplet 0; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64
rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64
rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_sqr (offset:nat) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Fast_sqr offset)) =
(va_QProc (va_code_Fast_sqr offset) ([va_Mod_flags; va_Mod_mem_heaplet 0; va_Mod_reg64 rR15;
va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9;
va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax;
va_Mod_mem]) (va_wp_Fast_sqr offset dst_b inA_b) (va_wpProof_Fast_sqr offset dst_b inA_b))
//--
//-- Fast_sqr_stdcall
val va_code_Fast_sqr_stdcall : win:bool -> Tot va_code
val va_codegen_success_Fast_sqr_stdcall : win:bool -> Tot va_pbool
val va_lemma_Fast_sqr_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Fast_sqr_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
Vale.X64.Decls.buffers_disjoint dst_b inA_b /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem_heaplet 0 va_s0) dst_in dst_b 8 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) inA_in inA_b 4 (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 (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let a0 = Vale.X64.Decls.buffer64_read
inA_b 0 (va_get_mem_heaplet 0 va_s0) in let a1 = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem_heaplet 0 va_s0) in let a2 = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem_heaplet 0 va_s0) in let a3 = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem_heaplet 0 va_s0) in let d0 = Vale.X64.Decls.buffer64_read dst_b 0
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b 2
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b 3
(va_get_mem_heaplet 0 va_sM) in let d4 = Vale.X64.Decls.buffer64_read dst_b 4
(va_get_mem_heaplet 0 va_sM) in let d5 = Vale.X64.Decls.buffer64_read dst_b 5
(va_get_mem_heaplet 0 va_sM) in let d6 = Vale.X64.Decls.buffer64_read dst_b 6
(va_get_mem_heaplet 0 va_sM) in let d7 = Vale.X64.Decls.buffer64_read dst_b 7
(va_get_mem_heaplet 0 va_sM) in let a = a0 + va_mul_nat pow2_64 a1 + va_mul_nat pow2_128 a2 +
va_mul_nat pow2_192 a3 in let d = d0 + va_mul_nat pow2_64 d1 + va_mul_nat pow2_128 d2 +
va_mul_nat pow2_192 d3 + va_mul_nat pow2_256 d4 + va_mul_nat pow2_320 d5 + va_mul_nat pow2_384
d6 + va_mul_nat pow2_448 d7 in d == va_mul_nat a a /\ Vale.X64.Decls.modifies_buffer dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) dst_in dst_b 8 (va_get_mem_layout va_sM) Secret /\ va_get_reg64
rRbx va_sM == va_get_reg64 rRbx va_s0 /\ va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0 /\
va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0 /\ va_get_reg64 rR14 va_sM == va_get_reg64
rR14 va_s0 /\ va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0 /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rRsp va_sM
(va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))))))))))
[@ va_qattr]
let va_wp_Fast_sqr_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (dst_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64
rRsi va_s0) in va_get_reg64 rRsp va_s0 == Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\
(adx_enabled /\ bmi2_enabled) /\ Vale.X64.Decls.buffers_disjoint dst_b inA_b /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem_heaplet 0 va_s0) dst_in dst_b 8 (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) inA_in inA_b 4
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rbx:nat64) (va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_rdi:nat64) (va_x_rsi:nat64)
(va_x_r8:nat64) (va_x_r9:nat64) (va_x_r10:nat64) (va_x_r11:nat64) (va_x_r13:nat64)
(va_x_r14:nat64) (va_x_r15:nat64) (va_x_rsp:nat64) (va_x_efl:Vale.X64.Flags.t)
(va_x_heap0:vale_heap) (va_x_stack:vale_stack) (va_x_stackTaint:memtaint) . let va_sM =
va_upd_stackTaint va_x_stackTaint (va_upd_stack va_x_stack (va_upd_mem_heaplet 0 va_x_heap0
(va_upd_flags va_x_efl (va_upd_reg64 rRsp va_x_rsp (va_upd_reg64 rR15 va_x_r15 (va_upd_reg64
rR14 va_x_r14 (va_upd_reg64 rR13 va_x_r13 (va_upd_reg64 rR11 va_x_r11 (va_upd_reg64 rR10
va_x_r10 (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rR8 va_x_r8 (va_upd_reg64 rRsi va_x_rsi
(va_upd_reg64 rRdi va_x_rdi (va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx
(va_upd_reg64 rRbx va_x_rbx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem
va_s0)))))))))))))))))) in va_get_ok va_sM /\ (let (dst_in:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let a0 =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem_heaplet 0 va_s0) in let a1 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem_heaplet 0 va_s0) in let a2 =
Vale.X64.Decls.buffer64_read inA_b 2 (va_get_mem_heaplet 0 va_s0) in let a3 =
Vale.X64.Decls.buffer64_read inA_b 3 (va_get_mem_heaplet 0 va_s0) in let d0 =
Vale.X64.Decls.buffer64_read dst_b 0 (va_get_mem_heaplet 0 va_sM) in let d1 =
Vale.X64.Decls.buffer64_read dst_b 1 (va_get_mem_heaplet 0 va_sM) in let d2 =
Vale.X64.Decls.buffer64_read dst_b 2 (va_get_mem_heaplet 0 va_sM) in let d3 =
Vale.X64.Decls.buffer64_read dst_b 3 (va_get_mem_heaplet 0 va_sM) in let d4 =
Vale.X64.Decls.buffer64_read dst_b 4 (va_get_mem_heaplet 0 va_sM) in let d5 =
Vale.X64.Decls.buffer64_read dst_b 5 (va_get_mem_heaplet 0 va_sM) in let d6 =
Vale.X64.Decls.buffer64_read dst_b 6 (va_get_mem_heaplet 0 va_sM) in let d7 =
Vale.X64.Decls.buffer64_read dst_b 7 (va_get_mem_heaplet 0 va_sM) in let a = a0 + va_mul_nat
pow2_64 a1 + va_mul_nat pow2_128 a2 + va_mul_nat pow2_192 a3 in let d = d0 + va_mul_nat pow2_64
d1 + va_mul_nat pow2_128 d2 + va_mul_nat pow2_192 d3 + va_mul_nat pow2_256 d4 + va_mul_nat
pow2_320 d5 + va_mul_nat pow2_384 d6 + va_mul_nat pow2_448 d7 in d == va_mul_nat a a /\
Vale.X64.Decls.modifies_buffer dst_b (va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM)
/\ Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_sM) dst_in dst_b 8
(va_get_mem_layout va_sM) Secret /\ va_get_reg64 rRbx va_sM == va_get_reg64 rRbx va_s0 /\
va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0 /\ va_get_reg64 rR13 va_sM == va_get_reg64
rR13 va_s0 /\ va_get_reg64 rR14 va_sM == va_get_reg64 rR14 va_s0 /\ va_get_reg64 rR15 va_sM ==
va_get_reg64 rR15 va_s0 /\ va_get_reg64 rRsp va_sM == va_get_reg64 rRsp va_s0) ==> va_k va_sM
(())))
val va_wpProof_Fast_sqr_stdcall : win:bool -> dst_b:buffer64 -> inA_b:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Fast_sqr_stdcall win dst_b inA_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Fast_sqr_stdcall win)
([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_heaplet 0; va_Mod_flags; va_Mod_reg64 rRsp;
va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13; va_Mod_reg64 rR11; va_Mod_reg64 rR10;
va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsi; va_Mod_reg64 rRdi; va_Mod_reg64 rRdx;
va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0 va_k ((va_sM,
va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Fast_sqr_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Fast_sqr_stdcall win)) =
(va_QProc (va_code_Fast_sqr_stdcall win) ([va_Mod_stackTaint; va_Mod_stack; va_Mod_mem_heaplet 0;
va_Mod_flags; va_Mod_reg64 rRsp; va_Mod_reg64 rR15; va_Mod_reg64 rR14; va_Mod_reg64 rR13;
va_Mod_reg64 rR11; va_Mod_reg64 rR10; va_Mod_reg64 rR9; va_Mod_reg64 rR8; va_Mod_reg64 rRsi;
va_Mod_reg64 rRdi; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRbx; va_Mod_reg64 rRax;
va_Mod_mem]) (va_wp_Fast_sqr_stdcall win dst_b inA_b) (va_wpProof_Fast_sqr_stdcall win dst_b
inA_b))
//--
//-- Sqr2_stdcall
val va_code_Sqr2_stdcall : win:bool -> Tot va_code
val va_codegen_success_Sqr2_stdcall : win:bool -> Tot va_pbool
val va_lemma_Sqr2_stdcall : va_b0:va_code -> va_s0:va_state -> win:bool -> dst_b:buffer64 ->
inA_b:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Sqr2_stdcall win) va_s0 /\ va_get_ok va_s0 /\ (let
(dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in va_get_reg64 rRsp va_s0 ==
Vale.X64.Stack_i.init_rsp (va_get_stack va_s0) /\ (adx_enabled /\ bmi2_enabled) /\
Vale.X64.Decls.buffers_disjoint dst_b inA_b /\ Vale.X64.Decls.validDstAddrs64
(va_get_mem_heaplet 0 va_s0) dst_in dst_b 16 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem_heaplet 0 va_s0) inA_in inA_b 8 (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 (dst_in:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (inA_in:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in let a0 = Vale.X64.Decls.buffer64_read
inA_b 0 (va_get_mem_heaplet 0 va_s0) in let a1 = Vale.X64.Decls.buffer64_read inA_b 1
(va_get_mem_heaplet 0 va_s0) in let a2 = Vale.X64.Decls.buffer64_read inA_b 2
(va_get_mem_heaplet 0 va_s0) in let a3 = Vale.X64.Decls.buffer64_read inA_b 3
(va_get_mem_heaplet 0 va_s0) in let d0 = Vale.X64.Decls.buffer64_read dst_b 0
(va_get_mem_heaplet 0 va_sM) in let d1 = Vale.X64.Decls.buffer64_read dst_b 1
(va_get_mem_heaplet 0 va_sM) in let d2 = Vale.X64.Decls.buffer64_read dst_b 2
(va_get_mem_heaplet 0 va_sM) in let d3 = Vale.X64.Decls.buffer64_read dst_b 3
(va_get_mem_heaplet 0 va_sM) in let d4 = Vale.X64.Decls.buffer64_read dst_b 4
(va_get_mem_heaplet 0 va_sM) in let d5 = Vale.X64.Decls.buffer64_read dst_b 5
(va_get_mem_heaplet 0 va_sM) in let d6 = Vale.X64.Decls.buffer64_read dst_b 6
(va_get_mem_heaplet 0 va_sM) in let d7 = Vale.X64.Decls.buffer64_read dst_b 7
(va_get_mem_heaplet 0 va_sM) in let a = a0 + va_mul_nat pow2_64 a1 + va_mul_nat pow2_128 a2 +
va_mul_nat pow2_192 a3 in let d = d0 + va_mul_nat pow2_64 d1 + va_mul_nat pow2_128 d2 +
va_mul_nat pow2_192 d3 + va_mul_nat pow2_256 d4 + va_mul_nat pow2_320 d5 + va_mul_nat pow2_384
d6 + va_mul_nat pow2_448 d7 in d == va_mul_nat a a /\ Vale.X64.Decls.modifies_buffer dst_b
(va_get_mem_heaplet 0 va_s0) (va_get_mem_heaplet 0 va_sM) /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem_heaplet 0 va_sM) dst_in dst_b 16 (va_get_mem_layout va_sM) Secret /\ va_get_reg64
rRbx va_sM == va_get_reg64 rRbx va_s0 /\ va_get_reg64 rRsi va_sM == va_get_reg64 rRsi va_s0 /\
va_get_reg64 rR13 va_sM == va_get_reg64 rR13 va_s0 /\ va_get_reg64 rR14 va_sM == va_get_reg64
rR14 va_s0 /\ va_get_reg64 rR15 va_sM == va_get_reg64 rR15 va_s0 /\ va_get_reg64 rRsp va_sM ==
va_get_reg64 rRsp va_s0) /\ va_state_eq va_sM (va_update_stackTaint va_sM (va_update_stack
va_sM (va_update_mem_heaplet 0 va_sM (va_update_flags va_sM (va_update_reg64 rRsp va_sM
(va_update_reg64 rR15 va_sM (va_update_reg64 rR14 va_sM (va_update_reg64 rR13 va_sM
(va_update_reg64 rR11 va_sM (va_update_reg64 rR10 va_sM (va_update_reg64 rR9 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRsi va_sM (va_update_reg64 rRdi va_sM
(va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM (va_update_reg64 rRbx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))))))))))
[@ va_qattr]
let va_wp_Sqr2_stdcall (win:bool) (dst_b:buffer64) (inA_b:buffer64) (va_s0:va_state) | false | true | Vale.Curve25519.X64.FastSqr.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 va_wp_Sqr2_stdcall
(win: bool)
(dst_b inA_b: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.Curve25519.X64.FastSqr.va_wp_Sqr2_stdcall | {
"file_name": "obj/Vale.Curve25519.X64.FastSqr.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
win: Prims.bool ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 10,
"end_line": 336,
"start_col": 2,
"start_line": 293
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": "F32xN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_32",
"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.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.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 op_String_Access #a #len = LSeq.index #a #len | let op_String_Access #a #len = | false | null | false | LSeq.index #a #len | {
"checked_file": "Hacl.Impl.Poly1305.Fields.fst.checked",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_32.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_256.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_128.fst.checked",
"Hacl.Impl.Poly1305.Field32xN.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.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Poly1305.Fields.fst"
} | [
"total"
] | [
"Lib.IntTypes.size_nat",
"Lib.Sequence.index",
"Lib.Sequence.lseq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_LessThan",
"Prims.eq2",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq"
] | [] | module Hacl.Impl.Poly1305.Fields
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Poly1305.Field32xN_32
open Hacl.Impl.Poly1305.Field32xN_128
open Hacl.Impl.Poly1305.Field32xN_256
open Hacl.Impl.Poly1305.Field32xN
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.Poly1305
module Vec = Hacl.Spec.Poly1305.Vec
module F32xN = Hacl.Impl.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --max_fuel 0 --max_fuel 0"
noextract
type field_spec =
| M32
| M128
| M256
unfold noextract
let width (s:field_spec) : Vec.lanes =
match s with
| M32 -> 1
| M128 -> 2
| M256 -> 4
unfold noextract
let limb (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M32 -> F32xN.zero 1
| M128 -> F32xN.zero 2
| M256 -> F32xN.zero 4
unfold noextract
let wide (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M32 -> 5ul
| M128 -> 5ul
| M256 -> 5ul
unfold noextract
let blocklen (s:field_spec) : r:size_t{0 < v r /\ v r == width s * S.size_block} =
match s with
| M32 -> 16ul
| M128 -> 32ul
| M256 -> 64ul
unfold noextract
let nelem (s:field_spec) : size_t =
match s with
| M32 -> 1ul
| M128 -> 2ul
| M256 -> 4ul
unfold noextract
let precomplen (s:field_spec) : size_t =
match s with
| M32 -> 20ul
| M128 -> 20ul
| M256 -> 20ul
inline_for_extraction noextract
type felem (s:field_spec) = lbuffer (limb s) (nlimb s)
type felem_wide (s:field_spec) = lbuffer (wide s) (nlimb s)
inline_for_extraction noextract
type precomp_r (s:field_spec) = lbuffer (limb s) (precomplen s)
noextract
val felem_fits: #s:field_spec -> h:mem -> f:felem s -> m:F32xN.scale32_5 -> Type0
let felem_fits #s h f m =
match s with
| M32 -> F32xN.felem_fits #1 h f m
| M128 -> F32xN.felem_fits #2 h f m
| M256 -> F32xN.felem_fits #4 h f m
noextract
val fas_nat: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq nat (width s))
let fas_nat #s h e =
match s with
| M32 -> F32xN.fas_nat #1 h e
| M128 -> F32xN.fas_nat #2 h e
| M256 -> F32xN.fas_nat #4 h e
noextract
val feval: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq S.felem (width s))
let feval #s h e =
match s with
| M32 -> F32xN.feval #1 h e
| M128 -> F32xN.feval #2 h e
| M256 -> F32xN.feval #4 h e | false | false | Hacl.Impl.Poly1305.Fields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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 op_String_Access : s: Lib.Sequence.lseq a len -> i: (n: Prims.nat{n <= Prims.pow2 32 - 1}){i < len}
-> r: a{r == FStar.Seq.Base.index (Lib.Sequence.to_seq s) i} | [] | Hacl.Impl.Poly1305.Fields.op_String_Access | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Fields.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Lib.Sequence.lseq a len -> i: (n: Prims.nat{n <= Prims.pow2 32 - 1}){i < len}
-> r: a{r == FStar.Seq.Base.index (Lib.Sequence.to_seq s) i} | {
"end_col": 49,
"end_line": 119,
"start_col": 31,
"start_line": 119
} |
|
Prims.GTot | val fas_nat: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq nat (width s)) | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": "F32xN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_32",
"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.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.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 fas_nat #s h e =
match s with
| M32 -> F32xN.fas_nat #1 h e
| M128 -> F32xN.fas_nat #2 h e
| M256 -> F32xN.fas_nat #4 h e | val fas_nat: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq nat (width s))
let fas_nat #s h e = | false | null | false | match s with
| M32 -> F32xN.fas_nat #1 h e
| M128 -> F32xN.fas_nat #2 h e
| M256 -> F32xN.fas_nat #4 h e | {
"checked_file": "Hacl.Impl.Poly1305.Fields.fst.checked",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_32.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_256.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_128.fst.checked",
"Hacl.Impl.Poly1305.Field32xN.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.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Poly1305.Fields.fst"
} | [
"sometrivial"
] | [
"Hacl.Impl.Poly1305.Fields.field_spec",
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Poly1305.Fields.felem",
"Hacl.Impl.Poly1305.Field32xN.fas_nat",
"Lib.Sequence.lseq",
"Prims.nat",
"Hacl.Impl.Poly1305.Fields.width"
] | [] | module Hacl.Impl.Poly1305.Fields
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Poly1305.Field32xN_32
open Hacl.Impl.Poly1305.Field32xN_128
open Hacl.Impl.Poly1305.Field32xN_256
open Hacl.Impl.Poly1305.Field32xN
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.Poly1305
module Vec = Hacl.Spec.Poly1305.Vec
module F32xN = Hacl.Impl.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --max_fuel 0 --max_fuel 0"
noextract
type field_spec =
| M32
| M128
| M256
unfold noextract
let width (s:field_spec) : Vec.lanes =
match s with
| M32 -> 1
| M128 -> 2
| M256 -> 4
unfold noextract
let limb (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M32 -> F32xN.zero 1
| M128 -> F32xN.zero 2
| M256 -> F32xN.zero 4
unfold noextract
let wide (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M32 -> 5ul
| M128 -> 5ul
| M256 -> 5ul
unfold noextract
let blocklen (s:field_spec) : r:size_t{0 < v r /\ v r == width s * S.size_block} =
match s with
| M32 -> 16ul
| M128 -> 32ul
| M256 -> 64ul
unfold noextract
let nelem (s:field_spec) : size_t =
match s with
| M32 -> 1ul
| M128 -> 2ul
| M256 -> 4ul
unfold noextract
let precomplen (s:field_spec) : size_t =
match s with
| M32 -> 20ul
| M128 -> 20ul
| M256 -> 20ul
inline_for_extraction noextract
type felem (s:field_spec) = lbuffer (limb s) (nlimb s)
type felem_wide (s:field_spec) = lbuffer (wide s) (nlimb s)
inline_for_extraction noextract
type precomp_r (s:field_spec) = lbuffer (limb s) (precomplen s)
noextract
val felem_fits: #s:field_spec -> h:mem -> f:felem s -> m:F32xN.scale32_5 -> Type0
let felem_fits #s h f m =
match s with
| M32 -> F32xN.felem_fits #1 h f m
| M128 -> F32xN.felem_fits #2 h f m
| M256 -> F32xN.felem_fits #4 h f m
noextract
val fas_nat: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq nat (width s)) | false | false | Hacl.Impl.Poly1305.Fields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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 fas_nat: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq nat (width s)) | [] | Hacl.Impl.Poly1305.Fields.fas_nat | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Fields.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> e: Hacl.Impl.Poly1305.Fields.felem s
-> Prims.GTot (Lib.Sequence.lseq Prims.nat (Hacl.Impl.Poly1305.Fields.width s)) | {
"end_col": 32,
"end_line": 108,
"start_col": 2,
"start_line": 105
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": "F32xN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_32",
"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.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.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 limb (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4 | let limb (s: field_spec) = | false | null | false | match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4 | {
"checked_file": "Hacl.Impl.Poly1305.Fields.fst.checked",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_32.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_256.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_128.fst.checked",
"Hacl.Impl.Poly1305.Field32xN.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.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Poly1305.Fields.fst"
} | [
"total"
] | [
"Hacl.Impl.Poly1305.Fields.field_spec",
"Hacl.Spec.Poly1305.Field32xN.uint64xN"
] | [] | module Hacl.Impl.Poly1305.Fields
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Poly1305.Field32xN_32
open Hacl.Impl.Poly1305.Field32xN_128
open Hacl.Impl.Poly1305.Field32xN_256
open Hacl.Impl.Poly1305.Field32xN
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.Poly1305
module Vec = Hacl.Spec.Poly1305.Vec
module F32xN = Hacl.Impl.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --max_fuel 0 --max_fuel 0"
noextract
type field_spec =
| M32
| M128
| M256
unfold noextract
let width (s:field_spec) : Vec.lanes =
match s with
| M32 -> 1
| M128 -> 2
| M256 -> 4
unfold noextract | false | true | Hacl.Impl.Poly1305.Fields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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 limb : s: Hacl.Impl.Poly1305.Fields.field_spec -> Type0 | [] | Hacl.Impl.Poly1305.Fields.limb | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Fields.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Impl.Poly1305.Fields.field_spec -> Type0 | {
"end_col": 28,
"end_line": 44,
"start_col": 2,
"start_line": 41
} |
|
Prims.Tot | val nelem (s: field_spec) : size_t | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": "F32xN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_32",
"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.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.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 nelem (s:field_spec) : size_t =
match s with
| M32 -> 1ul
| M128 -> 2ul
| M256 -> 4ul | val nelem (s: field_spec) : size_t
let nelem (s: field_spec) : size_t = | false | null | false | match s with
| M32 -> 1ul
| M128 -> 2ul
| M256 -> 4ul | {
"checked_file": "Hacl.Impl.Poly1305.Fields.fst.checked",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_32.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_256.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_128.fst.checked",
"Hacl.Impl.Poly1305.Field32xN.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.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Poly1305.Fields.fst"
} | [
"total"
] | [
"Hacl.Impl.Poly1305.Fields.field_spec",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.size_t"
] | [] | module Hacl.Impl.Poly1305.Fields
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Poly1305.Field32xN_32
open Hacl.Impl.Poly1305.Field32xN_128
open Hacl.Impl.Poly1305.Field32xN_256
open Hacl.Impl.Poly1305.Field32xN
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.Poly1305
module Vec = Hacl.Spec.Poly1305.Vec
module F32xN = Hacl.Impl.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --max_fuel 0 --max_fuel 0"
noextract
type field_spec =
| M32
| M128
| M256
unfold noextract
let width (s:field_spec) : Vec.lanes =
match s with
| M32 -> 1
| M128 -> 2
| M256 -> 4
unfold noextract
let limb (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M32 -> F32xN.zero 1
| M128 -> F32xN.zero 2
| M256 -> F32xN.zero 4
unfold noextract
let wide (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M32 -> 5ul
| M128 -> 5ul
| M256 -> 5ul
unfold noextract
let blocklen (s:field_spec) : r:size_t{0 < v r /\ v r == width s * S.size_block} =
match s with
| M32 -> 16ul
| M128 -> 32ul
| M256 -> 64ul
unfold noextract | false | true | Hacl.Impl.Poly1305.Fields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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 nelem (s: field_spec) : size_t | [] | Hacl.Impl.Poly1305.Fields.nelem | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Fields.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Impl.Poly1305.Fields.field_spec -> Lib.IntTypes.size_t | {
"end_col": 15,
"end_line": 79,
"start_col": 2,
"start_line": 76
} |
Prims.Tot | val nlimb (s: field_spec) : size_t | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": "F32xN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_32",
"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.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.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 nlimb (s:field_spec) : size_t =
match s with
| M32 -> 5ul
| M128 -> 5ul
| M256 -> 5ul | val nlimb (s: field_spec) : size_t
let nlimb (s: field_spec) : size_t = | false | null | false | match s with
| M32 -> 5ul
| M128 -> 5ul
| M256 -> 5ul | {
"checked_file": "Hacl.Impl.Poly1305.Fields.fst.checked",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_32.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_256.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_128.fst.checked",
"Hacl.Impl.Poly1305.Field32xN.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.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Poly1305.Fields.fst"
} | [
"total"
] | [
"Hacl.Impl.Poly1305.Fields.field_spec",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.size_t"
] | [] | module Hacl.Impl.Poly1305.Fields
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Poly1305.Field32xN_32
open Hacl.Impl.Poly1305.Field32xN_128
open Hacl.Impl.Poly1305.Field32xN_256
open Hacl.Impl.Poly1305.Field32xN
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.Poly1305
module Vec = Hacl.Spec.Poly1305.Vec
module F32xN = Hacl.Impl.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --max_fuel 0 --max_fuel 0"
noextract
type field_spec =
| M32
| M128
| M256
unfold noextract
let width (s:field_spec) : Vec.lanes =
match s with
| M32 -> 1
| M128 -> 2
| M256 -> 4
unfold noextract
let limb (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M32 -> F32xN.zero 1
| M128 -> F32xN.zero 2
| M256 -> F32xN.zero 4
unfold noextract
let wide (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract | false | true | Hacl.Impl.Poly1305.Fields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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 nlimb (s: field_spec) : size_t | [] | Hacl.Impl.Poly1305.Fields.nlimb | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Fields.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Impl.Poly1305.Fields.field_spec -> Lib.IntTypes.size_t | {
"end_col": 15,
"end_line": 65,
"start_col": 2,
"start_line": 62
} |
Prims.Tot | val precomplen (s: field_spec) : size_t | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": "F32xN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_32",
"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.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.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 precomplen (s:field_spec) : size_t =
match s with
| M32 -> 20ul
| M128 -> 20ul
| M256 -> 20ul | val precomplen (s: field_spec) : size_t
let precomplen (s: field_spec) : size_t = | false | null | false | match s with
| M32 -> 20ul
| M128 -> 20ul
| M256 -> 20ul | {
"checked_file": "Hacl.Impl.Poly1305.Fields.fst.checked",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_32.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_256.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_128.fst.checked",
"Hacl.Impl.Poly1305.Field32xN.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.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Poly1305.Fields.fst"
} | [
"total"
] | [
"Hacl.Impl.Poly1305.Fields.field_spec",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.size_t"
] | [] | module Hacl.Impl.Poly1305.Fields
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Poly1305.Field32xN_32
open Hacl.Impl.Poly1305.Field32xN_128
open Hacl.Impl.Poly1305.Field32xN_256
open Hacl.Impl.Poly1305.Field32xN
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.Poly1305
module Vec = Hacl.Spec.Poly1305.Vec
module F32xN = Hacl.Impl.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --max_fuel 0 --max_fuel 0"
noextract
type field_spec =
| M32
| M128
| M256
unfold noextract
let width (s:field_spec) : Vec.lanes =
match s with
| M32 -> 1
| M128 -> 2
| M256 -> 4
unfold noextract
let limb (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M32 -> F32xN.zero 1
| M128 -> F32xN.zero 2
| M256 -> F32xN.zero 4
unfold noextract
let wide (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M32 -> 5ul
| M128 -> 5ul
| M256 -> 5ul
unfold noextract
let blocklen (s:field_spec) : r:size_t{0 < v r /\ v r == width s * S.size_block} =
match s with
| M32 -> 16ul
| M128 -> 32ul
| M256 -> 64ul
unfold noextract
let nelem (s:field_spec) : size_t =
match s with
| M32 -> 1ul
| M128 -> 2ul
| M256 -> 4ul
unfold noextract | false | true | Hacl.Impl.Poly1305.Fields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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 precomplen (s: field_spec) : size_t | [] | Hacl.Impl.Poly1305.Fields.precomplen | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Fields.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Impl.Poly1305.Fields.field_spec -> Lib.IntTypes.size_t | {
"end_col": 16,
"end_line": 86,
"start_col": 2,
"start_line": 83
} |
Prims.Tot | val width (s: field_spec) : Vec.lanes | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": "F32xN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_32",
"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.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.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 width (s:field_spec) : Vec.lanes =
match s with
| M32 -> 1
| M128 -> 2
| M256 -> 4 | val width (s: field_spec) : Vec.lanes
let width (s: field_spec) : Vec.lanes = | false | null | false | match s with
| M32 -> 1
| M128 -> 2
| M256 -> 4 | {
"checked_file": "Hacl.Impl.Poly1305.Fields.fst.checked",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_32.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_256.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_128.fst.checked",
"Hacl.Impl.Poly1305.Field32xN.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.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Poly1305.Fields.fst"
} | [
"total"
] | [
"Hacl.Impl.Poly1305.Fields.field_spec",
"Hacl.Spec.Poly1305.Vec.lanes"
] | [] | module Hacl.Impl.Poly1305.Fields
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Poly1305.Field32xN_32
open Hacl.Impl.Poly1305.Field32xN_128
open Hacl.Impl.Poly1305.Field32xN_256
open Hacl.Impl.Poly1305.Field32xN
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.Poly1305
module Vec = Hacl.Spec.Poly1305.Vec
module F32xN = Hacl.Impl.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --max_fuel 0 --max_fuel 0"
noextract
type field_spec =
| M32
| M128
| M256
unfold noextract | false | true | Hacl.Impl.Poly1305.Fields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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 width (s: field_spec) : Vec.lanes | [] | Hacl.Impl.Poly1305.Fields.width | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Fields.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Impl.Poly1305.Fields.field_spec -> Hacl.Spec.Poly1305.Vec.lanes | {
"end_col": 13,
"end_line": 37,
"start_col": 2,
"start_line": 34
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": "F32xN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_32",
"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.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.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 wide (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4 | let wide (s: field_spec) = | false | null | false | match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4 | {
"checked_file": "Hacl.Impl.Poly1305.Fields.fst.checked",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_32.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_256.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_128.fst.checked",
"Hacl.Impl.Poly1305.Field32xN.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.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Poly1305.Fields.fst"
} | [
"total"
] | [
"Hacl.Impl.Poly1305.Fields.field_spec",
"Hacl.Spec.Poly1305.Field32xN.uint64xN"
] | [] | module Hacl.Impl.Poly1305.Fields
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Poly1305.Field32xN_32
open Hacl.Impl.Poly1305.Field32xN_128
open Hacl.Impl.Poly1305.Field32xN_256
open Hacl.Impl.Poly1305.Field32xN
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.Poly1305
module Vec = Hacl.Spec.Poly1305.Vec
module F32xN = Hacl.Impl.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --max_fuel 0 --max_fuel 0"
noextract
type field_spec =
| M32
| M128
| M256
unfold noextract
let width (s:field_spec) : Vec.lanes =
match s with
| M32 -> 1
| M128 -> 2
| M256 -> 4
unfold noextract
let limb (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M32 -> F32xN.zero 1
| M128 -> F32xN.zero 2
| M256 -> F32xN.zero 4
unfold noextract | false | true | Hacl.Impl.Poly1305.Fields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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 wide : s: Hacl.Impl.Poly1305.Fields.field_spec -> Type0 | [] | Hacl.Impl.Poly1305.Fields.wide | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Fields.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Impl.Poly1305.Fields.field_spec -> Type0 | {
"end_col": 28,
"end_line": 58,
"start_col": 2,
"start_line": 55
} |
|
Prims.Tot | val blocklen (s: field_spec) : r: size_t{0 < v r /\ v r == width s * S.size_block} | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": "F32xN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_32",
"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.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.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 blocklen (s:field_spec) : r:size_t{0 < v r /\ v r == width s * S.size_block} =
match s with
| M32 -> 16ul
| M128 -> 32ul
| M256 -> 64ul | val blocklen (s: field_spec) : r: size_t{0 < v r /\ v r == width s * S.size_block}
let blocklen (s: field_spec) : r: size_t{0 < v r /\ v r == width s * S.size_block} = | false | null | false | match s with
| M32 -> 16ul
| M128 -> 32ul
| M256 -> 64ul | {
"checked_file": "Hacl.Impl.Poly1305.Fields.fst.checked",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_32.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_256.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_128.fst.checked",
"Hacl.Impl.Poly1305.Field32xN.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.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Poly1305.Fields.fst"
} | [
"total"
] | [
"Hacl.Impl.Poly1305.Fields.field_spec",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.size_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.eq2",
"Prims.int",
"FStar.Mul.op_Star",
"Hacl.Impl.Poly1305.Fields.width",
"Spec.Poly1305.size_block"
] | [] | module Hacl.Impl.Poly1305.Fields
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Poly1305.Field32xN_32
open Hacl.Impl.Poly1305.Field32xN_128
open Hacl.Impl.Poly1305.Field32xN_256
open Hacl.Impl.Poly1305.Field32xN
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.Poly1305
module Vec = Hacl.Spec.Poly1305.Vec
module F32xN = Hacl.Impl.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --max_fuel 0 --max_fuel 0"
noextract
type field_spec =
| M32
| M128
| M256
unfold noextract
let width (s:field_spec) : Vec.lanes =
match s with
| M32 -> 1
| M128 -> 2
| M256 -> 4
unfold noextract
let limb (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M32 -> F32xN.zero 1
| M128 -> F32xN.zero 2
| M256 -> F32xN.zero 4
unfold noextract
let wide (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M32 -> 5ul
| M128 -> 5ul
| M256 -> 5ul
unfold noextract | false | false | Hacl.Impl.Poly1305.Fields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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 blocklen (s: field_spec) : r: size_t{0 < v r /\ v r == width s * S.size_block} | [] | Hacl.Impl.Poly1305.Fields.blocklen | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Fields.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Impl.Poly1305.Fields.field_spec
-> r:
Lib.IntTypes.size_t
{ 0 < Lib.IntTypes.v r /\
Lib.IntTypes.v r == Hacl.Impl.Poly1305.Fields.width s * Spec.Poly1305.size_block } | {
"end_col": 16,
"end_line": 72,
"start_col": 2,
"start_line": 69
} |
Prims.Tot | val limb_zero (s: field_spec) : limb s | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": "F32xN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_32",
"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.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.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 limb_zero (s:field_spec) : limb s=
match s with
| M32 -> F32xN.zero 1
| M128 -> F32xN.zero 2
| M256 -> F32xN.zero 4 | val limb_zero (s: field_spec) : limb s
let limb_zero (s: field_spec) : limb s = | false | null | false | match s with
| M32 -> F32xN.zero 1
| M128 -> F32xN.zero 2
| M256 -> F32xN.zero 4 | {
"checked_file": "Hacl.Impl.Poly1305.Fields.fst.checked",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_32.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_256.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_128.fst.checked",
"Hacl.Impl.Poly1305.Field32xN.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.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Poly1305.Fields.fst"
} | [
"total"
] | [
"Hacl.Impl.Poly1305.Fields.field_spec",
"Hacl.Spec.Poly1305.Field32xN.zero",
"Hacl.Impl.Poly1305.Fields.limb"
] | [] | module Hacl.Impl.Poly1305.Fields
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Poly1305.Field32xN_32
open Hacl.Impl.Poly1305.Field32xN_128
open Hacl.Impl.Poly1305.Field32xN_256
open Hacl.Impl.Poly1305.Field32xN
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.Poly1305
module Vec = Hacl.Spec.Poly1305.Vec
module F32xN = Hacl.Impl.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --max_fuel 0 --max_fuel 0"
noextract
type field_spec =
| M32
| M128
| M256
unfold noextract
let width (s:field_spec) : Vec.lanes =
match s with
| M32 -> 1
| M128 -> 2
| M256 -> 4
unfold noextract
let limb (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract | false | false | Hacl.Impl.Poly1305.Fields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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 limb_zero (s: field_spec) : limb s | [] | Hacl.Impl.Poly1305.Fields.limb_zero | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Fields.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Impl.Poly1305.Fields.field_spec -> Hacl.Impl.Poly1305.Fields.limb s | {
"end_col": 24,
"end_line": 51,
"start_col": 2,
"start_line": 48
} |
Prims.GTot | val feval: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq S.felem (width s)) | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": "F32xN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_32",
"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.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.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 feval #s h e =
match s with
| M32 -> F32xN.feval #1 h e
| M128 -> F32xN.feval #2 h e
| M256 -> F32xN.feval #4 h e | val feval: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq S.felem (width s))
let feval #s h e = | false | null | false | match s with
| M32 -> F32xN.feval #1 h e
| M128 -> F32xN.feval #2 h e
| M256 -> F32xN.feval #4 h e | {
"checked_file": "Hacl.Impl.Poly1305.Fields.fst.checked",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_32.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_256.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_128.fst.checked",
"Hacl.Impl.Poly1305.Field32xN.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.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Poly1305.Fields.fst"
} | [
"sometrivial"
] | [
"Hacl.Impl.Poly1305.Fields.field_spec",
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Poly1305.Fields.felem",
"Hacl.Impl.Poly1305.Field32xN.feval",
"Lib.Sequence.lseq",
"Spec.Poly1305.felem",
"Hacl.Impl.Poly1305.Fields.width"
] | [] | module Hacl.Impl.Poly1305.Fields
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Poly1305.Field32xN_32
open Hacl.Impl.Poly1305.Field32xN_128
open Hacl.Impl.Poly1305.Field32xN_256
open Hacl.Impl.Poly1305.Field32xN
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.Poly1305
module Vec = Hacl.Spec.Poly1305.Vec
module F32xN = Hacl.Impl.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --max_fuel 0 --max_fuel 0"
noextract
type field_spec =
| M32
| M128
| M256
unfold noextract
let width (s:field_spec) : Vec.lanes =
match s with
| M32 -> 1
| M128 -> 2
| M256 -> 4
unfold noextract
let limb (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M32 -> F32xN.zero 1
| M128 -> F32xN.zero 2
| M256 -> F32xN.zero 4
unfold noextract
let wide (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M32 -> 5ul
| M128 -> 5ul
| M256 -> 5ul
unfold noextract
let blocklen (s:field_spec) : r:size_t{0 < v r /\ v r == width s * S.size_block} =
match s with
| M32 -> 16ul
| M128 -> 32ul
| M256 -> 64ul
unfold noextract
let nelem (s:field_spec) : size_t =
match s with
| M32 -> 1ul
| M128 -> 2ul
| M256 -> 4ul
unfold noextract
let precomplen (s:field_spec) : size_t =
match s with
| M32 -> 20ul
| M128 -> 20ul
| M256 -> 20ul
inline_for_extraction noextract
type felem (s:field_spec) = lbuffer (limb s) (nlimb s)
type felem_wide (s:field_spec) = lbuffer (wide s) (nlimb s)
inline_for_extraction noextract
type precomp_r (s:field_spec) = lbuffer (limb s) (precomplen s)
noextract
val felem_fits: #s:field_spec -> h:mem -> f:felem s -> m:F32xN.scale32_5 -> Type0
let felem_fits #s h f m =
match s with
| M32 -> F32xN.felem_fits #1 h f m
| M128 -> F32xN.felem_fits #2 h f m
| M256 -> F32xN.felem_fits #4 h f m
noextract
val fas_nat: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq nat (width s))
let fas_nat #s h e =
match s with
| M32 -> F32xN.fas_nat #1 h e
| M128 -> F32xN.fas_nat #2 h e
| M256 -> F32xN.fas_nat #4 h e
noextract
val feval: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq S.felem (width s)) | false | false | Hacl.Impl.Poly1305.Fields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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 feval: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq S.felem (width s)) | [] | Hacl.Impl.Poly1305.Fields.feval | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Fields.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> e: Hacl.Impl.Poly1305.Fields.felem s
-> Prims.GTot (Lib.Sequence.lseq Spec.Poly1305.felem (Hacl.Impl.Poly1305.Fields.width s)) | {
"end_col": 30,
"end_line": 116,
"start_col": 2,
"start_line": 113
} |
Prims.Tot | val felem_fits: #s:field_spec -> h:mem -> f:felem s -> m:F32xN.scale32_5 -> Type0 | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": "F32xN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_32",
"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.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.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 felem_fits #s h f m =
match s with
| M32 -> F32xN.felem_fits #1 h f m
| M128 -> F32xN.felem_fits #2 h f m
| M256 -> F32xN.felem_fits #4 h f m | val felem_fits: #s:field_spec -> h:mem -> f:felem s -> m:F32xN.scale32_5 -> Type0
let felem_fits #s h f m = | false | null | false | match s with
| M32 -> F32xN.felem_fits #1 h f m
| M128 -> F32xN.felem_fits #2 h f m
| M256 -> F32xN.felem_fits #4 h f m | {
"checked_file": "Hacl.Impl.Poly1305.Fields.fst.checked",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_32.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_256.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_128.fst.checked",
"Hacl.Impl.Poly1305.Field32xN.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.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Poly1305.Fields.fst"
} | [
"total"
] | [
"Hacl.Impl.Poly1305.Fields.field_spec",
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Poly1305.Fields.felem",
"Hacl.Spec.Poly1305.Field32xN.scale32_5",
"Hacl.Impl.Poly1305.Field32xN.felem_fits"
] | [] | module Hacl.Impl.Poly1305.Fields
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Poly1305.Field32xN_32
open Hacl.Impl.Poly1305.Field32xN_128
open Hacl.Impl.Poly1305.Field32xN_256
open Hacl.Impl.Poly1305.Field32xN
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.Poly1305
module Vec = Hacl.Spec.Poly1305.Vec
module F32xN = Hacl.Impl.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --max_fuel 0 --max_fuel 0"
noextract
type field_spec =
| M32
| M128
| M256
unfold noextract
let width (s:field_spec) : Vec.lanes =
match s with
| M32 -> 1
| M128 -> 2
| M256 -> 4
unfold noextract
let limb (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M32 -> F32xN.zero 1
| M128 -> F32xN.zero 2
| M256 -> F32xN.zero 4
unfold noextract
let wide (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M32 -> 5ul
| M128 -> 5ul
| M256 -> 5ul
unfold noextract
let blocklen (s:field_spec) : r:size_t{0 < v r /\ v r == width s * S.size_block} =
match s with
| M32 -> 16ul
| M128 -> 32ul
| M256 -> 64ul
unfold noextract
let nelem (s:field_spec) : size_t =
match s with
| M32 -> 1ul
| M128 -> 2ul
| M256 -> 4ul
unfold noextract
let precomplen (s:field_spec) : size_t =
match s with
| M32 -> 20ul
| M128 -> 20ul
| M256 -> 20ul
inline_for_extraction noextract
type felem (s:field_spec) = lbuffer (limb s) (nlimb s)
type felem_wide (s:field_spec) = lbuffer (wide s) (nlimb s)
inline_for_extraction noextract
type precomp_r (s:field_spec) = lbuffer (limb s) (precomplen s)
noextract
val felem_fits: #s:field_spec -> h:mem -> f:felem s -> m:F32xN.scale32_5 -> Type0 | false | false | Hacl.Impl.Poly1305.Fields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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 felem_fits: #s:field_spec -> h:mem -> f:felem s -> m:F32xN.scale32_5 -> Type0 | [] | Hacl.Impl.Poly1305.Fields.felem_fits | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Fields.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
h: FStar.Monotonic.HyperStack.mem ->
f: Hacl.Impl.Poly1305.Fields.felem s ->
m: Hacl.Spec.Poly1305.Field32xN.scale32_5
-> Type0 | {
"end_col": 37,
"end_line": 100,
"start_col": 2,
"start_line": 97
} |
FStar.Pervasives.Lemma | val lemma_feval_is_fas_nat: #s:field_spec -> h:mem -> f:felem s ->
Lemma
(requires F32xN.felem_less #(width s) h f (pow2 128))
(ensures (forall (i:nat). i < width s ==> (feval h f).[i] == (fas_nat h f).[i])) | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": "F32xN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_32",
"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.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.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 lemma_feval_is_fas_nat #s h f =
F32xN.lemma_feval_is_fas_nat #(width s) h f | val lemma_feval_is_fas_nat: #s:field_spec -> h:mem -> f:felem s ->
Lemma
(requires F32xN.felem_less #(width s) h f (pow2 128))
(ensures (forall (i:nat). i < width s ==> (feval h f).[i] == (fas_nat h f).[i]))
let lemma_feval_is_fas_nat #s h f = | false | null | true | F32xN.lemma_feval_is_fas_nat #(width s) h f | {
"checked_file": "Hacl.Impl.Poly1305.Fields.fst.checked",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_32.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_256.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_128.fst.checked",
"Hacl.Impl.Poly1305.Field32xN.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.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Poly1305.Fields.fst"
} | [
"lemma"
] | [
"Hacl.Impl.Poly1305.Fields.field_spec",
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Poly1305.Fields.felem",
"Hacl.Impl.Poly1305.Field32xN.lemma_feval_is_fas_nat",
"Hacl.Impl.Poly1305.Fields.width",
"Prims.unit"
] | [] | module Hacl.Impl.Poly1305.Fields
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Poly1305.Field32xN_32
open Hacl.Impl.Poly1305.Field32xN_128
open Hacl.Impl.Poly1305.Field32xN_256
open Hacl.Impl.Poly1305.Field32xN
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.Poly1305
module Vec = Hacl.Spec.Poly1305.Vec
module F32xN = Hacl.Impl.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --max_fuel 0 --max_fuel 0"
noextract
type field_spec =
| M32
| M128
| M256
unfold noextract
let width (s:field_spec) : Vec.lanes =
match s with
| M32 -> 1
| M128 -> 2
| M256 -> 4
unfold noextract
let limb (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M32 -> F32xN.zero 1
| M128 -> F32xN.zero 2
| M256 -> F32xN.zero 4
unfold noextract
let wide (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M32 -> 5ul
| M128 -> 5ul
| M256 -> 5ul
unfold noextract
let blocklen (s:field_spec) : r:size_t{0 < v r /\ v r == width s * S.size_block} =
match s with
| M32 -> 16ul
| M128 -> 32ul
| M256 -> 64ul
unfold noextract
let nelem (s:field_spec) : size_t =
match s with
| M32 -> 1ul
| M128 -> 2ul
| M256 -> 4ul
unfold noextract
let precomplen (s:field_spec) : size_t =
match s with
| M32 -> 20ul
| M128 -> 20ul
| M256 -> 20ul
inline_for_extraction noextract
type felem (s:field_spec) = lbuffer (limb s) (nlimb s)
type felem_wide (s:field_spec) = lbuffer (wide s) (nlimb s)
inline_for_extraction noextract
type precomp_r (s:field_spec) = lbuffer (limb s) (precomplen s)
noextract
val felem_fits: #s:field_spec -> h:mem -> f:felem s -> m:F32xN.scale32_5 -> Type0
let felem_fits #s h f m =
match s with
| M32 -> F32xN.felem_fits #1 h f m
| M128 -> F32xN.felem_fits #2 h f m
| M256 -> F32xN.felem_fits #4 h f m
noextract
val fas_nat: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq nat (width s))
let fas_nat #s h e =
match s with
| M32 -> F32xN.fas_nat #1 h e
| M128 -> F32xN.fas_nat #2 h e
| M256 -> F32xN.fas_nat #4 h e
noextract
val feval: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq S.felem (width s))
let feval #s h e =
match s with
| M32 -> F32xN.feval #1 h e
| M128 -> F32xN.feval #2 h e
| M256 -> F32xN.feval #4 h e
unfold noextract
let op_String_Access #a #len = LSeq.index #a #len
val lemma_feval_is_fas_nat: #s:field_spec -> h:mem -> f:felem s ->
Lemma
(requires F32xN.felem_less #(width s) h f (pow2 128))
(ensures (forall (i:nat). i < width s ==> (feval h f).[i] == (fas_nat h f).[i])) | false | false | Hacl.Impl.Poly1305.Fields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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 lemma_feval_is_fas_nat: #s:field_spec -> h:mem -> f:felem s ->
Lemma
(requires F32xN.felem_less #(width s) h f (pow2 128))
(ensures (forall (i:nat). i < width s ==> (feval h f).[i] == (fas_nat h f).[i])) | [] | Hacl.Impl.Poly1305.Fields.lemma_feval_is_fas_nat | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Fields.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> f: Hacl.Impl.Poly1305.Fields.felem s
-> FStar.Pervasives.Lemma (requires Hacl.Impl.Poly1305.Field32xN.felem_less h f (Prims.pow2 128))
(ensures
forall (i: Prims.nat).
i < Hacl.Impl.Poly1305.Fields.width s ==>
(Hacl.Impl.Poly1305.Fields.feval h f).[ i ] ==
(Hacl.Impl.Poly1305.Fields.fas_nat h f).[ i ]) | {
"end_col": 45,
"end_line": 127,
"start_col": 2,
"start_line": 127
} |
FStar.HyperStack.ST.Stack | val set_zero:
#s:field_spec
-> f:felem s ->
Stack unit
(requires fun h -> live h f)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (0, 0, 0, 0, 0) /\
feval h1 f == LSeq.create (width s) 0) | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": "F32xN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_32",
"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.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.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 set_zero #s f =
match s with
| M32 -> F32xN.set_zero #1 f
| M128 -> F32xN.set_zero #2 f
| M256 -> F32xN.set_zero #4 f | val set_zero:
#s:field_spec
-> f:felem s ->
Stack unit
(requires fun h -> live h f)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (0, 0, 0, 0, 0) /\
feval h1 f == LSeq.create (width s) 0)
let set_zero #s f = | true | null | false | match s with
| M32 -> F32xN.set_zero #1 f
| M128 -> F32xN.set_zero #2 f
| M256 -> F32xN.set_zero #4 f | {
"checked_file": "Hacl.Impl.Poly1305.Fields.fst.checked",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_32.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_256.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_128.fst.checked",
"Hacl.Impl.Poly1305.Field32xN.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.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Poly1305.Fields.fst"
} | [] | [
"Hacl.Impl.Poly1305.Fields.field_spec",
"Hacl.Impl.Poly1305.Fields.felem",
"Hacl.Impl.Poly1305.Field32xN.set_zero",
"Prims.unit"
] | [] | module Hacl.Impl.Poly1305.Fields
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Poly1305.Field32xN_32
open Hacl.Impl.Poly1305.Field32xN_128
open Hacl.Impl.Poly1305.Field32xN_256
open Hacl.Impl.Poly1305.Field32xN
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.Poly1305
module Vec = Hacl.Spec.Poly1305.Vec
module F32xN = Hacl.Impl.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --max_fuel 0 --max_fuel 0"
noextract
type field_spec =
| M32
| M128
| M256
unfold noextract
let width (s:field_spec) : Vec.lanes =
match s with
| M32 -> 1
| M128 -> 2
| M256 -> 4
unfold noextract
let limb (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M32 -> F32xN.zero 1
| M128 -> F32xN.zero 2
| M256 -> F32xN.zero 4
unfold noextract
let wide (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M32 -> 5ul
| M128 -> 5ul
| M256 -> 5ul
unfold noextract
let blocklen (s:field_spec) : r:size_t{0 < v r /\ v r == width s * S.size_block} =
match s with
| M32 -> 16ul
| M128 -> 32ul
| M256 -> 64ul
unfold noextract
let nelem (s:field_spec) : size_t =
match s with
| M32 -> 1ul
| M128 -> 2ul
| M256 -> 4ul
unfold noextract
let precomplen (s:field_spec) : size_t =
match s with
| M32 -> 20ul
| M128 -> 20ul
| M256 -> 20ul
inline_for_extraction noextract
type felem (s:field_spec) = lbuffer (limb s) (nlimb s)
type felem_wide (s:field_spec) = lbuffer (wide s) (nlimb s)
inline_for_extraction noextract
type precomp_r (s:field_spec) = lbuffer (limb s) (precomplen s)
noextract
val felem_fits: #s:field_spec -> h:mem -> f:felem s -> m:F32xN.scale32_5 -> Type0
let felem_fits #s h f m =
match s with
| M32 -> F32xN.felem_fits #1 h f m
| M128 -> F32xN.felem_fits #2 h f m
| M256 -> F32xN.felem_fits #4 h f m
noextract
val fas_nat: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq nat (width s))
let fas_nat #s h e =
match s with
| M32 -> F32xN.fas_nat #1 h e
| M128 -> F32xN.fas_nat #2 h e
| M256 -> F32xN.fas_nat #4 h e
noextract
val feval: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq S.felem (width s))
let feval #s h e =
match s with
| M32 -> F32xN.feval #1 h e
| M128 -> F32xN.feval #2 h e
| M256 -> F32xN.feval #4 h e
unfold noextract
let op_String_Access #a #len = LSeq.index #a #len
val lemma_feval_is_fas_nat: #s:field_spec -> h:mem -> f:felem s ->
Lemma
(requires F32xN.felem_less #(width s) h f (pow2 128))
(ensures (forall (i:nat). i < width s ==> (feval h f).[i] == (fas_nat h f).[i]))
let lemma_feval_is_fas_nat #s h f =
F32xN.lemma_feval_is_fas_nat #(width s) h f
inline_for_extraction noextract
val create_felem: s:field_spec ->
StackInline (felem s)
(requires fun h -> True)
(ensures fun h0 f h1 ->
stack_allocated f h0 h1 (LSeq.create 5 (limb_zero s)) /\
feval h1 f == LSeq.create (width s) 0)
let create_felem s =
match s with
| M32 -> (F32xN.create_felem 1) <: felem s
| M128 -> (F32xN.create_felem 2) <: felem s
| M256 -> (F32xN.create_felem 4) <: felem s
inline_for_extraction noextract
val load_felem_le:
#s:field_spec
-> f:felem s
-> b:lbuffer uint8 16ul ->
Stack unit
(requires fun h -> live h f /\ live h b)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h1 f (pow2 128) /\
feval h1 f == LSeq.create (width s) (BSeq.nat_from_bytes_le (as_seq h0 b)))
let load_felem_le #s f b =
match s with
| M32 -> F32xN.load_felem_le #1 f b
| M128 -> F32xN.load_felem_le #2 f b
| M256 -> F32xN.load_felem_le #4 f b
inline_for_extraction noextract
val load_felems_le:
#s:field_spec
-> f:felem s
-> b:lbuffer uint8 (blocklen s) ->
Stack unit
(requires fun h -> live h f /\ live h b)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h1 f (pow2 128) /\
feval h1 f == Vec.load_elem #(width s) (as_seq h0 b))
let load_felems_le #s f b =
match s with
| M32 -> F32xN.load_felems_le #1 f b
| M128 -> F32xN.load_felems_le #2 f b
| M256 -> F32xN.load_felems_le #4 f b
inline_for_extraction noextract
val load_acc:
#s:field_spec
-> acc:felem s
-> b:lbuffer uint8 (blocklen s) ->
Stack unit
(requires fun h ->
live h acc /\ live h b /\ disjoint acc b /\
felem_fits h acc (2, 2, 2, 2, 2))
(ensures fun h0 _ h1 ->
modifies (loc acc) h0 h1 /\
felem_fits h1 acc (3, 3, 3, 3, 3) /\
feval h1 acc == Vec.load_acc #(width s) (as_seq h0 b) (feval h0 acc).[0])
let load_acc #s acc b =
match s with
| M32 -> Field32xN_32.load_acc1 acc b
| M128 -> Field32xN_128.load_acc2 acc b
| M256 -> Field32xN_256.load_acc4 acc b
inline_for_extraction noextract
val set_bit:
#s:field_spec
-> f:felem s
-> i:size_t{size_v i <= 128} ->
Stack unit
(requires fun h ->
live h f /\
felem_fits h f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h f (pow2 (v i)))
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
(Math.Lemmas.pow2_le_compat 128 (v i);
feval h1 f == LSeq.map (Vec.pfadd (pow2 (v i))) (feval h0 f)))
let set_bit #s f i =
match s with
| M32 -> F32xN.set_bit #1 f i
| M128 -> F32xN.set_bit #2 f i
| M256 -> F32xN.set_bit #4 f i
inline_for_extraction noextract
val set_bit128:
#s:field_spec
-> f:felem s ->
Stack unit
(requires fun h ->
live h f /\
felem_fits h f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h f (pow2 128))
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
feval h1 f == LSeq.map (Vec.pfadd (pow2 128)) (feval h0 f))
let set_bit128 #s f =
match s with
| M32 -> F32xN.set_bit128 #1 f
| M128 -> F32xN.set_bit128 #2 f
| M256 -> F32xN.set_bit128 #4 f
inline_for_extraction noextract
val set_zero:
#s:field_spec
-> f:felem s ->
Stack unit
(requires fun h -> live h f)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (0, 0, 0, 0, 0) /\
feval h1 f == LSeq.create (width s) 0) | false | false | Hacl.Impl.Poly1305.Fields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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 set_zero:
#s:field_spec
-> f:felem s ->
Stack unit
(requires fun h -> live h f)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (0, 0, 0, 0, 0) /\
feval h1 f == LSeq.create (width s) 0) | [] | Hacl.Impl.Poly1305.Fields.set_zero | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Fields.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Hacl.Impl.Poly1305.Fields.felem s -> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 31,
"end_line": 264,
"start_col": 2,
"start_line": 261
} |
FStar.HyperStack.ST.Stack | val uints64_from_felem_le:
#s:field_spec
-> f:felem s ->
Stack (uint64 & uint64)
(requires fun h ->
live h f /\ felem_fits h f (1, 1, 1, 1, 1))
(ensures fun h0 (lo, hi) h1 -> h0 == h1 /\
v hi * pow2 64 + v lo == (fas_nat h0 f).[0] % pow2 128) | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": "F32xN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_32",
"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.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.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 uints64_from_felem_le #s f =
match s with
| M32 -> F32xN.uints64_from_felem_le #1 f
| M128 -> F32xN.uints64_from_felem_le #2 f
| M256 -> F32xN.uints64_from_felem_le #4 f | val uints64_from_felem_le:
#s:field_spec
-> f:felem s ->
Stack (uint64 & uint64)
(requires fun h ->
live h f /\ felem_fits h f (1, 1, 1, 1, 1))
(ensures fun h0 (lo, hi) h1 -> h0 == h1 /\
v hi * pow2 64 + v lo == (fas_nat h0 f).[0] % pow2 128)
let uints64_from_felem_le #s f = | true | null | false | match s with
| M32 -> F32xN.uints64_from_felem_le #1 f
| M128 -> F32xN.uints64_from_felem_le #2 f
| M256 -> F32xN.uints64_from_felem_le #4 f | {
"checked_file": "Hacl.Impl.Poly1305.Fields.fst.checked",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_32.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_256.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_128.fst.checked",
"Hacl.Impl.Poly1305.Field32xN.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.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Poly1305.Fields.fst"
} | [] | [
"Hacl.Impl.Poly1305.Fields.field_spec",
"Hacl.Impl.Poly1305.Fields.felem",
"Hacl.Impl.Poly1305.Field32xN.uints64_from_felem_le",
"FStar.Pervasives.Native.tuple2",
"Lib.IntTypes.uint64"
] | [] | module Hacl.Impl.Poly1305.Fields
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Poly1305.Field32xN_32
open Hacl.Impl.Poly1305.Field32xN_128
open Hacl.Impl.Poly1305.Field32xN_256
open Hacl.Impl.Poly1305.Field32xN
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.Poly1305
module Vec = Hacl.Spec.Poly1305.Vec
module F32xN = Hacl.Impl.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --max_fuel 0 --max_fuel 0"
noextract
type field_spec =
| M32
| M128
| M256
unfold noextract
let width (s:field_spec) : Vec.lanes =
match s with
| M32 -> 1
| M128 -> 2
| M256 -> 4
unfold noextract
let limb (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M32 -> F32xN.zero 1
| M128 -> F32xN.zero 2
| M256 -> F32xN.zero 4
unfold noextract
let wide (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M32 -> 5ul
| M128 -> 5ul
| M256 -> 5ul
unfold noextract
let blocklen (s:field_spec) : r:size_t{0 < v r /\ v r == width s * S.size_block} =
match s with
| M32 -> 16ul
| M128 -> 32ul
| M256 -> 64ul
unfold noextract
let nelem (s:field_spec) : size_t =
match s with
| M32 -> 1ul
| M128 -> 2ul
| M256 -> 4ul
unfold noextract
let precomplen (s:field_spec) : size_t =
match s with
| M32 -> 20ul
| M128 -> 20ul
| M256 -> 20ul
inline_for_extraction noextract
type felem (s:field_spec) = lbuffer (limb s) (nlimb s)
type felem_wide (s:field_spec) = lbuffer (wide s) (nlimb s)
inline_for_extraction noextract
type precomp_r (s:field_spec) = lbuffer (limb s) (precomplen s)
noextract
val felem_fits: #s:field_spec -> h:mem -> f:felem s -> m:F32xN.scale32_5 -> Type0
let felem_fits #s h f m =
match s with
| M32 -> F32xN.felem_fits #1 h f m
| M128 -> F32xN.felem_fits #2 h f m
| M256 -> F32xN.felem_fits #4 h f m
noextract
val fas_nat: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq nat (width s))
let fas_nat #s h e =
match s with
| M32 -> F32xN.fas_nat #1 h e
| M128 -> F32xN.fas_nat #2 h e
| M256 -> F32xN.fas_nat #4 h e
noextract
val feval: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq S.felem (width s))
let feval #s h e =
match s with
| M32 -> F32xN.feval #1 h e
| M128 -> F32xN.feval #2 h e
| M256 -> F32xN.feval #4 h e
unfold noextract
let op_String_Access #a #len = LSeq.index #a #len
val lemma_feval_is_fas_nat: #s:field_spec -> h:mem -> f:felem s ->
Lemma
(requires F32xN.felem_less #(width s) h f (pow2 128))
(ensures (forall (i:nat). i < width s ==> (feval h f).[i] == (fas_nat h f).[i]))
let lemma_feval_is_fas_nat #s h f =
F32xN.lemma_feval_is_fas_nat #(width s) h f
inline_for_extraction noextract
val create_felem: s:field_spec ->
StackInline (felem s)
(requires fun h -> True)
(ensures fun h0 f h1 ->
stack_allocated f h0 h1 (LSeq.create 5 (limb_zero s)) /\
feval h1 f == LSeq.create (width s) 0)
let create_felem s =
match s with
| M32 -> (F32xN.create_felem 1) <: felem s
| M128 -> (F32xN.create_felem 2) <: felem s
| M256 -> (F32xN.create_felem 4) <: felem s
inline_for_extraction noextract
val load_felem_le:
#s:field_spec
-> f:felem s
-> b:lbuffer uint8 16ul ->
Stack unit
(requires fun h -> live h f /\ live h b)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h1 f (pow2 128) /\
feval h1 f == LSeq.create (width s) (BSeq.nat_from_bytes_le (as_seq h0 b)))
let load_felem_le #s f b =
match s with
| M32 -> F32xN.load_felem_le #1 f b
| M128 -> F32xN.load_felem_le #2 f b
| M256 -> F32xN.load_felem_le #4 f b
inline_for_extraction noextract
val load_felems_le:
#s:field_spec
-> f:felem s
-> b:lbuffer uint8 (blocklen s) ->
Stack unit
(requires fun h -> live h f /\ live h b)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h1 f (pow2 128) /\
feval h1 f == Vec.load_elem #(width s) (as_seq h0 b))
let load_felems_le #s f b =
match s with
| M32 -> F32xN.load_felems_le #1 f b
| M128 -> F32xN.load_felems_le #2 f b
| M256 -> F32xN.load_felems_le #4 f b
inline_for_extraction noextract
val load_acc:
#s:field_spec
-> acc:felem s
-> b:lbuffer uint8 (blocklen s) ->
Stack unit
(requires fun h ->
live h acc /\ live h b /\ disjoint acc b /\
felem_fits h acc (2, 2, 2, 2, 2))
(ensures fun h0 _ h1 ->
modifies (loc acc) h0 h1 /\
felem_fits h1 acc (3, 3, 3, 3, 3) /\
feval h1 acc == Vec.load_acc #(width s) (as_seq h0 b) (feval h0 acc).[0])
let load_acc #s acc b =
match s with
| M32 -> Field32xN_32.load_acc1 acc b
| M128 -> Field32xN_128.load_acc2 acc b
| M256 -> Field32xN_256.load_acc4 acc b
inline_for_extraction noextract
val set_bit:
#s:field_spec
-> f:felem s
-> i:size_t{size_v i <= 128} ->
Stack unit
(requires fun h ->
live h f /\
felem_fits h f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h f (pow2 (v i)))
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
(Math.Lemmas.pow2_le_compat 128 (v i);
feval h1 f == LSeq.map (Vec.pfadd (pow2 (v i))) (feval h0 f)))
let set_bit #s f i =
match s with
| M32 -> F32xN.set_bit #1 f i
| M128 -> F32xN.set_bit #2 f i
| M256 -> F32xN.set_bit #4 f i
inline_for_extraction noextract
val set_bit128:
#s:field_spec
-> f:felem s ->
Stack unit
(requires fun h ->
live h f /\
felem_fits h f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h f (pow2 128))
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
feval h1 f == LSeq.map (Vec.pfadd (pow2 128)) (feval h0 f))
let set_bit128 #s f =
match s with
| M32 -> F32xN.set_bit128 #1 f
| M128 -> F32xN.set_bit128 #2 f
| M256 -> F32xN.set_bit128 #4 f
inline_for_extraction noextract
val set_zero:
#s:field_spec
-> f:felem s ->
Stack unit
(requires fun h -> live h f)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (0, 0, 0, 0, 0) /\
feval h1 f == LSeq.create (width s) 0)
let set_zero #s f =
match s with
| M32 -> F32xN.set_zero #1 f
| M128 -> F32xN.set_zero #2 f
| M256 -> F32xN.set_zero #4 f
inline_for_extraction noextract
val reduce_felem:
#s:field_spec
-> f:felem s ->
Stack unit
(requires fun h -> live h f /\ felem_fits h f (2, 2, 2, 2, 2))
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
(fas_nat h1 f).[0] == (feval h0 f).[0])
let reduce_felem #s f =
match s with
| M32 -> F32xN.reduce_felem #1 f
| M128 -> F32xN.reduce_felem #2 f
| M256 -> F32xN.reduce_felem #4 f
inline_for_extraction noextract
val load_precompute_r:
#s:field_spec
-> p:precomp_r s
-> r0:uint64
-> r1:uint64 ->
Stack unit
(requires fun h -> live h p)
(ensures fun h0 _ h1 ->
modifies (loc p) h0 h1 /\
F32xN.load_precompute_r_post #(width s) h1 p /\
(assert (uint_v r1 * pow2 64 + uint_v r0 < pow2 128);
feval h1 (gsub p 0ul 5ul) ==
LSeq.create (width s) (uint_v r1 * pow2 64 + uint_v r0)))
let load_precompute_r #s p r0 r1 =
match s with
| M32 -> F32xN.load_precompute_r #1 p r0 r1
| M128 -> F32xN.load_precompute_r #2 p r0 r1
| M256 -> F32xN.load_precompute_r #4 p r0 r1
inline_for_extraction noextract
val fadd_mul_r:
#s:field_spec
-> out:felem s
-> f1:felem s
-> precomp:precomp_r s ->
Stack unit
(requires fun h ->
live h out /\ live h f1 /\ live h precomp /\
F32xN.fmul_precomp_r_pre #(width s) h precomp /\
felem_fits h out (2, 2, 2, 2, 2) /\
felem_fits h f1 (1, 1, 1, 1, 1))
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\
felem_fits h1 out (1, 2, 1, 1, 2) /\
feval h1 out ==
Vec.fmul (Vec.fadd (feval h0 out) (feval h0 f1)) (feval h0 (gsub precomp 0ul 5ul)))
let fadd_mul_r #s out f1 precomp =
match s with
| M32 -> F32xN.fadd_mul_r #1 out f1 precomp
| M128 -> F32xN.fadd_mul_r #2 out f1 precomp
| M256 -> F32xN.fadd_mul_r #4 out f1 precomp
inline_for_extraction noextract
val fmul_rn:
#s:field_spec
-> out:felem s
-> f1:felem s
-> precomp:precomp_r s ->
Stack unit
(requires fun h ->
live h out /\ live h f1 /\ live h precomp /\
(let rn = gsub precomp 10ul 5ul in
let rn_5 = gsub precomp 15ul 5ul in
felem_fits h f1 (3, 3, 3, 3, 3) /\
felem_fits h rn (2, 2, 2, 2, 2) /\
felem_fits h rn_5 (10, 10, 10, 10, 10) /\
F32xN.as_tup5 #(width s) h rn_5 == F32xN.precomp_r5 (F32xN.as_tup5 h rn)))
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\
felem_fits h1 out (1, 2, 1, 1, 2) /\
feval h1 out == Vec.fmul (feval h0 f1) (feval h0 (gsub precomp 10ul 5ul)))
let fmul_rn #s out f1 precomp =
match s with
| M32 -> F32xN.fmul_rn #1 out f1 precomp
| M128 -> F32xN.fmul_rn #2 out f1 precomp
| M256 -> F32xN.fmul_rn #4 out f1 precomp
inline_for_extraction noextract
val fmul_rn_normalize:
#s:field_spec
-> out:felem s
-> precomp:precomp_r s ->
Stack unit
(requires fun h ->
live h out /\ live h precomp /\
felem_fits h out (3, 3, 3, 3, 3) /\
F32xN.load_precompute_r_post #(width s) h precomp)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\
felem_fits h1 out (2, 2, 2, 2, 2) /\
(feval h1 out).[0] ==
Vec.normalize_n #(width s) (feval h0 (gsub precomp 0ul 5ul)).[0] (feval h0 out))
let fmul_rn_normalize #s out precomp =
match s with
| M32 -> Field32xN_32.fmul_r1_normalize out precomp
| M128 -> Field32xN_128.fmul_r2_normalize out precomp
| M256 -> Field32xN_256.fmul_r4_normalize out precomp
inline_for_extraction noextract
val fadd:
#s:field_spec
-> out:felem s
-> f1:felem s
-> f2:felem s ->
Stack unit
(requires fun h ->
live h out /\ live h f1 /\ live h f2 /\
felem_fits h f1 (2, 2, 2, 2, 2) /\
felem_fits h f2 (1, 1, 1, 1, 1))
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\
felem_fits h1 out (3, 3, 3, 3, 3) /\
feval h1 out == Vec.fadd (feval h0 f1) (feval h0 f2))
let fadd #s out f1 f2 =
match s with
| M32 -> F32xN.fadd #1 out f1 f2
| M128 -> F32xN.fadd #2 out f1 f2
| M256 -> F32xN.fadd #4 out f1 f2
inline_for_extraction noextract
val uints64_from_felem_le:
#s:field_spec
-> f:felem s ->
Stack (uint64 & uint64)
(requires fun h ->
live h f /\ felem_fits h f (1, 1, 1, 1, 1))
(ensures fun h0 (lo, hi) h1 -> h0 == h1 /\
v hi * pow2 64 + v lo == (fas_nat h0 f).[0] % pow2 128) | false | false | Hacl.Impl.Poly1305.Fields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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 uints64_from_felem_le:
#s:field_spec
-> f:felem s ->
Stack (uint64 & uint64)
(requires fun h ->
live h f /\ felem_fits h f (1, 1, 1, 1, 1))
(ensures fun h0 (lo, hi) h1 -> h0 == h1 /\
v hi * pow2 64 + v lo == (fas_nat h0 f).[0] % pow2 128) | [] | Hacl.Impl.Poly1305.Fields.uints64_from_felem_le | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Fields.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Hacl.Impl.Poly1305.Fields.felem s
-> FStar.HyperStack.ST.Stack (Lib.IntTypes.uint64 * Lib.IntTypes.uint64) | {
"end_col": 44,
"end_line": 418,
"start_col": 2,
"start_line": 415
} |
FStar.HyperStack.ST.Stack | val reduce_felem:
#s:field_spec
-> f:felem s ->
Stack unit
(requires fun h -> live h f /\ felem_fits h f (2, 2, 2, 2, 2))
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
(fas_nat h1 f).[0] == (feval h0 f).[0]) | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": "F32xN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_32",
"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.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.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 reduce_felem #s f =
match s with
| M32 -> F32xN.reduce_felem #1 f
| M128 -> F32xN.reduce_felem #2 f
| M256 -> F32xN.reduce_felem #4 f | val reduce_felem:
#s:field_spec
-> f:felem s ->
Stack unit
(requires fun h -> live h f /\ felem_fits h f (2, 2, 2, 2, 2))
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
(fas_nat h1 f).[0] == (feval h0 f).[0])
let reduce_felem #s f = | true | null | false | match s with
| M32 -> F32xN.reduce_felem #1 f
| M128 -> F32xN.reduce_felem #2 f
| M256 -> F32xN.reduce_felem #4 f | {
"checked_file": "Hacl.Impl.Poly1305.Fields.fst.checked",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_32.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_256.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_128.fst.checked",
"Hacl.Impl.Poly1305.Field32xN.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.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Poly1305.Fields.fst"
} | [] | [
"Hacl.Impl.Poly1305.Fields.field_spec",
"Hacl.Impl.Poly1305.Fields.felem",
"Hacl.Impl.Poly1305.Field32xN.reduce_felem",
"Prims.unit"
] | [] | module Hacl.Impl.Poly1305.Fields
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Poly1305.Field32xN_32
open Hacl.Impl.Poly1305.Field32xN_128
open Hacl.Impl.Poly1305.Field32xN_256
open Hacl.Impl.Poly1305.Field32xN
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.Poly1305
module Vec = Hacl.Spec.Poly1305.Vec
module F32xN = Hacl.Impl.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --max_fuel 0 --max_fuel 0"
noextract
type field_spec =
| M32
| M128
| M256
unfold noextract
let width (s:field_spec) : Vec.lanes =
match s with
| M32 -> 1
| M128 -> 2
| M256 -> 4
unfold noextract
let limb (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M32 -> F32xN.zero 1
| M128 -> F32xN.zero 2
| M256 -> F32xN.zero 4
unfold noextract
let wide (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M32 -> 5ul
| M128 -> 5ul
| M256 -> 5ul
unfold noextract
let blocklen (s:field_spec) : r:size_t{0 < v r /\ v r == width s * S.size_block} =
match s with
| M32 -> 16ul
| M128 -> 32ul
| M256 -> 64ul
unfold noextract
let nelem (s:field_spec) : size_t =
match s with
| M32 -> 1ul
| M128 -> 2ul
| M256 -> 4ul
unfold noextract
let precomplen (s:field_spec) : size_t =
match s with
| M32 -> 20ul
| M128 -> 20ul
| M256 -> 20ul
inline_for_extraction noextract
type felem (s:field_spec) = lbuffer (limb s) (nlimb s)
type felem_wide (s:field_spec) = lbuffer (wide s) (nlimb s)
inline_for_extraction noextract
type precomp_r (s:field_spec) = lbuffer (limb s) (precomplen s)
noextract
val felem_fits: #s:field_spec -> h:mem -> f:felem s -> m:F32xN.scale32_5 -> Type0
let felem_fits #s h f m =
match s with
| M32 -> F32xN.felem_fits #1 h f m
| M128 -> F32xN.felem_fits #2 h f m
| M256 -> F32xN.felem_fits #4 h f m
noextract
val fas_nat: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq nat (width s))
let fas_nat #s h e =
match s with
| M32 -> F32xN.fas_nat #1 h e
| M128 -> F32xN.fas_nat #2 h e
| M256 -> F32xN.fas_nat #4 h e
noextract
val feval: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq S.felem (width s))
let feval #s h e =
match s with
| M32 -> F32xN.feval #1 h e
| M128 -> F32xN.feval #2 h e
| M256 -> F32xN.feval #4 h e
unfold noextract
let op_String_Access #a #len = LSeq.index #a #len
val lemma_feval_is_fas_nat: #s:field_spec -> h:mem -> f:felem s ->
Lemma
(requires F32xN.felem_less #(width s) h f (pow2 128))
(ensures (forall (i:nat). i < width s ==> (feval h f).[i] == (fas_nat h f).[i]))
let lemma_feval_is_fas_nat #s h f =
F32xN.lemma_feval_is_fas_nat #(width s) h f
inline_for_extraction noextract
val create_felem: s:field_spec ->
StackInline (felem s)
(requires fun h -> True)
(ensures fun h0 f h1 ->
stack_allocated f h0 h1 (LSeq.create 5 (limb_zero s)) /\
feval h1 f == LSeq.create (width s) 0)
let create_felem s =
match s with
| M32 -> (F32xN.create_felem 1) <: felem s
| M128 -> (F32xN.create_felem 2) <: felem s
| M256 -> (F32xN.create_felem 4) <: felem s
inline_for_extraction noextract
val load_felem_le:
#s:field_spec
-> f:felem s
-> b:lbuffer uint8 16ul ->
Stack unit
(requires fun h -> live h f /\ live h b)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h1 f (pow2 128) /\
feval h1 f == LSeq.create (width s) (BSeq.nat_from_bytes_le (as_seq h0 b)))
let load_felem_le #s f b =
match s with
| M32 -> F32xN.load_felem_le #1 f b
| M128 -> F32xN.load_felem_le #2 f b
| M256 -> F32xN.load_felem_le #4 f b
inline_for_extraction noextract
val load_felems_le:
#s:field_spec
-> f:felem s
-> b:lbuffer uint8 (blocklen s) ->
Stack unit
(requires fun h -> live h f /\ live h b)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h1 f (pow2 128) /\
feval h1 f == Vec.load_elem #(width s) (as_seq h0 b))
let load_felems_le #s f b =
match s with
| M32 -> F32xN.load_felems_le #1 f b
| M128 -> F32xN.load_felems_le #2 f b
| M256 -> F32xN.load_felems_le #4 f b
inline_for_extraction noextract
val load_acc:
#s:field_spec
-> acc:felem s
-> b:lbuffer uint8 (blocklen s) ->
Stack unit
(requires fun h ->
live h acc /\ live h b /\ disjoint acc b /\
felem_fits h acc (2, 2, 2, 2, 2))
(ensures fun h0 _ h1 ->
modifies (loc acc) h0 h1 /\
felem_fits h1 acc (3, 3, 3, 3, 3) /\
feval h1 acc == Vec.load_acc #(width s) (as_seq h0 b) (feval h0 acc).[0])
let load_acc #s acc b =
match s with
| M32 -> Field32xN_32.load_acc1 acc b
| M128 -> Field32xN_128.load_acc2 acc b
| M256 -> Field32xN_256.load_acc4 acc b
inline_for_extraction noextract
val set_bit:
#s:field_spec
-> f:felem s
-> i:size_t{size_v i <= 128} ->
Stack unit
(requires fun h ->
live h f /\
felem_fits h f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h f (pow2 (v i)))
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
(Math.Lemmas.pow2_le_compat 128 (v i);
feval h1 f == LSeq.map (Vec.pfadd (pow2 (v i))) (feval h0 f)))
let set_bit #s f i =
match s with
| M32 -> F32xN.set_bit #1 f i
| M128 -> F32xN.set_bit #2 f i
| M256 -> F32xN.set_bit #4 f i
inline_for_extraction noextract
val set_bit128:
#s:field_spec
-> f:felem s ->
Stack unit
(requires fun h ->
live h f /\
felem_fits h f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h f (pow2 128))
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
feval h1 f == LSeq.map (Vec.pfadd (pow2 128)) (feval h0 f))
let set_bit128 #s f =
match s with
| M32 -> F32xN.set_bit128 #1 f
| M128 -> F32xN.set_bit128 #2 f
| M256 -> F32xN.set_bit128 #4 f
inline_for_extraction noextract
val set_zero:
#s:field_spec
-> f:felem s ->
Stack unit
(requires fun h -> live h f)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (0, 0, 0, 0, 0) /\
feval h1 f == LSeq.create (width s) 0)
let set_zero #s f =
match s with
| M32 -> F32xN.set_zero #1 f
| M128 -> F32xN.set_zero #2 f
| M256 -> F32xN.set_zero #4 f
inline_for_extraction noextract
val reduce_felem:
#s:field_spec
-> f:felem s ->
Stack unit
(requires fun h -> live h f /\ felem_fits h f (2, 2, 2, 2, 2))
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
(fas_nat h1 f).[0] == (feval h0 f).[0]) | false | false | Hacl.Impl.Poly1305.Fields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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 reduce_felem:
#s:field_spec
-> f:felem s ->
Stack unit
(requires fun h -> live h f /\ felem_fits h f (2, 2, 2, 2, 2))
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
(fas_nat h1 f).[0] == (feval h0 f).[0]) | [] | Hacl.Impl.Poly1305.Fields.reduce_felem | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Fields.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Hacl.Impl.Poly1305.Fields.felem s -> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 35,
"end_line": 282,
"start_col": 2,
"start_line": 279
} |
FStar.HyperStack.ST.Stack | val load_felem_le:
#s:field_spec
-> f:felem s
-> b:lbuffer uint8 16ul ->
Stack unit
(requires fun h -> live h f /\ live h b)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h1 f (pow2 128) /\
feval h1 f == LSeq.create (width s) (BSeq.nat_from_bytes_le (as_seq h0 b))) | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": "F32xN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_32",
"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.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.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 load_felem_le #s f b =
match s with
| M32 -> F32xN.load_felem_le #1 f b
| M128 -> F32xN.load_felem_le #2 f b
| M256 -> F32xN.load_felem_le #4 f b | val load_felem_le:
#s:field_spec
-> f:felem s
-> b:lbuffer uint8 16ul ->
Stack unit
(requires fun h -> live h f /\ live h b)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h1 f (pow2 128) /\
feval h1 f == LSeq.create (width s) (BSeq.nat_from_bytes_le (as_seq h0 b)))
let load_felem_le #s f b = | true | null | false | match s with
| M32 -> F32xN.load_felem_le #1 f b
| M128 -> F32xN.load_felem_le #2 f b
| M256 -> F32xN.load_felem_le #4 f b | {
"checked_file": "Hacl.Impl.Poly1305.Fields.fst.checked",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_32.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_256.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_128.fst.checked",
"Hacl.Impl.Poly1305.Field32xN.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.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Poly1305.Fields.fst"
} | [] | [
"Hacl.Impl.Poly1305.Fields.field_spec",
"Hacl.Impl.Poly1305.Fields.felem",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.Poly1305.Field32xN.load_felem_le",
"Prims.unit"
] | [] | module Hacl.Impl.Poly1305.Fields
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Poly1305.Field32xN_32
open Hacl.Impl.Poly1305.Field32xN_128
open Hacl.Impl.Poly1305.Field32xN_256
open Hacl.Impl.Poly1305.Field32xN
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.Poly1305
module Vec = Hacl.Spec.Poly1305.Vec
module F32xN = Hacl.Impl.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --max_fuel 0 --max_fuel 0"
noextract
type field_spec =
| M32
| M128
| M256
unfold noextract
let width (s:field_spec) : Vec.lanes =
match s with
| M32 -> 1
| M128 -> 2
| M256 -> 4
unfold noextract
let limb (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M32 -> F32xN.zero 1
| M128 -> F32xN.zero 2
| M256 -> F32xN.zero 4
unfold noextract
let wide (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M32 -> 5ul
| M128 -> 5ul
| M256 -> 5ul
unfold noextract
let blocklen (s:field_spec) : r:size_t{0 < v r /\ v r == width s * S.size_block} =
match s with
| M32 -> 16ul
| M128 -> 32ul
| M256 -> 64ul
unfold noextract
let nelem (s:field_spec) : size_t =
match s with
| M32 -> 1ul
| M128 -> 2ul
| M256 -> 4ul
unfold noextract
let precomplen (s:field_spec) : size_t =
match s with
| M32 -> 20ul
| M128 -> 20ul
| M256 -> 20ul
inline_for_extraction noextract
type felem (s:field_spec) = lbuffer (limb s) (nlimb s)
type felem_wide (s:field_spec) = lbuffer (wide s) (nlimb s)
inline_for_extraction noextract
type precomp_r (s:field_spec) = lbuffer (limb s) (precomplen s)
noextract
val felem_fits: #s:field_spec -> h:mem -> f:felem s -> m:F32xN.scale32_5 -> Type0
let felem_fits #s h f m =
match s with
| M32 -> F32xN.felem_fits #1 h f m
| M128 -> F32xN.felem_fits #2 h f m
| M256 -> F32xN.felem_fits #4 h f m
noextract
val fas_nat: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq nat (width s))
let fas_nat #s h e =
match s with
| M32 -> F32xN.fas_nat #1 h e
| M128 -> F32xN.fas_nat #2 h e
| M256 -> F32xN.fas_nat #4 h e
noextract
val feval: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq S.felem (width s))
let feval #s h e =
match s with
| M32 -> F32xN.feval #1 h e
| M128 -> F32xN.feval #2 h e
| M256 -> F32xN.feval #4 h e
unfold noextract
let op_String_Access #a #len = LSeq.index #a #len
val lemma_feval_is_fas_nat: #s:field_spec -> h:mem -> f:felem s ->
Lemma
(requires F32xN.felem_less #(width s) h f (pow2 128))
(ensures (forall (i:nat). i < width s ==> (feval h f).[i] == (fas_nat h f).[i]))
let lemma_feval_is_fas_nat #s h f =
F32xN.lemma_feval_is_fas_nat #(width s) h f
inline_for_extraction noextract
val create_felem: s:field_spec ->
StackInline (felem s)
(requires fun h -> True)
(ensures fun h0 f h1 ->
stack_allocated f h0 h1 (LSeq.create 5 (limb_zero s)) /\
feval h1 f == LSeq.create (width s) 0)
let create_felem s =
match s with
| M32 -> (F32xN.create_felem 1) <: felem s
| M128 -> (F32xN.create_felem 2) <: felem s
| M256 -> (F32xN.create_felem 4) <: felem s
inline_for_extraction noextract
val load_felem_le:
#s:field_spec
-> f:felem s
-> b:lbuffer uint8 16ul ->
Stack unit
(requires fun h -> live h f /\ live h b)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h1 f (pow2 128) /\
feval h1 f == LSeq.create (width s) (BSeq.nat_from_bytes_le (as_seq h0 b))) | false | false | Hacl.Impl.Poly1305.Fields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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 load_felem_le:
#s:field_spec
-> f:felem s
-> b:lbuffer uint8 16ul ->
Stack unit
(requires fun h -> live h f /\ live h b)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h1 f (pow2 128) /\
feval h1 f == LSeq.create (width s) (BSeq.nat_from_bytes_le (as_seq h0 b))) | [] | Hacl.Impl.Poly1305.Fields.load_felem_le | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Fields.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Hacl.Impl.Poly1305.Fields.felem s -> b: Lib.Buffer.lbuffer Lib.IntTypes.uint8 16ul
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 38,
"end_line": 161,
"start_col": 2,
"start_line": 158
} |
FStar.HyperStack.ST.StackInline | val create_felem: s:field_spec ->
StackInline (felem s)
(requires fun h -> True)
(ensures fun h0 f h1 ->
stack_allocated f h0 h1 (LSeq.create 5 (limb_zero s)) /\
feval h1 f == LSeq.create (width s) 0) | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": "F32xN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_32",
"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.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.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 create_felem s =
match s with
| M32 -> (F32xN.create_felem 1) <: felem s
| M128 -> (F32xN.create_felem 2) <: felem s
| M256 -> (F32xN.create_felem 4) <: felem s | val create_felem: s:field_spec ->
StackInline (felem s)
(requires fun h -> True)
(ensures fun h0 f h1 ->
stack_allocated f h0 h1 (LSeq.create 5 (limb_zero s)) /\
feval h1 f == LSeq.create (width s) 0)
let create_felem s = | true | null | false | match s with
| M32 -> (F32xN.create_felem 1) <: felem s
| M128 -> (F32xN.create_felem 2) <: felem s
| M256 -> (F32xN.create_felem 4) <: felem s | {
"checked_file": "Hacl.Impl.Poly1305.Fields.fst.checked",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_32.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_256.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_128.fst.checked",
"Hacl.Impl.Poly1305.Field32xN.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.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Poly1305.Fields.fst"
} | [] | [
"Hacl.Impl.Poly1305.Fields.field_spec",
"Hacl.Impl.Poly1305.Field32xN.create_felem",
"Hacl.Impl.Poly1305.Field32xN.felem",
"Hacl.Impl.Poly1305.Fields.felem"
] | [] | module Hacl.Impl.Poly1305.Fields
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Poly1305.Field32xN_32
open Hacl.Impl.Poly1305.Field32xN_128
open Hacl.Impl.Poly1305.Field32xN_256
open Hacl.Impl.Poly1305.Field32xN
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.Poly1305
module Vec = Hacl.Spec.Poly1305.Vec
module F32xN = Hacl.Impl.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --max_fuel 0 --max_fuel 0"
noextract
type field_spec =
| M32
| M128
| M256
unfold noextract
let width (s:field_spec) : Vec.lanes =
match s with
| M32 -> 1
| M128 -> 2
| M256 -> 4
unfold noextract
let limb (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M32 -> F32xN.zero 1
| M128 -> F32xN.zero 2
| M256 -> F32xN.zero 4
unfold noextract
let wide (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M32 -> 5ul
| M128 -> 5ul
| M256 -> 5ul
unfold noextract
let blocklen (s:field_spec) : r:size_t{0 < v r /\ v r == width s * S.size_block} =
match s with
| M32 -> 16ul
| M128 -> 32ul
| M256 -> 64ul
unfold noextract
let nelem (s:field_spec) : size_t =
match s with
| M32 -> 1ul
| M128 -> 2ul
| M256 -> 4ul
unfold noextract
let precomplen (s:field_spec) : size_t =
match s with
| M32 -> 20ul
| M128 -> 20ul
| M256 -> 20ul
inline_for_extraction noextract
type felem (s:field_spec) = lbuffer (limb s) (nlimb s)
type felem_wide (s:field_spec) = lbuffer (wide s) (nlimb s)
inline_for_extraction noextract
type precomp_r (s:field_spec) = lbuffer (limb s) (precomplen s)
noextract
val felem_fits: #s:field_spec -> h:mem -> f:felem s -> m:F32xN.scale32_5 -> Type0
let felem_fits #s h f m =
match s with
| M32 -> F32xN.felem_fits #1 h f m
| M128 -> F32xN.felem_fits #2 h f m
| M256 -> F32xN.felem_fits #4 h f m
noextract
val fas_nat: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq nat (width s))
let fas_nat #s h e =
match s with
| M32 -> F32xN.fas_nat #1 h e
| M128 -> F32xN.fas_nat #2 h e
| M256 -> F32xN.fas_nat #4 h e
noextract
val feval: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq S.felem (width s))
let feval #s h e =
match s with
| M32 -> F32xN.feval #1 h e
| M128 -> F32xN.feval #2 h e
| M256 -> F32xN.feval #4 h e
unfold noextract
let op_String_Access #a #len = LSeq.index #a #len
val lemma_feval_is_fas_nat: #s:field_spec -> h:mem -> f:felem s ->
Lemma
(requires F32xN.felem_less #(width s) h f (pow2 128))
(ensures (forall (i:nat). i < width s ==> (feval h f).[i] == (fas_nat h f).[i]))
let lemma_feval_is_fas_nat #s h f =
F32xN.lemma_feval_is_fas_nat #(width s) h f
inline_for_extraction noextract
val create_felem: s:field_spec ->
StackInline (felem s)
(requires fun h -> True)
(ensures fun h0 f h1 ->
stack_allocated f h0 h1 (LSeq.create 5 (limb_zero s)) /\
feval h1 f == LSeq.create (width s) 0) | false | false | Hacl.Impl.Poly1305.Fields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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 create_felem: s:field_spec ->
StackInline (felem s)
(requires fun h -> True)
(ensures fun h0 f h1 ->
stack_allocated f h0 h1 (LSeq.create 5 (limb_zero s)) /\
feval h1 f == LSeq.create (width s) 0) | [] | Hacl.Impl.Poly1305.Fields.create_felem | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Fields.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Impl.Poly1305.Fields.field_spec
-> FStar.HyperStack.ST.StackInline (Hacl.Impl.Poly1305.Fields.felem s) | {
"end_col": 45,
"end_line": 141,
"start_col": 2,
"start_line": 138
} |
FStar.HyperStack.ST.Stack | val set_bit:
#s:field_spec
-> f:felem s
-> i:size_t{size_v i <= 128} ->
Stack unit
(requires fun h ->
live h f /\
felem_fits h f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h f (pow2 (v i)))
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
(Math.Lemmas.pow2_le_compat 128 (v i);
feval h1 f == LSeq.map (Vec.pfadd (pow2 (v i))) (feval h0 f))) | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": "F32xN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_32",
"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.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.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 set_bit #s f i =
match s with
| M32 -> F32xN.set_bit #1 f i
| M128 -> F32xN.set_bit #2 f i
| M256 -> F32xN.set_bit #4 f i | val set_bit:
#s:field_spec
-> f:felem s
-> i:size_t{size_v i <= 128} ->
Stack unit
(requires fun h ->
live h f /\
felem_fits h f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h f (pow2 (v i)))
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
(Math.Lemmas.pow2_le_compat 128 (v i);
feval h1 f == LSeq.map (Vec.pfadd (pow2 (v i))) (feval h0 f)))
let set_bit #s f i = | true | null | false | match s with
| M32 -> F32xN.set_bit #1 f i
| M128 -> F32xN.set_bit #2 f i
| M256 -> F32xN.set_bit #4 f i | {
"checked_file": "Hacl.Impl.Poly1305.Fields.fst.checked",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_32.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_256.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_128.fst.checked",
"Hacl.Impl.Poly1305.Field32xN.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.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Poly1305.Fields.fst"
} | [] | [
"Hacl.Impl.Poly1305.Fields.field_spec",
"Hacl.Impl.Poly1305.Fields.felem",
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.size_v",
"Hacl.Impl.Poly1305.Field32xN.set_bit",
"Prims.unit"
] | [] | module Hacl.Impl.Poly1305.Fields
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Poly1305.Field32xN_32
open Hacl.Impl.Poly1305.Field32xN_128
open Hacl.Impl.Poly1305.Field32xN_256
open Hacl.Impl.Poly1305.Field32xN
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.Poly1305
module Vec = Hacl.Spec.Poly1305.Vec
module F32xN = Hacl.Impl.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --max_fuel 0 --max_fuel 0"
noextract
type field_spec =
| M32
| M128
| M256
unfold noextract
let width (s:field_spec) : Vec.lanes =
match s with
| M32 -> 1
| M128 -> 2
| M256 -> 4
unfold noextract
let limb (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M32 -> F32xN.zero 1
| M128 -> F32xN.zero 2
| M256 -> F32xN.zero 4
unfold noextract
let wide (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M32 -> 5ul
| M128 -> 5ul
| M256 -> 5ul
unfold noextract
let blocklen (s:field_spec) : r:size_t{0 < v r /\ v r == width s * S.size_block} =
match s with
| M32 -> 16ul
| M128 -> 32ul
| M256 -> 64ul
unfold noextract
let nelem (s:field_spec) : size_t =
match s with
| M32 -> 1ul
| M128 -> 2ul
| M256 -> 4ul
unfold noextract
let precomplen (s:field_spec) : size_t =
match s with
| M32 -> 20ul
| M128 -> 20ul
| M256 -> 20ul
inline_for_extraction noextract
type felem (s:field_spec) = lbuffer (limb s) (nlimb s)
type felem_wide (s:field_spec) = lbuffer (wide s) (nlimb s)
inline_for_extraction noextract
type precomp_r (s:field_spec) = lbuffer (limb s) (precomplen s)
noextract
val felem_fits: #s:field_spec -> h:mem -> f:felem s -> m:F32xN.scale32_5 -> Type0
let felem_fits #s h f m =
match s with
| M32 -> F32xN.felem_fits #1 h f m
| M128 -> F32xN.felem_fits #2 h f m
| M256 -> F32xN.felem_fits #4 h f m
noextract
val fas_nat: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq nat (width s))
let fas_nat #s h e =
match s with
| M32 -> F32xN.fas_nat #1 h e
| M128 -> F32xN.fas_nat #2 h e
| M256 -> F32xN.fas_nat #4 h e
noextract
val feval: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq S.felem (width s))
let feval #s h e =
match s with
| M32 -> F32xN.feval #1 h e
| M128 -> F32xN.feval #2 h e
| M256 -> F32xN.feval #4 h e
unfold noextract
let op_String_Access #a #len = LSeq.index #a #len
val lemma_feval_is_fas_nat: #s:field_spec -> h:mem -> f:felem s ->
Lemma
(requires F32xN.felem_less #(width s) h f (pow2 128))
(ensures (forall (i:nat). i < width s ==> (feval h f).[i] == (fas_nat h f).[i]))
let lemma_feval_is_fas_nat #s h f =
F32xN.lemma_feval_is_fas_nat #(width s) h f
inline_for_extraction noextract
val create_felem: s:field_spec ->
StackInline (felem s)
(requires fun h -> True)
(ensures fun h0 f h1 ->
stack_allocated f h0 h1 (LSeq.create 5 (limb_zero s)) /\
feval h1 f == LSeq.create (width s) 0)
let create_felem s =
match s with
| M32 -> (F32xN.create_felem 1) <: felem s
| M128 -> (F32xN.create_felem 2) <: felem s
| M256 -> (F32xN.create_felem 4) <: felem s
inline_for_extraction noextract
val load_felem_le:
#s:field_spec
-> f:felem s
-> b:lbuffer uint8 16ul ->
Stack unit
(requires fun h -> live h f /\ live h b)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h1 f (pow2 128) /\
feval h1 f == LSeq.create (width s) (BSeq.nat_from_bytes_le (as_seq h0 b)))
let load_felem_le #s f b =
match s with
| M32 -> F32xN.load_felem_le #1 f b
| M128 -> F32xN.load_felem_le #2 f b
| M256 -> F32xN.load_felem_le #4 f b
inline_for_extraction noextract
val load_felems_le:
#s:field_spec
-> f:felem s
-> b:lbuffer uint8 (blocklen s) ->
Stack unit
(requires fun h -> live h f /\ live h b)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h1 f (pow2 128) /\
feval h1 f == Vec.load_elem #(width s) (as_seq h0 b))
let load_felems_le #s f b =
match s with
| M32 -> F32xN.load_felems_le #1 f b
| M128 -> F32xN.load_felems_le #2 f b
| M256 -> F32xN.load_felems_le #4 f b
inline_for_extraction noextract
val load_acc:
#s:field_spec
-> acc:felem s
-> b:lbuffer uint8 (blocklen s) ->
Stack unit
(requires fun h ->
live h acc /\ live h b /\ disjoint acc b /\
felem_fits h acc (2, 2, 2, 2, 2))
(ensures fun h0 _ h1 ->
modifies (loc acc) h0 h1 /\
felem_fits h1 acc (3, 3, 3, 3, 3) /\
feval h1 acc == Vec.load_acc #(width s) (as_seq h0 b) (feval h0 acc).[0])
let load_acc #s acc b =
match s with
| M32 -> Field32xN_32.load_acc1 acc b
| M128 -> Field32xN_128.load_acc2 acc b
| M256 -> Field32xN_256.load_acc4 acc b
inline_for_extraction noextract
val set_bit:
#s:field_spec
-> f:felem s
-> i:size_t{size_v i <= 128} ->
Stack unit
(requires fun h ->
live h f /\
felem_fits h f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h f (pow2 (v i)))
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
(Math.Lemmas.pow2_le_compat 128 (v i);
feval h1 f == LSeq.map (Vec.pfadd (pow2 (v i))) (feval h0 f))) | false | false | Hacl.Impl.Poly1305.Fields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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 set_bit:
#s:field_spec
-> f:felem s
-> i:size_t{size_v i <= 128} ->
Stack unit
(requires fun h ->
live h f /\
felem_fits h f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h f (pow2 (v i)))
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
(Math.Lemmas.pow2_le_compat 128 (v i);
feval h1 f == LSeq.map (Vec.pfadd (pow2 (v i))) (feval h0 f))) | [] | Hacl.Impl.Poly1305.Fields.set_bit | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Fields.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Hacl.Impl.Poly1305.Fields.felem s -> i: Lib.IntTypes.size_t{Lib.IntTypes.size_v i <= 128}
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 32,
"end_line": 225,
"start_col": 2,
"start_line": 222
} |
FStar.HyperStack.ST.Stack | val set_bit128:
#s:field_spec
-> f:felem s ->
Stack unit
(requires fun h ->
live h f /\
felem_fits h f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h f (pow2 128))
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
feval h1 f == LSeq.map (Vec.pfadd (pow2 128)) (feval h0 f)) | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": "F32xN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_32",
"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.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.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 set_bit128 #s f =
match s with
| M32 -> F32xN.set_bit128 #1 f
| M128 -> F32xN.set_bit128 #2 f
| M256 -> F32xN.set_bit128 #4 f | val set_bit128:
#s:field_spec
-> f:felem s ->
Stack unit
(requires fun h ->
live h f /\
felem_fits h f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h f (pow2 128))
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
feval h1 f == LSeq.map (Vec.pfadd (pow2 128)) (feval h0 f))
let set_bit128 #s f = | true | null | false | match s with
| M32 -> F32xN.set_bit128 #1 f
| M128 -> F32xN.set_bit128 #2 f
| M256 -> F32xN.set_bit128 #4 f | {
"checked_file": "Hacl.Impl.Poly1305.Fields.fst.checked",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_32.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_256.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_128.fst.checked",
"Hacl.Impl.Poly1305.Field32xN.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.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Poly1305.Fields.fst"
} | [] | [
"Hacl.Impl.Poly1305.Fields.field_spec",
"Hacl.Impl.Poly1305.Fields.felem",
"Hacl.Impl.Poly1305.Field32xN.set_bit128",
"Prims.unit"
] | [] | module Hacl.Impl.Poly1305.Fields
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Poly1305.Field32xN_32
open Hacl.Impl.Poly1305.Field32xN_128
open Hacl.Impl.Poly1305.Field32xN_256
open Hacl.Impl.Poly1305.Field32xN
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.Poly1305
module Vec = Hacl.Spec.Poly1305.Vec
module F32xN = Hacl.Impl.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --max_fuel 0 --max_fuel 0"
noextract
type field_spec =
| M32
| M128
| M256
unfold noextract
let width (s:field_spec) : Vec.lanes =
match s with
| M32 -> 1
| M128 -> 2
| M256 -> 4
unfold noextract
let limb (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M32 -> F32xN.zero 1
| M128 -> F32xN.zero 2
| M256 -> F32xN.zero 4
unfold noextract
let wide (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M32 -> 5ul
| M128 -> 5ul
| M256 -> 5ul
unfold noextract
let blocklen (s:field_spec) : r:size_t{0 < v r /\ v r == width s * S.size_block} =
match s with
| M32 -> 16ul
| M128 -> 32ul
| M256 -> 64ul
unfold noextract
let nelem (s:field_spec) : size_t =
match s with
| M32 -> 1ul
| M128 -> 2ul
| M256 -> 4ul
unfold noextract
let precomplen (s:field_spec) : size_t =
match s with
| M32 -> 20ul
| M128 -> 20ul
| M256 -> 20ul
inline_for_extraction noextract
type felem (s:field_spec) = lbuffer (limb s) (nlimb s)
type felem_wide (s:field_spec) = lbuffer (wide s) (nlimb s)
inline_for_extraction noextract
type precomp_r (s:field_spec) = lbuffer (limb s) (precomplen s)
noextract
val felem_fits: #s:field_spec -> h:mem -> f:felem s -> m:F32xN.scale32_5 -> Type0
let felem_fits #s h f m =
match s with
| M32 -> F32xN.felem_fits #1 h f m
| M128 -> F32xN.felem_fits #2 h f m
| M256 -> F32xN.felem_fits #4 h f m
noextract
val fas_nat: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq nat (width s))
let fas_nat #s h e =
match s with
| M32 -> F32xN.fas_nat #1 h e
| M128 -> F32xN.fas_nat #2 h e
| M256 -> F32xN.fas_nat #4 h e
noextract
val feval: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq S.felem (width s))
let feval #s h e =
match s with
| M32 -> F32xN.feval #1 h e
| M128 -> F32xN.feval #2 h e
| M256 -> F32xN.feval #4 h e
unfold noextract
let op_String_Access #a #len = LSeq.index #a #len
val lemma_feval_is_fas_nat: #s:field_spec -> h:mem -> f:felem s ->
Lemma
(requires F32xN.felem_less #(width s) h f (pow2 128))
(ensures (forall (i:nat). i < width s ==> (feval h f).[i] == (fas_nat h f).[i]))
let lemma_feval_is_fas_nat #s h f =
F32xN.lemma_feval_is_fas_nat #(width s) h f
inline_for_extraction noextract
val create_felem: s:field_spec ->
StackInline (felem s)
(requires fun h -> True)
(ensures fun h0 f h1 ->
stack_allocated f h0 h1 (LSeq.create 5 (limb_zero s)) /\
feval h1 f == LSeq.create (width s) 0)
let create_felem s =
match s with
| M32 -> (F32xN.create_felem 1) <: felem s
| M128 -> (F32xN.create_felem 2) <: felem s
| M256 -> (F32xN.create_felem 4) <: felem s
inline_for_extraction noextract
val load_felem_le:
#s:field_spec
-> f:felem s
-> b:lbuffer uint8 16ul ->
Stack unit
(requires fun h -> live h f /\ live h b)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h1 f (pow2 128) /\
feval h1 f == LSeq.create (width s) (BSeq.nat_from_bytes_le (as_seq h0 b)))
let load_felem_le #s f b =
match s with
| M32 -> F32xN.load_felem_le #1 f b
| M128 -> F32xN.load_felem_le #2 f b
| M256 -> F32xN.load_felem_le #4 f b
inline_for_extraction noextract
val load_felems_le:
#s:field_spec
-> f:felem s
-> b:lbuffer uint8 (blocklen s) ->
Stack unit
(requires fun h -> live h f /\ live h b)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h1 f (pow2 128) /\
feval h1 f == Vec.load_elem #(width s) (as_seq h0 b))
let load_felems_le #s f b =
match s with
| M32 -> F32xN.load_felems_le #1 f b
| M128 -> F32xN.load_felems_le #2 f b
| M256 -> F32xN.load_felems_le #4 f b
inline_for_extraction noextract
val load_acc:
#s:field_spec
-> acc:felem s
-> b:lbuffer uint8 (blocklen s) ->
Stack unit
(requires fun h ->
live h acc /\ live h b /\ disjoint acc b /\
felem_fits h acc (2, 2, 2, 2, 2))
(ensures fun h0 _ h1 ->
modifies (loc acc) h0 h1 /\
felem_fits h1 acc (3, 3, 3, 3, 3) /\
feval h1 acc == Vec.load_acc #(width s) (as_seq h0 b) (feval h0 acc).[0])
let load_acc #s acc b =
match s with
| M32 -> Field32xN_32.load_acc1 acc b
| M128 -> Field32xN_128.load_acc2 acc b
| M256 -> Field32xN_256.load_acc4 acc b
inline_for_extraction noextract
val set_bit:
#s:field_spec
-> f:felem s
-> i:size_t{size_v i <= 128} ->
Stack unit
(requires fun h ->
live h f /\
felem_fits h f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h f (pow2 (v i)))
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
(Math.Lemmas.pow2_le_compat 128 (v i);
feval h1 f == LSeq.map (Vec.pfadd (pow2 (v i))) (feval h0 f)))
let set_bit #s f i =
match s with
| M32 -> F32xN.set_bit #1 f i
| M128 -> F32xN.set_bit #2 f i
| M256 -> F32xN.set_bit #4 f i
inline_for_extraction noextract
val set_bit128:
#s:field_spec
-> f:felem s ->
Stack unit
(requires fun h ->
live h f /\
felem_fits h f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h f (pow2 128))
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
feval h1 f == LSeq.map (Vec.pfadd (pow2 128)) (feval h0 f)) | false | false | Hacl.Impl.Poly1305.Fields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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 set_bit128:
#s:field_spec
-> f:felem s ->
Stack unit
(requires fun h ->
live h f /\
felem_fits h f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h f (pow2 128))
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
feval h1 f == LSeq.map (Vec.pfadd (pow2 128)) (feval h0 f)) | [] | Hacl.Impl.Poly1305.Fields.set_bit128 | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Fields.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Hacl.Impl.Poly1305.Fields.felem s -> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 33,
"end_line": 246,
"start_col": 2,
"start_line": 243
} |
FStar.HyperStack.ST.Stack | val fadd:
#s:field_spec
-> out:felem s
-> f1:felem s
-> f2:felem s ->
Stack unit
(requires fun h ->
live h out /\ live h f1 /\ live h f2 /\
felem_fits h f1 (2, 2, 2, 2, 2) /\
felem_fits h f2 (1, 1, 1, 1, 1))
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\
felem_fits h1 out (3, 3, 3, 3, 3) /\
feval h1 out == Vec.fadd (feval h0 f1) (feval h0 f2)) | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": "F32xN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_32",
"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.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.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 fadd #s out f1 f2 =
match s with
| M32 -> F32xN.fadd #1 out f1 f2
| M128 -> F32xN.fadd #2 out f1 f2
| M256 -> F32xN.fadd #4 out f1 f2 | val fadd:
#s:field_spec
-> out:felem s
-> f1:felem s
-> f2:felem s ->
Stack unit
(requires fun h ->
live h out /\ live h f1 /\ live h f2 /\
felem_fits h f1 (2, 2, 2, 2, 2) /\
felem_fits h f2 (1, 1, 1, 1, 1))
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\
felem_fits h1 out (3, 3, 3, 3, 3) /\
feval h1 out == Vec.fadd (feval h0 f1) (feval h0 f2))
let fadd #s out f1 f2 = | true | null | false | match s with
| M32 -> F32xN.fadd #1 out f1 f2
| M128 -> F32xN.fadd #2 out f1 f2
| M256 -> F32xN.fadd #4 out f1 f2 | {
"checked_file": "Hacl.Impl.Poly1305.Fields.fst.checked",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_32.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_256.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_128.fst.checked",
"Hacl.Impl.Poly1305.Field32xN.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.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Poly1305.Fields.fst"
} | [] | [
"Hacl.Impl.Poly1305.Fields.field_spec",
"Hacl.Impl.Poly1305.Fields.felem",
"Hacl.Impl.Poly1305.Field32xN.fadd",
"Prims.unit"
] | [] | module Hacl.Impl.Poly1305.Fields
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Poly1305.Field32xN_32
open Hacl.Impl.Poly1305.Field32xN_128
open Hacl.Impl.Poly1305.Field32xN_256
open Hacl.Impl.Poly1305.Field32xN
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.Poly1305
module Vec = Hacl.Spec.Poly1305.Vec
module F32xN = Hacl.Impl.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --max_fuel 0 --max_fuel 0"
noextract
type field_spec =
| M32
| M128
| M256
unfold noextract
let width (s:field_spec) : Vec.lanes =
match s with
| M32 -> 1
| M128 -> 2
| M256 -> 4
unfold noextract
let limb (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M32 -> F32xN.zero 1
| M128 -> F32xN.zero 2
| M256 -> F32xN.zero 4
unfold noextract
let wide (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M32 -> 5ul
| M128 -> 5ul
| M256 -> 5ul
unfold noextract
let blocklen (s:field_spec) : r:size_t{0 < v r /\ v r == width s * S.size_block} =
match s with
| M32 -> 16ul
| M128 -> 32ul
| M256 -> 64ul
unfold noextract
let nelem (s:field_spec) : size_t =
match s with
| M32 -> 1ul
| M128 -> 2ul
| M256 -> 4ul
unfold noextract
let precomplen (s:field_spec) : size_t =
match s with
| M32 -> 20ul
| M128 -> 20ul
| M256 -> 20ul
inline_for_extraction noextract
type felem (s:field_spec) = lbuffer (limb s) (nlimb s)
type felem_wide (s:field_spec) = lbuffer (wide s) (nlimb s)
inline_for_extraction noextract
type precomp_r (s:field_spec) = lbuffer (limb s) (precomplen s)
noextract
val felem_fits: #s:field_spec -> h:mem -> f:felem s -> m:F32xN.scale32_5 -> Type0
let felem_fits #s h f m =
match s with
| M32 -> F32xN.felem_fits #1 h f m
| M128 -> F32xN.felem_fits #2 h f m
| M256 -> F32xN.felem_fits #4 h f m
noextract
val fas_nat: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq nat (width s))
let fas_nat #s h e =
match s with
| M32 -> F32xN.fas_nat #1 h e
| M128 -> F32xN.fas_nat #2 h e
| M256 -> F32xN.fas_nat #4 h e
noextract
val feval: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq S.felem (width s))
let feval #s h e =
match s with
| M32 -> F32xN.feval #1 h e
| M128 -> F32xN.feval #2 h e
| M256 -> F32xN.feval #4 h e
unfold noextract
let op_String_Access #a #len = LSeq.index #a #len
val lemma_feval_is_fas_nat: #s:field_spec -> h:mem -> f:felem s ->
Lemma
(requires F32xN.felem_less #(width s) h f (pow2 128))
(ensures (forall (i:nat). i < width s ==> (feval h f).[i] == (fas_nat h f).[i]))
let lemma_feval_is_fas_nat #s h f =
F32xN.lemma_feval_is_fas_nat #(width s) h f
inline_for_extraction noextract
val create_felem: s:field_spec ->
StackInline (felem s)
(requires fun h -> True)
(ensures fun h0 f h1 ->
stack_allocated f h0 h1 (LSeq.create 5 (limb_zero s)) /\
feval h1 f == LSeq.create (width s) 0)
let create_felem s =
match s with
| M32 -> (F32xN.create_felem 1) <: felem s
| M128 -> (F32xN.create_felem 2) <: felem s
| M256 -> (F32xN.create_felem 4) <: felem s
inline_for_extraction noextract
val load_felem_le:
#s:field_spec
-> f:felem s
-> b:lbuffer uint8 16ul ->
Stack unit
(requires fun h -> live h f /\ live h b)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h1 f (pow2 128) /\
feval h1 f == LSeq.create (width s) (BSeq.nat_from_bytes_le (as_seq h0 b)))
let load_felem_le #s f b =
match s with
| M32 -> F32xN.load_felem_le #1 f b
| M128 -> F32xN.load_felem_le #2 f b
| M256 -> F32xN.load_felem_le #4 f b
inline_for_extraction noextract
val load_felems_le:
#s:field_spec
-> f:felem s
-> b:lbuffer uint8 (blocklen s) ->
Stack unit
(requires fun h -> live h f /\ live h b)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h1 f (pow2 128) /\
feval h1 f == Vec.load_elem #(width s) (as_seq h0 b))
let load_felems_le #s f b =
match s with
| M32 -> F32xN.load_felems_le #1 f b
| M128 -> F32xN.load_felems_le #2 f b
| M256 -> F32xN.load_felems_le #4 f b
inline_for_extraction noextract
val load_acc:
#s:field_spec
-> acc:felem s
-> b:lbuffer uint8 (blocklen s) ->
Stack unit
(requires fun h ->
live h acc /\ live h b /\ disjoint acc b /\
felem_fits h acc (2, 2, 2, 2, 2))
(ensures fun h0 _ h1 ->
modifies (loc acc) h0 h1 /\
felem_fits h1 acc (3, 3, 3, 3, 3) /\
feval h1 acc == Vec.load_acc #(width s) (as_seq h0 b) (feval h0 acc).[0])
let load_acc #s acc b =
match s with
| M32 -> Field32xN_32.load_acc1 acc b
| M128 -> Field32xN_128.load_acc2 acc b
| M256 -> Field32xN_256.load_acc4 acc b
inline_for_extraction noextract
val set_bit:
#s:field_spec
-> f:felem s
-> i:size_t{size_v i <= 128} ->
Stack unit
(requires fun h ->
live h f /\
felem_fits h f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h f (pow2 (v i)))
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
(Math.Lemmas.pow2_le_compat 128 (v i);
feval h1 f == LSeq.map (Vec.pfadd (pow2 (v i))) (feval h0 f)))
let set_bit #s f i =
match s with
| M32 -> F32xN.set_bit #1 f i
| M128 -> F32xN.set_bit #2 f i
| M256 -> F32xN.set_bit #4 f i
inline_for_extraction noextract
val set_bit128:
#s:field_spec
-> f:felem s ->
Stack unit
(requires fun h ->
live h f /\
felem_fits h f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h f (pow2 128))
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
feval h1 f == LSeq.map (Vec.pfadd (pow2 128)) (feval h0 f))
let set_bit128 #s f =
match s with
| M32 -> F32xN.set_bit128 #1 f
| M128 -> F32xN.set_bit128 #2 f
| M256 -> F32xN.set_bit128 #4 f
inline_for_extraction noextract
val set_zero:
#s:field_spec
-> f:felem s ->
Stack unit
(requires fun h -> live h f)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (0, 0, 0, 0, 0) /\
feval h1 f == LSeq.create (width s) 0)
let set_zero #s f =
match s with
| M32 -> F32xN.set_zero #1 f
| M128 -> F32xN.set_zero #2 f
| M256 -> F32xN.set_zero #4 f
inline_for_extraction noextract
val reduce_felem:
#s:field_spec
-> f:felem s ->
Stack unit
(requires fun h -> live h f /\ felem_fits h f (2, 2, 2, 2, 2))
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
(fas_nat h1 f).[0] == (feval h0 f).[0])
let reduce_felem #s f =
match s with
| M32 -> F32xN.reduce_felem #1 f
| M128 -> F32xN.reduce_felem #2 f
| M256 -> F32xN.reduce_felem #4 f
inline_for_extraction noextract
val load_precompute_r:
#s:field_spec
-> p:precomp_r s
-> r0:uint64
-> r1:uint64 ->
Stack unit
(requires fun h -> live h p)
(ensures fun h0 _ h1 ->
modifies (loc p) h0 h1 /\
F32xN.load_precompute_r_post #(width s) h1 p /\
(assert (uint_v r1 * pow2 64 + uint_v r0 < pow2 128);
feval h1 (gsub p 0ul 5ul) ==
LSeq.create (width s) (uint_v r1 * pow2 64 + uint_v r0)))
let load_precompute_r #s p r0 r1 =
match s with
| M32 -> F32xN.load_precompute_r #1 p r0 r1
| M128 -> F32xN.load_precompute_r #2 p r0 r1
| M256 -> F32xN.load_precompute_r #4 p r0 r1
inline_for_extraction noextract
val fadd_mul_r:
#s:field_spec
-> out:felem s
-> f1:felem s
-> precomp:precomp_r s ->
Stack unit
(requires fun h ->
live h out /\ live h f1 /\ live h precomp /\
F32xN.fmul_precomp_r_pre #(width s) h precomp /\
felem_fits h out (2, 2, 2, 2, 2) /\
felem_fits h f1 (1, 1, 1, 1, 1))
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\
felem_fits h1 out (1, 2, 1, 1, 2) /\
feval h1 out ==
Vec.fmul (Vec.fadd (feval h0 out) (feval h0 f1)) (feval h0 (gsub precomp 0ul 5ul)))
let fadd_mul_r #s out f1 precomp =
match s with
| M32 -> F32xN.fadd_mul_r #1 out f1 precomp
| M128 -> F32xN.fadd_mul_r #2 out f1 precomp
| M256 -> F32xN.fadd_mul_r #4 out f1 precomp
inline_for_extraction noextract
val fmul_rn:
#s:field_spec
-> out:felem s
-> f1:felem s
-> precomp:precomp_r s ->
Stack unit
(requires fun h ->
live h out /\ live h f1 /\ live h precomp /\
(let rn = gsub precomp 10ul 5ul in
let rn_5 = gsub precomp 15ul 5ul in
felem_fits h f1 (3, 3, 3, 3, 3) /\
felem_fits h rn (2, 2, 2, 2, 2) /\
felem_fits h rn_5 (10, 10, 10, 10, 10) /\
F32xN.as_tup5 #(width s) h rn_5 == F32xN.precomp_r5 (F32xN.as_tup5 h rn)))
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\
felem_fits h1 out (1, 2, 1, 1, 2) /\
feval h1 out == Vec.fmul (feval h0 f1) (feval h0 (gsub precomp 10ul 5ul)))
let fmul_rn #s out f1 precomp =
match s with
| M32 -> F32xN.fmul_rn #1 out f1 precomp
| M128 -> F32xN.fmul_rn #2 out f1 precomp
| M256 -> F32xN.fmul_rn #4 out f1 precomp
inline_for_extraction noextract
val fmul_rn_normalize:
#s:field_spec
-> out:felem s
-> precomp:precomp_r s ->
Stack unit
(requires fun h ->
live h out /\ live h precomp /\
felem_fits h out (3, 3, 3, 3, 3) /\
F32xN.load_precompute_r_post #(width s) h precomp)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\
felem_fits h1 out (2, 2, 2, 2, 2) /\
(feval h1 out).[0] ==
Vec.normalize_n #(width s) (feval h0 (gsub precomp 0ul 5ul)).[0] (feval h0 out))
let fmul_rn_normalize #s out precomp =
match s with
| M32 -> Field32xN_32.fmul_r1_normalize out precomp
| M128 -> Field32xN_128.fmul_r2_normalize out precomp
| M256 -> Field32xN_256.fmul_r4_normalize out precomp
inline_for_extraction noextract
val fadd:
#s:field_spec
-> out:felem s
-> f1:felem s
-> f2:felem s ->
Stack unit
(requires fun h ->
live h out /\ live h f1 /\ live h f2 /\
felem_fits h f1 (2, 2, 2, 2, 2) /\
felem_fits h f2 (1, 1, 1, 1, 1))
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\
felem_fits h1 out (3, 3, 3, 3, 3) /\
feval h1 out == Vec.fadd (feval h0 f1) (feval h0 f2)) | false | false | Hacl.Impl.Poly1305.Fields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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 fadd:
#s:field_spec
-> out:felem s
-> f1:felem s
-> f2:felem s ->
Stack unit
(requires fun h ->
live h out /\ live h f1 /\ live h f2 /\
felem_fits h f1 (2, 2, 2, 2, 2) /\
felem_fits h f2 (1, 1, 1, 1, 1))
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\
felem_fits h1 out (3, 3, 3, 3, 3) /\
feval h1 out == Vec.fadd (feval h0 f1) (feval h0 f2)) | [] | Hacl.Impl.Poly1305.Fields.fadd | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Fields.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
out: Hacl.Impl.Poly1305.Fields.felem s ->
f1: Hacl.Impl.Poly1305.Fields.felem s ->
f2: Hacl.Impl.Poly1305.Fields.felem s
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 35,
"end_line": 401,
"start_col": 2,
"start_line": 398
} |
FStar.HyperStack.ST.Stack | val load_acc:
#s:field_spec
-> acc:felem s
-> b:lbuffer uint8 (blocklen s) ->
Stack unit
(requires fun h ->
live h acc /\ live h b /\ disjoint acc b /\
felem_fits h acc (2, 2, 2, 2, 2))
(ensures fun h0 _ h1 ->
modifies (loc acc) h0 h1 /\
felem_fits h1 acc (3, 3, 3, 3, 3) /\
feval h1 acc == Vec.load_acc #(width s) (as_seq h0 b) (feval h0 acc).[0]) | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": "F32xN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_32",
"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.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.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 load_acc #s acc b =
match s with
| M32 -> Field32xN_32.load_acc1 acc b
| M128 -> Field32xN_128.load_acc2 acc b
| M256 -> Field32xN_256.load_acc4 acc b | val load_acc:
#s:field_spec
-> acc:felem s
-> b:lbuffer uint8 (blocklen s) ->
Stack unit
(requires fun h ->
live h acc /\ live h b /\ disjoint acc b /\
felem_fits h acc (2, 2, 2, 2, 2))
(ensures fun h0 _ h1 ->
modifies (loc acc) h0 h1 /\
felem_fits h1 acc (3, 3, 3, 3, 3) /\
feval h1 acc == Vec.load_acc #(width s) (as_seq h0 b) (feval h0 acc).[0])
let load_acc #s acc b = | true | null | false | match s with
| M32 -> Field32xN_32.load_acc1 acc b
| M128 -> Field32xN_128.load_acc2 acc b
| M256 -> Field32xN_256.load_acc4 acc b | {
"checked_file": "Hacl.Impl.Poly1305.Fields.fst.checked",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_32.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_256.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_128.fst.checked",
"Hacl.Impl.Poly1305.Field32xN.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.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Poly1305.Fields.fst"
} | [] | [
"Hacl.Impl.Poly1305.Fields.field_spec",
"Hacl.Impl.Poly1305.Fields.felem",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"Hacl.Impl.Poly1305.Fields.blocklen",
"Hacl.Impl.Poly1305.Field32xN_32.load_acc1",
"Prims.unit",
"Hacl.Impl.Poly1305.Field32xN_128.load_acc2",
"Hacl.Impl.Poly1305.Field32xN_256.load_acc4"
] | [] | module Hacl.Impl.Poly1305.Fields
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Poly1305.Field32xN_32
open Hacl.Impl.Poly1305.Field32xN_128
open Hacl.Impl.Poly1305.Field32xN_256
open Hacl.Impl.Poly1305.Field32xN
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.Poly1305
module Vec = Hacl.Spec.Poly1305.Vec
module F32xN = Hacl.Impl.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --max_fuel 0 --max_fuel 0"
noextract
type field_spec =
| M32
| M128
| M256
unfold noextract
let width (s:field_spec) : Vec.lanes =
match s with
| M32 -> 1
| M128 -> 2
| M256 -> 4
unfold noextract
let limb (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M32 -> F32xN.zero 1
| M128 -> F32xN.zero 2
| M256 -> F32xN.zero 4
unfold noextract
let wide (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M32 -> 5ul
| M128 -> 5ul
| M256 -> 5ul
unfold noextract
let blocklen (s:field_spec) : r:size_t{0 < v r /\ v r == width s * S.size_block} =
match s with
| M32 -> 16ul
| M128 -> 32ul
| M256 -> 64ul
unfold noextract
let nelem (s:field_spec) : size_t =
match s with
| M32 -> 1ul
| M128 -> 2ul
| M256 -> 4ul
unfold noextract
let precomplen (s:field_spec) : size_t =
match s with
| M32 -> 20ul
| M128 -> 20ul
| M256 -> 20ul
inline_for_extraction noextract
type felem (s:field_spec) = lbuffer (limb s) (nlimb s)
type felem_wide (s:field_spec) = lbuffer (wide s) (nlimb s)
inline_for_extraction noextract
type precomp_r (s:field_spec) = lbuffer (limb s) (precomplen s)
noextract
val felem_fits: #s:field_spec -> h:mem -> f:felem s -> m:F32xN.scale32_5 -> Type0
let felem_fits #s h f m =
match s with
| M32 -> F32xN.felem_fits #1 h f m
| M128 -> F32xN.felem_fits #2 h f m
| M256 -> F32xN.felem_fits #4 h f m
noextract
val fas_nat: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq nat (width s))
let fas_nat #s h e =
match s with
| M32 -> F32xN.fas_nat #1 h e
| M128 -> F32xN.fas_nat #2 h e
| M256 -> F32xN.fas_nat #4 h e
noextract
val feval: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq S.felem (width s))
let feval #s h e =
match s with
| M32 -> F32xN.feval #1 h e
| M128 -> F32xN.feval #2 h e
| M256 -> F32xN.feval #4 h e
unfold noextract
let op_String_Access #a #len = LSeq.index #a #len
val lemma_feval_is_fas_nat: #s:field_spec -> h:mem -> f:felem s ->
Lemma
(requires F32xN.felem_less #(width s) h f (pow2 128))
(ensures (forall (i:nat). i < width s ==> (feval h f).[i] == (fas_nat h f).[i]))
let lemma_feval_is_fas_nat #s h f =
F32xN.lemma_feval_is_fas_nat #(width s) h f
inline_for_extraction noextract
val create_felem: s:field_spec ->
StackInline (felem s)
(requires fun h -> True)
(ensures fun h0 f h1 ->
stack_allocated f h0 h1 (LSeq.create 5 (limb_zero s)) /\
feval h1 f == LSeq.create (width s) 0)
let create_felem s =
match s with
| M32 -> (F32xN.create_felem 1) <: felem s
| M128 -> (F32xN.create_felem 2) <: felem s
| M256 -> (F32xN.create_felem 4) <: felem s
inline_for_extraction noextract
val load_felem_le:
#s:field_spec
-> f:felem s
-> b:lbuffer uint8 16ul ->
Stack unit
(requires fun h -> live h f /\ live h b)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h1 f (pow2 128) /\
feval h1 f == LSeq.create (width s) (BSeq.nat_from_bytes_le (as_seq h0 b)))
let load_felem_le #s f b =
match s with
| M32 -> F32xN.load_felem_le #1 f b
| M128 -> F32xN.load_felem_le #2 f b
| M256 -> F32xN.load_felem_le #4 f b
inline_for_extraction noextract
val load_felems_le:
#s:field_spec
-> f:felem s
-> b:lbuffer uint8 (blocklen s) ->
Stack unit
(requires fun h -> live h f /\ live h b)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h1 f (pow2 128) /\
feval h1 f == Vec.load_elem #(width s) (as_seq h0 b))
let load_felems_le #s f b =
match s with
| M32 -> F32xN.load_felems_le #1 f b
| M128 -> F32xN.load_felems_le #2 f b
| M256 -> F32xN.load_felems_le #4 f b
inline_for_extraction noextract
val load_acc:
#s:field_spec
-> acc:felem s
-> b:lbuffer uint8 (blocklen s) ->
Stack unit
(requires fun h ->
live h acc /\ live h b /\ disjoint acc b /\
felem_fits h acc (2, 2, 2, 2, 2))
(ensures fun h0 _ h1 ->
modifies (loc acc) h0 h1 /\
felem_fits h1 acc (3, 3, 3, 3, 3) /\
feval h1 acc == Vec.load_acc #(width s) (as_seq h0 b) (feval h0 acc).[0]) | false | false | Hacl.Impl.Poly1305.Fields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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 load_acc:
#s:field_spec
-> acc:felem s
-> b:lbuffer uint8 (blocklen s) ->
Stack unit
(requires fun h ->
live h acc /\ live h b /\ disjoint acc b /\
felem_fits h acc (2, 2, 2, 2, 2))
(ensures fun h0 _ h1 ->
modifies (loc acc) h0 h1 /\
felem_fits h1 acc (3, 3, 3, 3, 3) /\
feval h1 acc == Vec.load_acc #(width s) (as_seq h0 b) (feval h0 acc).[0]) | [] | Hacl.Impl.Poly1305.Fields.load_acc | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Fields.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
acc: Hacl.Impl.Poly1305.Fields.felem s ->
b: Lib.Buffer.lbuffer Lib.IntTypes.uint8 (Hacl.Impl.Poly1305.Fields.blocklen s)
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 41,
"end_line": 202,
"start_col": 2,
"start_line": 199
} |
FStar.HyperStack.ST.Stack | val load_felems_le:
#s:field_spec
-> f:felem s
-> b:lbuffer uint8 (blocklen s) ->
Stack unit
(requires fun h -> live h f /\ live h b)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h1 f (pow2 128) /\
feval h1 f == Vec.load_elem #(width s) (as_seq h0 b)) | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": "F32xN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_32",
"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.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.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 load_felems_le #s f b =
match s with
| M32 -> F32xN.load_felems_le #1 f b
| M128 -> F32xN.load_felems_le #2 f b
| M256 -> F32xN.load_felems_le #4 f b | val load_felems_le:
#s:field_spec
-> f:felem s
-> b:lbuffer uint8 (blocklen s) ->
Stack unit
(requires fun h -> live h f /\ live h b)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h1 f (pow2 128) /\
feval h1 f == Vec.load_elem #(width s) (as_seq h0 b))
let load_felems_le #s f b = | true | null | false | match s with
| M32 -> F32xN.load_felems_le #1 f b
| M128 -> F32xN.load_felems_le #2 f b
| M256 -> F32xN.load_felems_le #4 f b | {
"checked_file": "Hacl.Impl.Poly1305.Fields.fst.checked",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_32.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_256.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_128.fst.checked",
"Hacl.Impl.Poly1305.Field32xN.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.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Poly1305.Fields.fst"
} | [] | [
"Hacl.Impl.Poly1305.Fields.field_spec",
"Hacl.Impl.Poly1305.Fields.felem",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"Hacl.Impl.Poly1305.Fields.blocklen",
"Hacl.Impl.Poly1305.Field32xN.load_felems_le",
"Prims.unit"
] | [] | module Hacl.Impl.Poly1305.Fields
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Poly1305.Field32xN_32
open Hacl.Impl.Poly1305.Field32xN_128
open Hacl.Impl.Poly1305.Field32xN_256
open Hacl.Impl.Poly1305.Field32xN
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.Poly1305
module Vec = Hacl.Spec.Poly1305.Vec
module F32xN = Hacl.Impl.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --max_fuel 0 --max_fuel 0"
noextract
type field_spec =
| M32
| M128
| M256
unfold noextract
let width (s:field_spec) : Vec.lanes =
match s with
| M32 -> 1
| M128 -> 2
| M256 -> 4
unfold noextract
let limb (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M32 -> F32xN.zero 1
| M128 -> F32xN.zero 2
| M256 -> F32xN.zero 4
unfold noextract
let wide (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M32 -> 5ul
| M128 -> 5ul
| M256 -> 5ul
unfold noextract
let blocklen (s:field_spec) : r:size_t{0 < v r /\ v r == width s * S.size_block} =
match s with
| M32 -> 16ul
| M128 -> 32ul
| M256 -> 64ul
unfold noextract
let nelem (s:field_spec) : size_t =
match s with
| M32 -> 1ul
| M128 -> 2ul
| M256 -> 4ul
unfold noextract
let precomplen (s:field_spec) : size_t =
match s with
| M32 -> 20ul
| M128 -> 20ul
| M256 -> 20ul
inline_for_extraction noextract
type felem (s:field_spec) = lbuffer (limb s) (nlimb s)
type felem_wide (s:field_spec) = lbuffer (wide s) (nlimb s)
inline_for_extraction noextract
type precomp_r (s:field_spec) = lbuffer (limb s) (precomplen s)
noextract
val felem_fits: #s:field_spec -> h:mem -> f:felem s -> m:F32xN.scale32_5 -> Type0
let felem_fits #s h f m =
match s with
| M32 -> F32xN.felem_fits #1 h f m
| M128 -> F32xN.felem_fits #2 h f m
| M256 -> F32xN.felem_fits #4 h f m
noextract
val fas_nat: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq nat (width s))
let fas_nat #s h e =
match s with
| M32 -> F32xN.fas_nat #1 h e
| M128 -> F32xN.fas_nat #2 h e
| M256 -> F32xN.fas_nat #4 h e
noextract
val feval: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq S.felem (width s))
let feval #s h e =
match s with
| M32 -> F32xN.feval #1 h e
| M128 -> F32xN.feval #2 h e
| M256 -> F32xN.feval #4 h e
unfold noextract
let op_String_Access #a #len = LSeq.index #a #len
val lemma_feval_is_fas_nat: #s:field_spec -> h:mem -> f:felem s ->
Lemma
(requires F32xN.felem_less #(width s) h f (pow2 128))
(ensures (forall (i:nat). i < width s ==> (feval h f).[i] == (fas_nat h f).[i]))
let lemma_feval_is_fas_nat #s h f =
F32xN.lemma_feval_is_fas_nat #(width s) h f
inline_for_extraction noextract
val create_felem: s:field_spec ->
StackInline (felem s)
(requires fun h -> True)
(ensures fun h0 f h1 ->
stack_allocated f h0 h1 (LSeq.create 5 (limb_zero s)) /\
feval h1 f == LSeq.create (width s) 0)
let create_felem s =
match s with
| M32 -> (F32xN.create_felem 1) <: felem s
| M128 -> (F32xN.create_felem 2) <: felem s
| M256 -> (F32xN.create_felem 4) <: felem s
inline_for_extraction noextract
val load_felem_le:
#s:field_spec
-> f:felem s
-> b:lbuffer uint8 16ul ->
Stack unit
(requires fun h -> live h f /\ live h b)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h1 f (pow2 128) /\
feval h1 f == LSeq.create (width s) (BSeq.nat_from_bytes_le (as_seq h0 b)))
let load_felem_le #s f b =
match s with
| M32 -> F32xN.load_felem_le #1 f b
| M128 -> F32xN.load_felem_le #2 f b
| M256 -> F32xN.load_felem_le #4 f b
inline_for_extraction noextract
val load_felems_le:
#s:field_spec
-> f:felem s
-> b:lbuffer uint8 (blocklen s) ->
Stack unit
(requires fun h -> live h f /\ live h b)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h1 f (pow2 128) /\
feval h1 f == Vec.load_elem #(width s) (as_seq h0 b)) | false | false | Hacl.Impl.Poly1305.Fields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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 load_felems_le:
#s:field_spec
-> f:felem s
-> b:lbuffer uint8 (blocklen s) ->
Stack unit
(requires fun h -> live h f /\ live h b)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h1 f (pow2 128) /\
feval h1 f == Vec.load_elem #(width s) (as_seq h0 b)) | [] | Hacl.Impl.Poly1305.Fields.load_felems_le | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Fields.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f: Hacl.Impl.Poly1305.Fields.felem s ->
b: Lib.Buffer.lbuffer Lib.IntTypes.uint8 (Hacl.Impl.Poly1305.Fields.blocklen s)
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 39,
"end_line": 181,
"start_col": 2,
"start_line": 178
} |
FStar.HyperStack.ST.Stack | val load_precompute_r:
#s:field_spec
-> p:precomp_r s
-> r0:uint64
-> r1:uint64 ->
Stack unit
(requires fun h -> live h p)
(ensures fun h0 _ h1 ->
modifies (loc p) h0 h1 /\
F32xN.load_precompute_r_post #(width s) h1 p /\
(assert (uint_v r1 * pow2 64 + uint_v r0 < pow2 128);
feval h1 (gsub p 0ul 5ul) ==
LSeq.create (width s) (uint_v r1 * pow2 64 + uint_v r0))) | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": "F32xN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"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.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN_32",
"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.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.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 load_precompute_r #s p r0 r1 =
match s with
| M32 -> F32xN.load_precompute_r #1 p r0 r1
| M128 -> F32xN.load_precompute_r #2 p r0 r1
| M256 -> F32xN.load_precompute_r #4 p r0 r1 | val load_precompute_r:
#s:field_spec
-> p:precomp_r s
-> r0:uint64
-> r1:uint64 ->
Stack unit
(requires fun h -> live h p)
(ensures fun h0 _ h1 ->
modifies (loc p) h0 h1 /\
F32xN.load_precompute_r_post #(width s) h1 p /\
(assert (uint_v r1 * pow2 64 + uint_v r0 < pow2 128);
feval h1 (gsub p 0ul 5ul) ==
LSeq.create (width s) (uint_v r1 * pow2 64 + uint_v r0)))
let load_precompute_r #s p r0 r1 = | true | null | false | match s with
| M32 -> F32xN.load_precompute_r #1 p r0 r1
| M128 -> F32xN.load_precompute_r #2 p r0 r1
| M256 -> F32xN.load_precompute_r #4 p r0 r1 | {
"checked_file": "Hacl.Impl.Poly1305.Fields.fst.checked",
"dependencies": [
"Spec.Poly1305.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_32.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_256.fst.checked",
"Hacl.Impl.Poly1305.Field32xN_128.fst.checked",
"Hacl.Impl.Poly1305.Field32xN.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.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Poly1305.Fields.fst"
} | [] | [
"Hacl.Impl.Poly1305.Fields.field_spec",
"Hacl.Impl.Poly1305.Fields.precomp_r",
"Lib.IntTypes.uint64",
"Hacl.Impl.Poly1305.Field32xN.load_precompute_r",
"Prims.unit"
] | [] | module Hacl.Impl.Poly1305.Fields
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Poly1305.Field32xN_32
open Hacl.Impl.Poly1305.Field32xN_128
open Hacl.Impl.Poly1305.Field32xN_256
open Hacl.Impl.Poly1305.Field32xN
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.Poly1305
module Vec = Hacl.Spec.Poly1305.Vec
module F32xN = Hacl.Impl.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --max_fuel 0 --max_fuel 0"
noextract
type field_spec =
| M32
| M128
| M256
unfold noextract
let width (s:field_spec) : Vec.lanes =
match s with
| M32 -> 1
| M128 -> 2
| M256 -> 4
unfold noextract
let limb (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M32 -> F32xN.zero 1
| M128 -> F32xN.zero 2
| M256 -> F32xN.zero 4
unfold noextract
let wide (s:field_spec) =
match s with
| M32 -> F32xN.uint64xN 1
| M128 -> F32xN.uint64xN 2
| M256 -> F32xN.uint64xN 4
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M32 -> 5ul
| M128 -> 5ul
| M256 -> 5ul
unfold noextract
let blocklen (s:field_spec) : r:size_t{0 < v r /\ v r == width s * S.size_block} =
match s with
| M32 -> 16ul
| M128 -> 32ul
| M256 -> 64ul
unfold noextract
let nelem (s:field_spec) : size_t =
match s with
| M32 -> 1ul
| M128 -> 2ul
| M256 -> 4ul
unfold noextract
let precomplen (s:field_spec) : size_t =
match s with
| M32 -> 20ul
| M128 -> 20ul
| M256 -> 20ul
inline_for_extraction noextract
type felem (s:field_spec) = lbuffer (limb s) (nlimb s)
type felem_wide (s:field_spec) = lbuffer (wide s) (nlimb s)
inline_for_extraction noextract
type precomp_r (s:field_spec) = lbuffer (limb s) (precomplen s)
noextract
val felem_fits: #s:field_spec -> h:mem -> f:felem s -> m:F32xN.scale32_5 -> Type0
let felem_fits #s h f m =
match s with
| M32 -> F32xN.felem_fits #1 h f m
| M128 -> F32xN.felem_fits #2 h f m
| M256 -> F32xN.felem_fits #4 h f m
noextract
val fas_nat: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq nat (width s))
let fas_nat #s h e =
match s with
| M32 -> F32xN.fas_nat #1 h e
| M128 -> F32xN.fas_nat #2 h e
| M256 -> F32xN.fas_nat #4 h e
noextract
val feval: #s:field_spec -> h:mem -> e:felem s -> GTot (LSeq.lseq S.felem (width s))
let feval #s h e =
match s with
| M32 -> F32xN.feval #1 h e
| M128 -> F32xN.feval #2 h e
| M256 -> F32xN.feval #4 h e
unfold noextract
let op_String_Access #a #len = LSeq.index #a #len
val lemma_feval_is_fas_nat: #s:field_spec -> h:mem -> f:felem s ->
Lemma
(requires F32xN.felem_less #(width s) h f (pow2 128))
(ensures (forall (i:nat). i < width s ==> (feval h f).[i] == (fas_nat h f).[i]))
let lemma_feval_is_fas_nat #s h f =
F32xN.lemma_feval_is_fas_nat #(width s) h f
inline_for_extraction noextract
val create_felem: s:field_spec ->
StackInline (felem s)
(requires fun h -> True)
(ensures fun h0 f h1 ->
stack_allocated f h0 h1 (LSeq.create 5 (limb_zero s)) /\
feval h1 f == LSeq.create (width s) 0)
let create_felem s =
match s with
| M32 -> (F32xN.create_felem 1) <: felem s
| M128 -> (F32xN.create_felem 2) <: felem s
| M256 -> (F32xN.create_felem 4) <: felem s
inline_for_extraction noextract
val load_felem_le:
#s:field_spec
-> f:felem s
-> b:lbuffer uint8 16ul ->
Stack unit
(requires fun h -> live h f /\ live h b)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h1 f (pow2 128) /\
feval h1 f == LSeq.create (width s) (BSeq.nat_from_bytes_le (as_seq h0 b)))
let load_felem_le #s f b =
match s with
| M32 -> F32xN.load_felem_le #1 f b
| M128 -> F32xN.load_felem_le #2 f b
| M256 -> F32xN.load_felem_le #4 f b
inline_for_extraction noextract
val load_felems_le:
#s:field_spec
-> f:felem s
-> b:lbuffer uint8 (blocklen s) ->
Stack unit
(requires fun h -> live h f /\ live h b)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h1 f (pow2 128) /\
feval h1 f == Vec.load_elem #(width s) (as_seq h0 b))
let load_felems_le #s f b =
match s with
| M32 -> F32xN.load_felems_le #1 f b
| M128 -> F32xN.load_felems_le #2 f b
| M256 -> F32xN.load_felems_le #4 f b
inline_for_extraction noextract
val load_acc:
#s:field_spec
-> acc:felem s
-> b:lbuffer uint8 (blocklen s) ->
Stack unit
(requires fun h ->
live h acc /\ live h b /\ disjoint acc b /\
felem_fits h acc (2, 2, 2, 2, 2))
(ensures fun h0 _ h1 ->
modifies (loc acc) h0 h1 /\
felem_fits h1 acc (3, 3, 3, 3, 3) /\
feval h1 acc == Vec.load_acc #(width s) (as_seq h0 b) (feval h0 acc).[0])
let load_acc #s acc b =
match s with
| M32 -> Field32xN_32.load_acc1 acc b
| M128 -> Field32xN_128.load_acc2 acc b
| M256 -> Field32xN_256.load_acc4 acc b
inline_for_extraction noextract
val set_bit:
#s:field_spec
-> f:felem s
-> i:size_t{size_v i <= 128} ->
Stack unit
(requires fun h ->
live h f /\
felem_fits h f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h f (pow2 (v i)))
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
(Math.Lemmas.pow2_le_compat 128 (v i);
feval h1 f == LSeq.map (Vec.pfadd (pow2 (v i))) (feval h0 f)))
let set_bit #s f i =
match s with
| M32 -> F32xN.set_bit #1 f i
| M128 -> F32xN.set_bit #2 f i
| M256 -> F32xN.set_bit #4 f i
inline_for_extraction noextract
val set_bit128:
#s:field_spec
-> f:felem s ->
Stack unit
(requires fun h ->
live h f /\
felem_fits h f (1, 1, 1, 1, 1) /\
F32xN.felem_less #(width s) h f (pow2 128))
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
feval h1 f == LSeq.map (Vec.pfadd (pow2 128)) (feval h0 f))
let set_bit128 #s f =
match s with
| M32 -> F32xN.set_bit128 #1 f
| M128 -> F32xN.set_bit128 #2 f
| M256 -> F32xN.set_bit128 #4 f
inline_for_extraction noextract
val set_zero:
#s:field_spec
-> f:felem s ->
Stack unit
(requires fun h -> live h f)
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (0, 0, 0, 0, 0) /\
feval h1 f == LSeq.create (width s) 0)
let set_zero #s f =
match s with
| M32 -> F32xN.set_zero #1 f
| M128 -> F32xN.set_zero #2 f
| M256 -> F32xN.set_zero #4 f
inline_for_extraction noextract
val reduce_felem:
#s:field_spec
-> f:felem s ->
Stack unit
(requires fun h -> live h f /\ felem_fits h f (2, 2, 2, 2, 2))
(ensures fun h0 _ h1 ->
modifies (loc f) h0 h1 /\
felem_fits h1 f (1, 1, 1, 1, 1) /\
(fas_nat h1 f).[0] == (feval h0 f).[0])
let reduce_felem #s f =
match s with
| M32 -> F32xN.reduce_felem #1 f
| M128 -> F32xN.reduce_felem #2 f
| M256 -> F32xN.reduce_felem #4 f
inline_for_extraction noextract
val load_precompute_r:
#s:field_spec
-> p:precomp_r s
-> r0:uint64
-> r1:uint64 ->
Stack unit
(requires fun h -> live h p)
(ensures fun h0 _ h1 ->
modifies (loc p) h0 h1 /\
F32xN.load_precompute_r_post #(width s) h1 p /\
(assert (uint_v r1 * pow2 64 + uint_v r0 < pow2 128);
feval h1 (gsub p 0ul 5ul) ==
LSeq.create (width s) (uint_v r1 * pow2 64 + uint_v r0))) | false | false | Hacl.Impl.Poly1305.Fields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"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 load_precompute_r:
#s:field_spec
-> p:precomp_r s
-> r0:uint64
-> r1:uint64 ->
Stack unit
(requires fun h -> live h p)
(ensures fun h0 _ h1 ->
modifies (loc p) h0 h1 /\
F32xN.load_precompute_r_post #(width s) h1 p /\
(assert (uint_v r1 * pow2 64 + uint_v r0 < pow2 128);
feval h1 (gsub p 0ul 5ul) ==
LSeq.create (width s) (uint_v r1 * pow2 64 + uint_v r0))) | [] | Hacl.Impl.Poly1305.Fields.load_precompute_r | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Fields.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Hacl.Impl.Poly1305.Fields.precomp_r s -> r0: Lib.IntTypes.uint64 -> r1: Lib.IntTypes.uint64
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 46,
"end_line": 304,
"start_col": 2,
"start_line": 301
} |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.