file_name
stringlengths 5
52
| name
stringlengths 4
95
| original_source_type
stringlengths 0
23k
| source_type
stringlengths 9
23k
| source_definition
stringlengths 9
57.9k
| source
dict | source_range
dict | file_context
stringlengths 0
721k
| dependencies
dict | opens_and_abbrevs
listlengths 2
94
| vconfig
dict | interleaved
bool 1
class | verbose_type
stringlengths 1
7.42k
| effect
stringclasses 118
values | effect_flags
sequencelengths 0
2
| mutual_with
sequencelengths 0
11
| ideal_premises
sequencelengths 0
236
| proof_features
sequencelengths 0
1
| is_simple_lemma
bool 2
classes | is_div
bool 2
classes | is_proof
bool 2
classes | is_simply_typed
bool 2
classes | is_type
bool 2
classes | partial_definition
stringlengths 5
3.99k
| completed_definiton
stringlengths 1
1.63M
| isa_cross_project_example
bool 1
class |
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
FStar.Tactics.PatternMatching.fst | FStar.Tactics.PatternMatching.hoist_and_apply | val hoist_and_apply (head: term) (arg_terms: list term) (hoisted_args: list argv) : Tac term | val hoist_and_apply (head: term) (arg_terms: list term) (hoisted_args: list argv) : Tac term | let rec hoist_and_apply (head:term) (arg_terms:list term) (hoisted_args:list argv)
: Tac term =
match arg_terms with
| [] -> mk_app head (List.rev hoisted_args)
| arg_term::rest ->
let n = List.Tot.length hoisted_args in
//let bv = fresh_bv_named ("x" ^ (string_of_int n)) in
let nb : binder = {
ppname = seal ("x" ^ string_of_int n);
sort = pack Tv_Unknown;
uniq = fresh ();
qual = Q_Explicit;
attrs = [] ;
}
in
pack (Tv_Let false [] nb arg_term (hoist_and_apply head rest ((pack (Tv_Var (binder_to_namedv nb)), Q_Explicit)::hoisted_args))) | {
"file_name": "ulib/FStar.Tactics.PatternMatching.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 132,
"end_line": 725,
"start_col": 0,
"start_line": 710
} | (*
Copyright 2008-2018 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.
*)
/// ==========================
/// Pattern-matching tactics
/// ==========================
///
/// :Author: Clément Pit-Claudel
/// :Contact: clement.pitclaudel@live.com
/// :Date: 2017-10-13
module FStar.Tactics.PatternMatching
open FStar.Tactics.V2
/// Contents
/// ========
///
/// 1 Contents
/// 2 Motivation
/// 3 Some utility functions
/// 4 Pattern types
/// 5 Pattern matching exceptions
/// 5.1 Types of exceptions
/// 5.2 The exception monad
/// 5.3 Liftings
/// 6 Pattern interpretation
/// 7 Pattern-matching problems
/// 7.1 Definitions
/// 7.2 Resolution
/// 8 A DSL for pattern-matching
/// 8.1 Pattern notations
/// 8.2 Problem notations
/// 8.3 Continuations
/// 9 Putting it all together
/// 10 Examples
/// 10.1 Simple examples
/// 10.2 A real-life example
/// 11 Possible extensions
/// 12 Notes
///
/// Motivation
/// ==========
///
/// Suppose you have a goal of the form ``squash (a == b)``. How do you capture
/// `a` and `b` for further inspection?
///
/// Here's a basic (but cumbersome!) implementation:
let fetch_eq_side () : Tac (term * term) =
let g = cur_goal () in
match inspect g with
| Tv_App squash (g, _) ->
(match inspect squash with
| Tv_UInst squash _
| Tv_FVar squash ->
if fv_to_string squash = flatten_name squash_qn then
(match inspect g with
| Tv_App eq_type_x (y, _) ->
(match inspect eq_type_x with
| Tv_App eq_type (x, _) ->
(match inspect eq_type with
| Tv_App eq (typ, _) ->
(match inspect eq with
| Tv_UInst eq _
| Tv_FVar eq ->
if fv_to_string eq = flatten_name eq2_qn then
(x, y)
else fail "not an equality"
| _ -> fail "not an app2 of fvar: ")
| _ -> fail "not an app3")
| _ -> fail "not an app2")
| _ -> fail "not an app under squash")
else fail "not a squash"
| _ -> fail "not an app of fvar at top level")
| _ -> fail "not an app at top level"
/// …and here's how you could use it:
(* let _ = *)
(* assert_by_tactic (1 + 1 == 2) *)
(* (fun () -> let l, r = fetch_eq_side () in *)
(* print (term_to_string l ^ " / " ^ term_to_string r)) *)
/// This file defines pattern-matching primitives that let you write the same
/// thing like this…
///
/// .. code:: fstar
///
/// let fetch_eq_side' #a () : Tac (term * term) =
/// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) ->
/// (quote left, quote right) <: Tac (term * term))
///
/// let _ =
/// assert_by_tactic (1 + 1 == 2)
/// (fun () -> let l, r = fetch_eq_side' #int () in
/// print (term_to_string l ^ " / " ^ term_to_string r))
///
/// …or, more succinctly, like this:
///
/// .. code:: fstar
///
/// let _ =
/// assert_by_tactic (1 + 1 == 2)
/// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) ->
/// let l, r = quote left, quote right in
/// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit))
/// Some utility functions
/// ======================
///
/// (Skip over this part on a quick read — these are just convenience functions)
(** Ensure that tactic `t` fails. **)
let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit =
match trytac t with
| Some _ -> fail message
| None -> ()
/// The following two tactics are needed because of issues with the ``Tac``
/// effect.
let implies_intro' () : Tac unit =
let _ = implies_intro () in ()
let repeat' #a (f: unit -> Tac a) : Tac unit =
let _ = repeat f in ()
let and_elim' (h: binding) : Tac unit =
and_elim (pack (Tv_Var h));
clear h
(** Use a hypothesis at type a to satisfy a goal at type squash a *)
let exact_hyp (a: Type0) (h: namedv) : Tac unit =
let hd = quote (FStar.Squash.return_squash #a) in
exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)])
(** Use a hypothesis h (of type a) to satisfy a goal at type a *)
let exact_hyp' (h: namedv): Tac unit =
exact (pack (Tv_Var h))
/// Pattern types
/// =============
///
/// Patterns are defined using a simple inductive type, mirroring the structure
/// of ``term_view``.
type varname = string
type qn = string
type pattern =
| PVar: name: varname -> pattern
| PQn: qn: qn -> pattern
| PType: pattern
| PApp: hd: pattern -> arg: pattern -> pattern
let desc_of_pattern = function
| PVar _ -> "a variable"
| PQn qn -> "a constant (" ^ qn ^ ")"
| PType -> "Type"
| PApp _ _ -> "a function application"
let rec string_of_pattern = function
| PVar x -> "?" ^ x
| PQn qn -> qn
| PType -> "Type"
| PApp l r -> "(" ^ string_of_pattern l ^ " "
^ string_of_pattern r ^ ")"
/// Pattern matching exceptions
/// ===========================
///
/// Pattern-matching is defined as a pure, monadic function (because of issues
/// with combining DM4F effects, but also because it helps with debugging).
/// This section defines the exception monad.
///
/// Types of exceptions
/// -------------------
noeq type match_exception =
| NameMismatch of qn * qn
| SimpleMismatch of pattern * term
| NonLinearMismatch of varname * term * term
| UnsupportedTermInPattern of term
| IncorrectTypeInAbsPatBinder of typ
let term_head t : Tac string =
match inspect t with
| Tv_Var bv -> "Tv_Var"
| Tv_BVar fv -> "Tv_BVar"
| Tv_FVar fv -> "Tv_FVar"
| Tv_UInst _ _ -> "Tv_UInst"
| Tv_App f x -> "Tv_App"
| Tv_Abs x t -> "Tv_Abs"
| Tv_Arrow x t -> "Tv_Arrow"
| Tv_Type _ -> "Tv_Type"
| Tv_Refine x t -> "Tv_Refine"
| Tv_Const cst -> "Tv_Const"
| Tv_Uvar i t -> "Tv_Uvar"
| Tv_Let r attrs b t1 t2 -> "Tv_Let"
| Tv_Match t _ branches -> "Tv_Match"
| Tv_AscribedT _ _ _ _ -> "Tv_AscribedT"
| Tv_AscribedC _ _ _ _ -> "Tv_AscribedC"
| Tv_Unknown -> "Tv_Unknown"
| Tv_Unsupp -> "Tv_Unsupp"
let string_of_match_exception = function
| NameMismatch (qn1, qn2) ->
"Match failure (name mismatch): expecting " ^
qn1 ^ ", found " ^ qn2
| SimpleMismatch (pat, tm) ->
"Match failure (sort mismatch): expecting " ^
desc_of_pattern pat ^ ", got " ^ term_to_string tm
| NonLinearMismatch (nm, t1, t2) ->
"Match failure (nonlinear mismatch): variable " ^ nm ^
" needs to match both " ^ (term_to_string t1) ^
" and " ^ (term_to_string t2)
| UnsupportedTermInPattern tm ->
"Match failure (unsupported term in pattern): " ^
term_to_string tm ^ " (" ^ term_head tm ^ ")"
| IncorrectTypeInAbsPatBinder typ ->
"Incorrect type in pattern-matching binder: " ^
term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)"
/// The exception monad
/// -------------------
noeq type match_res a =
| Success of a
| Failure of match_exception
let return #a (x: a) : match_res a =
Success x
let (let?) (#a #b: Type)
(f: match_res a)
(g: a -> Tac (match_res b))
: Tac (match_res b) =
match f with
| Success aa -> g aa
| Failure ex -> Failure ex
let raise #a (ex: match_exception) : match_res a =
Failure ex
/// Liftings
/// --------
///
/// There's a natural lifting from the exception monad into the tactic effect:
let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b =
match f aa with
| Success bb -> bb
| Failure ex -> Tactics.fail (string_of_match_exception ex)
let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b =
match f aa with
| Success bb -> bb
| Failure ex -> Tactics.fail (string_of_match_exception ex)
/// Pattern interpretation
/// ======================
///
/// This section implement pattern-matching. This is strictly a one term, one
/// pattern implementation — handling cases in which mutliple hypotheses match
/// the same pattern is done later.
type bindings = list (varname * term)
let string_of_bindings (bindings: bindings) =
String.concat "\n"
(map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm))
bindings)
(** Match a pattern against a term.
`cur_bindings` is a list of bindings collected while matching previous parts of
the pattern. Returns a result in the exception monad. **)
let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term)
: Tac (match_res bindings) =
let interp_var (v: varname) cur_bindings tm =
match List.Tot.Base.assoc v cur_bindings with
| Some tm' -> if term_eq tm tm' then return cur_bindings
else raise (NonLinearMismatch (v, tm, tm'))
| None -> return ((v, tm) :: cur_bindings) in
let interp_qn (qn: qn) cur_bindings tm =
match inspect tm with
| Tv_UInst fv _
| Tv_FVar fv ->
if fv_to_string fv = qn then return cur_bindings
else raise (NameMismatch (qn, (fv_to_string fv)))
| _ -> raise (SimpleMismatch (pat, tm)) in
let interp_type cur_bindings tm =
match inspect tm with
| Tv_Type _ -> return cur_bindings
| _ -> raise (SimpleMismatch (pat, tm)) in
let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm =
match inspect tm with
| Tv_App hd (arg, _) ->
let? with_hd = interp_pattern_aux p_hd cur_bindings hd in
let? with_arg = interp_pattern_aux p_arg with_hd arg in
return with_arg
| _ -> raise (SimpleMismatch (pat, tm)) in
match pat with
| PVar var -> interp_var var cur_bindings tm
| PQn qn -> interp_qn qn cur_bindings tm
| PType -> interp_type cur_bindings tm
| PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm
(** Match a pattern `pat` against a term.
Returns a result in the exception monad. **)
let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) =
fun (tm: term) ->
let? rev_bindings = interp_pattern_aux pat [] tm in
return (List.Tot.Base.rev rev_bindings)
(** Match a term `tm` against a pattern `pat`.
Raises an exception if the match fails. This is mostly useful for debugging:
use ``mgw`` to capture matches. **)
let match_term pat (tm : term) : Tac bindings =
match interp_pattern pat (norm_term [] tm) with
| Success bb -> bb
| Failure ex -> Tactics.fail (string_of_match_exception ex)
/// Pattern-matching problems
/// =========================
///
/// Generalizing past single-term single-pattern problems, we obtain the
/// following notions of pattern-matching problems and solutions:
let debug msg : Tac unit = () // print msg
/// Definitions
/// -----------
let absvar = binding
type hypothesis = binding
/// A matching problem is composed of holes (``mp_vars``), hypothesis patterns
/// (``mp_hyps``), and a goal pattern (``mp_goal``).
noeq type matching_problem =
{ mp_vars: list varname;
mp_hyps: list (varname * pattern);
mp_goal: option pattern }
let string_of_matching_problem mp =
let vars =
String.concat ", " mp.mp_vars in
let hyps =
String.concat "\n "
(List.Tot.Base.map (fun (nm, pat) ->
nm ^ ": " ^ (string_of_pattern pat)) mp.mp_hyps) in
let goal = match mp.mp_goal with
| None -> "_"
| Some pat -> string_of_pattern pat in
"\n{ vars: " ^ vars ^ "\n" ^
" hyps: " ^ hyps ^ "\n" ^
" goal: " ^ goal ^ " }"
/// A solution is composed of terms captured to mach the holes, and binders
/// captured to match hypothesis patterns.
noeq type matching_solution =
{ ms_vars: list (varname * term);
ms_hyps: list (varname * hypothesis) }
let string_of_matching_solution ms =
let vars =
String.concat "\n "
(map (fun (varname, tm) ->
varname ^ ": " ^ (term_to_string tm)) ms.ms_vars) in
let hyps =
String.concat "\n "
(map (fun (nm, binding) ->
nm ^ ": " ^ (binding_to_string binding)) ms.ms_hyps) in
"\n{ vars: " ^ vars ^ "\n" ^
" hyps: " ^ hyps ^ " }"
(** Find a varname in an association list; fail if it can't be found. **)
let assoc_varname_fail (#b: Type) (key: varname) (ls: list (varname * b))
: Tac b =
match List.Tot.Base.assoc key ls with
| None -> fail ("Not found: " ^ key)
| Some x -> x
let ms_locate_hyp (a: Type) (solution: matching_solution)
(name: varname) : Tac hypothesis =
assoc_varname_fail name solution.ms_hyps
let ms_locate_var (a: Type) (solution: matching_solution)
(name: varname) : Tac a =
unquote #a (assoc_varname_fail name solution.ms_vars)
let ms_locate_unit (a: Type) _solution _binder_name : Tac unit =
()
/// Resolution
/// ----------
///
/// Solving a matching problem is a two-steps process: find an initial
/// assignment for holes based on the goal pattern, then find a set of
/// hypotheses matching hypothesis patterns.
///
/// Note that the implementation takes a continuation of type
/// ``matching_solution -> Tac a``. This continuation is needed because we want
/// users to be able to provide extra criteria on matching solutions (most
/// commonly, this criterion is that a particular tactic should run
/// successfuly).
///
/// This makes it easy to implement a simple for of search through the context,
/// where one can find a hypothesis matching a particular predicate by
/// constructing a trivial matching problem and passing the predicate as the
/// continuation.
(** Scan ``hypotheses`` for a match for ``pat`` that lets ``body`` succeed.
``name`` is used to refer to the hypothesis matched in the final solution.
``part_sol`` includes bindings gathered while matching previous solutions. **)
let rec solve_mp_for_single_hyp #a
(name: varname)
(pat: pattern)
(hypotheses: list hypothesis)
(body: matching_solution -> Tac a)
(part_sol: matching_solution)
: Tac a =
match hypotheses with
| [] ->
fail #a "No matching hypothesis"
| h :: hs ->
or_else // Must be in ``Tac`` here to run `body`
(fun () ->
match interp_pattern_aux pat part_sol.ms_vars (type_of_binding h) with
| Failure ex ->
fail ("Failed to match hyp: " ^ (string_of_match_exception ex))
| Success bindings ->
let ms_hyps = (name, h) :: part_sol.ms_hyps in
body ({ part_sol with ms_vars = bindings; ms_hyps = ms_hyps }))
(fun () ->
solve_mp_for_single_hyp name pat hs body part_sol)
(** Scan ``hypotheses`` for matches for ``mp_hyps`` that lets ``body``
succeed. **)
let rec solve_mp_for_hyps #a
(mp_hyps: list (varname * pattern))
(hypotheses: list hypothesis)
(body: matching_solution -> Tac a)
(partial_solution: matching_solution)
: Tac a =
match mp_hyps with
| [] -> body partial_solution
| (name, pat) :: pats ->
solve_mp_for_single_hyp name pat hypotheses
(solve_mp_for_hyps pats hypotheses body)
partial_solution
(** Solve a matching problem.
The solution returned is constructed to ensure that the continuation ``body``
succeeds: this implements the usual backtracking-match semantics. **)
let solve_mp #a (problem: matching_problem)
(hypotheses: list hypothesis) (goal: term)
(body: matching_solution -> Tac a)
: Tac a =
let goal_ps =
match problem.mp_goal with
| None -> { ms_vars = []; ms_hyps = [] }
| Some pat ->
match interp_pattern pat goal with
| Failure ex -> fail ("Failed to match goal: " ^ (string_of_match_exception ex))
| Success bindings -> { ms_vars = bindings; ms_hyps = [] } in
solve_mp_for_hyps #a problem.mp_hyps hypotheses body goal_ps
/// A DSL for pattern-matching
/// ==========================
///
/// Using pattern-matching problems as defined above is relatively cumbersome,
/// so we now introduce a lightweight notation, in two steps: pattern notations,
/// and matching-problem notations.
///
/// Pattern notations
/// -----------------
///
/// The first part of our pattern-matching syntax is pattern notations: we
/// provide a reflective function which constructs a pattern from a term:
/// variables are holes, free variables are constants, and applications are
/// application patterns.
(* FIXME: MOVE *)
let name_of_namedv (x:namedv) : Tac string =
unseal (inspect_namedv x).ppname
(** Compile a term `tm` into a pattern. **)
let rec pattern_of_term_ex tm : Tac (match_res pattern) =
match inspect tm with
| Tv_Var bv ->
return (PVar (name_of_namedv bv))
| Tv_FVar fv
| Tv_UInst fv _ ->
let qn = fv_to_string fv in
return (PQn qn)
| Tv_Type _ ->
return PType
| Tv_App f (x, _) ->
let? fpat = pattern_of_term_ex f in
let? xpat = pattern_of_term_ex x in
return (PApp fpat xpat)
| _ -> raise (UnsupportedTermInPattern tm)
(** β-reduce a term `tm`.
This is useful to remove needles function applications introduced by F*, like
``(fun a b c -> a) 1 2 3``. **)
let beta_reduce (tm: term) : Tac term =
norm_term [] tm
(** Compile a term `tm` into a pattern. **)
let pattern_of_term tm : Tac pattern =
match pattern_of_term_ex tm with
| Success bb -> bb
| Failure ex -> Tactics.fail (string_of_match_exception ex)
/// Problem notations
/// -----------------
///
/// We then introduce a DSL for matching problems, best explained on the
/// following example::
///
/// (fun (a b c: ①) (h1 h2 h3: hyp ②) (g: pm_goal ③) → ④)
///
/// This notation is intended to express a pattern-matching problems with three
/// holes ``a``, ``b``, and ``c`` of type ①, matching hypotheses ``h1``, ``h2``,
/// and ``h3`` against pattern ② and the goal against the pattern ③. The body
/// of the notation (④) is then run with appropriate terms bound to ``a``,
/// ``b``, and ``c``, appropriate binders bound to ``h1``, ``h2``, and ``h3``,
/// and ``()`` bound to ``g``.
///
/// We call these patterns ``abspat``s (abstraction patterns), and we provide
/// facilities to parse them into matching problems, and to run their bodies
/// against a particular matching solution.
// We used to annotate variables with an explicit 'var' marker, but then that
// var annotation leaked into the types of other hypotheses due to type
// inference, requiring non-trivial normalization.
// let var (a: Type) = a
let hyp (a: Type) = binding
let pm_goal (a: Type) = unit
let hyp_qn = `%hyp
let goal_qn = `%pm_goal
noeq type abspat_binder_kind =
| ABKVar of typ
| ABKHyp
| ABKGoal
let string_of_abspat_binder_kind = function
| ABKVar _ -> "varname"
| ABKHyp -> "hyp"
| ABKGoal -> "goal"
noeq type abspat_argspec =
{ asa_name: absvar;
asa_kind: abspat_binder_kind }
// We must store this continuation, because recomputing it yields different
// names when the binders are re-opened.
type abspat_continuation =
list abspat_argspec * term
let type_of_named_binder (nb : binder) : term =
nb.sort
let classify_abspat_binder (b : binder): Tac (abspat_binder_kind * term) =
let varname = "v" in
let hyp_pat = PApp (PQn hyp_qn) (PVar varname) in
let goal_pat = PApp (PQn goal_qn) (PVar varname) in
let typ = type_of_named_binder b in
match interp_pattern hyp_pat typ with
| Success [(_, hyp_typ)] -> ABKHyp, hyp_typ
| Success _ -> fail "classifiy_abspat_binder: impossible (1)"
| Failure _ ->
match interp_pattern goal_pat typ with
| Success [(_, goal_typ)] -> ABKGoal, goal_typ
| Success _ -> fail "classifiy_abspat_binder: impossible (2)"
| Failure _ -> ABKVar typ, typ
(** Split an abstraction `tm` into a list of binders and a body. **)
let rec binders_and_body_of_abs tm : Tac (list binder * term) =
match inspect tm with
| Tv_Abs binder tm ->
let binders, body = binders_and_body_of_abs tm in
binder :: binders, body
| _ -> [], tm
let cleanup_abspat (t: term) : Tac term =
norm_term [] t
let name_of_named_binder (nb : binder) : Tac string =
unseal nb.ppname
(** Parse a notation into a matching problem and a continuation.
Pattern-matching notations are of the form ``(fun binders… -> continuation)``,
where ``binders`` are of one of the forms ``var …``, ``hyp …``, or ``goal …``.
``var`` binders are typed holes to be used in other binders; ``hyp`` binders
indicate a pattern to be matched against hypotheses; and ``goal`` binders match
the goal.
A reduction phase is run to ensure that the pattern looks reasonable; it is
needed because F* tends to infer arguments in β-expanded form.
The continuation returned can't directly be applied to a pattern-matching
solution; see ``interp_abspat_continuation`` below for that. **)
let matching_problem_of_abs (tm: term)
: Tac (matching_problem * abspat_continuation) =
let binders, body = binders_and_body_of_abs (cleanup_abspat tm) in
debug ("Got binders: " ^ (String.concat ", "
(map (fun b -> name_of_named_binder b <: Tac string) binders)));
let classified_binders : list (binder & string & abspat_binder_kind & typ) =
map (fun binder ->
let bv_name = name_of_named_binder binder in
debug ("Got binder: " ^ bv_name ^ "; type is " ^
term_to_string (type_of_named_binder binder));
let binder_kind, typ = classify_abspat_binder binder in
(binder, bv_name, binder_kind, typ))
binders in
let problem =
fold_left
(fun problem (binder, bv_name, binder_kind, typ) ->
debug ("Compiling binder " ^ name_of_named_binder binder ^
", classified as " ^ string_of_abspat_binder_kind binder_kind ^
", with type " ^ term_to_string typ);
match binder_kind with
| ABKVar _ -> { problem with mp_vars = bv_name :: problem.mp_vars }
| ABKHyp -> { problem with mp_hyps = (bv_name, (pattern_of_term typ))
:: problem.mp_hyps }
| ABKGoal -> { problem with mp_goal = Some (pattern_of_term typ) })
({ mp_vars = []; mp_hyps = []; mp_goal = None })
classified_binders in
let continuation =
let abspat_argspec_of_binder xx : Tac abspat_argspec =
match xx with | (binder, xx, binder_kind, yy) ->
{ asa_name = binder_to_binding binder; asa_kind = binder_kind } in
(map abspat_argspec_of_binder classified_binders, tm) in
let mp =
{ mp_vars = List.Tot.Base.rev #varname problem.mp_vars;
mp_hyps = List.Tot.Base.rev #(varname * pattern) problem.mp_hyps;
mp_goal = problem.mp_goal } in
debug ("Got matching problem: " ^ (string_of_matching_problem mp));
mp, continuation
/// Continuations
/// -------------
///
/// Parsing an abspat yields a matching problem and a continuation of type
/// ``abspat_continuation``, which is essentially just a list of binders and a
/// term (the body of the abstraction pattern).
(** Get the (quoted) type expected by a specific kind of abspat binder. **)
let arg_type_of_binder_kind binder_kind : Tac term =
match binder_kind with
| ABKVar typ -> typ
| ABKHyp -> `binder
| ABKGoal -> `unit
(** Retrieve the function used to locate a value for a given abspat binder. **)
let locate_fn_of_binder_kind binder_kind =
match binder_kind with
| ABKVar _ -> `ms_locate_var
| ABKHyp -> `ms_locate_hyp
| ABKGoal -> `ms_locate_unit
(** Construct a term fetching the value of an abspat argument from a quoted
matching solution ``solution_term``. **)
let abspat_arg_of_abspat_argspec solution_term (argspec: abspat_argspec)
: Tac term =
let loc_fn = locate_fn_of_binder_kind argspec.asa_kind in
let name_tm = pack (Tv_Const (C_String (unseal argspec.asa_name.ppname))) in
let locate_args = [(arg_type_of_binder_kind argspec.asa_kind, Q_Explicit);
(solution_term, Q_Explicit); (name_tm, Q_Explicit)] in
mk_app loc_fn locate_args
(** Specialize a continuation of type ``abspat_continuation``.
This constructs a fully applied version of `continuation`, but it requires a
quoted solution to be passed in. **) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.String.fsti.checked",
"FStar.Squash.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.PatternMatching.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
head: FStar.Tactics.NamedView.term ->
arg_terms: Prims.list FStar.Tactics.NamedView.term ->
hoisted_args: Prims.list FStar.Stubs.Reflection.V2.Data.argv
-> FStar.Tactics.Effect.Tac FStar.Tactics.NamedView.term | FStar.Tactics.Effect.Tac | [] | [] | [
"FStar.Tactics.NamedView.term",
"Prims.list",
"FStar.Stubs.Reflection.V2.Data.argv",
"FStar.Reflection.V2.Derived.mk_app",
"FStar.List.Tot.Base.rev",
"FStar.Tactics.NamedView.pack",
"FStar.Tactics.NamedView.named_term_view",
"FStar.Tactics.NamedView.Tv_Let",
"Prims.Nil",
"FStar.Tactics.PatternMatching.hoist_and_apply",
"Prims.Cons",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Stubs.Reflection.Types.term",
"FStar.Stubs.Reflection.V2.Data.aqualv",
"FStar.Tactics.NamedView.Tv_Var",
"FStar.Tactics.V2.SyntaxCoercions.binder_to_namedv",
"FStar.Stubs.Reflection.V2.Data.Q_Explicit",
"FStar.Tactics.NamedView.binder",
"FStar.Tactics.NamedView.Mkbinder",
"FStar.Sealed.seal",
"Prims.string",
"Prims.op_Hat",
"Prims.string_of_int",
"FStar.Tactics.NamedView.Tv_Unknown",
"Prims.nat",
"FStar.Stubs.Tactics.V2.Builtins.fresh",
"FStar.List.Tot.Base.length"
] | [
"recursion"
] | false | true | false | false | false | let rec hoist_and_apply (head: term) (arg_terms: list term) (hoisted_args: list argv) : Tac term =
| match arg_terms with
| [] -> mk_app head (List.rev hoisted_args)
| arg_term :: rest ->
let n = List.Tot.length hoisted_args in
let nb:binder =
{
ppname = seal ("x" ^ string_of_int n);
sort = pack Tv_Unknown;
uniq = fresh ();
qual = Q_Explicit;
attrs = []
}
in
pack (Tv_Let false
[]
nb
arg_term
(hoist_and_apply head
rest
((pack (Tv_Var (binder_to_namedv nb)), Q_Explicit) :: hoisted_args))) | false |
MerkleTree.Spec.fst | MerkleTree.Spec.mt_get | val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz) | val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz) | let mt_get #_ #_ mt idx = S.index mt idx | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 40,
"end_line": 51,
"start_col": 0,
"start_line": 51
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n} | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | mt: MerkleTree.Spec.merkle_tree n -> idx: Prims.nat{idx < Prims.pow2 n}
-> Prims.GTot MerkleTree.Spec.padded_hash | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.pos",
"Prims.nat",
"MerkleTree.Spec.merkle_tree",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"FStar.Seq.Base.index",
"MerkleTree.Spec.padded_hash"
] | [] | false | false | false | false | false | let mt_get #_ #_ mt idx =
| S.index mt idx | false |
FStar.Tactics.PatternMatching.fst | FStar.Tactics.PatternMatching.solve_mp_for_single_hyp | val solve_mp_for_single_hyp
(#a: _)
(name: varname)
(pat: pattern)
(hypotheses: list hypothesis)
(body: (matching_solution -> Tac a))
(part_sol: matching_solution)
: Tac a | val solve_mp_for_single_hyp
(#a: _)
(name: varname)
(pat: pattern)
(hypotheses: list hypothesis)
(body: (matching_solution -> Tac a))
(part_sol: matching_solution)
: Tac a | let rec solve_mp_for_single_hyp #a
(name: varname)
(pat: pattern)
(hypotheses: list hypothesis)
(body: matching_solution -> Tac a)
(part_sol: matching_solution)
: Tac a =
match hypotheses with
| [] ->
fail #a "No matching hypothesis"
| h :: hs ->
or_else // Must be in ``Tac`` here to run `body`
(fun () ->
match interp_pattern_aux pat part_sol.ms_vars (type_of_binding h) with
| Failure ex ->
fail ("Failed to match hyp: " ^ (string_of_match_exception ex))
| Success bindings ->
let ms_hyps = (name, h) :: part_sol.ms_hyps in
body ({ part_sol with ms_vars = bindings; ms_hyps = ms_hyps }))
(fun () ->
solve_mp_for_single_hyp name pat hs body part_sol) | {
"file_name": "ulib/FStar.Tactics.PatternMatching.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 59,
"end_line": 453,
"start_col": 0,
"start_line": 433
} | (*
Copyright 2008-2018 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.
*)
/// ==========================
/// Pattern-matching tactics
/// ==========================
///
/// :Author: Clément Pit-Claudel
/// :Contact: clement.pitclaudel@live.com
/// :Date: 2017-10-13
module FStar.Tactics.PatternMatching
open FStar.Tactics.V2
/// Contents
/// ========
///
/// 1 Contents
/// 2 Motivation
/// 3 Some utility functions
/// 4 Pattern types
/// 5 Pattern matching exceptions
/// 5.1 Types of exceptions
/// 5.2 The exception monad
/// 5.3 Liftings
/// 6 Pattern interpretation
/// 7 Pattern-matching problems
/// 7.1 Definitions
/// 7.2 Resolution
/// 8 A DSL for pattern-matching
/// 8.1 Pattern notations
/// 8.2 Problem notations
/// 8.3 Continuations
/// 9 Putting it all together
/// 10 Examples
/// 10.1 Simple examples
/// 10.2 A real-life example
/// 11 Possible extensions
/// 12 Notes
///
/// Motivation
/// ==========
///
/// Suppose you have a goal of the form ``squash (a == b)``. How do you capture
/// `a` and `b` for further inspection?
///
/// Here's a basic (but cumbersome!) implementation:
let fetch_eq_side () : Tac (term * term) =
let g = cur_goal () in
match inspect g with
| Tv_App squash (g, _) ->
(match inspect squash with
| Tv_UInst squash _
| Tv_FVar squash ->
if fv_to_string squash = flatten_name squash_qn then
(match inspect g with
| Tv_App eq_type_x (y, _) ->
(match inspect eq_type_x with
| Tv_App eq_type (x, _) ->
(match inspect eq_type with
| Tv_App eq (typ, _) ->
(match inspect eq with
| Tv_UInst eq _
| Tv_FVar eq ->
if fv_to_string eq = flatten_name eq2_qn then
(x, y)
else fail "not an equality"
| _ -> fail "not an app2 of fvar: ")
| _ -> fail "not an app3")
| _ -> fail "not an app2")
| _ -> fail "not an app under squash")
else fail "not a squash"
| _ -> fail "not an app of fvar at top level")
| _ -> fail "not an app at top level"
/// …and here's how you could use it:
(* let _ = *)
(* assert_by_tactic (1 + 1 == 2) *)
(* (fun () -> let l, r = fetch_eq_side () in *)
(* print (term_to_string l ^ " / " ^ term_to_string r)) *)
/// This file defines pattern-matching primitives that let you write the same
/// thing like this…
///
/// .. code:: fstar
///
/// let fetch_eq_side' #a () : Tac (term * term) =
/// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) ->
/// (quote left, quote right) <: Tac (term * term))
///
/// let _ =
/// assert_by_tactic (1 + 1 == 2)
/// (fun () -> let l, r = fetch_eq_side' #int () in
/// print (term_to_string l ^ " / " ^ term_to_string r))
///
/// …or, more succinctly, like this:
///
/// .. code:: fstar
///
/// let _ =
/// assert_by_tactic (1 + 1 == 2)
/// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) ->
/// let l, r = quote left, quote right in
/// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit))
/// Some utility functions
/// ======================
///
/// (Skip over this part on a quick read — these are just convenience functions)
(** Ensure that tactic `t` fails. **)
let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit =
match trytac t with
| Some _ -> fail message
| None -> ()
/// The following two tactics are needed because of issues with the ``Tac``
/// effect.
let implies_intro' () : Tac unit =
let _ = implies_intro () in ()
let repeat' #a (f: unit -> Tac a) : Tac unit =
let _ = repeat f in ()
let and_elim' (h: binding) : Tac unit =
and_elim (pack (Tv_Var h));
clear h
(** Use a hypothesis at type a to satisfy a goal at type squash a *)
let exact_hyp (a: Type0) (h: namedv) : Tac unit =
let hd = quote (FStar.Squash.return_squash #a) in
exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)])
(** Use a hypothesis h (of type a) to satisfy a goal at type a *)
let exact_hyp' (h: namedv): Tac unit =
exact (pack (Tv_Var h))
/// Pattern types
/// =============
///
/// Patterns are defined using a simple inductive type, mirroring the structure
/// of ``term_view``.
type varname = string
type qn = string
type pattern =
| PVar: name: varname -> pattern
| PQn: qn: qn -> pattern
| PType: pattern
| PApp: hd: pattern -> arg: pattern -> pattern
let desc_of_pattern = function
| PVar _ -> "a variable"
| PQn qn -> "a constant (" ^ qn ^ ")"
| PType -> "Type"
| PApp _ _ -> "a function application"
let rec string_of_pattern = function
| PVar x -> "?" ^ x
| PQn qn -> qn
| PType -> "Type"
| PApp l r -> "(" ^ string_of_pattern l ^ " "
^ string_of_pattern r ^ ")"
/// Pattern matching exceptions
/// ===========================
///
/// Pattern-matching is defined as a pure, monadic function (because of issues
/// with combining DM4F effects, but also because it helps with debugging).
/// This section defines the exception monad.
///
/// Types of exceptions
/// -------------------
noeq type match_exception =
| NameMismatch of qn * qn
| SimpleMismatch of pattern * term
| NonLinearMismatch of varname * term * term
| UnsupportedTermInPattern of term
| IncorrectTypeInAbsPatBinder of typ
let term_head t : Tac string =
match inspect t with
| Tv_Var bv -> "Tv_Var"
| Tv_BVar fv -> "Tv_BVar"
| Tv_FVar fv -> "Tv_FVar"
| Tv_UInst _ _ -> "Tv_UInst"
| Tv_App f x -> "Tv_App"
| Tv_Abs x t -> "Tv_Abs"
| Tv_Arrow x t -> "Tv_Arrow"
| Tv_Type _ -> "Tv_Type"
| Tv_Refine x t -> "Tv_Refine"
| Tv_Const cst -> "Tv_Const"
| Tv_Uvar i t -> "Tv_Uvar"
| Tv_Let r attrs b t1 t2 -> "Tv_Let"
| Tv_Match t _ branches -> "Tv_Match"
| Tv_AscribedT _ _ _ _ -> "Tv_AscribedT"
| Tv_AscribedC _ _ _ _ -> "Tv_AscribedC"
| Tv_Unknown -> "Tv_Unknown"
| Tv_Unsupp -> "Tv_Unsupp"
let string_of_match_exception = function
| NameMismatch (qn1, qn2) ->
"Match failure (name mismatch): expecting " ^
qn1 ^ ", found " ^ qn2
| SimpleMismatch (pat, tm) ->
"Match failure (sort mismatch): expecting " ^
desc_of_pattern pat ^ ", got " ^ term_to_string tm
| NonLinearMismatch (nm, t1, t2) ->
"Match failure (nonlinear mismatch): variable " ^ nm ^
" needs to match both " ^ (term_to_string t1) ^
" and " ^ (term_to_string t2)
| UnsupportedTermInPattern tm ->
"Match failure (unsupported term in pattern): " ^
term_to_string tm ^ " (" ^ term_head tm ^ ")"
| IncorrectTypeInAbsPatBinder typ ->
"Incorrect type in pattern-matching binder: " ^
term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)"
/// The exception monad
/// -------------------
noeq type match_res a =
| Success of a
| Failure of match_exception
let return #a (x: a) : match_res a =
Success x
let (let?) (#a #b: Type)
(f: match_res a)
(g: a -> Tac (match_res b))
: Tac (match_res b) =
match f with
| Success aa -> g aa
| Failure ex -> Failure ex
let raise #a (ex: match_exception) : match_res a =
Failure ex
/// Liftings
/// --------
///
/// There's a natural lifting from the exception monad into the tactic effect:
let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b =
match f aa with
| Success bb -> bb
| Failure ex -> Tactics.fail (string_of_match_exception ex)
let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b =
match f aa with
| Success bb -> bb
| Failure ex -> Tactics.fail (string_of_match_exception ex)
/// Pattern interpretation
/// ======================
///
/// This section implement pattern-matching. This is strictly a one term, one
/// pattern implementation — handling cases in which mutliple hypotheses match
/// the same pattern is done later.
type bindings = list (varname * term)
let string_of_bindings (bindings: bindings) =
String.concat "\n"
(map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm))
bindings)
(** Match a pattern against a term.
`cur_bindings` is a list of bindings collected while matching previous parts of
the pattern. Returns a result in the exception monad. **)
let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term)
: Tac (match_res bindings) =
let interp_var (v: varname) cur_bindings tm =
match List.Tot.Base.assoc v cur_bindings with
| Some tm' -> if term_eq tm tm' then return cur_bindings
else raise (NonLinearMismatch (v, tm, tm'))
| None -> return ((v, tm) :: cur_bindings) in
let interp_qn (qn: qn) cur_bindings tm =
match inspect tm with
| Tv_UInst fv _
| Tv_FVar fv ->
if fv_to_string fv = qn then return cur_bindings
else raise (NameMismatch (qn, (fv_to_string fv)))
| _ -> raise (SimpleMismatch (pat, tm)) in
let interp_type cur_bindings tm =
match inspect tm with
| Tv_Type _ -> return cur_bindings
| _ -> raise (SimpleMismatch (pat, tm)) in
let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm =
match inspect tm with
| Tv_App hd (arg, _) ->
let? with_hd = interp_pattern_aux p_hd cur_bindings hd in
let? with_arg = interp_pattern_aux p_arg with_hd arg in
return with_arg
| _ -> raise (SimpleMismatch (pat, tm)) in
match pat with
| PVar var -> interp_var var cur_bindings tm
| PQn qn -> interp_qn qn cur_bindings tm
| PType -> interp_type cur_bindings tm
| PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm
(** Match a pattern `pat` against a term.
Returns a result in the exception monad. **)
let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) =
fun (tm: term) ->
let? rev_bindings = interp_pattern_aux pat [] tm in
return (List.Tot.Base.rev rev_bindings)
(** Match a term `tm` against a pattern `pat`.
Raises an exception if the match fails. This is mostly useful for debugging:
use ``mgw`` to capture matches. **)
let match_term pat (tm : term) : Tac bindings =
match interp_pattern pat (norm_term [] tm) with
| Success bb -> bb
| Failure ex -> Tactics.fail (string_of_match_exception ex)
/// Pattern-matching problems
/// =========================
///
/// Generalizing past single-term single-pattern problems, we obtain the
/// following notions of pattern-matching problems and solutions:
let debug msg : Tac unit = () // print msg
/// Definitions
/// -----------
let absvar = binding
type hypothesis = binding
/// A matching problem is composed of holes (``mp_vars``), hypothesis patterns
/// (``mp_hyps``), and a goal pattern (``mp_goal``).
noeq type matching_problem =
{ mp_vars: list varname;
mp_hyps: list (varname * pattern);
mp_goal: option pattern }
let string_of_matching_problem mp =
let vars =
String.concat ", " mp.mp_vars in
let hyps =
String.concat "\n "
(List.Tot.Base.map (fun (nm, pat) ->
nm ^ ": " ^ (string_of_pattern pat)) mp.mp_hyps) in
let goal = match mp.mp_goal with
| None -> "_"
| Some pat -> string_of_pattern pat in
"\n{ vars: " ^ vars ^ "\n" ^
" hyps: " ^ hyps ^ "\n" ^
" goal: " ^ goal ^ " }"
/// A solution is composed of terms captured to mach the holes, and binders
/// captured to match hypothesis patterns.
noeq type matching_solution =
{ ms_vars: list (varname * term);
ms_hyps: list (varname * hypothesis) }
let string_of_matching_solution ms =
let vars =
String.concat "\n "
(map (fun (varname, tm) ->
varname ^ ": " ^ (term_to_string tm)) ms.ms_vars) in
let hyps =
String.concat "\n "
(map (fun (nm, binding) ->
nm ^ ": " ^ (binding_to_string binding)) ms.ms_hyps) in
"\n{ vars: " ^ vars ^ "\n" ^
" hyps: " ^ hyps ^ " }"
(** Find a varname in an association list; fail if it can't be found. **)
let assoc_varname_fail (#b: Type) (key: varname) (ls: list (varname * b))
: Tac b =
match List.Tot.Base.assoc key ls with
| None -> fail ("Not found: " ^ key)
| Some x -> x
let ms_locate_hyp (a: Type) (solution: matching_solution)
(name: varname) : Tac hypothesis =
assoc_varname_fail name solution.ms_hyps
let ms_locate_var (a: Type) (solution: matching_solution)
(name: varname) : Tac a =
unquote #a (assoc_varname_fail name solution.ms_vars)
let ms_locate_unit (a: Type) _solution _binder_name : Tac unit =
()
/// Resolution
/// ----------
///
/// Solving a matching problem is a two-steps process: find an initial
/// assignment for holes based on the goal pattern, then find a set of
/// hypotheses matching hypothesis patterns.
///
/// Note that the implementation takes a continuation of type
/// ``matching_solution -> Tac a``. This continuation is needed because we want
/// users to be able to provide extra criteria on matching solutions (most
/// commonly, this criterion is that a particular tactic should run
/// successfuly).
///
/// This makes it easy to implement a simple for of search through the context,
/// where one can find a hypothesis matching a particular predicate by
/// constructing a trivial matching problem and passing the predicate as the
/// continuation.
(** Scan ``hypotheses`` for a match for ``pat`` that lets ``body`` succeed.
``name`` is used to refer to the hypothesis matched in the final solution. | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.String.fsti.checked",
"FStar.Squash.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.PatternMatching.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
name: FStar.Tactics.PatternMatching.varname ->
pat: FStar.Tactics.PatternMatching.pattern ->
hypotheses: Prims.list FStar.Tactics.PatternMatching.hypothesis ->
body: (_: FStar.Tactics.PatternMatching.matching_solution -> FStar.Tactics.Effect.Tac a) ->
part_sol: FStar.Tactics.PatternMatching.matching_solution
-> FStar.Tactics.Effect.Tac a | FStar.Tactics.Effect.Tac | [] | [] | [
"FStar.Tactics.PatternMatching.varname",
"FStar.Tactics.PatternMatching.pattern",
"Prims.list",
"FStar.Tactics.PatternMatching.hypothesis",
"FStar.Tactics.PatternMatching.matching_solution",
"FStar.Tactics.V2.Derived.fail",
"FStar.Tactics.V2.Derived.or_else",
"Prims.unit",
"FStar.Tactics.PatternMatching.match_exception",
"Prims.string",
"Prims.op_Hat",
"FStar.Tactics.PatternMatching.string_of_match_exception",
"FStar.Tactics.PatternMatching.bindings",
"FStar.Tactics.PatternMatching.Mkmatching_solution",
"FStar.Pervasives.Native.tuple2",
"Prims.Cons",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Tactics.PatternMatching.__proj__Mkmatching_solution__item__ms_hyps",
"FStar.Tactics.PatternMatching.match_res",
"FStar.Tactics.PatternMatching.interp_pattern_aux",
"FStar.Tactics.PatternMatching.__proj__Mkmatching_solution__item__ms_vars",
"FStar.Tactics.V2.Derived.type_of_binding",
"FStar.Tactics.PatternMatching.solve_mp_for_single_hyp"
] | [
"recursion"
] | false | true | false | false | false | let rec solve_mp_for_single_hyp
#a
(name: varname)
(pat: pattern)
(hypotheses: list hypothesis)
(body: (matching_solution -> Tac a))
(part_sol: matching_solution)
: Tac a =
| match hypotheses with
| [] -> fail #a "No matching hypothesis"
| h :: hs ->
or_else (fun () ->
match interp_pattern_aux pat part_sol.ms_vars (type_of_binding h) with
| Failure ex -> fail ("Failed to match hyp: " ^ (string_of_match_exception ex))
| Success bindings ->
let ms_hyps = (name, h) :: part_sol.ms_hyps in
body ({ part_sol with ms_vars = bindings; ms_hyps = ms_hyps }))
(fun () -> solve_mp_for_single_hyp name pat hs body part_sol) | false |
FStar.Tactics.PatternMatching.fst | FStar.Tactics.PatternMatching.classify_abspat_binder | val classify_abspat_binder (b: binder) : Tac (abspat_binder_kind * term) | val classify_abspat_binder (b: binder) : Tac (abspat_binder_kind * term) | let classify_abspat_binder (b : binder): Tac (abspat_binder_kind * term) =
let varname = "v" in
let hyp_pat = PApp (PQn hyp_qn) (PVar varname) in
let goal_pat = PApp (PQn goal_qn) (PVar varname) in
let typ = type_of_named_binder b in
match interp_pattern hyp_pat typ with
| Success [(_, hyp_typ)] -> ABKHyp, hyp_typ
| Success _ -> fail "classifiy_abspat_binder: impossible (1)"
| Failure _ ->
match interp_pattern goal_pat typ with
| Success [(_, goal_typ)] -> ABKGoal, goal_typ
| Success _ -> fail "classifiy_abspat_binder: impossible (2)"
| Failure _ -> ABKVar typ, typ | {
"file_name": "ulib/FStar.Tactics.PatternMatching.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 34,
"end_line": 600,
"start_col": 0,
"start_line": 587
} | (*
Copyright 2008-2018 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.
*)
/// ==========================
/// Pattern-matching tactics
/// ==========================
///
/// :Author: Clément Pit-Claudel
/// :Contact: clement.pitclaudel@live.com
/// :Date: 2017-10-13
module FStar.Tactics.PatternMatching
open FStar.Tactics.V2
/// Contents
/// ========
///
/// 1 Contents
/// 2 Motivation
/// 3 Some utility functions
/// 4 Pattern types
/// 5 Pattern matching exceptions
/// 5.1 Types of exceptions
/// 5.2 The exception monad
/// 5.3 Liftings
/// 6 Pattern interpretation
/// 7 Pattern-matching problems
/// 7.1 Definitions
/// 7.2 Resolution
/// 8 A DSL for pattern-matching
/// 8.1 Pattern notations
/// 8.2 Problem notations
/// 8.3 Continuations
/// 9 Putting it all together
/// 10 Examples
/// 10.1 Simple examples
/// 10.2 A real-life example
/// 11 Possible extensions
/// 12 Notes
///
/// Motivation
/// ==========
///
/// Suppose you have a goal of the form ``squash (a == b)``. How do you capture
/// `a` and `b` for further inspection?
///
/// Here's a basic (but cumbersome!) implementation:
let fetch_eq_side () : Tac (term * term) =
let g = cur_goal () in
match inspect g with
| Tv_App squash (g, _) ->
(match inspect squash with
| Tv_UInst squash _
| Tv_FVar squash ->
if fv_to_string squash = flatten_name squash_qn then
(match inspect g with
| Tv_App eq_type_x (y, _) ->
(match inspect eq_type_x with
| Tv_App eq_type (x, _) ->
(match inspect eq_type with
| Tv_App eq (typ, _) ->
(match inspect eq with
| Tv_UInst eq _
| Tv_FVar eq ->
if fv_to_string eq = flatten_name eq2_qn then
(x, y)
else fail "not an equality"
| _ -> fail "not an app2 of fvar: ")
| _ -> fail "not an app3")
| _ -> fail "not an app2")
| _ -> fail "not an app under squash")
else fail "not a squash"
| _ -> fail "not an app of fvar at top level")
| _ -> fail "not an app at top level"
/// …and here's how you could use it:
(* let _ = *)
(* assert_by_tactic (1 + 1 == 2) *)
(* (fun () -> let l, r = fetch_eq_side () in *)
(* print (term_to_string l ^ " / " ^ term_to_string r)) *)
/// This file defines pattern-matching primitives that let you write the same
/// thing like this…
///
/// .. code:: fstar
///
/// let fetch_eq_side' #a () : Tac (term * term) =
/// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) ->
/// (quote left, quote right) <: Tac (term * term))
///
/// let _ =
/// assert_by_tactic (1 + 1 == 2)
/// (fun () -> let l, r = fetch_eq_side' #int () in
/// print (term_to_string l ^ " / " ^ term_to_string r))
///
/// …or, more succinctly, like this:
///
/// .. code:: fstar
///
/// let _ =
/// assert_by_tactic (1 + 1 == 2)
/// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) ->
/// let l, r = quote left, quote right in
/// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit))
/// Some utility functions
/// ======================
///
/// (Skip over this part on a quick read — these are just convenience functions)
(** Ensure that tactic `t` fails. **)
let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit =
match trytac t with
| Some _ -> fail message
| None -> ()
/// The following two tactics are needed because of issues with the ``Tac``
/// effect.
let implies_intro' () : Tac unit =
let _ = implies_intro () in ()
let repeat' #a (f: unit -> Tac a) : Tac unit =
let _ = repeat f in ()
let and_elim' (h: binding) : Tac unit =
and_elim (pack (Tv_Var h));
clear h
(** Use a hypothesis at type a to satisfy a goal at type squash a *)
let exact_hyp (a: Type0) (h: namedv) : Tac unit =
let hd = quote (FStar.Squash.return_squash #a) in
exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)])
(** Use a hypothesis h (of type a) to satisfy a goal at type a *)
let exact_hyp' (h: namedv): Tac unit =
exact (pack (Tv_Var h))
/// Pattern types
/// =============
///
/// Patterns are defined using a simple inductive type, mirroring the structure
/// of ``term_view``.
type varname = string
type qn = string
type pattern =
| PVar: name: varname -> pattern
| PQn: qn: qn -> pattern
| PType: pattern
| PApp: hd: pattern -> arg: pattern -> pattern
let desc_of_pattern = function
| PVar _ -> "a variable"
| PQn qn -> "a constant (" ^ qn ^ ")"
| PType -> "Type"
| PApp _ _ -> "a function application"
let rec string_of_pattern = function
| PVar x -> "?" ^ x
| PQn qn -> qn
| PType -> "Type"
| PApp l r -> "(" ^ string_of_pattern l ^ " "
^ string_of_pattern r ^ ")"
/// Pattern matching exceptions
/// ===========================
///
/// Pattern-matching is defined as a pure, monadic function (because of issues
/// with combining DM4F effects, but also because it helps with debugging).
/// This section defines the exception monad.
///
/// Types of exceptions
/// -------------------
noeq type match_exception =
| NameMismatch of qn * qn
| SimpleMismatch of pattern * term
| NonLinearMismatch of varname * term * term
| UnsupportedTermInPattern of term
| IncorrectTypeInAbsPatBinder of typ
let term_head t : Tac string =
match inspect t with
| Tv_Var bv -> "Tv_Var"
| Tv_BVar fv -> "Tv_BVar"
| Tv_FVar fv -> "Tv_FVar"
| Tv_UInst _ _ -> "Tv_UInst"
| Tv_App f x -> "Tv_App"
| Tv_Abs x t -> "Tv_Abs"
| Tv_Arrow x t -> "Tv_Arrow"
| Tv_Type _ -> "Tv_Type"
| Tv_Refine x t -> "Tv_Refine"
| Tv_Const cst -> "Tv_Const"
| Tv_Uvar i t -> "Tv_Uvar"
| Tv_Let r attrs b t1 t2 -> "Tv_Let"
| Tv_Match t _ branches -> "Tv_Match"
| Tv_AscribedT _ _ _ _ -> "Tv_AscribedT"
| Tv_AscribedC _ _ _ _ -> "Tv_AscribedC"
| Tv_Unknown -> "Tv_Unknown"
| Tv_Unsupp -> "Tv_Unsupp"
let string_of_match_exception = function
| NameMismatch (qn1, qn2) ->
"Match failure (name mismatch): expecting " ^
qn1 ^ ", found " ^ qn2
| SimpleMismatch (pat, tm) ->
"Match failure (sort mismatch): expecting " ^
desc_of_pattern pat ^ ", got " ^ term_to_string tm
| NonLinearMismatch (nm, t1, t2) ->
"Match failure (nonlinear mismatch): variable " ^ nm ^
" needs to match both " ^ (term_to_string t1) ^
" and " ^ (term_to_string t2)
| UnsupportedTermInPattern tm ->
"Match failure (unsupported term in pattern): " ^
term_to_string tm ^ " (" ^ term_head tm ^ ")"
| IncorrectTypeInAbsPatBinder typ ->
"Incorrect type in pattern-matching binder: " ^
term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)"
/// The exception monad
/// -------------------
noeq type match_res a =
| Success of a
| Failure of match_exception
let return #a (x: a) : match_res a =
Success x
let (let?) (#a #b: Type)
(f: match_res a)
(g: a -> Tac (match_res b))
: Tac (match_res b) =
match f with
| Success aa -> g aa
| Failure ex -> Failure ex
let raise #a (ex: match_exception) : match_res a =
Failure ex
/// Liftings
/// --------
///
/// There's a natural lifting from the exception monad into the tactic effect:
let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b =
match f aa with
| Success bb -> bb
| Failure ex -> Tactics.fail (string_of_match_exception ex)
let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b =
match f aa with
| Success bb -> bb
| Failure ex -> Tactics.fail (string_of_match_exception ex)
/// Pattern interpretation
/// ======================
///
/// This section implement pattern-matching. This is strictly a one term, one
/// pattern implementation — handling cases in which mutliple hypotheses match
/// the same pattern is done later.
type bindings = list (varname * term)
let string_of_bindings (bindings: bindings) =
String.concat "\n"
(map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm))
bindings)
(** Match a pattern against a term.
`cur_bindings` is a list of bindings collected while matching previous parts of
the pattern. Returns a result in the exception monad. **)
let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term)
: Tac (match_res bindings) =
let interp_var (v: varname) cur_bindings tm =
match List.Tot.Base.assoc v cur_bindings with
| Some tm' -> if term_eq tm tm' then return cur_bindings
else raise (NonLinearMismatch (v, tm, tm'))
| None -> return ((v, tm) :: cur_bindings) in
let interp_qn (qn: qn) cur_bindings tm =
match inspect tm with
| Tv_UInst fv _
| Tv_FVar fv ->
if fv_to_string fv = qn then return cur_bindings
else raise (NameMismatch (qn, (fv_to_string fv)))
| _ -> raise (SimpleMismatch (pat, tm)) in
let interp_type cur_bindings tm =
match inspect tm with
| Tv_Type _ -> return cur_bindings
| _ -> raise (SimpleMismatch (pat, tm)) in
let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm =
match inspect tm with
| Tv_App hd (arg, _) ->
let? with_hd = interp_pattern_aux p_hd cur_bindings hd in
let? with_arg = interp_pattern_aux p_arg with_hd arg in
return with_arg
| _ -> raise (SimpleMismatch (pat, tm)) in
match pat with
| PVar var -> interp_var var cur_bindings tm
| PQn qn -> interp_qn qn cur_bindings tm
| PType -> interp_type cur_bindings tm
| PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm
(** Match a pattern `pat` against a term.
Returns a result in the exception monad. **)
let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) =
fun (tm: term) ->
let? rev_bindings = interp_pattern_aux pat [] tm in
return (List.Tot.Base.rev rev_bindings)
(** Match a term `tm` against a pattern `pat`.
Raises an exception if the match fails. This is mostly useful for debugging:
use ``mgw`` to capture matches. **)
let match_term pat (tm : term) : Tac bindings =
match interp_pattern pat (norm_term [] tm) with
| Success bb -> bb
| Failure ex -> Tactics.fail (string_of_match_exception ex)
/// Pattern-matching problems
/// =========================
///
/// Generalizing past single-term single-pattern problems, we obtain the
/// following notions of pattern-matching problems and solutions:
let debug msg : Tac unit = () // print msg
/// Definitions
/// -----------
let absvar = binding
type hypothesis = binding
/// A matching problem is composed of holes (``mp_vars``), hypothesis patterns
/// (``mp_hyps``), and a goal pattern (``mp_goal``).
noeq type matching_problem =
{ mp_vars: list varname;
mp_hyps: list (varname * pattern);
mp_goal: option pattern }
let string_of_matching_problem mp =
let vars =
String.concat ", " mp.mp_vars in
let hyps =
String.concat "\n "
(List.Tot.Base.map (fun (nm, pat) ->
nm ^ ": " ^ (string_of_pattern pat)) mp.mp_hyps) in
let goal = match mp.mp_goal with
| None -> "_"
| Some pat -> string_of_pattern pat in
"\n{ vars: " ^ vars ^ "\n" ^
" hyps: " ^ hyps ^ "\n" ^
" goal: " ^ goal ^ " }"
/// A solution is composed of terms captured to mach the holes, and binders
/// captured to match hypothesis patterns.
noeq type matching_solution =
{ ms_vars: list (varname * term);
ms_hyps: list (varname * hypothesis) }
let string_of_matching_solution ms =
let vars =
String.concat "\n "
(map (fun (varname, tm) ->
varname ^ ": " ^ (term_to_string tm)) ms.ms_vars) in
let hyps =
String.concat "\n "
(map (fun (nm, binding) ->
nm ^ ": " ^ (binding_to_string binding)) ms.ms_hyps) in
"\n{ vars: " ^ vars ^ "\n" ^
" hyps: " ^ hyps ^ " }"
(** Find a varname in an association list; fail if it can't be found. **)
let assoc_varname_fail (#b: Type) (key: varname) (ls: list (varname * b))
: Tac b =
match List.Tot.Base.assoc key ls with
| None -> fail ("Not found: " ^ key)
| Some x -> x
let ms_locate_hyp (a: Type) (solution: matching_solution)
(name: varname) : Tac hypothesis =
assoc_varname_fail name solution.ms_hyps
let ms_locate_var (a: Type) (solution: matching_solution)
(name: varname) : Tac a =
unquote #a (assoc_varname_fail name solution.ms_vars)
let ms_locate_unit (a: Type) _solution _binder_name : Tac unit =
()
/// Resolution
/// ----------
///
/// Solving a matching problem is a two-steps process: find an initial
/// assignment for holes based on the goal pattern, then find a set of
/// hypotheses matching hypothesis patterns.
///
/// Note that the implementation takes a continuation of type
/// ``matching_solution -> Tac a``. This continuation is needed because we want
/// users to be able to provide extra criteria on matching solutions (most
/// commonly, this criterion is that a particular tactic should run
/// successfuly).
///
/// This makes it easy to implement a simple for of search through the context,
/// where one can find a hypothesis matching a particular predicate by
/// constructing a trivial matching problem and passing the predicate as the
/// continuation.
(** Scan ``hypotheses`` for a match for ``pat`` that lets ``body`` succeed.
``name`` is used to refer to the hypothesis matched in the final solution.
``part_sol`` includes bindings gathered while matching previous solutions. **)
let rec solve_mp_for_single_hyp #a
(name: varname)
(pat: pattern)
(hypotheses: list hypothesis)
(body: matching_solution -> Tac a)
(part_sol: matching_solution)
: Tac a =
match hypotheses with
| [] ->
fail #a "No matching hypothesis"
| h :: hs ->
or_else // Must be in ``Tac`` here to run `body`
(fun () ->
match interp_pattern_aux pat part_sol.ms_vars (type_of_binding h) with
| Failure ex ->
fail ("Failed to match hyp: " ^ (string_of_match_exception ex))
| Success bindings ->
let ms_hyps = (name, h) :: part_sol.ms_hyps in
body ({ part_sol with ms_vars = bindings; ms_hyps = ms_hyps }))
(fun () ->
solve_mp_for_single_hyp name pat hs body part_sol)
(** Scan ``hypotheses`` for matches for ``mp_hyps`` that lets ``body``
succeed. **)
let rec solve_mp_for_hyps #a
(mp_hyps: list (varname * pattern))
(hypotheses: list hypothesis)
(body: matching_solution -> Tac a)
(partial_solution: matching_solution)
: Tac a =
match mp_hyps with
| [] -> body partial_solution
| (name, pat) :: pats ->
solve_mp_for_single_hyp name pat hypotheses
(solve_mp_for_hyps pats hypotheses body)
partial_solution
(** Solve a matching problem.
The solution returned is constructed to ensure that the continuation ``body``
succeeds: this implements the usual backtracking-match semantics. **)
let solve_mp #a (problem: matching_problem)
(hypotheses: list hypothesis) (goal: term)
(body: matching_solution -> Tac a)
: Tac a =
let goal_ps =
match problem.mp_goal with
| None -> { ms_vars = []; ms_hyps = [] }
| Some pat ->
match interp_pattern pat goal with
| Failure ex -> fail ("Failed to match goal: " ^ (string_of_match_exception ex))
| Success bindings -> { ms_vars = bindings; ms_hyps = [] } in
solve_mp_for_hyps #a problem.mp_hyps hypotheses body goal_ps
/// A DSL for pattern-matching
/// ==========================
///
/// Using pattern-matching problems as defined above is relatively cumbersome,
/// so we now introduce a lightweight notation, in two steps: pattern notations,
/// and matching-problem notations.
///
/// Pattern notations
/// -----------------
///
/// The first part of our pattern-matching syntax is pattern notations: we
/// provide a reflective function which constructs a pattern from a term:
/// variables are holes, free variables are constants, and applications are
/// application patterns.
(* FIXME: MOVE *)
let name_of_namedv (x:namedv) : Tac string =
unseal (inspect_namedv x).ppname
(** Compile a term `tm` into a pattern. **)
let rec pattern_of_term_ex tm : Tac (match_res pattern) =
match inspect tm with
| Tv_Var bv ->
return (PVar (name_of_namedv bv))
| Tv_FVar fv
| Tv_UInst fv _ ->
let qn = fv_to_string fv in
return (PQn qn)
| Tv_Type _ ->
return PType
| Tv_App f (x, _) ->
let? fpat = pattern_of_term_ex f in
let? xpat = pattern_of_term_ex x in
return (PApp fpat xpat)
| _ -> raise (UnsupportedTermInPattern tm)
(** β-reduce a term `tm`.
This is useful to remove needles function applications introduced by F*, like
``(fun a b c -> a) 1 2 3``. **)
let beta_reduce (tm: term) : Tac term =
norm_term [] tm
(** Compile a term `tm` into a pattern. **)
let pattern_of_term tm : Tac pattern =
match pattern_of_term_ex tm with
| Success bb -> bb
| Failure ex -> Tactics.fail (string_of_match_exception ex)
/// Problem notations
/// -----------------
///
/// We then introduce a DSL for matching problems, best explained on the
/// following example::
///
/// (fun (a b c: ①) (h1 h2 h3: hyp ②) (g: pm_goal ③) → ④)
///
/// This notation is intended to express a pattern-matching problems with three
/// holes ``a``, ``b``, and ``c`` of type ①, matching hypotheses ``h1``, ``h2``,
/// and ``h3`` against pattern ② and the goal against the pattern ③. The body
/// of the notation (④) is then run with appropriate terms bound to ``a``,
/// ``b``, and ``c``, appropriate binders bound to ``h1``, ``h2``, and ``h3``,
/// and ``()`` bound to ``g``.
///
/// We call these patterns ``abspat``s (abstraction patterns), and we provide
/// facilities to parse them into matching problems, and to run their bodies
/// against a particular matching solution.
// We used to annotate variables with an explicit 'var' marker, but then that
// var annotation leaked into the types of other hypotheses due to type
// inference, requiring non-trivial normalization.
// let var (a: Type) = a
let hyp (a: Type) = binding
let pm_goal (a: Type) = unit
let hyp_qn = `%hyp
let goal_qn = `%pm_goal
noeq type abspat_binder_kind =
| ABKVar of typ
| ABKHyp
| ABKGoal
let string_of_abspat_binder_kind = function
| ABKVar _ -> "varname"
| ABKHyp -> "hyp"
| ABKGoal -> "goal"
noeq type abspat_argspec =
{ asa_name: absvar;
asa_kind: abspat_binder_kind }
// We must store this continuation, because recomputing it yields different
// names when the binders are re-opened.
type abspat_continuation =
list abspat_argspec * term
let type_of_named_binder (nb : binder) : term =
nb.sort | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.String.fsti.checked",
"FStar.Squash.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.PatternMatching.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b: FStar.Tactics.NamedView.binder
-> FStar.Tactics.Effect.Tac
(FStar.Tactics.PatternMatching.abspat_binder_kind * FStar.Tactics.NamedView.term) | FStar.Tactics.Effect.Tac | [] | [] | [
"FStar.Tactics.NamedView.binder",
"FStar.Tactics.PatternMatching.varname",
"FStar.Tactics.NamedView.term",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Tactics.PatternMatching.abspat_binder_kind",
"FStar.Tactics.PatternMatching.ABKHyp",
"FStar.Pervasives.Native.tuple2",
"FStar.Tactics.PatternMatching.bindings",
"FStar.Tactics.V2.Derived.fail",
"FStar.Tactics.PatternMatching.match_exception",
"FStar.Tactics.PatternMatching.ABKGoal",
"FStar.Tactics.PatternMatching.ABKVar",
"FStar.Tactics.PatternMatching.match_res",
"FStar.Tactics.PatternMatching.interp_pattern",
"FStar.Tactics.PatternMatching.type_of_named_binder",
"FStar.Tactics.PatternMatching.pattern",
"FStar.Tactics.PatternMatching.PApp",
"FStar.Tactics.PatternMatching.PQn",
"FStar.Tactics.PatternMatching.goal_qn",
"FStar.Tactics.PatternMatching.PVar",
"FStar.Tactics.PatternMatching.hyp_qn",
"Prims.string"
] | [] | false | true | false | false | false | let classify_abspat_binder (b: binder) : Tac (abspat_binder_kind * term) =
| let varname = "v" in
let hyp_pat = PApp (PQn hyp_qn) (PVar varname) in
let goal_pat = PApp (PQn goal_qn) (PVar varname) in
let typ = type_of_named_binder b in
match interp_pattern hyp_pat typ with
| Success [_, hyp_typ] -> ABKHyp, hyp_typ
| Success _ -> fail "classifiy_abspat_binder: impossible (1)"
| Failure _ ->
match interp_pattern goal_pat typ with
| Success [_, goal_typ] -> ABKGoal, goal_typ
| Success _ -> fail "classifiy_abspat_binder: impossible (2)"
| Failure _ -> ABKVar typ, typ | false |
FStar.Tactics.PatternMatching.fst | FStar.Tactics.PatternMatching.string_of_abspat_binder_kind | val string_of_abspat_binder_kind : _: FStar.Tactics.PatternMatching.abspat_binder_kind -> Prims.string | let string_of_abspat_binder_kind = function
| ABKVar _ -> "varname"
| ABKHyp -> "hyp"
| ABKGoal -> "goal" | {
"file_name": "ulib/FStar.Tactics.PatternMatching.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 21,
"end_line": 573,
"start_col": 0,
"start_line": 570
} | (*
Copyright 2008-2018 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.
*)
/// ==========================
/// Pattern-matching tactics
/// ==========================
///
/// :Author: Clément Pit-Claudel
/// :Contact: clement.pitclaudel@live.com
/// :Date: 2017-10-13
module FStar.Tactics.PatternMatching
open FStar.Tactics.V2
/// Contents
/// ========
///
/// 1 Contents
/// 2 Motivation
/// 3 Some utility functions
/// 4 Pattern types
/// 5 Pattern matching exceptions
/// 5.1 Types of exceptions
/// 5.2 The exception monad
/// 5.3 Liftings
/// 6 Pattern interpretation
/// 7 Pattern-matching problems
/// 7.1 Definitions
/// 7.2 Resolution
/// 8 A DSL for pattern-matching
/// 8.1 Pattern notations
/// 8.2 Problem notations
/// 8.3 Continuations
/// 9 Putting it all together
/// 10 Examples
/// 10.1 Simple examples
/// 10.2 A real-life example
/// 11 Possible extensions
/// 12 Notes
///
/// Motivation
/// ==========
///
/// Suppose you have a goal of the form ``squash (a == b)``. How do you capture
/// `a` and `b` for further inspection?
///
/// Here's a basic (but cumbersome!) implementation:
let fetch_eq_side () : Tac (term * term) =
let g = cur_goal () in
match inspect g with
| Tv_App squash (g, _) ->
(match inspect squash with
| Tv_UInst squash _
| Tv_FVar squash ->
if fv_to_string squash = flatten_name squash_qn then
(match inspect g with
| Tv_App eq_type_x (y, _) ->
(match inspect eq_type_x with
| Tv_App eq_type (x, _) ->
(match inspect eq_type with
| Tv_App eq (typ, _) ->
(match inspect eq with
| Tv_UInst eq _
| Tv_FVar eq ->
if fv_to_string eq = flatten_name eq2_qn then
(x, y)
else fail "not an equality"
| _ -> fail "not an app2 of fvar: ")
| _ -> fail "not an app3")
| _ -> fail "not an app2")
| _ -> fail "not an app under squash")
else fail "not a squash"
| _ -> fail "not an app of fvar at top level")
| _ -> fail "not an app at top level"
/// …and here's how you could use it:
(* let _ = *)
(* assert_by_tactic (1 + 1 == 2) *)
(* (fun () -> let l, r = fetch_eq_side () in *)
(* print (term_to_string l ^ " / " ^ term_to_string r)) *)
/// This file defines pattern-matching primitives that let you write the same
/// thing like this…
///
/// .. code:: fstar
///
/// let fetch_eq_side' #a () : Tac (term * term) =
/// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) ->
/// (quote left, quote right) <: Tac (term * term))
///
/// let _ =
/// assert_by_tactic (1 + 1 == 2)
/// (fun () -> let l, r = fetch_eq_side' #int () in
/// print (term_to_string l ^ " / " ^ term_to_string r))
///
/// …or, more succinctly, like this:
///
/// .. code:: fstar
///
/// let _ =
/// assert_by_tactic (1 + 1 == 2)
/// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) ->
/// let l, r = quote left, quote right in
/// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit))
/// Some utility functions
/// ======================
///
/// (Skip over this part on a quick read — these are just convenience functions)
(** Ensure that tactic `t` fails. **)
let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit =
match trytac t with
| Some _ -> fail message
| None -> ()
/// The following two tactics are needed because of issues with the ``Tac``
/// effect.
let implies_intro' () : Tac unit =
let _ = implies_intro () in ()
let repeat' #a (f: unit -> Tac a) : Tac unit =
let _ = repeat f in ()
let and_elim' (h: binding) : Tac unit =
and_elim (pack (Tv_Var h));
clear h
(** Use a hypothesis at type a to satisfy a goal at type squash a *)
let exact_hyp (a: Type0) (h: namedv) : Tac unit =
let hd = quote (FStar.Squash.return_squash #a) in
exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)])
(** Use a hypothesis h (of type a) to satisfy a goal at type a *)
let exact_hyp' (h: namedv): Tac unit =
exact (pack (Tv_Var h))
/// Pattern types
/// =============
///
/// Patterns are defined using a simple inductive type, mirroring the structure
/// of ``term_view``.
type varname = string
type qn = string
type pattern =
| PVar: name: varname -> pattern
| PQn: qn: qn -> pattern
| PType: pattern
| PApp: hd: pattern -> arg: pattern -> pattern
let desc_of_pattern = function
| PVar _ -> "a variable"
| PQn qn -> "a constant (" ^ qn ^ ")"
| PType -> "Type"
| PApp _ _ -> "a function application"
let rec string_of_pattern = function
| PVar x -> "?" ^ x
| PQn qn -> qn
| PType -> "Type"
| PApp l r -> "(" ^ string_of_pattern l ^ " "
^ string_of_pattern r ^ ")"
/// Pattern matching exceptions
/// ===========================
///
/// Pattern-matching is defined as a pure, monadic function (because of issues
/// with combining DM4F effects, but also because it helps with debugging).
/// This section defines the exception monad.
///
/// Types of exceptions
/// -------------------
noeq type match_exception =
| NameMismatch of qn * qn
| SimpleMismatch of pattern * term
| NonLinearMismatch of varname * term * term
| UnsupportedTermInPattern of term
| IncorrectTypeInAbsPatBinder of typ
let term_head t : Tac string =
match inspect t with
| Tv_Var bv -> "Tv_Var"
| Tv_BVar fv -> "Tv_BVar"
| Tv_FVar fv -> "Tv_FVar"
| Tv_UInst _ _ -> "Tv_UInst"
| Tv_App f x -> "Tv_App"
| Tv_Abs x t -> "Tv_Abs"
| Tv_Arrow x t -> "Tv_Arrow"
| Tv_Type _ -> "Tv_Type"
| Tv_Refine x t -> "Tv_Refine"
| Tv_Const cst -> "Tv_Const"
| Tv_Uvar i t -> "Tv_Uvar"
| Tv_Let r attrs b t1 t2 -> "Tv_Let"
| Tv_Match t _ branches -> "Tv_Match"
| Tv_AscribedT _ _ _ _ -> "Tv_AscribedT"
| Tv_AscribedC _ _ _ _ -> "Tv_AscribedC"
| Tv_Unknown -> "Tv_Unknown"
| Tv_Unsupp -> "Tv_Unsupp"
let string_of_match_exception = function
| NameMismatch (qn1, qn2) ->
"Match failure (name mismatch): expecting " ^
qn1 ^ ", found " ^ qn2
| SimpleMismatch (pat, tm) ->
"Match failure (sort mismatch): expecting " ^
desc_of_pattern pat ^ ", got " ^ term_to_string tm
| NonLinearMismatch (nm, t1, t2) ->
"Match failure (nonlinear mismatch): variable " ^ nm ^
" needs to match both " ^ (term_to_string t1) ^
" and " ^ (term_to_string t2)
| UnsupportedTermInPattern tm ->
"Match failure (unsupported term in pattern): " ^
term_to_string tm ^ " (" ^ term_head tm ^ ")"
| IncorrectTypeInAbsPatBinder typ ->
"Incorrect type in pattern-matching binder: " ^
term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)"
/// The exception monad
/// -------------------
noeq type match_res a =
| Success of a
| Failure of match_exception
let return #a (x: a) : match_res a =
Success x
let (let?) (#a #b: Type)
(f: match_res a)
(g: a -> Tac (match_res b))
: Tac (match_res b) =
match f with
| Success aa -> g aa
| Failure ex -> Failure ex
let raise #a (ex: match_exception) : match_res a =
Failure ex
/// Liftings
/// --------
///
/// There's a natural lifting from the exception monad into the tactic effect:
let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b =
match f aa with
| Success bb -> bb
| Failure ex -> Tactics.fail (string_of_match_exception ex)
let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b =
match f aa with
| Success bb -> bb
| Failure ex -> Tactics.fail (string_of_match_exception ex)
/// Pattern interpretation
/// ======================
///
/// This section implement pattern-matching. This is strictly a one term, one
/// pattern implementation — handling cases in which mutliple hypotheses match
/// the same pattern is done later.
type bindings = list (varname * term)
let string_of_bindings (bindings: bindings) =
String.concat "\n"
(map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm))
bindings)
(** Match a pattern against a term.
`cur_bindings` is a list of bindings collected while matching previous parts of
the pattern. Returns a result in the exception monad. **)
let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term)
: Tac (match_res bindings) =
let interp_var (v: varname) cur_bindings tm =
match List.Tot.Base.assoc v cur_bindings with
| Some tm' -> if term_eq tm tm' then return cur_bindings
else raise (NonLinearMismatch (v, tm, tm'))
| None -> return ((v, tm) :: cur_bindings) in
let interp_qn (qn: qn) cur_bindings tm =
match inspect tm with
| Tv_UInst fv _
| Tv_FVar fv ->
if fv_to_string fv = qn then return cur_bindings
else raise (NameMismatch (qn, (fv_to_string fv)))
| _ -> raise (SimpleMismatch (pat, tm)) in
let interp_type cur_bindings tm =
match inspect tm with
| Tv_Type _ -> return cur_bindings
| _ -> raise (SimpleMismatch (pat, tm)) in
let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm =
match inspect tm with
| Tv_App hd (arg, _) ->
let? with_hd = interp_pattern_aux p_hd cur_bindings hd in
let? with_arg = interp_pattern_aux p_arg with_hd arg in
return with_arg
| _ -> raise (SimpleMismatch (pat, tm)) in
match pat with
| PVar var -> interp_var var cur_bindings tm
| PQn qn -> interp_qn qn cur_bindings tm
| PType -> interp_type cur_bindings tm
| PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm
(** Match a pattern `pat` against a term.
Returns a result in the exception monad. **)
let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) =
fun (tm: term) ->
let? rev_bindings = interp_pattern_aux pat [] tm in
return (List.Tot.Base.rev rev_bindings)
(** Match a term `tm` against a pattern `pat`.
Raises an exception if the match fails. This is mostly useful for debugging:
use ``mgw`` to capture matches. **)
let match_term pat (tm : term) : Tac bindings =
match interp_pattern pat (norm_term [] tm) with
| Success bb -> bb
| Failure ex -> Tactics.fail (string_of_match_exception ex)
/// Pattern-matching problems
/// =========================
///
/// Generalizing past single-term single-pattern problems, we obtain the
/// following notions of pattern-matching problems and solutions:
let debug msg : Tac unit = () // print msg
/// Definitions
/// -----------
let absvar = binding
type hypothesis = binding
/// A matching problem is composed of holes (``mp_vars``), hypothesis patterns
/// (``mp_hyps``), and a goal pattern (``mp_goal``).
noeq type matching_problem =
{ mp_vars: list varname;
mp_hyps: list (varname * pattern);
mp_goal: option pattern }
let string_of_matching_problem mp =
let vars =
String.concat ", " mp.mp_vars in
let hyps =
String.concat "\n "
(List.Tot.Base.map (fun (nm, pat) ->
nm ^ ": " ^ (string_of_pattern pat)) mp.mp_hyps) in
let goal = match mp.mp_goal with
| None -> "_"
| Some pat -> string_of_pattern pat in
"\n{ vars: " ^ vars ^ "\n" ^
" hyps: " ^ hyps ^ "\n" ^
" goal: " ^ goal ^ " }"
/// A solution is composed of terms captured to mach the holes, and binders
/// captured to match hypothesis patterns.
noeq type matching_solution =
{ ms_vars: list (varname * term);
ms_hyps: list (varname * hypothesis) }
let string_of_matching_solution ms =
let vars =
String.concat "\n "
(map (fun (varname, tm) ->
varname ^ ": " ^ (term_to_string tm)) ms.ms_vars) in
let hyps =
String.concat "\n "
(map (fun (nm, binding) ->
nm ^ ": " ^ (binding_to_string binding)) ms.ms_hyps) in
"\n{ vars: " ^ vars ^ "\n" ^
" hyps: " ^ hyps ^ " }"
(** Find a varname in an association list; fail if it can't be found. **)
let assoc_varname_fail (#b: Type) (key: varname) (ls: list (varname * b))
: Tac b =
match List.Tot.Base.assoc key ls with
| None -> fail ("Not found: " ^ key)
| Some x -> x
let ms_locate_hyp (a: Type) (solution: matching_solution)
(name: varname) : Tac hypothesis =
assoc_varname_fail name solution.ms_hyps
let ms_locate_var (a: Type) (solution: matching_solution)
(name: varname) : Tac a =
unquote #a (assoc_varname_fail name solution.ms_vars)
let ms_locate_unit (a: Type) _solution _binder_name : Tac unit =
()
/// Resolution
/// ----------
///
/// Solving a matching problem is a two-steps process: find an initial
/// assignment for holes based on the goal pattern, then find a set of
/// hypotheses matching hypothesis patterns.
///
/// Note that the implementation takes a continuation of type
/// ``matching_solution -> Tac a``. This continuation is needed because we want
/// users to be able to provide extra criteria on matching solutions (most
/// commonly, this criterion is that a particular tactic should run
/// successfuly).
///
/// This makes it easy to implement a simple for of search through the context,
/// where one can find a hypothesis matching a particular predicate by
/// constructing a trivial matching problem and passing the predicate as the
/// continuation.
(** Scan ``hypotheses`` for a match for ``pat`` that lets ``body`` succeed.
``name`` is used to refer to the hypothesis matched in the final solution.
``part_sol`` includes bindings gathered while matching previous solutions. **)
let rec solve_mp_for_single_hyp #a
(name: varname)
(pat: pattern)
(hypotheses: list hypothesis)
(body: matching_solution -> Tac a)
(part_sol: matching_solution)
: Tac a =
match hypotheses with
| [] ->
fail #a "No matching hypothesis"
| h :: hs ->
or_else // Must be in ``Tac`` here to run `body`
(fun () ->
match interp_pattern_aux pat part_sol.ms_vars (type_of_binding h) with
| Failure ex ->
fail ("Failed to match hyp: " ^ (string_of_match_exception ex))
| Success bindings ->
let ms_hyps = (name, h) :: part_sol.ms_hyps in
body ({ part_sol with ms_vars = bindings; ms_hyps = ms_hyps }))
(fun () ->
solve_mp_for_single_hyp name pat hs body part_sol)
(** Scan ``hypotheses`` for matches for ``mp_hyps`` that lets ``body``
succeed. **)
let rec solve_mp_for_hyps #a
(mp_hyps: list (varname * pattern))
(hypotheses: list hypothesis)
(body: matching_solution -> Tac a)
(partial_solution: matching_solution)
: Tac a =
match mp_hyps with
| [] -> body partial_solution
| (name, pat) :: pats ->
solve_mp_for_single_hyp name pat hypotheses
(solve_mp_for_hyps pats hypotheses body)
partial_solution
(** Solve a matching problem.
The solution returned is constructed to ensure that the continuation ``body``
succeeds: this implements the usual backtracking-match semantics. **)
let solve_mp #a (problem: matching_problem)
(hypotheses: list hypothesis) (goal: term)
(body: matching_solution -> Tac a)
: Tac a =
let goal_ps =
match problem.mp_goal with
| None -> { ms_vars = []; ms_hyps = [] }
| Some pat ->
match interp_pattern pat goal with
| Failure ex -> fail ("Failed to match goal: " ^ (string_of_match_exception ex))
| Success bindings -> { ms_vars = bindings; ms_hyps = [] } in
solve_mp_for_hyps #a problem.mp_hyps hypotheses body goal_ps
/// A DSL for pattern-matching
/// ==========================
///
/// Using pattern-matching problems as defined above is relatively cumbersome,
/// so we now introduce a lightweight notation, in two steps: pattern notations,
/// and matching-problem notations.
///
/// Pattern notations
/// -----------------
///
/// The first part of our pattern-matching syntax is pattern notations: we
/// provide a reflective function which constructs a pattern from a term:
/// variables are holes, free variables are constants, and applications are
/// application patterns.
(* FIXME: MOVE *)
let name_of_namedv (x:namedv) : Tac string =
unseal (inspect_namedv x).ppname
(** Compile a term `tm` into a pattern. **)
let rec pattern_of_term_ex tm : Tac (match_res pattern) =
match inspect tm with
| Tv_Var bv ->
return (PVar (name_of_namedv bv))
| Tv_FVar fv
| Tv_UInst fv _ ->
let qn = fv_to_string fv in
return (PQn qn)
| Tv_Type _ ->
return PType
| Tv_App f (x, _) ->
let? fpat = pattern_of_term_ex f in
let? xpat = pattern_of_term_ex x in
return (PApp fpat xpat)
| _ -> raise (UnsupportedTermInPattern tm)
(** β-reduce a term `tm`.
This is useful to remove needles function applications introduced by F*, like
``(fun a b c -> a) 1 2 3``. **)
let beta_reduce (tm: term) : Tac term =
norm_term [] tm
(** Compile a term `tm` into a pattern. **)
let pattern_of_term tm : Tac pattern =
match pattern_of_term_ex tm with
| Success bb -> bb
| Failure ex -> Tactics.fail (string_of_match_exception ex)
/// Problem notations
/// -----------------
///
/// We then introduce a DSL for matching problems, best explained on the
/// following example::
///
/// (fun (a b c: ①) (h1 h2 h3: hyp ②) (g: pm_goal ③) → ④)
///
/// This notation is intended to express a pattern-matching problems with three
/// holes ``a``, ``b``, and ``c`` of type ①, matching hypotheses ``h1``, ``h2``,
/// and ``h3`` against pattern ② and the goal against the pattern ③. The body
/// of the notation (④) is then run with appropriate terms bound to ``a``,
/// ``b``, and ``c``, appropriate binders bound to ``h1``, ``h2``, and ``h3``,
/// and ``()`` bound to ``g``.
///
/// We call these patterns ``abspat``s (abstraction patterns), and we provide
/// facilities to parse them into matching problems, and to run their bodies
/// against a particular matching solution.
// We used to annotate variables with an explicit 'var' marker, but then that
// var annotation leaked into the types of other hypotheses due to type
// inference, requiring non-trivial normalization.
// let var (a: Type) = a
let hyp (a: Type) = binding
let pm_goal (a: Type) = unit
let hyp_qn = `%hyp
let goal_qn = `%pm_goal
noeq type abspat_binder_kind =
| ABKVar of typ
| ABKHyp
| ABKGoal | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.String.fsti.checked",
"FStar.Squash.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.PatternMatching.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: FStar.Tactics.PatternMatching.abspat_binder_kind -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"FStar.Tactics.PatternMatching.abspat_binder_kind",
"FStar.Stubs.Reflection.Types.typ",
"Prims.string"
] | [] | false | false | false | true | false | let string_of_abspat_binder_kind =
| function
| ABKVar _ -> "varname"
| ABKHyp -> "hyp"
| ABKGoal -> "goal" | false |
|
MerkleTree.Spec.fst | MerkleTree.Spec.mt_next_lv | val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1)) | val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1)) | let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 62,
"end_line": 99,
"start_col": 0,
"start_line": 99
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | mt: MerkleTree.Spec.merkle_tree n -> Prims.GTot (MerkleTree.Spec.merkle_tree (n - 1)) | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"MerkleTree.Spec.merkle_tree",
"MerkleTree.Spec.hs_next_lv",
"Prims.pow2",
"Prims.op_Subtraction"
] | [] | false | false | false | false | false | let mt_next_lv #_ #f #n mt =
| hs_next_lv #_ #f #(pow2 (n - 1)) mt | false |
Hacl.Spec.SHA2.Lemmas.fst | Hacl.Spec.SHA2.Lemmas.transpose_ws8_lemma_ij | val transpose_ws8_lemma_ij:
#a:sha2_alg
-> #m:m_spec{lanes a m == 8}
-> ws:ws_spec a m
-> j:nat{j < lanes a m}
-> i:nat{i < 16} ->
Lemma
(let l = lanes a m in
(vec_v (transpose_ws8 ws).[i]).[j] == (vec_v ws.[i / l * l + j]).[i % l]) | val transpose_ws8_lemma_ij:
#a:sha2_alg
-> #m:m_spec{lanes a m == 8}
-> ws:ws_spec a m
-> j:nat{j < lanes a m}
-> i:nat{i < 16} ->
Lemma
(let l = lanes a m in
(vec_v (transpose_ws8 ws).[i]).[j] == (vec_v ws.[i / l * l + j]).[i % l]) | let transpose_ws8_lemma_ij #a #m ws j i =
let l = lanes a m in
let i_sub = i / l in
let j_sub = i % l in
assert (i_sub * l + j_sub == i);
let vs = sub ws (i_sub * l) l in
eq_intro (sub (transpose_ws8 ws) (i_sub * l) l) (transpose8x8_lseq vs);
assert ((vec_v (transpose_ws8 ws).[i]).[j] == (vec_v (transpose8x8_lseq vs).[j_sub]).[j]);
transpose8x8_lemma vs;
assert ((vec_v (transpose_ws8 ws).[i]).[j] == (vec_v ws.[i_sub * lanes a m + j]).[j_sub]) | {
"file_name": "code/sha2-mb/Hacl.Spec.SHA2.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 91,
"end_line": 61,
"start_col": 0,
"start_line": 51
} | module Hacl.Spec.SHA2.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.IntVector
open Lib.IntVector.Transpose
open Spec.Hash.Definitions
open Hacl.Spec.SHA2.Vec
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1"
val transpose_ws4_lemma_ij:
#a:sha2_alg
-> #m:m_spec{lanes a m == 4} // lanes a m * lanes a m = 16
-> ws:ws_spec a m
-> j:nat{j < lanes a m}
-> i:nat{i < 16} ->
Lemma
(let l = lanes a m in
(vec_v (transpose_ws4 ws).[i]).[j] == (vec_v ws.[i / l * l + j]).[i % l])
let transpose_ws4_lemma_ij #a #m ws j i =
let l = lanes a m in
let i_sub = i / l in
let j_sub = i % l in
assert (i_sub * l + j_sub == i);
let vs = sub ws (i_sub * l) l in
eq_intro (sub (transpose_ws4 ws) (i_sub * l) l) (transpose4x4_lseq vs);
//assert ((transpose_ws4 ws).[i] == (sub (transpose_ws4 ws) (i_sub * l) l).[j_sub]);
//assert ((transpose_ws4 ws).[i] == (transpose4x4_lseq vs).[j_sub]);
assert ((vec_v (transpose_ws4 ws).[i]).[j] == (vec_v (transpose4x4_lseq vs).[j_sub]).[j]);
transpose4x4_lemma vs;
assert ((vec_v (transpose_ws4 ws).[i]).[j] == (vec_v vs.[j]).[j_sub]);
assert ((vec_v (transpose_ws4 ws).[i]).[j] == (vec_v ws.[i_sub * l + j]).[j_sub])
val transpose_ws8_lemma_ij:
#a:sha2_alg
-> #m:m_spec{lanes a m == 8}
-> ws:ws_spec a m
-> j:nat{j < lanes a m}
-> i:nat{i < 16} ->
Lemma
(let l = lanes a m in
(vec_v (transpose_ws8 ws).[i]).[j] == (vec_v ws.[i / l * l + j]).[i % l]) | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.Transpose.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.SHA2.Vec.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.SHA2.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.SHA2.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector.Transpose",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"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.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
ws: Hacl.Spec.SHA2.Vec.ws_spec a m ->
j: Prims.nat{j < Hacl.Spec.SHA2.Vec.lanes a m} ->
i: Prims.nat{i < 16}
-> FStar.Pervasives.Lemma
(ensures
(let l = Hacl.Spec.SHA2.Vec.lanes a m in
(Lib.IntVector.vec_v (Hacl.Spec.SHA2.Vec.transpose_ws8 ws).[ i ]).[ j ] ==
(Lib.IntVector.vec_v ws.[ (i / l) * l + j ]).[ i % l ])) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Spec.Hash.Definitions.sha2_alg",
"Hacl.Spec.SHA2.Vec.m_spec",
"Prims.eq2",
"Prims.int",
"Hacl.Spec.SHA2.Vec.lanes",
"Hacl.Spec.SHA2.Vec.ws_spec",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims._assert",
"Lib.IntTypes.uint_t",
"Spec.Hash.Definitions.word_t",
"Lib.IntTypes.SEC",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.IntVector.vec_v",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.SHA2.Vec.element_t",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Hacl.Spec.SHA2.Vec.transpose_ws8",
"Prims.unit",
"Lib.IntVector.Transpose.transpose8x8_lemma",
"Lib.IntVector.vec_t",
"Lib.IntVector.Transpose.transpose8x8_lseq",
"Lib.Sequence.eq_intro",
"Lib.Sequence.sub",
"Lib.Sequence.lseq",
"Prims.l_and",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.slice",
"Prims.op_Multiply",
"Prims.l_Forall",
"Lib.Sequence.index",
"Prims.op_Modulus",
"Prims.op_Division",
"Hacl.Spec.SHA2.Vec.lanes_t"
] | [] | true | false | true | false | false | let transpose_ws8_lemma_ij #a #m ws j i =
| let l = lanes a m in
let i_sub = i / l in
let j_sub = i % l in
assert (i_sub * l + j_sub == i);
let vs = sub ws (i_sub * l) l in
eq_intro (sub (transpose_ws8 ws) (i_sub * l) l) (transpose8x8_lseq vs);
assert ((vec_v (transpose_ws8 ws).[ i ]).[ j ] == (vec_v (transpose8x8_lseq vs).[ j_sub ]).[ j ]);
transpose8x8_lemma vs;
assert ((vec_v (transpose_ws8 ws).[ i ]).[ j ] == (vec_v ws.[ i_sub * lanes a m + j ]).[ j_sub ]) | false |
MerkleTree.Spec.fst | MerkleTree.Spec.sha256_compress | val sha256_compress: hash_fun_t #32 | val sha256_compress: hash_fun_t #32 | let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc () | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 40,
"end_line": 23,
"start_col": 0,
"start_line": 18
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz) | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | MerkleTree.Spec.hash_fun_t | Prims.Tot | [
"total"
] | [] | [
"MerkleTree.Spec.hash",
"Spec.Agile.Hash.finish",
"Spec.Hash.Definitions.words_state",
"Spec.Agile.Hash.update",
"FStar.Seq.Base.append",
"Lib.IntTypes.uint8",
"Spec.Hash.Definitions.init_t",
"Spec.Agile.Hash.init",
"Spec.Hash.Definitions.hash_alg",
"Spec.Hash.Definitions.SHA2_256"
] | [] | false | false | false | false | false | let sha256_compress src1 src2 =
| let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc () | false |
GradedMonad.fst | GradedMonad.monoid_nat_plus | [@@ FStar.Tactics.Typeclasses.tcinstance]
val monoid_nat_plus:monoid nat | [@@ FStar.Tactics.Typeclasses.tcinstance]
val monoid_nat_plus:monoid nat | instance monoid_nat_plus : monoid nat =
{
op = (fun (x y:nat) -> x + y);
one = 0;
properties = ()
} | {
"file_name": "examples/typeclasses/GradedMonad.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 1,
"end_line": 26,
"start_col": 0,
"start_line": 21
} | module GradedMonad
(* NB: this is the old version of the graded monad that has a monoid
index parameter everywhere instead of a constraint on the type. We
keep it for CI purposes. See doc/book/code/GradedMonad.fst for better
version. *)
#set-options "--warn_error -350"
//SNIPPET_START:monoid$
class monoid (a:Type) =
{
op : a -> a -> a;
one : a;
properties: squash (
(forall (x:a). op one x == x /\ op x one == x) /\
(forall (x y z:a). op x (op y z) == op (op x y) z)
);
} | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "GradedMonad.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | GradedMonad.monoid Prims.nat | Prims.Tot | [
"total"
] | [] | [
"GradedMonad.Mkmonoid",
"Prims.nat",
"Prims.op_Addition"
] | [] | false | false | false | true | false | [@@ FStar.Tactics.Typeclasses.tcinstance]
let monoid_nat_plus:monoid nat =
| { op = (fun (x: nat) (y: nat) -> x + y); one = 0; properties = () } | false |
MerkleTree.Spec.fst | MerkleTree.Spec.mt_next_lv_mt_right | val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt))) | val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt))) | let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1)) | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 69,
"end_line": 109,
"start_col": 0,
"start_line": 108
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n -> | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | mt: MerkleTree.Spec.merkle_tree n
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.equal (MerkleTree.Spec.mt_next_lv (MerkleTree.Spec.mt_right mt))
(MerkleTree.Spec.mt_right (MerkleTree.Spec.mt_next_lv mt))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"MerkleTree.Spec.merkle_tree",
"MerkleTree.Spec.hs_next_lv_slice",
"Prims.pow2",
"Prims.op_Subtraction",
"Prims.unit"
] | [] | true | false | true | false | false | let mt_next_lv_mt_right #hsz #f #n mt =
| hs_next_lv_slice #hsz #f #(pow2 (n - 1)) mt (pow2 (n - 2)) (pow2 (n - 1)) | false |
MerkleTree.Spec.fst | MerkleTree.Spec.mt_next_rel | val mt_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
GTot Type0 | val mt_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
GTot Type0 | let mt_next_rel #hsz #f n mt nmt =
hs_next_rel #hsz #f (pow2 (n-1)) mt nmt | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 41,
"end_line": 160,
"start_col": 0,
"start_line": 159
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1))
val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2)))
let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]);
assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]);
assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i])
val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2))
(S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2)))
let mt_next_lv_equiv #hsz #f j n mt1 mt2 =
hs_next_lv_equiv #_ #f j (pow2 (n-1)) mt1 mt2
val hs_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes #hsz {S.length hs = 2 * n} ->
nhs:hashes #hsz {S.length nhs = n} ->
GTot Type0
let hs_next_rel #hsz #f n hs nhs =
forall (i:nat{i < n}).
S.index nhs i ==
padded_hash_fun #hsz f (S.index hs (2 * i)) (S.index hs (2 * i + 1))
val mt_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) -> | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | n: Prims.pos -> mt: MerkleTree.Spec.merkle_tree n -> nmt: MerkleTree.Spec.merkle_tree (n - 1)
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"MerkleTree.Spec.merkle_tree",
"Prims.op_Subtraction",
"MerkleTree.Spec.hs_next_rel",
"Prims.pow2"
] | [] | false | false | false | false | true | let mt_next_rel #hsz #f n mt nmt =
| hs_next_rel #hsz #f (pow2 (n - 1)) mt nmt | false |
MerkleTree.Spec.fst | MerkleTree.Spec.mt_right | val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1) | val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1) | let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n) | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 56,
"end_line": 61,
"start_col": 0,
"start_line": 61
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1)) | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | mt: MerkleTree.Spec.merkle_tree n -> MerkleTree.Spec.merkle_tree (n - 1) | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.merkle_tree",
"FStar.Seq.Base.slice",
"MerkleTree.Spec.padded_hash",
"Prims.pow2",
"Prims.op_Subtraction"
] | [] | false | false | false | false | false | let mt_right #_ #n mt =
| S.slice mt (pow2 (n - 1)) (pow2 n) | false |
MerkleTree.Spec.fst | MerkleTree.Spec.hs_next_rel | val hs_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes #hsz {S.length hs = 2 * n} ->
nhs:hashes #hsz {S.length nhs = n} ->
GTot Type0 | val hs_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes #hsz {S.length hs = 2 * n} ->
nhs:hashes #hsz {S.length nhs = n} ->
GTot Type0 | let hs_next_rel #hsz #f n hs nhs =
forall (i:nat{i < n}).
S.index nhs i ==
padded_hash_fun #hsz f (S.index hs (2 * i)) (S.index hs (2 * i + 1)) | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 72,
"end_line": 151,
"start_col": 0,
"start_line": 148
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1))
val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2)))
let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]);
assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]);
assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i])
val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2))
(S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2)))
let mt_next_lv_equiv #hsz #f j n mt1 mt2 =
hs_next_lv_equiv #_ #f j (pow2 (n-1)) mt1 mt2
val hs_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes #hsz {S.length hs = 2 * n} ->
nhs:hashes #hsz {S.length nhs = n} -> | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
n: Prims.nat ->
hs: MerkleTree.Spec.hashes{FStar.Seq.Base.length hs = 2 * n} ->
nhs: MerkleTree.Spec.hashes{FStar.Seq.Base.length nhs = n}
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"MerkleTree.Spec.hashes",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"MerkleTree.Spec.padded_hash",
"FStar.Mul.op_Star",
"Prims.l_Forall",
"Prims.op_LessThan",
"Prims.eq2",
"FStar.Seq.Base.index",
"MerkleTree.Spec.padded_hash_fun",
"Prims.op_Addition"
] | [] | false | false | false | false | true | let hs_next_rel #hsz #f n hs nhs =
| forall (i: nat{i < n}).
S.index nhs i == padded_hash_fun #hsz f (S.index hs (2 * i)) (S.index hs (2 * i + 1)) | false |
MerkleTree.Spec.fst | MerkleTree.Spec.mt_next_lv_equiv | val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2))
(S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2))) | val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2))
(S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2))) | let mt_next_lv_equiv #hsz #f j n mt1 mt2 =
hs_next_lv_equiv #_ #f j (pow2 (n-1)) mt1 mt2 | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 47,
"end_line": 140,
"start_col": 0,
"start_line": 139
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1))
val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2)))
let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]);
assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]);
assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i])
val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2)) | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
j: Prims.nat ->
n: Prims.pos{j <= Prims.pow2 n} ->
mt1: MerkleTree.Spec.merkle_tree n ->
mt2: MerkleTree.Spec.merkle_tree n
-> FStar.Pervasives.Lemma
(requires FStar.Seq.Base.equal (FStar.Seq.Base.slice mt1 0 j) (FStar.Seq.Base.slice mt2 0 j))
(ensures
FStar.Seq.Base.equal (FStar.Seq.Base.slice (MerkleTree.Spec.mt_next_lv mt1) 0 (j / 2))
(FStar.Seq.Base.slice (MerkleTree.Spec.mt_next_lv mt2) 0 (j / 2))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.pow2",
"MerkleTree.Spec.merkle_tree",
"MerkleTree.Spec.hs_next_lv_equiv",
"Prims.op_Subtraction",
"Prims.unit"
] | [] | true | false | true | false | false | let mt_next_lv_equiv #hsz #f j n mt1 mt2 =
| hs_next_lv_equiv #_ #f j (pow2 (n - 1)) mt1 mt2 | false |
Hacl.Spec.SHA2.Lemmas.fst | Hacl.Spec.SHA2.Lemmas.transpose_state4_lemma | val transpose_state4_lemma:
#a:sha2_alg
-> #m:m_spec{lanes a m == 4}
-> st:state_spec a m
-> j:nat{j < lanes a m}
-> i:nat{i < 8 * word_length a} ->
Lemma
(let l = lanes a m in
let ind = 8 * j + i / word_length a in
Seq.index (vec_v (transpose_state st).[ind / l]) (ind % l) ==
Seq.index (state_spec_v st).[j] (i / word_length a)) | val transpose_state4_lemma:
#a:sha2_alg
-> #m:m_spec{lanes a m == 4}
-> st:state_spec a m
-> j:nat{j < lanes a m}
-> i:nat{i < 8 * word_length a} ->
Lemma
(let l = lanes a m in
let ind = 8 * j + i / word_length a in
Seq.index (vec_v (transpose_state st).[ind / l]) (ind % l) ==
Seq.index (state_spec_v st).[j] (i / word_length a)) | let transpose_state4_lemma #a #m st j i =
let r0 = transpose4x4_lseq (sub st 0 4) in
transpose4x4_lemma (sub st 0 4);
let r1 = transpose4x4_lseq (sub st 4 4) in
transpose4x4_lemma (sub st 4 4) | {
"file_name": "code/sha2-mb/Hacl.Spec.SHA2.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 33,
"end_line": 98,
"start_col": 0,
"start_line": 94
} | module Hacl.Spec.SHA2.Lemmas
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.IntVector
open Lib.IntVector.Transpose
open Spec.Hash.Definitions
open Hacl.Spec.SHA2.Vec
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1"
val transpose_ws4_lemma_ij:
#a:sha2_alg
-> #m:m_spec{lanes a m == 4} // lanes a m * lanes a m = 16
-> ws:ws_spec a m
-> j:nat{j < lanes a m}
-> i:nat{i < 16} ->
Lemma
(let l = lanes a m in
(vec_v (transpose_ws4 ws).[i]).[j] == (vec_v ws.[i / l * l + j]).[i % l])
let transpose_ws4_lemma_ij #a #m ws j i =
let l = lanes a m in
let i_sub = i / l in
let j_sub = i % l in
assert (i_sub * l + j_sub == i);
let vs = sub ws (i_sub * l) l in
eq_intro (sub (transpose_ws4 ws) (i_sub * l) l) (transpose4x4_lseq vs);
//assert ((transpose_ws4 ws).[i] == (sub (transpose_ws4 ws) (i_sub * l) l).[j_sub]);
//assert ((transpose_ws4 ws).[i] == (transpose4x4_lseq vs).[j_sub]);
assert ((vec_v (transpose_ws4 ws).[i]).[j] == (vec_v (transpose4x4_lseq vs).[j_sub]).[j]);
transpose4x4_lemma vs;
assert ((vec_v (transpose_ws4 ws).[i]).[j] == (vec_v vs.[j]).[j_sub]);
assert ((vec_v (transpose_ws4 ws).[i]).[j] == (vec_v ws.[i_sub * l + j]).[j_sub])
val transpose_ws8_lemma_ij:
#a:sha2_alg
-> #m:m_spec{lanes a m == 8}
-> ws:ws_spec a m
-> j:nat{j < lanes a m}
-> i:nat{i < 16} ->
Lemma
(let l = lanes a m in
(vec_v (transpose_ws8 ws).[i]).[j] == (vec_v ws.[i / l * l + j]).[i % l])
let transpose_ws8_lemma_ij #a #m ws j i =
let l = lanes a m in
let i_sub = i / l in
let j_sub = i % l in
assert (i_sub * l + j_sub == i);
let vs = sub ws (i_sub * l) l in
eq_intro (sub (transpose_ws8 ws) (i_sub * l) l) (transpose8x8_lseq vs);
assert ((vec_v (transpose_ws8 ws).[i]).[j] == (vec_v (transpose8x8_lseq vs).[j_sub]).[j]);
transpose8x8_lemma vs;
assert ((vec_v (transpose_ws8 ws).[i]).[j] == (vec_v ws.[i_sub * lanes a m + j]).[j_sub])
val transpose_ws_lemma_ij:
#a:sha2_alg
-> #m:m_spec{is_supported a m}
-> ws:ws_spec a m
-> j:nat{j < lanes a m}
-> i:nat{i < 16} ->
Lemma
(let l = lanes a m in
((ws_spec_v (transpose_ws ws)).[j]).[i] == (vec_v ws.[i / l * l + j]).[i % l])
let transpose_ws_lemma_ij #a #m ws j i =
assert (((ws_spec_v (transpose_ws ws)).[j]).[i] == (vec_v (transpose_ws ws).[i]).[j]);
match lanes a m with
| 1 -> ()
| 4 -> transpose_ws4_lemma_ij #a #m ws j i
| 8 -> transpose_ws8_lemma_ij #a #m ws j i
val transpose_state4_lemma:
#a:sha2_alg
-> #m:m_spec{lanes a m == 4}
-> st:state_spec a m
-> j:nat{j < lanes a m}
-> i:nat{i < 8 * word_length a} ->
Lemma
(let l = lanes a m in
let ind = 8 * j + i / word_length a in
Seq.index (vec_v (transpose_state st).[ind / l]) (ind % l) ==
Seq.index (state_spec_v st).[j] (i / word_length a)) | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.Transpose.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.SHA2.Vec.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.SHA2.Lemmas.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.SHA2.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector.Transpose",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"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.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
st: Hacl.Spec.SHA2.Vec.state_spec a m ->
j: Prims.nat{j < Hacl.Spec.SHA2.Vec.lanes a m} ->
i: Prims.nat{i < 8 * Spec.Hash.Definitions.word_length a}
-> FStar.Pervasives.Lemma
(ensures
(let l = Hacl.Spec.SHA2.Vec.lanes a m in
let ind = 8 * j + i / Spec.Hash.Definitions.word_length a in
FStar.Seq.Base.index (Lib.IntVector.vec_v (Hacl.Spec.SHA2.Vec.transpose_state st).[ ind / l
])
(ind % l) ==
FStar.Seq.Base.index (Hacl.Spec.SHA2.Vec.state_spec_v st).[ j ]
(i / Spec.Hash.Definitions.word_length a))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Spec.Hash.Definitions.sha2_alg",
"Hacl.Spec.SHA2.Vec.m_spec",
"Prims.eq2",
"Prims.int",
"Hacl.Spec.SHA2.Vec.lanes",
"Hacl.Spec.SHA2.Vec.state_spec",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Mul.op_Star",
"Spec.Hash.Definitions.word_length",
"Lib.IntVector.Transpose.transpose4x4_lemma",
"Spec.Hash.Definitions.word_t",
"Lib.Sequence.sub",
"Hacl.Spec.SHA2.Vec.element_t",
"Lib.Sequence.lseq",
"Lib.IntVector.vec_t",
"Lib.IntVector.Transpose.transpose4x4_lseq",
"Prims.unit"
] | [] | true | false | true | false | false | let transpose_state4_lemma #a #m st j i =
| let r0 = transpose4x4_lseq (sub st 0 4) in
transpose4x4_lemma (sub st 0 4);
let r1 = transpose4x4_lseq (sub st 4 4) in
transpose4x4_lemma (sub st 4 4) | false |
MerkleTree.Spec.fst | MerkleTree.Spec.hs_next_lv | val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n}) | val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n}) | let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs))) | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 60,
"end_line": 72,
"start_col": 0,
"start_line": 68
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = () | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | hs: MerkleTree.Spec.hashes{FStar.Seq.Base.length hs = 2 * n}
-> Prims.GTot (nhs: MerkleTree.Spec.hashes{FStar.Seq.Base.length nhs = n}) | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"MerkleTree.Spec.hashes",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"MerkleTree.Spec.padded_hash",
"FStar.Mul.op_Star",
"FStar.Seq.Base.empty",
"Prims.bool",
"FStar.Seq.Base.cons",
"MerkleTree.Spec.padded_hash_fun",
"MerkleTree.Spec.op_String_Access",
"MerkleTree.Spec.hs_next_lv",
"Prims.op_Subtraction",
"FStar.Seq.Base.slice"
] | [
"recursion"
] | false | false | false | false | false | let rec hs_next_lv #hsz #f #n hs =
| if n = 0
then S.empty
else
S.cons (padded_hash_fun #hsz f hs.[ 0 ] hs.[ 1 ])
(hs_next_lv #hsz #f #(n - 1) (S.slice hs 2 (S.length hs))) | false |
MerkleTree.Spec.fst | MerkleTree.Spec.mt_get_root | val mt_get_root:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n -> GTot (padded_hash #hsz) | val mt_get_root:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n -> GTot (padded_hash #hsz) | let rec mt_get_root #hsz #f #n mt =
if n = 0 then mt.[0]
else mt_get_root #_ #f (mt_next_lv #_ #f mt) | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 46,
"end_line": 230,
"start_col": 0,
"start_line": 228
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1))
val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2)))
let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]);
assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]);
assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i])
val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2))
(S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2)))
let mt_next_lv_equiv #hsz #f j n mt1 mt2 =
hs_next_lv_equiv #_ #f j (pow2 (n-1)) mt1 mt2
val hs_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes #hsz {S.length hs = 2 * n} ->
nhs:hashes #hsz {S.length nhs = n} ->
GTot Type0
let hs_next_rel #hsz #f n hs nhs =
forall (i:nat{i < n}).
S.index nhs i ==
padded_hash_fun #hsz f (S.index hs (2 * i)) (S.index hs (2 * i + 1))
val mt_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
GTot Type0
let mt_next_rel #hsz #f n mt nmt =
hs_next_rel #hsz #f (pow2 (n-1)) mt nmt
val hs_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes{S.length hs = 2 * n} ->
nhs:hashes{S.length nhs = n} ->
Lemma (requires hs_next_rel #_ #f n hs nhs)
(ensures S.equal nhs (hs_next_lv #_ #f #n hs))
let rec hs_next_rel_next_lv #hsz #f n hs nhs =
if n = 0 then ()
else hs_next_rel_next_lv #_ #f (n - 1)
(S.slice hs 2 (S.length hs))
(S.slice nhs 1 (S.length nhs))
val mt_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures S.equal nmt (mt_next_lv #_ #f mt))
let mt_next_rel_next_lv #hsz #f n mt nmt =
hs_next_rel_next_lv #_ #f (pow2 (n-1)) mt nmt
val mt_next_rel_upd_even:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i) v)
(S.upd nmt i (padded_hash_fun #hsz f v (S.index mt (2 * i + 1)))))
let mt_next_rel_upd_even #hsz #f n mt nmt i v = ()
#push-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
val mt_next_rel_upd_even_pad:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash #hsz ->
Lemma (requires (mt_next_rel #_ #f n mt nmt) /\ (S.index mt (2 * i + 1) == HPad))
(ensures (mt_next_rel #_ #f n (S.upd mt (2 * i) v) (S.upd nmt i v)))
let mt_next_rel_upd_even_pad #hsz #f n mt nmt i v = ()
#pop-options
val mt_next_rel_upd_odd:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i + 1) v)
(S.upd nmt i (padded_hash_fun #_ f (S.index mt (2 * i)) v)))
let mt_next_rel_upd_odd #hsz #f n mt nmt i v = ()
// fournet: just [root]?
val mt_get_root:
#hsz:pos -> #f:hash_fun_t #hsz -> | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | mt: MerkleTree.Spec.merkle_tree n -> Prims.GTot MerkleTree.Spec.padded_hash | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"MerkleTree.Spec.merkle_tree",
"Prims.op_Equality",
"Prims.int",
"MerkleTree.Spec.op_String_Access",
"Prims.bool",
"MerkleTree.Spec.mt_get_root",
"Prims.op_Subtraction",
"MerkleTree.Spec.mt_next_lv",
"MerkleTree.Spec.padded_hash"
] | [
"recursion"
] | false | false | false | false | false | let rec mt_get_root #hsz #f #n mt =
| if n = 0 then mt.[ 0 ] else mt_get_root #_ #f (mt_next_lv #_ #f mt) | false |
MerkleTree.Spec.fst | MerkleTree.Spec.rpmt | val rpmt : n: Prims.nat -> i: Prims.nat{i <= Prims.pow2 n} -> Type0 | let rpmt (#hsz:pos) (#f:hash_fun_t) (n:nat) (i:nat{i <= pow2 n}) =
mt:merkle_tree #hsz n {
raw_hashes #_ #f (S.slice mt 0 i) /\
pad_hashes #_ #f (S.slice mt i (S.length mt)) } | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 51,
"end_line": 385,
"start_col": 0,
"start_line": 382
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1))
val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2)))
let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]);
assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]);
assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i])
val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2))
(S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2)))
let mt_next_lv_equiv #hsz #f j n mt1 mt2 =
hs_next_lv_equiv #_ #f j (pow2 (n-1)) mt1 mt2
val hs_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes #hsz {S.length hs = 2 * n} ->
nhs:hashes #hsz {S.length nhs = n} ->
GTot Type0
let hs_next_rel #hsz #f n hs nhs =
forall (i:nat{i < n}).
S.index nhs i ==
padded_hash_fun #hsz f (S.index hs (2 * i)) (S.index hs (2 * i + 1))
val mt_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
GTot Type0
let mt_next_rel #hsz #f n mt nmt =
hs_next_rel #hsz #f (pow2 (n-1)) mt nmt
val hs_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes{S.length hs = 2 * n} ->
nhs:hashes{S.length nhs = n} ->
Lemma (requires hs_next_rel #_ #f n hs nhs)
(ensures S.equal nhs (hs_next_lv #_ #f #n hs))
let rec hs_next_rel_next_lv #hsz #f n hs nhs =
if n = 0 then ()
else hs_next_rel_next_lv #_ #f (n - 1)
(S.slice hs 2 (S.length hs))
(S.slice nhs 1 (S.length nhs))
val mt_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures S.equal nmt (mt_next_lv #_ #f mt))
let mt_next_rel_next_lv #hsz #f n mt nmt =
hs_next_rel_next_lv #_ #f (pow2 (n-1)) mt nmt
val mt_next_rel_upd_even:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i) v)
(S.upd nmt i (padded_hash_fun #hsz f v (S.index mt (2 * i + 1)))))
let mt_next_rel_upd_even #hsz #f n mt nmt i v = ()
#push-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
val mt_next_rel_upd_even_pad:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash #hsz ->
Lemma (requires (mt_next_rel #_ #f n mt nmt) /\ (S.index mt (2 * i + 1) == HPad))
(ensures (mt_next_rel #_ #f n (S.upd mt (2 * i) v) (S.upd nmt i v)))
let mt_next_rel_upd_even_pad #hsz #f n mt nmt i v = ()
#pop-options
val mt_next_rel_upd_odd:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i + 1) v)
(S.upd nmt i (padded_hash_fun #_ f (S.index mt (2 * i)) v)))
let mt_next_rel_upd_odd #hsz #f n mt nmt i v = ()
// fournet: just [root]?
val mt_get_root:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n -> GTot (padded_hash #hsz)
let rec mt_get_root #hsz #f #n mt =
if n = 0 then mt.[0]
else mt_get_root #_ #f (mt_next_lv #_ #f mt)
#push-options "--initial_fuel 2 --max_fuel 2"
val mt_get_root_step: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (mt_get_root #_ #f mt ==
padded_hash_fun #_ f (mt_get_root #_ #f (mt_left mt)) (mt_get_root #_ #f (mt_right mt)))
let rec mt_get_root_step #hsz #f #n mt =
if n = 1 then ()
else begin
mt_get_root_step #_ #f (mt_next_lv #_ #f mt);
mt_next_lv_mt_left #_ #f mt;
mt_next_lv_mt_right #_ #f mt
end
#pop-options
type path #hsz n = S.lseq (padded_hash #hsz) n
/// We first specify full paths, including padding.
val mt_get_path:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
mt:merkle_tree #hsz n -> i:nat{i < pow2 n} -> GTot (path #hsz n)
let rec mt_get_path #hsz #f #n t i =
if n = 0 then S.empty
else S.cons
(if i % 2 = 0 then t.[i + 1] else t.[i - 1])
(mt_get_path #_ #f (mt_next_lv #_ #f t) (i / 2))
val mt_verify_:
#hsz:pos -> #f:hash_fun_t #hsz ->#n:nat ->
p:path #hsz n -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> GTot (padded_hash #hsz)
let rec mt_verify_ #hsz #f #n p idx h =
if n = 0 then h
else mt_verify_ #_ #f #(n-1) (S.tail p) (idx / 2)
(if idx % 2 = 0
then padded_hash_fun #_ f h (S.head p)
else padded_hash_fun #_ f (S.head p) h)
val mt_verify:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
p:(path #hsz n) -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> padded_hash #hsz -> GTot prop
let mt_verify #hsz #f #n p idx h rt =
rt == mt_verify_ #_ #f p idx h
/// Correctness: the root of a tree is correctly recomputed from any of its paths
val hs_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
hs:hashes{S.length hs = 2 * n} -> idx:nat{idx < 2 * n} ->
Lemma ((hs_next_lv #_ #f #n hs).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f hs.[idx] hs.[idx + 1]
else padded_hash_fun #_ f hs.[idx - 1] hs.[idx]))
let rec hs_next_lv_get #hsz #f #n hs idx =
if idx < 2 then ()
else hs_next_lv_get #_ #f #(n-1) (S.slice hs 2 (S.length hs)) (idx - 2)
val mt_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} ->
Lemma (
(mt_next_lv #_ #f mt).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f mt.[idx] mt.[idx + 1]
else padded_hash_fun #_ f mt.[idx - 1] mt.[idx]))
let mt_next_lv_get #hsz #f #n mt idx =
hs_next_lv_get #_ #f #(pow2 (n-1)) mt idx
val mt_get_path_ok_:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
t:merkle_tree #hsz n -> i:nat{i < pow2 n} ->
Lemma (mt_verify_ #_ #f (mt_get_path #_ #f t i) i (mt_get t i) == mt_get_root #_ #f t)
let rec mt_get_path_ok_ #hsz #f #n mt idx =
if n = 0 then ()
else begin
assert (S.head (mt_get_path #_ #f mt idx) ==
(if idx % 2 = 0 then mt.[idx + 1] else mt.[idx - 1]));
assert (S.equal (S.tail (mt_get_path #_ #f mt idx))
(mt_get_path #_ #f (mt_next_lv #_ #f mt) (idx / 2)));
mt_get_path_ok_ #_ #f (mt_next_lv #_ #f mt) (idx / 2);
mt_next_lv_get #_ #f mt idx
end
/// Security: we reduce tree collisions to collisions on the hash
/// compression function. Such collisions yield collisions on the SHA2
/// standard (by adding the same length and padding to the
/// accumulators).
///
/// One complication addressed in the proof is the handling of
/// implicit padding.
/// All hashes in a sequence are raw hashes, not padding
val raw_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes #hsz -> Tot Type0 (decreases (S.length hs))
let rec raw_hashes #hsz #f hs =
if S.length hs = 0 then True
else (HRaw? (S.head hs) /\ raw_hashes #_ #f (S.tail hs))
val raw_hashes_raws:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes{raw_hashes #hsz #f hs} ->
Tot (S.seq (hash #hsz)) (decreases (S.length hs))
let rec raw_hashes_raws #hsz #f hs =
if S.length hs = 0 then S.empty
else S.cons (HRaw?.hr (S.head hs)) (raw_hashes_raws #_ #f (S.tail hs))
val raw_hashes_index:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat{i < S.length hs} ->
Lemma (requires raw_hashes #_ #f hs)
(ensures HRaw? #hsz hs.[i])
(decreases i)
let rec raw_hashes_index #hsz #f hs i =
if i = 0 then ()
else raw_hashes_index #_ #f (S.tail hs) (i - 1)
val raw_hashes_slice:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat -> j:nat{i <= j && j <= S.length hs} ->
Lemma (requires raw_hashes #_ #f hs)
(ensures raw_hashes #_ #f (S.slice hs i j))
(decreases (j - i))
let rec raw_hashes_slice #hsz #f hs i j =
if i = j then ()
else (
raw_hashes_index #_ #f hs i;
raw_hashes_slice #_ #f hs (i + 1) j)
/// All hashes in a sequence are just padding
val pad_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes #hsz -> Type0
let pad_hashes #hsz #f hs =
S.equal hs (S.create (S.length hs) HPad)
val pad_hashes_slice:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat -> j:nat{i <= j && j <= S.length hs} ->
Lemma (requires pad_hashes #_ #f hs)
(ensures pad_hashes #_ #f (S.slice hs i j))
(decreases (j - i))
let rec pad_hashes_slice #hsz #f hs i j =
if i = j then ()
else pad_hashes_slice #_ #f hs (i + 1) j
/// Right-padded Merkle tree, a tree refinement | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | n: Prims.nat -> i: Prims.nat{i <= Prims.pow2 n} -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.pow2",
"MerkleTree.Spec.merkle_tree",
"Prims.l_and",
"MerkleTree.Spec.raw_hashes",
"FStar.Seq.Base.slice",
"MerkleTree.Spec.padded_hash",
"MerkleTree.Spec.pad_hashes",
"FStar.Seq.Base.length"
] | [] | false | false | false | false | true | let rpmt (#hsz: pos) (#f: hash_fun_t) (n: nat) (i: nat{i <= pow2 n}) =
| mt:
merkle_tree #hsz n
{raw_hashes #_ #f (S.slice mt 0 i) /\ pad_hashes #_ #f (S.slice mt i (S.length mt))} | false |
|
MerkleTree.Spec.fst | MerkleTree.Spec.mt_left | val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1) | val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1) | let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1)) | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 48,
"end_line": 58,
"start_col": 0,
"start_line": 58
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1" | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | mt: MerkleTree.Spec.merkle_tree n -> MerkleTree.Spec.merkle_tree (n - 1) | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.merkle_tree",
"FStar.Seq.Base.slice",
"MerkleTree.Spec.padded_hash",
"Prims.pow2",
"Prims.op_Subtraction"
] | [] | false | false | false | false | false | let mt_left #_ #n mt =
| S.slice mt 0 (pow2 (n - 1)) | false |
MerkleTree.Spec.fst | MerkleTree.Spec.hs_next_lv_index | val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1]) | val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1]) | let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1) | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 77,
"end_line": 78,
"start_col": 0,
"start_line": 76
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} -> | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | hs: MerkleTree.Spec.hashes{FStar.Seq.Base.length hs = 2 * n} -> i: Prims.nat{i < n}
-> FStar.Pervasives.Lemma
(ensures
(MerkleTree.Spec.hs_next_lv hs).[ i ] ==
MerkleTree.Spec.padded_hash_fun f hs.[ 2 * i ] hs.[ 2 * i + 1 ]) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"MerkleTree.Spec.hashes",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"MerkleTree.Spec.padded_hash",
"FStar.Mul.op_Star",
"Prims.op_LessThan",
"Prims.op_BarBar",
"Prims.bool",
"MerkleTree.Spec.hs_next_lv_index",
"Prims.op_Subtraction",
"FStar.Seq.Base.slice",
"Prims.unit"
] | [
"recursion"
] | false | false | true | false | false | let rec hs_next_lv_index #hsz #f #n hs i =
| if n = 0 || i = 0
then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1) | false |
MerkleTree.Spec.fst | MerkleTree.Spec.rpmt_get_root_pad_hashes | val rpmt_get_root_pad_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #_ #f n i ->
Lemma (pad_hashes #_ #f mt <==> HPad? (mt_get_root #_ #f mt)) | val rpmt_get_root_pad_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #_ #f n i ->
Lemma (pad_hashes #_ #f mt <==> HPad? (mt_get_root #_ #f mt)) | let rpmt_get_root_pad_hashes #_ #f #n #i mt =
rpmt_pad_hashes_index_0 #_ #f mt;
mt_get_root_pad_index_0 #_ #f mt | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 34,
"end_line": 465,
"start_col": 0,
"start_line": 463
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1))
val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2)))
let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]);
assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]);
assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i])
val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2))
(S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2)))
let mt_next_lv_equiv #hsz #f j n mt1 mt2 =
hs_next_lv_equiv #_ #f j (pow2 (n-1)) mt1 mt2
val hs_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes #hsz {S.length hs = 2 * n} ->
nhs:hashes #hsz {S.length nhs = n} ->
GTot Type0
let hs_next_rel #hsz #f n hs nhs =
forall (i:nat{i < n}).
S.index nhs i ==
padded_hash_fun #hsz f (S.index hs (2 * i)) (S.index hs (2 * i + 1))
val mt_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
GTot Type0
let mt_next_rel #hsz #f n mt nmt =
hs_next_rel #hsz #f (pow2 (n-1)) mt nmt
val hs_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes{S.length hs = 2 * n} ->
nhs:hashes{S.length nhs = n} ->
Lemma (requires hs_next_rel #_ #f n hs nhs)
(ensures S.equal nhs (hs_next_lv #_ #f #n hs))
let rec hs_next_rel_next_lv #hsz #f n hs nhs =
if n = 0 then ()
else hs_next_rel_next_lv #_ #f (n - 1)
(S.slice hs 2 (S.length hs))
(S.slice nhs 1 (S.length nhs))
val mt_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures S.equal nmt (mt_next_lv #_ #f mt))
let mt_next_rel_next_lv #hsz #f n mt nmt =
hs_next_rel_next_lv #_ #f (pow2 (n-1)) mt nmt
val mt_next_rel_upd_even:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i) v)
(S.upd nmt i (padded_hash_fun #hsz f v (S.index mt (2 * i + 1)))))
let mt_next_rel_upd_even #hsz #f n mt nmt i v = ()
#push-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
val mt_next_rel_upd_even_pad:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash #hsz ->
Lemma (requires (mt_next_rel #_ #f n mt nmt) /\ (S.index mt (2 * i + 1) == HPad))
(ensures (mt_next_rel #_ #f n (S.upd mt (2 * i) v) (S.upd nmt i v)))
let mt_next_rel_upd_even_pad #hsz #f n mt nmt i v = ()
#pop-options
val mt_next_rel_upd_odd:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i + 1) v)
(S.upd nmt i (padded_hash_fun #_ f (S.index mt (2 * i)) v)))
let mt_next_rel_upd_odd #hsz #f n mt nmt i v = ()
// fournet: just [root]?
val mt_get_root:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n -> GTot (padded_hash #hsz)
let rec mt_get_root #hsz #f #n mt =
if n = 0 then mt.[0]
else mt_get_root #_ #f (mt_next_lv #_ #f mt)
#push-options "--initial_fuel 2 --max_fuel 2"
val mt_get_root_step: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (mt_get_root #_ #f mt ==
padded_hash_fun #_ f (mt_get_root #_ #f (mt_left mt)) (mt_get_root #_ #f (mt_right mt)))
let rec mt_get_root_step #hsz #f #n mt =
if n = 1 then ()
else begin
mt_get_root_step #_ #f (mt_next_lv #_ #f mt);
mt_next_lv_mt_left #_ #f mt;
mt_next_lv_mt_right #_ #f mt
end
#pop-options
type path #hsz n = S.lseq (padded_hash #hsz) n
/// We first specify full paths, including padding.
val mt_get_path:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
mt:merkle_tree #hsz n -> i:nat{i < pow2 n} -> GTot (path #hsz n)
let rec mt_get_path #hsz #f #n t i =
if n = 0 then S.empty
else S.cons
(if i % 2 = 0 then t.[i + 1] else t.[i - 1])
(mt_get_path #_ #f (mt_next_lv #_ #f t) (i / 2))
val mt_verify_:
#hsz:pos -> #f:hash_fun_t #hsz ->#n:nat ->
p:path #hsz n -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> GTot (padded_hash #hsz)
let rec mt_verify_ #hsz #f #n p idx h =
if n = 0 then h
else mt_verify_ #_ #f #(n-1) (S.tail p) (idx / 2)
(if idx % 2 = 0
then padded_hash_fun #_ f h (S.head p)
else padded_hash_fun #_ f (S.head p) h)
val mt_verify:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
p:(path #hsz n) -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> padded_hash #hsz -> GTot prop
let mt_verify #hsz #f #n p idx h rt =
rt == mt_verify_ #_ #f p idx h
/// Correctness: the root of a tree is correctly recomputed from any of its paths
val hs_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
hs:hashes{S.length hs = 2 * n} -> idx:nat{idx < 2 * n} ->
Lemma ((hs_next_lv #_ #f #n hs).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f hs.[idx] hs.[idx + 1]
else padded_hash_fun #_ f hs.[idx - 1] hs.[idx]))
let rec hs_next_lv_get #hsz #f #n hs idx =
if idx < 2 then ()
else hs_next_lv_get #_ #f #(n-1) (S.slice hs 2 (S.length hs)) (idx - 2)
val mt_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} ->
Lemma (
(mt_next_lv #_ #f mt).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f mt.[idx] mt.[idx + 1]
else padded_hash_fun #_ f mt.[idx - 1] mt.[idx]))
let mt_next_lv_get #hsz #f #n mt idx =
hs_next_lv_get #_ #f #(pow2 (n-1)) mt idx
val mt_get_path_ok_:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
t:merkle_tree #hsz n -> i:nat{i < pow2 n} ->
Lemma (mt_verify_ #_ #f (mt_get_path #_ #f t i) i (mt_get t i) == mt_get_root #_ #f t)
let rec mt_get_path_ok_ #hsz #f #n mt idx =
if n = 0 then ()
else begin
assert (S.head (mt_get_path #_ #f mt idx) ==
(if idx % 2 = 0 then mt.[idx + 1] else mt.[idx - 1]));
assert (S.equal (S.tail (mt_get_path #_ #f mt idx))
(mt_get_path #_ #f (mt_next_lv #_ #f mt) (idx / 2)));
mt_get_path_ok_ #_ #f (mt_next_lv #_ #f mt) (idx / 2);
mt_next_lv_get #_ #f mt idx
end
/// Security: we reduce tree collisions to collisions on the hash
/// compression function. Such collisions yield collisions on the SHA2
/// standard (by adding the same length and padding to the
/// accumulators).
///
/// One complication addressed in the proof is the handling of
/// implicit padding.
/// All hashes in a sequence are raw hashes, not padding
val raw_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes #hsz -> Tot Type0 (decreases (S.length hs))
let rec raw_hashes #hsz #f hs =
if S.length hs = 0 then True
else (HRaw? (S.head hs) /\ raw_hashes #_ #f (S.tail hs))
val raw_hashes_raws:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes{raw_hashes #hsz #f hs} ->
Tot (S.seq (hash #hsz)) (decreases (S.length hs))
let rec raw_hashes_raws #hsz #f hs =
if S.length hs = 0 then S.empty
else S.cons (HRaw?.hr (S.head hs)) (raw_hashes_raws #_ #f (S.tail hs))
val raw_hashes_index:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat{i < S.length hs} ->
Lemma (requires raw_hashes #_ #f hs)
(ensures HRaw? #hsz hs.[i])
(decreases i)
let rec raw_hashes_index #hsz #f hs i =
if i = 0 then ()
else raw_hashes_index #_ #f (S.tail hs) (i - 1)
val raw_hashes_slice:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat -> j:nat{i <= j && j <= S.length hs} ->
Lemma (requires raw_hashes #_ #f hs)
(ensures raw_hashes #_ #f (S.slice hs i j))
(decreases (j - i))
let rec raw_hashes_slice #hsz #f hs i j =
if i = j then ()
else (
raw_hashes_index #_ #f hs i;
raw_hashes_slice #_ #f hs (i + 1) j)
/// All hashes in a sequence are just padding
val pad_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes #hsz -> Type0
let pad_hashes #hsz #f hs =
S.equal hs (S.create (S.length hs) HPad)
val pad_hashes_slice:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat -> j:nat{i <= j && j <= S.length hs} ->
Lemma (requires pad_hashes #_ #f hs)
(ensures pad_hashes #_ #f (S.slice hs i j))
(decreases (j - i))
let rec pad_hashes_slice #hsz #f hs i j =
if i = j then ()
else pad_hashes_slice #_ #f hs (i + 1) j
/// Right-padded Merkle tree, a tree refinement
let rpmt (#hsz:pos) (#f:hash_fun_t) (n:nat) (i:nat{i <= pow2 n}) =
mt:merkle_tree #hsz n {
raw_hashes #_ #f (S.slice mt 0 i) /\
pad_hashes #_ #f (S.slice mt i (S.length mt)) }
val rpmt_raws: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #hsz #f n i -> S.seq (hash #hsz)
let rpmt_raws #hsz #f #n #i mt = raw_hashes_raws #_ #f (S.slice mt 0 i)
val rpmt_i_0: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> mt:rpmt #hsz #f n 0 ->
Lemma (S.equal mt (S.create (pow2 n) (HPad #hsz)))
let rpmt_i_0 #hsz #f #n mt = ()
val rpmt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> #i:nat{i <= pow2 n} -> rpmt #hsz #f n i ->
rpmt #hsz #f (n-1) (if i <= pow2 (n-1) then i else pow2 (n-1))
let rpmt_left #hsz #f #n #i mt =
if i <= pow2 (n-1)
then pad_hashes_slice #_ #f (S.slice mt i (S.length mt)) 0 (pow2 (n-1) - i)
else raw_hashes_slice #_ #f (S.slice mt 0 i) 0 (pow2 (n-1));
mt_left mt
#push-options "--z3rlimit 40"
val rpmt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> #i:nat{i <= pow2 n} -> rpmt #hsz #f n i ->
rpmt #_ #f (n-1) (if i <= pow2 (n-1) then 0 else i - pow2 (n-1))
let rpmt_right #hsz #f #n #i mt =
if i <= pow2 (n-1)
then pad_hashes_slice #_ #f (S.slice mt i (S.length mt)) (pow2 (n-1) - i) (pow2 n - i)
else raw_hashes_slice #_ #f (S.slice mt 0 i) (pow2 (n-1)) i;
mt_right mt
/// Two right-padded Merkle trees collide when
/// 1) they have the same height (`n`) and number of raw hashes (`i`),
/// 2) their contents differ, and
/// 3) their roots are same.
// fournet: we may want to work towards removing 1) using a hash prefix
noeq
type mt_collide (#hsz:pos) (#f:hash_fun_t #hsz) (n:nat) (i:nat{i <= pow2 n}) = | Collision:
mt1:rpmt #_ #f n i -> mt2:rpmt #_ #f n i {
mt1 =!= mt2 /\
mt_get_root #_ #f #_ mt1 == mt_get_root #_ #f #_ mt2 } -> mt_collide #_ #f n i
noeq
type hash2_raw_collide = | Collision2:
#hsz:pos -> #f:hash_fun_t #hsz ->
lh1:hash -> rh1:hash ->
lh2:hash -> rh2:hash {
(lh1 =!= lh2 \/ rh1 =!= rh2) /\
f lh1 rh1 == f lh2 rh2 } -> hash2_raw_collide
/// Auxiliary lemmas for the proof
val rpmt_pad_hashes_0:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #_ #f n i ->
Lemma (i = 0 <==> pad_hashes #_ #f mt )
let rpmt_pad_hashes_0 #_ #_ #n #i mt = ()
val rpmt_pad_hashes_index_0:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> #i:nat{i <= pow2 n} ->
mt:rpmt #_ #f n i ->
Lemma (pad_hashes #_ #f mt <==> HPad? mt.[0])
let rpmt_pad_hashes_index_0 #_ #_ #n #i mt = ()
val mt_get_root_pad_index_0:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n ->
Lemma (HPad? mt.[0] <==> HPad? (mt_get_root #_ #f mt))
let rec mt_get_root_pad_index_0 #hsz #f #n (mt:merkle_tree #hsz n) =
if n = 0 then ()
else
let mt:merkle_tree #hsz (n-1) = mt_next_lv #_ #f #n mt in
mt_get_root_pad_index_0 #_ #f #(n-1) mt
#pop-options
val rpmt_get_root_pad_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #_ #f n i -> | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | mt: MerkleTree.Spec.rpmt n i
-> FStar.Pervasives.Lemma
(ensures MerkleTree.Spec.pad_hashes mt <==> HPad? (MerkleTree.Spec.mt_get_root mt)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.pow2",
"MerkleTree.Spec.rpmt",
"MerkleTree.Spec.mt_get_root_pad_index_0",
"Prims.unit",
"MerkleTree.Spec.rpmt_pad_hashes_index_0"
] | [] | true | false | true | false | false | let rpmt_get_root_pad_hashes #_ #f #n #i mt =
| rpmt_pad_hashes_index_0 #_ #f mt;
mt_get_root_pad_index_0 #_ #f mt | false |
MerkleTree.Spec.fst | MerkleTree.Spec.raw_hashes_raws | val raw_hashes_raws:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes{raw_hashes #hsz #f hs} ->
Tot (S.seq (hash #hsz)) (decreases (S.length hs)) | val raw_hashes_raws:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes{raw_hashes #hsz #f hs} ->
Tot (S.seq (hash #hsz)) (decreases (S.length hs)) | let rec raw_hashes_raws #hsz #f hs =
if S.length hs = 0 then S.empty
else S.cons (HRaw?.hr (S.head hs)) (raw_hashes_raws #_ #f (S.tail hs)) | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 72,
"end_line": 339,
"start_col": 0,
"start_line": 337
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1))
val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2)))
let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]);
assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]);
assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i])
val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2))
(S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2)))
let mt_next_lv_equiv #hsz #f j n mt1 mt2 =
hs_next_lv_equiv #_ #f j (pow2 (n-1)) mt1 mt2
val hs_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes #hsz {S.length hs = 2 * n} ->
nhs:hashes #hsz {S.length nhs = n} ->
GTot Type0
let hs_next_rel #hsz #f n hs nhs =
forall (i:nat{i < n}).
S.index nhs i ==
padded_hash_fun #hsz f (S.index hs (2 * i)) (S.index hs (2 * i + 1))
val mt_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
GTot Type0
let mt_next_rel #hsz #f n mt nmt =
hs_next_rel #hsz #f (pow2 (n-1)) mt nmt
val hs_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes{S.length hs = 2 * n} ->
nhs:hashes{S.length nhs = n} ->
Lemma (requires hs_next_rel #_ #f n hs nhs)
(ensures S.equal nhs (hs_next_lv #_ #f #n hs))
let rec hs_next_rel_next_lv #hsz #f n hs nhs =
if n = 0 then ()
else hs_next_rel_next_lv #_ #f (n - 1)
(S.slice hs 2 (S.length hs))
(S.slice nhs 1 (S.length nhs))
val mt_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures S.equal nmt (mt_next_lv #_ #f mt))
let mt_next_rel_next_lv #hsz #f n mt nmt =
hs_next_rel_next_lv #_ #f (pow2 (n-1)) mt nmt
val mt_next_rel_upd_even:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i) v)
(S.upd nmt i (padded_hash_fun #hsz f v (S.index mt (2 * i + 1)))))
let mt_next_rel_upd_even #hsz #f n mt nmt i v = ()
#push-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
val mt_next_rel_upd_even_pad:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash #hsz ->
Lemma (requires (mt_next_rel #_ #f n mt nmt) /\ (S.index mt (2 * i + 1) == HPad))
(ensures (mt_next_rel #_ #f n (S.upd mt (2 * i) v) (S.upd nmt i v)))
let mt_next_rel_upd_even_pad #hsz #f n mt nmt i v = ()
#pop-options
val mt_next_rel_upd_odd:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i + 1) v)
(S.upd nmt i (padded_hash_fun #_ f (S.index mt (2 * i)) v)))
let mt_next_rel_upd_odd #hsz #f n mt nmt i v = ()
// fournet: just [root]?
val mt_get_root:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n -> GTot (padded_hash #hsz)
let rec mt_get_root #hsz #f #n mt =
if n = 0 then mt.[0]
else mt_get_root #_ #f (mt_next_lv #_ #f mt)
#push-options "--initial_fuel 2 --max_fuel 2"
val mt_get_root_step: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (mt_get_root #_ #f mt ==
padded_hash_fun #_ f (mt_get_root #_ #f (mt_left mt)) (mt_get_root #_ #f (mt_right mt)))
let rec mt_get_root_step #hsz #f #n mt =
if n = 1 then ()
else begin
mt_get_root_step #_ #f (mt_next_lv #_ #f mt);
mt_next_lv_mt_left #_ #f mt;
mt_next_lv_mt_right #_ #f mt
end
#pop-options
type path #hsz n = S.lseq (padded_hash #hsz) n
/// We first specify full paths, including padding.
val mt_get_path:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
mt:merkle_tree #hsz n -> i:nat{i < pow2 n} -> GTot (path #hsz n)
let rec mt_get_path #hsz #f #n t i =
if n = 0 then S.empty
else S.cons
(if i % 2 = 0 then t.[i + 1] else t.[i - 1])
(mt_get_path #_ #f (mt_next_lv #_ #f t) (i / 2))
val mt_verify_:
#hsz:pos -> #f:hash_fun_t #hsz ->#n:nat ->
p:path #hsz n -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> GTot (padded_hash #hsz)
let rec mt_verify_ #hsz #f #n p idx h =
if n = 0 then h
else mt_verify_ #_ #f #(n-1) (S.tail p) (idx / 2)
(if idx % 2 = 0
then padded_hash_fun #_ f h (S.head p)
else padded_hash_fun #_ f (S.head p) h)
val mt_verify:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
p:(path #hsz n) -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> padded_hash #hsz -> GTot prop
let mt_verify #hsz #f #n p idx h rt =
rt == mt_verify_ #_ #f p idx h
/// Correctness: the root of a tree is correctly recomputed from any of its paths
val hs_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
hs:hashes{S.length hs = 2 * n} -> idx:nat{idx < 2 * n} ->
Lemma ((hs_next_lv #_ #f #n hs).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f hs.[idx] hs.[idx + 1]
else padded_hash_fun #_ f hs.[idx - 1] hs.[idx]))
let rec hs_next_lv_get #hsz #f #n hs idx =
if idx < 2 then ()
else hs_next_lv_get #_ #f #(n-1) (S.slice hs 2 (S.length hs)) (idx - 2)
val mt_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} ->
Lemma (
(mt_next_lv #_ #f mt).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f mt.[idx] mt.[idx + 1]
else padded_hash_fun #_ f mt.[idx - 1] mt.[idx]))
let mt_next_lv_get #hsz #f #n mt idx =
hs_next_lv_get #_ #f #(pow2 (n-1)) mt idx
val mt_get_path_ok_:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
t:merkle_tree #hsz n -> i:nat{i < pow2 n} ->
Lemma (mt_verify_ #_ #f (mt_get_path #_ #f t i) i (mt_get t i) == mt_get_root #_ #f t)
let rec mt_get_path_ok_ #hsz #f #n mt idx =
if n = 0 then ()
else begin
assert (S.head (mt_get_path #_ #f mt idx) ==
(if idx % 2 = 0 then mt.[idx + 1] else mt.[idx - 1]));
assert (S.equal (S.tail (mt_get_path #_ #f mt idx))
(mt_get_path #_ #f (mt_next_lv #_ #f mt) (idx / 2)));
mt_get_path_ok_ #_ #f (mt_next_lv #_ #f mt) (idx / 2);
mt_next_lv_get #_ #f mt idx
end
/// Security: we reduce tree collisions to collisions on the hash
/// compression function. Such collisions yield collisions on the SHA2
/// standard (by adding the same length and padding to the
/// accumulators).
///
/// One complication addressed in the proof is the handling of
/// implicit padding.
/// All hashes in a sequence are raw hashes, not padding
val raw_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes #hsz -> Tot Type0 (decreases (S.length hs))
let rec raw_hashes #hsz #f hs =
if S.length hs = 0 then True
else (HRaw? (S.head hs) /\ raw_hashes #_ #f (S.tail hs))
val raw_hashes_raws:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes{raw_hashes #hsz #f hs} -> | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | hs: MerkleTree.Spec.hashes{MerkleTree.Spec.raw_hashes hs}
-> Prims.Tot (FStar.Seq.Base.seq MerkleTree.Spec.hash) | Prims.Tot | [
"total",
""
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"MerkleTree.Spec.hashes",
"MerkleTree.Spec.raw_hashes",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"MerkleTree.Spec.padded_hash",
"FStar.Seq.Base.empty",
"MerkleTree.Spec.hash",
"Prims.bool",
"FStar.Seq.Base.cons",
"MerkleTree.Spec.__proj__HRaw__item__hr",
"FStar.Seq.Properties.head",
"MerkleTree.Spec.raw_hashes_raws",
"FStar.Seq.Properties.tail",
"FStar.Seq.Base.seq"
] | [
"recursion"
] | false | false | false | false | false | let rec raw_hashes_raws #hsz #f hs =
| if S.length hs = 0
then S.empty
else S.cons (HRaw?.hr (S.head hs)) (raw_hashes_raws #_ #f (S.tail hs)) | false |
MerkleTree.Spec.fst | MerkleTree.Spec.mt_next_rel_next_lv | val mt_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures S.equal nmt (mt_next_lv #_ #f mt)) | val mt_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures S.equal nmt (mt_next_lv #_ #f mt)) | let mt_next_rel_next_lv #hsz #f n mt nmt =
hs_next_rel_next_lv #_ #f (pow2 (n-1)) mt nmt | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 47,
"end_line": 183,
"start_col": 0,
"start_line": 182
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1))
val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2)))
let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]);
assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]);
assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i])
val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2))
(S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2)))
let mt_next_lv_equiv #hsz #f j n mt1 mt2 =
hs_next_lv_equiv #_ #f j (pow2 (n-1)) mt1 mt2
val hs_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes #hsz {S.length hs = 2 * n} ->
nhs:hashes #hsz {S.length nhs = n} ->
GTot Type0
let hs_next_rel #hsz #f n hs nhs =
forall (i:nat{i < n}).
S.index nhs i ==
padded_hash_fun #hsz f (S.index hs (2 * i)) (S.index hs (2 * i + 1))
val mt_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
GTot Type0
let mt_next_rel #hsz #f n mt nmt =
hs_next_rel #hsz #f (pow2 (n-1)) mt nmt
val hs_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes{S.length hs = 2 * n} ->
nhs:hashes{S.length nhs = n} ->
Lemma (requires hs_next_rel #_ #f n hs nhs)
(ensures S.equal nhs (hs_next_lv #_ #f #n hs))
let rec hs_next_rel_next_lv #hsz #f n hs nhs =
if n = 0 then ()
else hs_next_rel_next_lv #_ #f (n - 1)
(S.slice hs 2 (S.length hs))
(S.slice nhs 1 (S.length nhs))
val mt_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
Lemma (requires mt_next_rel #_ #f n mt nmt) | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | n: Prims.pos -> mt: MerkleTree.Spec.merkle_tree n -> nmt: MerkleTree.Spec.merkle_tree (n - 1)
-> FStar.Pervasives.Lemma (requires MerkleTree.Spec.mt_next_rel n mt nmt)
(ensures FStar.Seq.Base.equal nmt (MerkleTree.Spec.mt_next_lv mt)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"MerkleTree.Spec.merkle_tree",
"Prims.op_Subtraction",
"MerkleTree.Spec.hs_next_rel_next_lv",
"Prims.pow2",
"Prims.unit"
] | [] | true | false | true | false | false | let mt_next_rel_next_lv #hsz #f n mt nmt =
| hs_next_rel_next_lv #_ #f (pow2 (n - 1)) mt nmt | false |
MerkleTree.Spec.fst | MerkleTree.Spec.mt_next_lv_mt_left | val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt))) | val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt))) | let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2)) | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 56,
"end_line": 104,
"start_col": 0,
"start_line": 103
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n -> | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | mt: MerkleTree.Spec.merkle_tree n
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.equal (MerkleTree.Spec.mt_next_lv (MerkleTree.Spec.mt_left mt))
(MerkleTree.Spec.mt_left (MerkleTree.Spec.mt_next_lv mt))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"MerkleTree.Spec.merkle_tree",
"MerkleTree.Spec.hs_next_lv_slice",
"Prims.pow2",
"Prims.op_Subtraction",
"Prims.unit"
] | [] | true | false | true | false | false | let mt_next_lv_mt_left #hsz #f #n mt =
| hs_next_lv_slice #_ #f #(pow2 (n - 1)) mt 0 (pow2 (n - 2)) | false |
Vale.Curve25519.FastHybrid_helpers.fst | Vale.Curve25519.FastHybrid_helpers.pow2int_four | val pow2int_four (c0 c1 c2 c3: int) : int | val pow2int_four (c0 c1 c2 c3: int) : int | let pow2int_four (c0 c1 c2 c3:int) : int = c0 + c1 * pow2_64 + c2 * pow2_128 + c3 * pow2_192 | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.FastHybrid_helpers.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 92,
"end_line": 120,
"start_col": 0,
"start_line": 120
} | module Vale.Curve25519.FastHybrid_helpers
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
open FStar.Tactics
open FStar.Tactics.CanonCommSemiring
open Vale.Curve25519.Fast_defs
open Vale.Curve25519.Fast_lemmas_internal
#reset-options "--max_fuel 0 --max_ifuel 0 --using_facts_from '* -FStar.Tactics -FStar.Reflection'"
let lemma_carry_prime (a0 a1 a2 a3 a0' a1' a2' a3' carry_in:nat64) (carry:bit) : Lemma
(requires pow2_five a0' a1' a2' a3' carry == pow2_four a0 a1 a2 a3 + carry_in * 38 /\
carry_in * 38 - 1 + 38 < pow2_64)
(ensures a0' + carry * 38 < pow2_64 /\
(pow2_four (a0' + carry * 38) a1' a2' a3') % prime == (pow2_four a0 a1 a2 a3 + carry_in * pow2_256) % prime)
=
assert (a0' + carry * 38 < pow2_64);
calc (==) {
(pow2_four a0 a1 a2 a3 + carry_in * pow2_256) % prime;
== { lemma_mul_pow256_add (pow2_four a0 a1 a2 a3) carry_in }
(pow2_four a0 a1 a2 a3 + carry_in * 38) % prime;
== {}
(pow2_five a0' a1' a2' a3' carry) % prime;
== { _ by (int_canon()) }
(pow2_four a0' a1' a2' a3' + (carry * pow2_256)) % prime;
== { lemma_mul_pow256_add (pow2_four a0' a1' a2' a3') carry }
(pow2_four a0' a1' a2' a3' + (carry * 38)) % prime;
== { calc (==) {
(pow2_four a0' a1' a2' a3') + (carry * 38);
== { _ by (int_canon()) }
pow2_four (a0' + carry * 38) a1' a2' a3';
}
}
(pow2_four (a0' + carry * 38) a1' a2' a3') % prime;
};
()
#reset-options "--z3rlimit 30 --max_fuel 0 --max_ifuel 0 --using_facts_from '* -FStar.Tactics -FStar.Reflection'"
let lemma_fast_mul1 (a:nat)
(b a0 a1 a2 a3
ba0_hi ba0_lo
ba1_hi ba1_lo
ba2_hi ba2_lo
ba3_hi ba3_lo
s1 s2 s3 s4:nat64) : Lemma
(requires a = pow2_four a0 a1 a2 a3 /\
pow2_64 * ba0_hi + ba0_lo == b * a0 /\
pow2_64 * ba1_hi + ba1_lo == b * a1 /\
pow2_64 * ba2_hi + ba2_lo == b * a2 /\
pow2_64 * ba3_hi + ba3_lo == b * a3 /\
(let s1', c1 = add_carry ba1_lo ba0_hi 0 in
let s2', c2 = add_carry ba2_lo ba1_hi c1 in
let s3', c3 = add_carry ba3_lo ba2_hi c2 in
let s4', c4 = add_carry ba3_hi 0 c3 in
s1 == s1' /\
s2 == s2' /\
s3 == s3' /\
s4 == s4' /\
c4 == 0)
)
(ensures pow2_five ba0_lo s1 s2 s3 s4 == a * b)
=
assert_by_tactic (b * pow2_four a0 a1 a2 a3 == pow2_four (b*a0) (b*a1) (b*a2) (b*a3)) int_canon;
//lemma_prod_bounds ba0_hi ba0_lo b a0;
//lemma_prod_bounds ba1_hi ba1_lo b a1;
//lemma_prod_bounds ba2_hi ba2_lo b a2;
//lemma_prod_bounds ba3_hi ba3_lo b a3;
()
let lemma_addition (a d:nat) (a0 a1 a2 a3 d0 d1 d2 d3 d4:nat64)
(s0 s1 s2 s3 s4:nat64) : Lemma
(requires a = pow2_four a0 a1 a2 a3 /\
d = pow2_five d0 d1 d2 d3 d4 /\
(let s0', c0 = add_carry a0 d0 0 in
let s1', c1 = add_carry a1 d1 c0 in
let s2', c2 = add_carry a2 d2 c1 in
let s3', c3 = add_carry a3 d3 c2 in
let s4', c4 = add_carry d4 0 c3 in
s0 == s0' /\
s1 == s1' /\
s2 == s2' /\
s3 == s3' /\
s4 == s4' /\
c4 == 0))
(ensures a + d == pow2_five s0 s1 s2 s3 s4)
=
()
let lemma_carry_wide (a0 a1 a2 a3 a4 a5 a6 a7
d0 d1 d2 d3 carry
d0' d1' d2' d3':nat64) : Lemma
(requires pow2_five d0 d1 d2 d3 carry == 38 * pow2_four a4 a5 a6 a7 + pow2_four a0 a1 a2 a3 /\
pow2_four d0' d1' d2' d3' % prime == ((pow2_four d0 d1 d2 d3) + carry * pow2_256) % prime)
(ensures (pow2_four d0' d1' d2' d3') % prime == (pow2_eight a0 a1 a2 a3 a4 a5 a6 a7) % prime)
=
calc (==) {
pow2_four d0' d1' d2' d3' % prime;
== { calc (==) {
(pow2_four d0 d1 d2 d3) + carry * pow2_256;
== { _ by (int_canon()) }
pow2_five d0 d1 d2 d3 carry;
}
}
pow2_five d0 d1 d2 d3 carry % prime;
== {}
(pow2_four a0 a1 a2 a3 + 38 * pow2_four a4 a5 a6 a7) % prime;
== { lemma_mul_pow256_add (pow2_four a0 a1 a2 a3) (pow2_four a4 a5 a6 a7) }
(pow2_four a0 a1 a2 a3 + pow2_256 * pow2_four a4 a5 a6 a7) % prime;
== { _ by (int_canon()) }
(pow2_eight a0 a1 a2 a3 a4 a5 a6 a7) % prime;
} | {
"checked_file": "/",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_lemmas_internal.fsti.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Curve25519.FastHybrid_helpers.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_internal",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 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": 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"
} | false | c0: Prims.int -> c1: Prims.int -> c2: Prims.int -> c3: Prims.int -> Prims.int | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Vale.Def.Words_s.pow2_64",
"Vale.Def.Words_s.pow2_128",
"Vale.Curve25519.Fast_defs.pow2_192"
] | [] | false | false | false | true | false | let pow2int_four (c0 c1 c2 c3: int) : int =
| c0 + c1 * pow2_64 + c2 * pow2_128 + c3 * pow2_192 | false |
MerkleTree.Spec.fst | MerkleTree.Spec.raw_hashes | val raw_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes #hsz -> Tot Type0 (decreases (S.length hs)) | val raw_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes #hsz -> Tot Type0 (decreases (S.length hs)) | let rec raw_hashes #hsz #f hs =
if S.length hs = 0 then True
else (HRaw? (S.head hs) /\ raw_hashes #_ #f (S.tail hs)) | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 58,
"end_line": 331,
"start_col": 0,
"start_line": 329
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1))
val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2)))
let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]);
assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]);
assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i])
val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2))
(S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2)))
let mt_next_lv_equiv #hsz #f j n mt1 mt2 =
hs_next_lv_equiv #_ #f j (pow2 (n-1)) mt1 mt2
val hs_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes #hsz {S.length hs = 2 * n} ->
nhs:hashes #hsz {S.length nhs = n} ->
GTot Type0
let hs_next_rel #hsz #f n hs nhs =
forall (i:nat{i < n}).
S.index nhs i ==
padded_hash_fun #hsz f (S.index hs (2 * i)) (S.index hs (2 * i + 1))
val mt_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
GTot Type0
let mt_next_rel #hsz #f n mt nmt =
hs_next_rel #hsz #f (pow2 (n-1)) mt nmt
val hs_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes{S.length hs = 2 * n} ->
nhs:hashes{S.length nhs = n} ->
Lemma (requires hs_next_rel #_ #f n hs nhs)
(ensures S.equal nhs (hs_next_lv #_ #f #n hs))
let rec hs_next_rel_next_lv #hsz #f n hs nhs =
if n = 0 then ()
else hs_next_rel_next_lv #_ #f (n - 1)
(S.slice hs 2 (S.length hs))
(S.slice nhs 1 (S.length nhs))
val mt_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures S.equal nmt (mt_next_lv #_ #f mt))
let mt_next_rel_next_lv #hsz #f n mt nmt =
hs_next_rel_next_lv #_ #f (pow2 (n-1)) mt nmt
val mt_next_rel_upd_even:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i) v)
(S.upd nmt i (padded_hash_fun #hsz f v (S.index mt (2 * i + 1)))))
let mt_next_rel_upd_even #hsz #f n mt nmt i v = ()
#push-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
val mt_next_rel_upd_even_pad:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash #hsz ->
Lemma (requires (mt_next_rel #_ #f n mt nmt) /\ (S.index mt (2 * i + 1) == HPad))
(ensures (mt_next_rel #_ #f n (S.upd mt (2 * i) v) (S.upd nmt i v)))
let mt_next_rel_upd_even_pad #hsz #f n mt nmt i v = ()
#pop-options
val mt_next_rel_upd_odd:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i + 1) v)
(S.upd nmt i (padded_hash_fun #_ f (S.index mt (2 * i)) v)))
let mt_next_rel_upd_odd #hsz #f n mt nmt i v = ()
// fournet: just [root]?
val mt_get_root:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n -> GTot (padded_hash #hsz)
let rec mt_get_root #hsz #f #n mt =
if n = 0 then mt.[0]
else mt_get_root #_ #f (mt_next_lv #_ #f mt)
#push-options "--initial_fuel 2 --max_fuel 2"
val mt_get_root_step: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (mt_get_root #_ #f mt ==
padded_hash_fun #_ f (mt_get_root #_ #f (mt_left mt)) (mt_get_root #_ #f (mt_right mt)))
let rec mt_get_root_step #hsz #f #n mt =
if n = 1 then ()
else begin
mt_get_root_step #_ #f (mt_next_lv #_ #f mt);
mt_next_lv_mt_left #_ #f mt;
mt_next_lv_mt_right #_ #f mt
end
#pop-options
type path #hsz n = S.lseq (padded_hash #hsz) n
/// We first specify full paths, including padding.
val mt_get_path:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
mt:merkle_tree #hsz n -> i:nat{i < pow2 n} -> GTot (path #hsz n)
let rec mt_get_path #hsz #f #n t i =
if n = 0 then S.empty
else S.cons
(if i % 2 = 0 then t.[i + 1] else t.[i - 1])
(mt_get_path #_ #f (mt_next_lv #_ #f t) (i / 2))
val mt_verify_:
#hsz:pos -> #f:hash_fun_t #hsz ->#n:nat ->
p:path #hsz n -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> GTot (padded_hash #hsz)
let rec mt_verify_ #hsz #f #n p idx h =
if n = 0 then h
else mt_verify_ #_ #f #(n-1) (S.tail p) (idx / 2)
(if idx % 2 = 0
then padded_hash_fun #_ f h (S.head p)
else padded_hash_fun #_ f (S.head p) h)
val mt_verify:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
p:(path #hsz n) -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> padded_hash #hsz -> GTot prop
let mt_verify #hsz #f #n p idx h rt =
rt == mt_verify_ #_ #f p idx h
/// Correctness: the root of a tree is correctly recomputed from any of its paths
val hs_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
hs:hashes{S.length hs = 2 * n} -> idx:nat{idx < 2 * n} ->
Lemma ((hs_next_lv #_ #f #n hs).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f hs.[idx] hs.[idx + 1]
else padded_hash_fun #_ f hs.[idx - 1] hs.[idx]))
let rec hs_next_lv_get #hsz #f #n hs idx =
if idx < 2 then ()
else hs_next_lv_get #_ #f #(n-1) (S.slice hs 2 (S.length hs)) (idx - 2)
val mt_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} ->
Lemma (
(mt_next_lv #_ #f mt).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f mt.[idx] mt.[idx + 1]
else padded_hash_fun #_ f mt.[idx - 1] mt.[idx]))
let mt_next_lv_get #hsz #f #n mt idx =
hs_next_lv_get #_ #f #(pow2 (n-1)) mt idx
val mt_get_path_ok_:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
t:merkle_tree #hsz n -> i:nat{i < pow2 n} ->
Lemma (mt_verify_ #_ #f (mt_get_path #_ #f t i) i (mt_get t i) == mt_get_root #_ #f t)
let rec mt_get_path_ok_ #hsz #f #n mt idx =
if n = 0 then ()
else begin
assert (S.head (mt_get_path #_ #f mt idx) ==
(if idx % 2 = 0 then mt.[idx + 1] else mt.[idx - 1]));
assert (S.equal (S.tail (mt_get_path #_ #f mt idx))
(mt_get_path #_ #f (mt_next_lv #_ #f mt) (idx / 2)));
mt_get_path_ok_ #_ #f (mt_next_lv #_ #f mt) (idx / 2);
mt_next_lv_get #_ #f mt idx
end
/// Security: we reduce tree collisions to collisions on the hash
/// compression function. Such collisions yield collisions on the SHA2
/// standard (by adding the same length and padding to the
/// accumulators).
///
/// One complication addressed in the proof is the handling of
/// implicit padding.
/// All hashes in a sequence are raw hashes, not padding
val raw_hashes:
#hsz:pos -> #f:hash_fun_t #hsz -> | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | hs: MerkleTree.Spec.hashes -> Prims.Tot Type0 | Prims.Tot | [
"total",
""
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"MerkleTree.Spec.hashes",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"MerkleTree.Spec.padded_hash",
"Prims.l_True",
"Prims.bool",
"Prims.l_and",
"Prims.b2t",
"MerkleTree.Spec.uu___is_HRaw",
"FStar.Seq.Properties.head",
"MerkleTree.Spec.raw_hashes",
"FStar.Seq.Properties.tail"
] | [
"recursion"
] | false | false | false | false | true | let rec raw_hashes #hsz #f hs =
| if S.length hs = 0 then True else (HRaw? (S.head hs) /\ raw_hashes #_ #f (S.tail hs)) | false |
MerkleTree.Spec.fst | MerkleTree.Spec.raw_hashes_slice | val raw_hashes_slice:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat -> j:nat{i <= j && j <= S.length hs} ->
Lemma (requires raw_hashes #_ #f hs)
(ensures raw_hashes #_ #f (S.slice hs i j))
(decreases (j - i)) | val raw_hashes_slice:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat -> j:nat{i <= j && j <= S.length hs} ->
Lemma (requires raw_hashes #_ #f hs)
(ensures raw_hashes #_ #f (S.slice hs i j))
(decreases (j - i)) | let rec raw_hashes_slice #hsz #f hs i j =
if i = j then ()
else (
raw_hashes_index #_ #f hs i;
raw_hashes_slice #_ #f hs (i + 1) j) | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 40,
"end_line": 361,
"start_col": 0,
"start_line": 357
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1))
val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2)))
let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]);
assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]);
assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i])
val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2))
(S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2)))
let mt_next_lv_equiv #hsz #f j n mt1 mt2 =
hs_next_lv_equiv #_ #f j (pow2 (n-1)) mt1 mt2
val hs_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes #hsz {S.length hs = 2 * n} ->
nhs:hashes #hsz {S.length nhs = n} ->
GTot Type0
let hs_next_rel #hsz #f n hs nhs =
forall (i:nat{i < n}).
S.index nhs i ==
padded_hash_fun #hsz f (S.index hs (2 * i)) (S.index hs (2 * i + 1))
val mt_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
GTot Type0
let mt_next_rel #hsz #f n mt nmt =
hs_next_rel #hsz #f (pow2 (n-1)) mt nmt
val hs_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes{S.length hs = 2 * n} ->
nhs:hashes{S.length nhs = n} ->
Lemma (requires hs_next_rel #_ #f n hs nhs)
(ensures S.equal nhs (hs_next_lv #_ #f #n hs))
let rec hs_next_rel_next_lv #hsz #f n hs nhs =
if n = 0 then ()
else hs_next_rel_next_lv #_ #f (n - 1)
(S.slice hs 2 (S.length hs))
(S.slice nhs 1 (S.length nhs))
val mt_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures S.equal nmt (mt_next_lv #_ #f mt))
let mt_next_rel_next_lv #hsz #f n mt nmt =
hs_next_rel_next_lv #_ #f (pow2 (n-1)) mt nmt
val mt_next_rel_upd_even:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i) v)
(S.upd nmt i (padded_hash_fun #hsz f v (S.index mt (2 * i + 1)))))
let mt_next_rel_upd_even #hsz #f n mt nmt i v = ()
#push-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
val mt_next_rel_upd_even_pad:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash #hsz ->
Lemma (requires (mt_next_rel #_ #f n mt nmt) /\ (S.index mt (2 * i + 1) == HPad))
(ensures (mt_next_rel #_ #f n (S.upd mt (2 * i) v) (S.upd nmt i v)))
let mt_next_rel_upd_even_pad #hsz #f n mt nmt i v = ()
#pop-options
val mt_next_rel_upd_odd:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i + 1) v)
(S.upd nmt i (padded_hash_fun #_ f (S.index mt (2 * i)) v)))
let mt_next_rel_upd_odd #hsz #f n mt nmt i v = ()
// fournet: just [root]?
val mt_get_root:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n -> GTot (padded_hash #hsz)
let rec mt_get_root #hsz #f #n mt =
if n = 0 then mt.[0]
else mt_get_root #_ #f (mt_next_lv #_ #f mt)
#push-options "--initial_fuel 2 --max_fuel 2"
val mt_get_root_step: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (mt_get_root #_ #f mt ==
padded_hash_fun #_ f (mt_get_root #_ #f (mt_left mt)) (mt_get_root #_ #f (mt_right mt)))
let rec mt_get_root_step #hsz #f #n mt =
if n = 1 then ()
else begin
mt_get_root_step #_ #f (mt_next_lv #_ #f mt);
mt_next_lv_mt_left #_ #f mt;
mt_next_lv_mt_right #_ #f mt
end
#pop-options
type path #hsz n = S.lseq (padded_hash #hsz) n
/// We first specify full paths, including padding.
val mt_get_path:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
mt:merkle_tree #hsz n -> i:nat{i < pow2 n} -> GTot (path #hsz n)
let rec mt_get_path #hsz #f #n t i =
if n = 0 then S.empty
else S.cons
(if i % 2 = 0 then t.[i + 1] else t.[i - 1])
(mt_get_path #_ #f (mt_next_lv #_ #f t) (i / 2))
val mt_verify_:
#hsz:pos -> #f:hash_fun_t #hsz ->#n:nat ->
p:path #hsz n -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> GTot (padded_hash #hsz)
let rec mt_verify_ #hsz #f #n p idx h =
if n = 0 then h
else mt_verify_ #_ #f #(n-1) (S.tail p) (idx / 2)
(if idx % 2 = 0
then padded_hash_fun #_ f h (S.head p)
else padded_hash_fun #_ f (S.head p) h)
val mt_verify:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
p:(path #hsz n) -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> padded_hash #hsz -> GTot prop
let mt_verify #hsz #f #n p idx h rt =
rt == mt_verify_ #_ #f p idx h
/// Correctness: the root of a tree is correctly recomputed from any of its paths
val hs_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
hs:hashes{S.length hs = 2 * n} -> idx:nat{idx < 2 * n} ->
Lemma ((hs_next_lv #_ #f #n hs).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f hs.[idx] hs.[idx + 1]
else padded_hash_fun #_ f hs.[idx - 1] hs.[idx]))
let rec hs_next_lv_get #hsz #f #n hs idx =
if idx < 2 then ()
else hs_next_lv_get #_ #f #(n-1) (S.slice hs 2 (S.length hs)) (idx - 2)
val mt_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} ->
Lemma (
(mt_next_lv #_ #f mt).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f mt.[idx] mt.[idx + 1]
else padded_hash_fun #_ f mt.[idx - 1] mt.[idx]))
let mt_next_lv_get #hsz #f #n mt idx =
hs_next_lv_get #_ #f #(pow2 (n-1)) mt idx
val mt_get_path_ok_:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
t:merkle_tree #hsz n -> i:nat{i < pow2 n} ->
Lemma (mt_verify_ #_ #f (mt_get_path #_ #f t i) i (mt_get t i) == mt_get_root #_ #f t)
let rec mt_get_path_ok_ #hsz #f #n mt idx =
if n = 0 then ()
else begin
assert (S.head (mt_get_path #_ #f mt idx) ==
(if idx % 2 = 0 then mt.[idx + 1] else mt.[idx - 1]));
assert (S.equal (S.tail (mt_get_path #_ #f mt idx))
(mt_get_path #_ #f (mt_next_lv #_ #f mt) (idx / 2)));
mt_get_path_ok_ #_ #f (mt_next_lv #_ #f mt) (idx / 2);
mt_next_lv_get #_ #f mt idx
end
/// Security: we reduce tree collisions to collisions on the hash
/// compression function. Such collisions yield collisions on the SHA2
/// standard (by adding the same length and padding to the
/// accumulators).
///
/// One complication addressed in the proof is the handling of
/// implicit padding.
/// All hashes in a sequence are raw hashes, not padding
val raw_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes #hsz -> Tot Type0 (decreases (S.length hs))
let rec raw_hashes #hsz #f hs =
if S.length hs = 0 then True
else (HRaw? (S.head hs) /\ raw_hashes #_ #f (S.tail hs))
val raw_hashes_raws:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes{raw_hashes #hsz #f hs} ->
Tot (S.seq (hash #hsz)) (decreases (S.length hs))
let rec raw_hashes_raws #hsz #f hs =
if S.length hs = 0 then S.empty
else S.cons (HRaw?.hr (S.head hs)) (raw_hashes_raws #_ #f (S.tail hs))
val raw_hashes_index:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat{i < S.length hs} ->
Lemma (requires raw_hashes #_ #f hs)
(ensures HRaw? #hsz hs.[i])
(decreases i)
let rec raw_hashes_index #hsz #f hs i =
if i = 0 then ()
else raw_hashes_index #_ #f (S.tail hs) (i - 1)
val raw_hashes_slice:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat -> j:nat{i <= j && j <= S.length hs} ->
Lemma (requires raw_hashes #_ #f hs)
(ensures raw_hashes #_ #f (S.slice hs i j)) | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | hs: MerkleTree.Spec.hashes -> i: Prims.nat -> j: Prims.nat{i <= j && j <= FStar.Seq.Base.length hs}
-> FStar.Pervasives.Lemma (requires MerkleTree.Spec.raw_hashes hs)
(ensures MerkleTree.Spec.raw_hashes (FStar.Seq.Base.slice hs i j))
(decreases j - i) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"MerkleTree.Spec.hashes",
"Prims.nat",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"MerkleTree.Spec.padded_hash",
"Prims.op_Equality",
"Prims.bool",
"MerkleTree.Spec.raw_hashes_slice",
"Prims.op_Addition",
"Prims.unit",
"MerkleTree.Spec.raw_hashes_index"
] | [
"recursion"
] | false | false | true | false | false | let rec raw_hashes_slice #hsz #f hs i j =
| if i = j
then ()
else
(raw_hashes_index #_ #f hs i;
raw_hashes_slice #_ #f hs (i + 1) j) | false |
FStar.Tactics.PatternMatching.fst | FStar.Tactics.PatternMatching.matching_problem_of_abs | val matching_problem_of_abs (tm: term) : Tac (matching_problem * abspat_continuation) | val matching_problem_of_abs (tm: term) : Tac (matching_problem * abspat_continuation) | let matching_problem_of_abs (tm: term)
: Tac (matching_problem * abspat_continuation) =
let binders, body = binders_and_body_of_abs (cleanup_abspat tm) in
debug ("Got binders: " ^ (String.concat ", "
(map (fun b -> name_of_named_binder b <: Tac string) binders)));
let classified_binders : list (binder & string & abspat_binder_kind & typ) =
map (fun binder ->
let bv_name = name_of_named_binder binder in
debug ("Got binder: " ^ bv_name ^ "; type is " ^
term_to_string (type_of_named_binder binder));
let binder_kind, typ = classify_abspat_binder binder in
(binder, bv_name, binder_kind, typ))
binders in
let problem =
fold_left
(fun problem (binder, bv_name, binder_kind, typ) ->
debug ("Compiling binder " ^ name_of_named_binder binder ^
", classified as " ^ string_of_abspat_binder_kind binder_kind ^
", with type " ^ term_to_string typ);
match binder_kind with
| ABKVar _ -> { problem with mp_vars = bv_name :: problem.mp_vars }
| ABKHyp -> { problem with mp_hyps = (bv_name, (pattern_of_term typ))
:: problem.mp_hyps }
| ABKGoal -> { problem with mp_goal = Some (pattern_of_term typ) })
({ mp_vars = []; mp_hyps = []; mp_goal = None })
classified_binders in
let continuation =
let abspat_argspec_of_binder xx : Tac abspat_argspec =
match xx with | (binder, xx, binder_kind, yy) ->
{ asa_name = binder_to_binding binder; asa_kind = binder_kind } in
(map abspat_argspec_of_binder classified_binders, tm) in
let mp =
{ mp_vars = List.Tot.Base.rev #varname problem.mp_vars;
mp_hyps = List.Tot.Base.rev #(varname * pattern) problem.mp_hyps;
mp_goal = problem.mp_goal } in
debug ("Got matching problem: " ^ (string_of_matching_problem mp));
mp, continuation | {
"file_name": "ulib/FStar.Tactics.PatternMatching.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 18,
"end_line": 673,
"start_col": 0,
"start_line": 631
} | (*
Copyright 2008-2018 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.
*)
/// ==========================
/// Pattern-matching tactics
/// ==========================
///
/// :Author: Clément Pit-Claudel
/// :Contact: clement.pitclaudel@live.com
/// :Date: 2017-10-13
module FStar.Tactics.PatternMatching
open FStar.Tactics.V2
/// Contents
/// ========
///
/// 1 Contents
/// 2 Motivation
/// 3 Some utility functions
/// 4 Pattern types
/// 5 Pattern matching exceptions
/// 5.1 Types of exceptions
/// 5.2 The exception monad
/// 5.3 Liftings
/// 6 Pattern interpretation
/// 7 Pattern-matching problems
/// 7.1 Definitions
/// 7.2 Resolution
/// 8 A DSL for pattern-matching
/// 8.1 Pattern notations
/// 8.2 Problem notations
/// 8.3 Continuations
/// 9 Putting it all together
/// 10 Examples
/// 10.1 Simple examples
/// 10.2 A real-life example
/// 11 Possible extensions
/// 12 Notes
///
/// Motivation
/// ==========
///
/// Suppose you have a goal of the form ``squash (a == b)``. How do you capture
/// `a` and `b` for further inspection?
///
/// Here's a basic (but cumbersome!) implementation:
let fetch_eq_side () : Tac (term * term) =
let g = cur_goal () in
match inspect g with
| Tv_App squash (g, _) ->
(match inspect squash with
| Tv_UInst squash _
| Tv_FVar squash ->
if fv_to_string squash = flatten_name squash_qn then
(match inspect g with
| Tv_App eq_type_x (y, _) ->
(match inspect eq_type_x with
| Tv_App eq_type (x, _) ->
(match inspect eq_type with
| Tv_App eq (typ, _) ->
(match inspect eq with
| Tv_UInst eq _
| Tv_FVar eq ->
if fv_to_string eq = flatten_name eq2_qn then
(x, y)
else fail "not an equality"
| _ -> fail "not an app2 of fvar: ")
| _ -> fail "not an app3")
| _ -> fail "not an app2")
| _ -> fail "not an app under squash")
else fail "not a squash"
| _ -> fail "not an app of fvar at top level")
| _ -> fail "not an app at top level"
/// …and here's how you could use it:
(* let _ = *)
(* assert_by_tactic (1 + 1 == 2) *)
(* (fun () -> let l, r = fetch_eq_side () in *)
(* print (term_to_string l ^ " / " ^ term_to_string r)) *)
/// This file defines pattern-matching primitives that let you write the same
/// thing like this…
///
/// .. code:: fstar
///
/// let fetch_eq_side' #a () : Tac (term * term) =
/// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) ->
/// (quote left, quote right) <: Tac (term * term))
///
/// let _ =
/// assert_by_tactic (1 + 1 == 2)
/// (fun () -> let l, r = fetch_eq_side' #int () in
/// print (term_to_string l ^ " / " ^ term_to_string r))
///
/// …or, more succinctly, like this:
///
/// .. code:: fstar
///
/// let _ =
/// assert_by_tactic (1 + 1 == 2)
/// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) ->
/// let l, r = quote left, quote right in
/// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit))
/// Some utility functions
/// ======================
///
/// (Skip over this part on a quick read — these are just convenience functions)
(** Ensure that tactic `t` fails. **)
let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit =
match trytac t with
| Some _ -> fail message
| None -> ()
/// The following two tactics are needed because of issues with the ``Tac``
/// effect.
let implies_intro' () : Tac unit =
let _ = implies_intro () in ()
let repeat' #a (f: unit -> Tac a) : Tac unit =
let _ = repeat f in ()
let and_elim' (h: binding) : Tac unit =
and_elim (pack (Tv_Var h));
clear h
(** Use a hypothesis at type a to satisfy a goal at type squash a *)
let exact_hyp (a: Type0) (h: namedv) : Tac unit =
let hd = quote (FStar.Squash.return_squash #a) in
exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)])
(** Use a hypothesis h (of type a) to satisfy a goal at type a *)
let exact_hyp' (h: namedv): Tac unit =
exact (pack (Tv_Var h))
/// Pattern types
/// =============
///
/// Patterns are defined using a simple inductive type, mirroring the structure
/// of ``term_view``.
type varname = string
type qn = string
type pattern =
| PVar: name: varname -> pattern
| PQn: qn: qn -> pattern
| PType: pattern
| PApp: hd: pattern -> arg: pattern -> pattern
let desc_of_pattern = function
| PVar _ -> "a variable"
| PQn qn -> "a constant (" ^ qn ^ ")"
| PType -> "Type"
| PApp _ _ -> "a function application"
let rec string_of_pattern = function
| PVar x -> "?" ^ x
| PQn qn -> qn
| PType -> "Type"
| PApp l r -> "(" ^ string_of_pattern l ^ " "
^ string_of_pattern r ^ ")"
/// Pattern matching exceptions
/// ===========================
///
/// Pattern-matching is defined as a pure, monadic function (because of issues
/// with combining DM4F effects, but also because it helps with debugging).
/// This section defines the exception monad.
///
/// Types of exceptions
/// -------------------
noeq type match_exception =
| NameMismatch of qn * qn
| SimpleMismatch of pattern * term
| NonLinearMismatch of varname * term * term
| UnsupportedTermInPattern of term
| IncorrectTypeInAbsPatBinder of typ
let term_head t : Tac string =
match inspect t with
| Tv_Var bv -> "Tv_Var"
| Tv_BVar fv -> "Tv_BVar"
| Tv_FVar fv -> "Tv_FVar"
| Tv_UInst _ _ -> "Tv_UInst"
| Tv_App f x -> "Tv_App"
| Tv_Abs x t -> "Tv_Abs"
| Tv_Arrow x t -> "Tv_Arrow"
| Tv_Type _ -> "Tv_Type"
| Tv_Refine x t -> "Tv_Refine"
| Tv_Const cst -> "Tv_Const"
| Tv_Uvar i t -> "Tv_Uvar"
| Tv_Let r attrs b t1 t2 -> "Tv_Let"
| Tv_Match t _ branches -> "Tv_Match"
| Tv_AscribedT _ _ _ _ -> "Tv_AscribedT"
| Tv_AscribedC _ _ _ _ -> "Tv_AscribedC"
| Tv_Unknown -> "Tv_Unknown"
| Tv_Unsupp -> "Tv_Unsupp"
let string_of_match_exception = function
| NameMismatch (qn1, qn2) ->
"Match failure (name mismatch): expecting " ^
qn1 ^ ", found " ^ qn2
| SimpleMismatch (pat, tm) ->
"Match failure (sort mismatch): expecting " ^
desc_of_pattern pat ^ ", got " ^ term_to_string tm
| NonLinearMismatch (nm, t1, t2) ->
"Match failure (nonlinear mismatch): variable " ^ nm ^
" needs to match both " ^ (term_to_string t1) ^
" and " ^ (term_to_string t2)
| UnsupportedTermInPattern tm ->
"Match failure (unsupported term in pattern): " ^
term_to_string tm ^ " (" ^ term_head tm ^ ")"
| IncorrectTypeInAbsPatBinder typ ->
"Incorrect type in pattern-matching binder: " ^
term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)"
/// The exception monad
/// -------------------
noeq type match_res a =
| Success of a
| Failure of match_exception
let return #a (x: a) : match_res a =
Success x
let (let?) (#a #b: Type)
(f: match_res a)
(g: a -> Tac (match_res b))
: Tac (match_res b) =
match f with
| Success aa -> g aa
| Failure ex -> Failure ex
let raise #a (ex: match_exception) : match_res a =
Failure ex
/// Liftings
/// --------
///
/// There's a natural lifting from the exception monad into the tactic effect:
let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b =
match f aa with
| Success bb -> bb
| Failure ex -> Tactics.fail (string_of_match_exception ex)
let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b =
match f aa with
| Success bb -> bb
| Failure ex -> Tactics.fail (string_of_match_exception ex)
/// Pattern interpretation
/// ======================
///
/// This section implement pattern-matching. This is strictly a one term, one
/// pattern implementation — handling cases in which mutliple hypotheses match
/// the same pattern is done later.
type bindings = list (varname * term)
let string_of_bindings (bindings: bindings) =
String.concat "\n"
(map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm))
bindings)
(** Match a pattern against a term.
`cur_bindings` is a list of bindings collected while matching previous parts of
the pattern. Returns a result in the exception monad. **)
let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term)
: Tac (match_res bindings) =
let interp_var (v: varname) cur_bindings tm =
match List.Tot.Base.assoc v cur_bindings with
| Some tm' -> if term_eq tm tm' then return cur_bindings
else raise (NonLinearMismatch (v, tm, tm'))
| None -> return ((v, tm) :: cur_bindings) in
let interp_qn (qn: qn) cur_bindings tm =
match inspect tm with
| Tv_UInst fv _
| Tv_FVar fv ->
if fv_to_string fv = qn then return cur_bindings
else raise (NameMismatch (qn, (fv_to_string fv)))
| _ -> raise (SimpleMismatch (pat, tm)) in
let interp_type cur_bindings tm =
match inspect tm with
| Tv_Type _ -> return cur_bindings
| _ -> raise (SimpleMismatch (pat, tm)) in
let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm =
match inspect tm with
| Tv_App hd (arg, _) ->
let? with_hd = interp_pattern_aux p_hd cur_bindings hd in
let? with_arg = interp_pattern_aux p_arg with_hd arg in
return with_arg
| _ -> raise (SimpleMismatch (pat, tm)) in
match pat with
| PVar var -> interp_var var cur_bindings tm
| PQn qn -> interp_qn qn cur_bindings tm
| PType -> interp_type cur_bindings tm
| PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm
(** Match a pattern `pat` against a term.
Returns a result in the exception monad. **)
let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) =
fun (tm: term) ->
let? rev_bindings = interp_pattern_aux pat [] tm in
return (List.Tot.Base.rev rev_bindings)
(** Match a term `tm` against a pattern `pat`.
Raises an exception if the match fails. This is mostly useful for debugging:
use ``mgw`` to capture matches. **)
let match_term pat (tm : term) : Tac bindings =
match interp_pattern pat (norm_term [] tm) with
| Success bb -> bb
| Failure ex -> Tactics.fail (string_of_match_exception ex)
/// Pattern-matching problems
/// =========================
///
/// Generalizing past single-term single-pattern problems, we obtain the
/// following notions of pattern-matching problems and solutions:
let debug msg : Tac unit = () // print msg
/// Definitions
/// -----------
let absvar = binding
type hypothesis = binding
/// A matching problem is composed of holes (``mp_vars``), hypothesis patterns
/// (``mp_hyps``), and a goal pattern (``mp_goal``).
noeq type matching_problem =
{ mp_vars: list varname;
mp_hyps: list (varname * pattern);
mp_goal: option pattern }
let string_of_matching_problem mp =
let vars =
String.concat ", " mp.mp_vars in
let hyps =
String.concat "\n "
(List.Tot.Base.map (fun (nm, pat) ->
nm ^ ": " ^ (string_of_pattern pat)) mp.mp_hyps) in
let goal = match mp.mp_goal with
| None -> "_"
| Some pat -> string_of_pattern pat in
"\n{ vars: " ^ vars ^ "\n" ^
" hyps: " ^ hyps ^ "\n" ^
" goal: " ^ goal ^ " }"
/// A solution is composed of terms captured to mach the holes, and binders
/// captured to match hypothesis patterns.
noeq type matching_solution =
{ ms_vars: list (varname * term);
ms_hyps: list (varname * hypothesis) }
let string_of_matching_solution ms =
let vars =
String.concat "\n "
(map (fun (varname, tm) ->
varname ^ ": " ^ (term_to_string tm)) ms.ms_vars) in
let hyps =
String.concat "\n "
(map (fun (nm, binding) ->
nm ^ ": " ^ (binding_to_string binding)) ms.ms_hyps) in
"\n{ vars: " ^ vars ^ "\n" ^
" hyps: " ^ hyps ^ " }"
(** Find a varname in an association list; fail if it can't be found. **)
let assoc_varname_fail (#b: Type) (key: varname) (ls: list (varname * b))
: Tac b =
match List.Tot.Base.assoc key ls with
| None -> fail ("Not found: " ^ key)
| Some x -> x
let ms_locate_hyp (a: Type) (solution: matching_solution)
(name: varname) : Tac hypothesis =
assoc_varname_fail name solution.ms_hyps
let ms_locate_var (a: Type) (solution: matching_solution)
(name: varname) : Tac a =
unquote #a (assoc_varname_fail name solution.ms_vars)
let ms_locate_unit (a: Type) _solution _binder_name : Tac unit =
()
/// Resolution
/// ----------
///
/// Solving a matching problem is a two-steps process: find an initial
/// assignment for holes based on the goal pattern, then find a set of
/// hypotheses matching hypothesis patterns.
///
/// Note that the implementation takes a continuation of type
/// ``matching_solution -> Tac a``. This continuation is needed because we want
/// users to be able to provide extra criteria on matching solutions (most
/// commonly, this criterion is that a particular tactic should run
/// successfuly).
///
/// This makes it easy to implement a simple for of search through the context,
/// where one can find a hypothesis matching a particular predicate by
/// constructing a trivial matching problem and passing the predicate as the
/// continuation.
(** Scan ``hypotheses`` for a match for ``pat`` that lets ``body`` succeed.
``name`` is used to refer to the hypothesis matched in the final solution.
``part_sol`` includes bindings gathered while matching previous solutions. **)
let rec solve_mp_for_single_hyp #a
(name: varname)
(pat: pattern)
(hypotheses: list hypothesis)
(body: matching_solution -> Tac a)
(part_sol: matching_solution)
: Tac a =
match hypotheses with
| [] ->
fail #a "No matching hypothesis"
| h :: hs ->
or_else // Must be in ``Tac`` here to run `body`
(fun () ->
match interp_pattern_aux pat part_sol.ms_vars (type_of_binding h) with
| Failure ex ->
fail ("Failed to match hyp: " ^ (string_of_match_exception ex))
| Success bindings ->
let ms_hyps = (name, h) :: part_sol.ms_hyps in
body ({ part_sol with ms_vars = bindings; ms_hyps = ms_hyps }))
(fun () ->
solve_mp_for_single_hyp name pat hs body part_sol)
(** Scan ``hypotheses`` for matches for ``mp_hyps`` that lets ``body``
succeed. **)
let rec solve_mp_for_hyps #a
(mp_hyps: list (varname * pattern))
(hypotheses: list hypothesis)
(body: matching_solution -> Tac a)
(partial_solution: matching_solution)
: Tac a =
match mp_hyps with
| [] -> body partial_solution
| (name, pat) :: pats ->
solve_mp_for_single_hyp name pat hypotheses
(solve_mp_for_hyps pats hypotheses body)
partial_solution
(** Solve a matching problem.
The solution returned is constructed to ensure that the continuation ``body``
succeeds: this implements the usual backtracking-match semantics. **)
let solve_mp #a (problem: matching_problem)
(hypotheses: list hypothesis) (goal: term)
(body: matching_solution -> Tac a)
: Tac a =
let goal_ps =
match problem.mp_goal with
| None -> { ms_vars = []; ms_hyps = [] }
| Some pat ->
match interp_pattern pat goal with
| Failure ex -> fail ("Failed to match goal: " ^ (string_of_match_exception ex))
| Success bindings -> { ms_vars = bindings; ms_hyps = [] } in
solve_mp_for_hyps #a problem.mp_hyps hypotheses body goal_ps
/// A DSL for pattern-matching
/// ==========================
///
/// Using pattern-matching problems as defined above is relatively cumbersome,
/// so we now introduce a lightweight notation, in two steps: pattern notations,
/// and matching-problem notations.
///
/// Pattern notations
/// -----------------
///
/// The first part of our pattern-matching syntax is pattern notations: we
/// provide a reflective function which constructs a pattern from a term:
/// variables are holes, free variables are constants, and applications are
/// application patterns.
(* FIXME: MOVE *)
let name_of_namedv (x:namedv) : Tac string =
unseal (inspect_namedv x).ppname
(** Compile a term `tm` into a pattern. **)
let rec pattern_of_term_ex tm : Tac (match_res pattern) =
match inspect tm with
| Tv_Var bv ->
return (PVar (name_of_namedv bv))
| Tv_FVar fv
| Tv_UInst fv _ ->
let qn = fv_to_string fv in
return (PQn qn)
| Tv_Type _ ->
return PType
| Tv_App f (x, _) ->
let? fpat = pattern_of_term_ex f in
let? xpat = pattern_of_term_ex x in
return (PApp fpat xpat)
| _ -> raise (UnsupportedTermInPattern tm)
(** β-reduce a term `tm`.
This is useful to remove needles function applications introduced by F*, like
``(fun a b c -> a) 1 2 3``. **)
let beta_reduce (tm: term) : Tac term =
norm_term [] tm
(** Compile a term `tm` into a pattern. **)
let pattern_of_term tm : Tac pattern =
match pattern_of_term_ex tm with
| Success bb -> bb
| Failure ex -> Tactics.fail (string_of_match_exception ex)
/// Problem notations
/// -----------------
///
/// We then introduce a DSL for matching problems, best explained on the
/// following example::
///
/// (fun (a b c: ①) (h1 h2 h3: hyp ②) (g: pm_goal ③) → ④)
///
/// This notation is intended to express a pattern-matching problems with three
/// holes ``a``, ``b``, and ``c`` of type ①, matching hypotheses ``h1``, ``h2``,
/// and ``h3`` against pattern ② and the goal against the pattern ③. The body
/// of the notation (④) is then run with appropriate terms bound to ``a``,
/// ``b``, and ``c``, appropriate binders bound to ``h1``, ``h2``, and ``h3``,
/// and ``()`` bound to ``g``.
///
/// We call these patterns ``abspat``s (abstraction patterns), and we provide
/// facilities to parse them into matching problems, and to run their bodies
/// against a particular matching solution.
// We used to annotate variables with an explicit 'var' marker, but then that
// var annotation leaked into the types of other hypotheses due to type
// inference, requiring non-trivial normalization.
// let var (a: Type) = a
let hyp (a: Type) = binding
let pm_goal (a: Type) = unit
let hyp_qn = `%hyp
let goal_qn = `%pm_goal
noeq type abspat_binder_kind =
| ABKVar of typ
| ABKHyp
| ABKGoal
let string_of_abspat_binder_kind = function
| ABKVar _ -> "varname"
| ABKHyp -> "hyp"
| ABKGoal -> "goal"
noeq type abspat_argspec =
{ asa_name: absvar;
asa_kind: abspat_binder_kind }
// We must store this continuation, because recomputing it yields different
// names when the binders are re-opened.
type abspat_continuation =
list abspat_argspec * term
let type_of_named_binder (nb : binder) : term =
nb.sort
let classify_abspat_binder (b : binder): Tac (abspat_binder_kind * term) =
let varname = "v" in
let hyp_pat = PApp (PQn hyp_qn) (PVar varname) in
let goal_pat = PApp (PQn goal_qn) (PVar varname) in
let typ = type_of_named_binder b in
match interp_pattern hyp_pat typ with
| Success [(_, hyp_typ)] -> ABKHyp, hyp_typ
| Success _ -> fail "classifiy_abspat_binder: impossible (1)"
| Failure _ ->
match interp_pattern goal_pat typ with
| Success [(_, goal_typ)] -> ABKGoal, goal_typ
| Success _ -> fail "classifiy_abspat_binder: impossible (2)"
| Failure _ -> ABKVar typ, typ
(** Split an abstraction `tm` into a list of binders and a body. **)
let rec binders_and_body_of_abs tm : Tac (list binder * term) =
match inspect tm with
| Tv_Abs binder tm ->
let binders, body = binders_and_body_of_abs tm in
binder :: binders, body
| _ -> [], tm
let cleanup_abspat (t: term) : Tac term =
norm_term [] t
let name_of_named_binder (nb : binder) : Tac string =
unseal nb.ppname
(** Parse a notation into a matching problem and a continuation.
Pattern-matching notations are of the form ``(fun binders… -> continuation)``,
where ``binders`` are of one of the forms ``var …``, ``hyp …``, or ``goal …``.
``var`` binders are typed holes to be used in other binders; ``hyp`` binders
indicate a pattern to be matched against hypotheses; and ``goal`` binders match
the goal.
A reduction phase is run to ensure that the pattern looks reasonable; it is
needed because F* tends to infer arguments in β-expanded form.
The continuation returned can't directly be applied to a pattern-matching | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.String.fsti.checked",
"FStar.Squash.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.PatternMatching.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | tm: FStar.Tactics.NamedView.term
-> FStar.Tactics.Effect.Tac
(FStar.Tactics.PatternMatching.matching_problem *
FStar.Tactics.PatternMatching.abspat_continuation) | FStar.Tactics.Effect.Tac | [] | [] | [
"FStar.Tactics.NamedView.term",
"Prims.list",
"FStar.Tactics.NamedView.binder",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Tactics.PatternMatching.matching_problem",
"FStar.Tactics.PatternMatching.abspat_continuation",
"FStar.Pervasives.Native.tuple2",
"Prims.unit",
"FStar.Tactics.PatternMatching.debug",
"Prims.string",
"Prims.op_Hat",
"FStar.Tactics.PatternMatching.string_of_matching_problem",
"FStar.Tactics.PatternMatching.Mkmatching_problem",
"FStar.List.Tot.Base.rev",
"FStar.Tactics.PatternMatching.varname",
"FStar.Tactics.PatternMatching.__proj__Mkmatching_problem__item__mp_vars",
"FStar.Tactics.PatternMatching.pattern",
"FStar.Tactics.PatternMatching.__proj__Mkmatching_problem__item__mp_hyps",
"FStar.Tactics.PatternMatching.__proj__Mkmatching_problem__item__mp_goal",
"FStar.Tactics.PatternMatching.abspat_argspec",
"FStar.Tactics.Util.map",
"FStar.Pervasives.Native.tuple4",
"FStar.Tactics.PatternMatching.abspat_binder_kind",
"FStar.Stubs.Reflection.Types.typ",
"FStar.Tactics.PatternMatching.Mkabspat_argspec",
"FStar.Tactics.NamedView.binder_to_binding",
"FStar.Tactics.Util.fold_left",
"FStar.Stubs.Reflection.Types.term",
"Prims.Cons",
"FStar.Tactics.PatternMatching.pattern_of_term",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.Some",
"FStar.Tactics.PatternMatching.string_of_abspat_binder_kind",
"FStar.Stubs.Tactics.V2.Builtins.term_to_string",
"FStar.Tactics.PatternMatching.name_of_named_binder",
"Prims.Nil",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.Mktuple4",
"FStar.Tactics.PatternMatching.classify_abspat_binder",
"FStar.Tactics.PatternMatching.type_of_named_binder",
"FStar.String.concat",
"FStar.Tactics.PatternMatching.binders_and_body_of_abs",
"FStar.Tactics.PatternMatching.cleanup_abspat"
] | [] | false | true | false | false | false | let matching_problem_of_abs (tm: term) : Tac (matching_problem * abspat_continuation) =
| let binders, body = binders_and_body_of_abs (cleanup_abspat tm) in
debug ("Got binders: " ^
(String.concat ", " (map (fun b -> name_of_named_binder b <: Tac string) binders)));
let classified_binders:list (binder & string & abspat_binder_kind & typ) =
map (fun binder ->
let bv_name = name_of_named_binder binder in
debug ("Got binder: " ^
bv_name ^ "; type is " ^ term_to_string (type_of_named_binder binder));
let binder_kind, typ = classify_abspat_binder binder in
(binder, bv_name, binder_kind, typ))
binders
in
let problem =
fold_left (fun problem (binder, bv_name, binder_kind, typ) ->
debug ("Compiling binder " ^
name_of_named_binder binder ^
", classified as " ^
string_of_abspat_binder_kind binder_kind ^ ", with type " ^ term_to_string typ);
match binder_kind with
| ABKVar _ -> { problem with mp_vars = bv_name :: problem.mp_vars }
| ABKHyp -> { problem with mp_hyps = (bv_name, (pattern_of_term typ)) :: problem.mp_hyps }
| ABKGoal -> { problem with mp_goal = Some (pattern_of_term typ) })
({ mp_vars = []; mp_hyps = []; mp_goal = None })
classified_binders
in
let continuation =
let abspat_argspec_of_binder xx : Tac abspat_argspec =
match xx with
| binder, xx, binder_kind, yy -> { asa_name = binder_to_binding binder; asa_kind = binder_kind }
in
(map abspat_argspec_of_binder classified_binders, tm)
in
let mp =
{
mp_vars = List.Tot.Base.rev #varname problem.mp_vars;
mp_hyps = List.Tot.Base.rev #(varname * pattern) problem.mp_hyps;
mp_goal = problem.mp_goal
}
in
debug ("Got matching problem: " ^ (string_of_matching_problem mp));
mp, continuation | false |
MerkleTree.Spec.fst | MerkleTree.Spec.mt_verify_ | val mt_verify_:
#hsz:pos -> #f:hash_fun_t #hsz ->#n:nat ->
p:path #hsz n -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> GTot (padded_hash #hsz) | val mt_verify_:
#hsz:pos -> #f:hash_fun_t #hsz ->#n:nat ->
p:path #hsz n -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> GTot (padded_hash #hsz) | let rec mt_verify_ #hsz #f #n p idx h =
if n = 0 then h
else mt_verify_ #_ #f #(n-1) (S.tail p) (idx / 2)
(if idx % 2 = 0
then padded_hash_fun #_ f h (S.head p)
else padded_hash_fun #_ f (S.head p) h) | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 58,
"end_line": 268,
"start_col": 0,
"start_line": 263
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1))
val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2)))
let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]);
assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]);
assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i])
val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2))
(S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2)))
let mt_next_lv_equiv #hsz #f j n mt1 mt2 =
hs_next_lv_equiv #_ #f j (pow2 (n-1)) mt1 mt2
val hs_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes #hsz {S.length hs = 2 * n} ->
nhs:hashes #hsz {S.length nhs = n} ->
GTot Type0
let hs_next_rel #hsz #f n hs nhs =
forall (i:nat{i < n}).
S.index nhs i ==
padded_hash_fun #hsz f (S.index hs (2 * i)) (S.index hs (2 * i + 1))
val mt_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
GTot Type0
let mt_next_rel #hsz #f n mt nmt =
hs_next_rel #hsz #f (pow2 (n-1)) mt nmt
val hs_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes{S.length hs = 2 * n} ->
nhs:hashes{S.length nhs = n} ->
Lemma (requires hs_next_rel #_ #f n hs nhs)
(ensures S.equal nhs (hs_next_lv #_ #f #n hs))
let rec hs_next_rel_next_lv #hsz #f n hs nhs =
if n = 0 then ()
else hs_next_rel_next_lv #_ #f (n - 1)
(S.slice hs 2 (S.length hs))
(S.slice nhs 1 (S.length nhs))
val mt_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures S.equal nmt (mt_next_lv #_ #f mt))
let mt_next_rel_next_lv #hsz #f n mt nmt =
hs_next_rel_next_lv #_ #f (pow2 (n-1)) mt nmt
val mt_next_rel_upd_even:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i) v)
(S.upd nmt i (padded_hash_fun #hsz f v (S.index mt (2 * i + 1)))))
let mt_next_rel_upd_even #hsz #f n mt nmt i v = ()
#push-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
val mt_next_rel_upd_even_pad:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash #hsz ->
Lemma (requires (mt_next_rel #_ #f n mt nmt) /\ (S.index mt (2 * i + 1) == HPad))
(ensures (mt_next_rel #_ #f n (S.upd mt (2 * i) v) (S.upd nmt i v)))
let mt_next_rel_upd_even_pad #hsz #f n mt nmt i v = ()
#pop-options
val mt_next_rel_upd_odd:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i + 1) v)
(S.upd nmt i (padded_hash_fun #_ f (S.index mt (2 * i)) v)))
let mt_next_rel_upd_odd #hsz #f n mt nmt i v = ()
// fournet: just [root]?
val mt_get_root:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n -> GTot (padded_hash #hsz)
let rec mt_get_root #hsz #f #n mt =
if n = 0 then mt.[0]
else mt_get_root #_ #f (mt_next_lv #_ #f mt)
#push-options "--initial_fuel 2 --max_fuel 2"
val mt_get_root_step: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (mt_get_root #_ #f mt ==
padded_hash_fun #_ f (mt_get_root #_ #f (mt_left mt)) (mt_get_root #_ #f (mt_right mt)))
let rec mt_get_root_step #hsz #f #n mt =
if n = 1 then ()
else begin
mt_get_root_step #_ #f (mt_next_lv #_ #f mt);
mt_next_lv_mt_left #_ #f mt;
mt_next_lv_mt_right #_ #f mt
end
#pop-options
type path #hsz n = S.lseq (padded_hash #hsz) n
/// We first specify full paths, including padding.
val mt_get_path:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
mt:merkle_tree #hsz n -> i:nat{i < pow2 n} -> GTot (path #hsz n)
let rec mt_get_path #hsz #f #n t i =
if n = 0 then S.empty
else S.cons
(if i % 2 = 0 then t.[i + 1] else t.[i - 1])
(mt_get_path #_ #f (mt_next_lv #_ #f t) (i / 2))
val mt_verify_:
#hsz:pos -> #f:hash_fun_t #hsz ->#n:nat -> | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p: MerkleTree.Spec.path n -> idx: Prims.nat{idx < Prims.pow2 n} -> h: MerkleTree.Spec.padded_hash
-> Prims.GTot MerkleTree.Spec.padded_hash | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"MerkleTree.Spec.path",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"MerkleTree.Spec.padded_hash",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"MerkleTree.Spec.mt_verify_",
"Prims.op_Subtraction",
"FStar.Seq.Properties.tail",
"Prims.op_Division",
"Prims.op_Modulus",
"MerkleTree.Spec.padded_hash_fun",
"FStar.Seq.Properties.head",
"Prims.l_or",
"Prims.precedes",
"Prims.l_and",
"Prims.op_Equals_Equals_Equals"
] | [
"recursion"
] | false | false | false | false | false | let rec mt_verify_ #hsz #f #n p idx h =
| if n = 0
then h
else
mt_verify_ #_
#f
#(n - 1)
(S.tail p)
(idx / 2)
(if idx % 2 = 0 then padded_hash_fun #_ f h (S.head p) else padded_hash_fun #_ f (S.head p) h) | false |
MerkleTree.Spec.fst | MerkleTree.Spec.raw_hashes_index | val raw_hashes_index:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat{i < S.length hs} ->
Lemma (requires raw_hashes #_ #f hs)
(ensures HRaw? #hsz hs.[i])
(decreases i) | val raw_hashes_index:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat{i < S.length hs} ->
Lemma (requires raw_hashes #_ #f hs)
(ensures HRaw? #hsz hs.[i])
(decreases i) | let rec raw_hashes_index #hsz #f hs i =
if i = 0 then ()
else raw_hashes_index #_ #f (S.tail hs) (i - 1) | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 49,
"end_line": 349,
"start_col": 0,
"start_line": 347
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1))
val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2)))
let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]);
assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]);
assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i])
val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2))
(S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2)))
let mt_next_lv_equiv #hsz #f j n mt1 mt2 =
hs_next_lv_equiv #_ #f j (pow2 (n-1)) mt1 mt2
val hs_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes #hsz {S.length hs = 2 * n} ->
nhs:hashes #hsz {S.length nhs = n} ->
GTot Type0
let hs_next_rel #hsz #f n hs nhs =
forall (i:nat{i < n}).
S.index nhs i ==
padded_hash_fun #hsz f (S.index hs (2 * i)) (S.index hs (2 * i + 1))
val mt_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
GTot Type0
let mt_next_rel #hsz #f n mt nmt =
hs_next_rel #hsz #f (pow2 (n-1)) mt nmt
val hs_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes{S.length hs = 2 * n} ->
nhs:hashes{S.length nhs = n} ->
Lemma (requires hs_next_rel #_ #f n hs nhs)
(ensures S.equal nhs (hs_next_lv #_ #f #n hs))
let rec hs_next_rel_next_lv #hsz #f n hs nhs =
if n = 0 then ()
else hs_next_rel_next_lv #_ #f (n - 1)
(S.slice hs 2 (S.length hs))
(S.slice nhs 1 (S.length nhs))
val mt_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures S.equal nmt (mt_next_lv #_ #f mt))
let mt_next_rel_next_lv #hsz #f n mt nmt =
hs_next_rel_next_lv #_ #f (pow2 (n-1)) mt nmt
val mt_next_rel_upd_even:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i) v)
(S.upd nmt i (padded_hash_fun #hsz f v (S.index mt (2 * i + 1)))))
let mt_next_rel_upd_even #hsz #f n mt nmt i v = ()
#push-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
val mt_next_rel_upd_even_pad:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash #hsz ->
Lemma (requires (mt_next_rel #_ #f n mt nmt) /\ (S.index mt (2 * i + 1) == HPad))
(ensures (mt_next_rel #_ #f n (S.upd mt (2 * i) v) (S.upd nmt i v)))
let mt_next_rel_upd_even_pad #hsz #f n mt nmt i v = ()
#pop-options
val mt_next_rel_upd_odd:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i + 1) v)
(S.upd nmt i (padded_hash_fun #_ f (S.index mt (2 * i)) v)))
let mt_next_rel_upd_odd #hsz #f n mt nmt i v = ()
// fournet: just [root]?
val mt_get_root:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n -> GTot (padded_hash #hsz)
let rec mt_get_root #hsz #f #n mt =
if n = 0 then mt.[0]
else mt_get_root #_ #f (mt_next_lv #_ #f mt)
#push-options "--initial_fuel 2 --max_fuel 2"
val mt_get_root_step: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (mt_get_root #_ #f mt ==
padded_hash_fun #_ f (mt_get_root #_ #f (mt_left mt)) (mt_get_root #_ #f (mt_right mt)))
let rec mt_get_root_step #hsz #f #n mt =
if n = 1 then ()
else begin
mt_get_root_step #_ #f (mt_next_lv #_ #f mt);
mt_next_lv_mt_left #_ #f mt;
mt_next_lv_mt_right #_ #f mt
end
#pop-options
type path #hsz n = S.lseq (padded_hash #hsz) n
/// We first specify full paths, including padding.
val mt_get_path:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
mt:merkle_tree #hsz n -> i:nat{i < pow2 n} -> GTot (path #hsz n)
let rec mt_get_path #hsz #f #n t i =
if n = 0 then S.empty
else S.cons
(if i % 2 = 0 then t.[i + 1] else t.[i - 1])
(mt_get_path #_ #f (mt_next_lv #_ #f t) (i / 2))
val mt_verify_:
#hsz:pos -> #f:hash_fun_t #hsz ->#n:nat ->
p:path #hsz n -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> GTot (padded_hash #hsz)
let rec mt_verify_ #hsz #f #n p idx h =
if n = 0 then h
else mt_verify_ #_ #f #(n-1) (S.tail p) (idx / 2)
(if idx % 2 = 0
then padded_hash_fun #_ f h (S.head p)
else padded_hash_fun #_ f (S.head p) h)
val mt_verify:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
p:(path #hsz n) -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> padded_hash #hsz -> GTot prop
let mt_verify #hsz #f #n p idx h rt =
rt == mt_verify_ #_ #f p idx h
/// Correctness: the root of a tree is correctly recomputed from any of its paths
val hs_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
hs:hashes{S.length hs = 2 * n} -> idx:nat{idx < 2 * n} ->
Lemma ((hs_next_lv #_ #f #n hs).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f hs.[idx] hs.[idx + 1]
else padded_hash_fun #_ f hs.[idx - 1] hs.[idx]))
let rec hs_next_lv_get #hsz #f #n hs idx =
if idx < 2 then ()
else hs_next_lv_get #_ #f #(n-1) (S.slice hs 2 (S.length hs)) (idx - 2)
val mt_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} ->
Lemma (
(mt_next_lv #_ #f mt).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f mt.[idx] mt.[idx + 1]
else padded_hash_fun #_ f mt.[idx - 1] mt.[idx]))
let mt_next_lv_get #hsz #f #n mt idx =
hs_next_lv_get #_ #f #(pow2 (n-1)) mt idx
val mt_get_path_ok_:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
t:merkle_tree #hsz n -> i:nat{i < pow2 n} ->
Lemma (mt_verify_ #_ #f (mt_get_path #_ #f t i) i (mt_get t i) == mt_get_root #_ #f t)
let rec mt_get_path_ok_ #hsz #f #n mt idx =
if n = 0 then ()
else begin
assert (S.head (mt_get_path #_ #f mt idx) ==
(if idx % 2 = 0 then mt.[idx + 1] else mt.[idx - 1]));
assert (S.equal (S.tail (mt_get_path #_ #f mt idx))
(mt_get_path #_ #f (mt_next_lv #_ #f mt) (idx / 2)));
mt_get_path_ok_ #_ #f (mt_next_lv #_ #f mt) (idx / 2);
mt_next_lv_get #_ #f mt idx
end
/// Security: we reduce tree collisions to collisions on the hash
/// compression function. Such collisions yield collisions on the SHA2
/// standard (by adding the same length and padding to the
/// accumulators).
///
/// One complication addressed in the proof is the handling of
/// implicit padding.
/// All hashes in a sequence are raw hashes, not padding
val raw_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes #hsz -> Tot Type0 (decreases (S.length hs))
let rec raw_hashes #hsz #f hs =
if S.length hs = 0 then True
else (HRaw? (S.head hs) /\ raw_hashes #_ #f (S.tail hs))
val raw_hashes_raws:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes{raw_hashes #hsz #f hs} ->
Tot (S.seq (hash #hsz)) (decreases (S.length hs))
let rec raw_hashes_raws #hsz #f hs =
if S.length hs = 0 then S.empty
else S.cons (HRaw?.hr (S.head hs)) (raw_hashes_raws #_ #f (S.tail hs))
val raw_hashes_index:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat{i < S.length hs} ->
Lemma (requires raw_hashes #_ #f hs)
(ensures HRaw? #hsz hs.[i]) | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | hs: MerkleTree.Spec.hashes -> i: Prims.nat{i < FStar.Seq.Base.length hs}
-> FStar.Pervasives.Lemma (requires MerkleTree.Spec.raw_hashes hs)
(ensures HRaw? hs.[ i ])
(decreases i) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"MerkleTree.Spec.hashes",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"MerkleTree.Spec.padded_hash",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"MerkleTree.Spec.raw_hashes_index",
"FStar.Seq.Properties.tail",
"Prims.op_Subtraction",
"Prims.unit"
] | [
"recursion"
] | false | false | true | false | false | let rec raw_hashes_index #hsz #f hs i =
| if i = 0 then () else raw_hashes_index #_ #f (S.tail hs) (i - 1) | false |
MerkleTree.Spec.fst | MerkleTree.Spec.rpmt_get_root_raw | val rpmt_get_root_raw:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #_ #f n i ->
Lemma (i > 0 <==> HRaw? (mt_get_root #_ #f mt)) | val rpmt_get_root_raw:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #_ #f n i ->
Lemma (i > 0 <==> HRaw? (mt_get_root #_ #f mt)) | let rpmt_get_root_raw #hsz #f #n #i mt =
allow_inversion (padded_hash #hsz);
rpmt_get_root_pad #_ #f mt | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 28,
"end_line": 481,
"start_col": 0,
"start_line": 479
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1))
val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2)))
let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]);
assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]);
assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i])
val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2))
(S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2)))
let mt_next_lv_equiv #hsz #f j n mt1 mt2 =
hs_next_lv_equiv #_ #f j (pow2 (n-1)) mt1 mt2
val hs_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes #hsz {S.length hs = 2 * n} ->
nhs:hashes #hsz {S.length nhs = n} ->
GTot Type0
let hs_next_rel #hsz #f n hs nhs =
forall (i:nat{i < n}).
S.index nhs i ==
padded_hash_fun #hsz f (S.index hs (2 * i)) (S.index hs (2 * i + 1))
val mt_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
GTot Type0
let mt_next_rel #hsz #f n mt nmt =
hs_next_rel #hsz #f (pow2 (n-1)) mt nmt
val hs_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes{S.length hs = 2 * n} ->
nhs:hashes{S.length nhs = n} ->
Lemma (requires hs_next_rel #_ #f n hs nhs)
(ensures S.equal nhs (hs_next_lv #_ #f #n hs))
let rec hs_next_rel_next_lv #hsz #f n hs nhs =
if n = 0 then ()
else hs_next_rel_next_lv #_ #f (n - 1)
(S.slice hs 2 (S.length hs))
(S.slice nhs 1 (S.length nhs))
val mt_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures S.equal nmt (mt_next_lv #_ #f mt))
let mt_next_rel_next_lv #hsz #f n mt nmt =
hs_next_rel_next_lv #_ #f (pow2 (n-1)) mt nmt
val mt_next_rel_upd_even:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i) v)
(S.upd nmt i (padded_hash_fun #hsz f v (S.index mt (2 * i + 1)))))
let mt_next_rel_upd_even #hsz #f n mt nmt i v = ()
#push-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
val mt_next_rel_upd_even_pad:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash #hsz ->
Lemma (requires (mt_next_rel #_ #f n mt nmt) /\ (S.index mt (2 * i + 1) == HPad))
(ensures (mt_next_rel #_ #f n (S.upd mt (2 * i) v) (S.upd nmt i v)))
let mt_next_rel_upd_even_pad #hsz #f n mt nmt i v = ()
#pop-options
val mt_next_rel_upd_odd:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i + 1) v)
(S.upd nmt i (padded_hash_fun #_ f (S.index mt (2 * i)) v)))
let mt_next_rel_upd_odd #hsz #f n mt nmt i v = ()
// fournet: just [root]?
val mt_get_root:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n -> GTot (padded_hash #hsz)
let rec mt_get_root #hsz #f #n mt =
if n = 0 then mt.[0]
else mt_get_root #_ #f (mt_next_lv #_ #f mt)
#push-options "--initial_fuel 2 --max_fuel 2"
val mt_get_root_step: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (mt_get_root #_ #f mt ==
padded_hash_fun #_ f (mt_get_root #_ #f (mt_left mt)) (mt_get_root #_ #f (mt_right mt)))
let rec mt_get_root_step #hsz #f #n mt =
if n = 1 then ()
else begin
mt_get_root_step #_ #f (mt_next_lv #_ #f mt);
mt_next_lv_mt_left #_ #f mt;
mt_next_lv_mt_right #_ #f mt
end
#pop-options
type path #hsz n = S.lseq (padded_hash #hsz) n
/// We first specify full paths, including padding.
val mt_get_path:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
mt:merkle_tree #hsz n -> i:nat{i < pow2 n} -> GTot (path #hsz n)
let rec mt_get_path #hsz #f #n t i =
if n = 0 then S.empty
else S.cons
(if i % 2 = 0 then t.[i + 1] else t.[i - 1])
(mt_get_path #_ #f (mt_next_lv #_ #f t) (i / 2))
val mt_verify_:
#hsz:pos -> #f:hash_fun_t #hsz ->#n:nat ->
p:path #hsz n -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> GTot (padded_hash #hsz)
let rec mt_verify_ #hsz #f #n p idx h =
if n = 0 then h
else mt_verify_ #_ #f #(n-1) (S.tail p) (idx / 2)
(if idx % 2 = 0
then padded_hash_fun #_ f h (S.head p)
else padded_hash_fun #_ f (S.head p) h)
val mt_verify:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
p:(path #hsz n) -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> padded_hash #hsz -> GTot prop
let mt_verify #hsz #f #n p idx h rt =
rt == mt_verify_ #_ #f p idx h
/// Correctness: the root of a tree is correctly recomputed from any of its paths
val hs_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
hs:hashes{S.length hs = 2 * n} -> idx:nat{idx < 2 * n} ->
Lemma ((hs_next_lv #_ #f #n hs).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f hs.[idx] hs.[idx + 1]
else padded_hash_fun #_ f hs.[idx - 1] hs.[idx]))
let rec hs_next_lv_get #hsz #f #n hs idx =
if idx < 2 then ()
else hs_next_lv_get #_ #f #(n-1) (S.slice hs 2 (S.length hs)) (idx - 2)
val mt_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} ->
Lemma (
(mt_next_lv #_ #f mt).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f mt.[idx] mt.[idx + 1]
else padded_hash_fun #_ f mt.[idx - 1] mt.[idx]))
let mt_next_lv_get #hsz #f #n mt idx =
hs_next_lv_get #_ #f #(pow2 (n-1)) mt idx
val mt_get_path_ok_:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
t:merkle_tree #hsz n -> i:nat{i < pow2 n} ->
Lemma (mt_verify_ #_ #f (mt_get_path #_ #f t i) i (mt_get t i) == mt_get_root #_ #f t)
let rec mt_get_path_ok_ #hsz #f #n mt idx =
if n = 0 then ()
else begin
assert (S.head (mt_get_path #_ #f mt idx) ==
(if idx % 2 = 0 then mt.[idx + 1] else mt.[idx - 1]));
assert (S.equal (S.tail (mt_get_path #_ #f mt idx))
(mt_get_path #_ #f (mt_next_lv #_ #f mt) (idx / 2)));
mt_get_path_ok_ #_ #f (mt_next_lv #_ #f mt) (idx / 2);
mt_next_lv_get #_ #f mt idx
end
/// Security: we reduce tree collisions to collisions on the hash
/// compression function. Such collisions yield collisions on the SHA2
/// standard (by adding the same length and padding to the
/// accumulators).
///
/// One complication addressed in the proof is the handling of
/// implicit padding.
/// All hashes in a sequence are raw hashes, not padding
val raw_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes #hsz -> Tot Type0 (decreases (S.length hs))
let rec raw_hashes #hsz #f hs =
if S.length hs = 0 then True
else (HRaw? (S.head hs) /\ raw_hashes #_ #f (S.tail hs))
val raw_hashes_raws:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes{raw_hashes #hsz #f hs} ->
Tot (S.seq (hash #hsz)) (decreases (S.length hs))
let rec raw_hashes_raws #hsz #f hs =
if S.length hs = 0 then S.empty
else S.cons (HRaw?.hr (S.head hs)) (raw_hashes_raws #_ #f (S.tail hs))
val raw_hashes_index:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat{i < S.length hs} ->
Lemma (requires raw_hashes #_ #f hs)
(ensures HRaw? #hsz hs.[i])
(decreases i)
let rec raw_hashes_index #hsz #f hs i =
if i = 0 then ()
else raw_hashes_index #_ #f (S.tail hs) (i - 1)
val raw_hashes_slice:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat -> j:nat{i <= j && j <= S.length hs} ->
Lemma (requires raw_hashes #_ #f hs)
(ensures raw_hashes #_ #f (S.slice hs i j))
(decreases (j - i))
let rec raw_hashes_slice #hsz #f hs i j =
if i = j then ()
else (
raw_hashes_index #_ #f hs i;
raw_hashes_slice #_ #f hs (i + 1) j)
/// All hashes in a sequence are just padding
val pad_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes #hsz -> Type0
let pad_hashes #hsz #f hs =
S.equal hs (S.create (S.length hs) HPad)
val pad_hashes_slice:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat -> j:nat{i <= j && j <= S.length hs} ->
Lemma (requires pad_hashes #_ #f hs)
(ensures pad_hashes #_ #f (S.slice hs i j))
(decreases (j - i))
let rec pad_hashes_slice #hsz #f hs i j =
if i = j then ()
else pad_hashes_slice #_ #f hs (i + 1) j
/// Right-padded Merkle tree, a tree refinement
let rpmt (#hsz:pos) (#f:hash_fun_t) (n:nat) (i:nat{i <= pow2 n}) =
mt:merkle_tree #hsz n {
raw_hashes #_ #f (S.slice mt 0 i) /\
pad_hashes #_ #f (S.slice mt i (S.length mt)) }
val rpmt_raws: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #hsz #f n i -> S.seq (hash #hsz)
let rpmt_raws #hsz #f #n #i mt = raw_hashes_raws #_ #f (S.slice mt 0 i)
val rpmt_i_0: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> mt:rpmt #hsz #f n 0 ->
Lemma (S.equal mt (S.create (pow2 n) (HPad #hsz)))
let rpmt_i_0 #hsz #f #n mt = ()
val rpmt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> #i:nat{i <= pow2 n} -> rpmt #hsz #f n i ->
rpmt #hsz #f (n-1) (if i <= pow2 (n-1) then i else pow2 (n-1))
let rpmt_left #hsz #f #n #i mt =
if i <= pow2 (n-1)
then pad_hashes_slice #_ #f (S.slice mt i (S.length mt)) 0 (pow2 (n-1) - i)
else raw_hashes_slice #_ #f (S.slice mt 0 i) 0 (pow2 (n-1));
mt_left mt
#push-options "--z3rlimit 40"
val rpmt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> #i:nat{i <= pow2 n} -> rpmt #hsz #f n i ->
rpmt #_ #f (n-1) (if i <= pow2 (n-1) then 0 else i - pow2 (n-1))
let rpmt_right #hsz #f #n #i mt =
if i <= pow2 (n-1)
then pad_hashes_slice #_ #f (S.slice mt i (S.length mt)) (pow2 (n-1) - i) (pow2 n - i)
else raw_hashes_slice #_ #f (S.slice mt 0 i) (pow2 (n-1)) i;
mt_right mt
/// Two right-padded Merkle trees collide when
/// 1) they have the same height (`n`) and number of raw hashes (`i`),
/// 2) their contents differ, and
/// 3) their roots are same.
// fournet: we may want to work towards removing 1) using a hash prefix
noeq
type mt_collide (#hsz:pos) (#f:hash_fun_t #hsz) (n:nat) (i:nat{i <= pow2 n}) = | Collision:
mt1:rpmt #_ #f n i -> mt2:rpmt #_ #f n i {
mt1 =!= mt2 /\
mt_get_root #_ #f #_ mt1 == mt_get_root #_ #f #_ mt2 } -> mt_collide #_ #f n i
noeq
type hash2_raw_collide = | Collision2:
#hsz:pos -> #f:hash_fun_t #hsz ->
lh1:hash -> rh1:hash ->
lh2:hash -> rh2:hash {
(lh1 =!= lh2 \/ rh1 =!= rh2) /\
f lh1 rh1 == f lh2 rh2 } -> hash2_raw_collide
/// Auxiliary lemmas for the proof
val rpmt_pad_hashes_0:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #_ #f n i ->
Lemma (i = 0 <==> pad_hashes #_ #f mt )
let rpmt_pad_hashes_0 #_ #_ #n #i mt = ()
val rpmt_pad_hashes_index_0:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> #i:nat{i <= pow2 n} ->
mt:rpmt #_ #f n i ->
Lemma (pad_hashes #_ #f mt <==> HPad? mt.[0])
let rpmt_pad_hashes_index_0 #_ #_ #n #i mt = ()
val mt_get_root_pad_index_0:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n ->
Lemma (HPad? mt.[0] <==> HPad? (mt_get_root #_ #f mt))
let rec mt_get_root_pad_index_0 #hsz #f #n (mt:merkle_tree #hsz n) =
if n = 0 then ()
else
let mt:merkle_tree #hsz (n-1) = mt_next_lv #_ #f #n mt in
mt_get_root_pad_index_0 #_ #f #(n-1) mt
#pop-options
val rpmt_get_root_pad_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #_ #f n i ->
Lemma (pad_hashes #_ #f mt <==> HPad? (mt_get_root #_ #f mt))
let rpmt_get_root_pad_hashes #_ #f #n #i mt =
rpmt_pad_hashes_index_0 #_ #f mt;
mt_get_root_pad_index_0 #_ #f mt
val rpmt_get_root_pad:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #_ #f n i ->
Lemma (i = 0 <==> HPad? (mt_get_root #_ #f mt))
let rpmt_get_root_pad #_ #f #n #i mt =
rpmt_get_root_pad_hashes #_ #f mt;
rpmt_pad_hashes_0 #_ #f mt
val rpmt_get_root_raw:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #_ #f n i -> | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | mt: MerkleTree.Spec.rpmt n i
-> FStar.Pervasives.Lemma (ensures i > 0 <==> HRaw? (MerkleTree.Spec.mt_get_root mt)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.pow2",
"MerkleTree.Spec.rpmt",
"MerkleTree.Spec.rpmt_get_root_pad",
"Prims.unit",
"FStar.Pervasives.allow_inversion",
"MerkleTree.Spec.padded_hash"
] | [] | true | false | true | false | false | let rpmt_get_root_raw #hsz #f #n #i mt =
| allow_inversion (padded_hash #hsz);
rpmt_get_root_pad #_ #f mt | false |
MerkleTree.Spec.fst | MerkleTree.Spec.rpmt_get_root_pad | val rpmt_get_root_pad:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #_ #f n i ->
Lemma (i = 0 <==> HPad? (mt_get_root #_ #f mt)) | val rpmt_get_root_pad:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #_ #f n i ->
Lemma (i = 0 <==> HPad? (mt_get_root #_ #f mt)) | let rpmt_get_root_pad #_ #f #n #i mt =
rpmt_get_root_pad_hashes #_ #f mt;
rpmt_pad_hashes_0 #_ #f mt | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 28,
"end_line": 473,
"start_col": 0,
"start_line": 471
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1))
val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2)))
let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]);
assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]);
assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i])
val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2))
(S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2)))
let mt_next_lv_equiv #hsz #f j n mt1 mt2 =
hs_next_lv_equiv #_ #f j (pow2 (n-1)) mt1 mt2
val hs_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes #hsz {S.length hs = 2 * n} ->
nhs:hashes #hsz {S.length nhs = n} ->
GTot Type0
let hs_next_rel #hsz #f n hs nhs =
forall (i:nat{i < n}).
S.index nhs i ==
padded_hash_fun #hsz f (S.index hs (2 * i)) (S.index hs (2 * i + 1))
val mt_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
GTot Type0
let mt_next_rel #hsz #f n mt nmt =
hs_next_rel #hsz #f (pow2 (n-1)) mt nmt
val hs_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes{S.length hs = 2 * n} ->
nhs:hashes{S.length nhs = n} ->
Lemma (requires hs_next_rel #_ #f n hs nhs)
(ensures S.equal nhs (hs_next_lv #_ #f #n hs))
let rec hs_next_rel_next_lv #hsz #f n hs nhs =
if n = 0 then ()
else hs_next_rel_next_lv #_ #f (n - 1)
(S.slice hs 2 (S.length hs))
(S.slice nhs 1 (S.length nhs))
val mt_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures S.equal nmt (mt_next_lv #_ #f mt))
let mt_next_rel_next_lv #hsz #f n mt nmt =
hs_next_rel_next_lv #_ #f (pow2 (n-1)) mt nmt
val mt_next_rel_upd_even:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i) v)
(S.upd nmt i (padded_hash_fun #hsz f v (S.index mt (2 * i + 1)))))
let mt_next_rel_upd_even #hsz #f n mt nmt i v = ()
#push-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
val mt_next_rel_upd_even_pad:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash #hsz ->
Lemma (requires (mt_next_rel #_ #f n mt nmt) /\ (S.index mt (2 * i + 1) == HPad))
(ensures (mt_next_rel #_ #f n (S.upd mt (2 * i) v) (S.upd nmt i v)))
let mt_next_rel_upd_even_pad #hsz #f n mt nmt i v = ()
#pop-options
val mt_next_rel_upd_odd:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i + 1) v)
(S.upd nmt i (padded_hash_fun #_ f (S.index mt (2 * i)) v)))
let mt_next_rel_upd_odd #hsz #f n mt nmt i v = ()
// fournet: just [root]?
val mt_get_root:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n -> GTot (padded_hash #hsz)
let rec mt_get_root #hsz #f #n mt =
if n = 0 then mt.[0]
else mt_get_root #_ #f (mt_next_lv #_ #f mt)
#push-options "--initial_fuel 2 --max_fuel 2"
val mt_get_root_step: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (mt_get_root #_ #f mt ==
padded_hash_fun #_ f (mt_get_root #_ #f (mt_left mt)) (mt_get_root #_ #f (mt_right mt)))
let rec mt_get_root_step #hsz #f #n mt =
if n = 1 then ()
else begin
mt_get_root_step #_ #f (mt_next_lv #_ #f mt);
mt_next_lv_mt_left #_ #f mt;
mt_next_lv_mt_right #_ #f mt
end
#pop-options
type path #hsz n = S.lseq (padded_hash #hsz) n
/// We first specify full paths, including padding.
val mt_get_path:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
mt:merkle_tree #hsz n -> i:nat{i < pow2 n} -> GTot (path #hsz n)
let rec mt_get_path #hsz #f #n t i =
if n = 0 then S.empty
else S.cons
(if i % 2 = 0 then t.[i + 1] else t.[i - 1])
(mt_get_path #_ #f (mt_next_lv #_ #f t) (i / 2))
val mt_verify_:
#hsz:pos -> #f:hash_fun_t #hsz ->#n:nat ->
p:path #hsz n -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> GTot (padded_hash #hsz)
let rec mt_verify_ #hsz #f #n p idx h =
if n = 0 then h
else mt_verify_ #_ #f #(n-1) (S.tail p) (idx / 2)
(if idx % 2 = 0
then padded_hash_fun #_ f h (S.head p)
else padded_hash_fun #_ f (S.head p) h)
val mt_verify:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
p:(path #hsz n) -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> padded_hash #hsz -> GTot prop
let mt_verify #hsz #f #n p idx h rt =
rt == mt_verify_ #_ #f p idx h
/// Correctness: the root of a tree is correctly recomputed from any of its paths
val hs_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
hs:hashes{S.length hs = 2 * n} -> idx:nat{idx < 2 * n} ->
Lemma ((hs_next_lv #_ #f #n hs).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f hs.[idx] hs.[idx + 1]
else padded_hash_fun #_ f hs.[idx - 1] hs.[idx]))
let rec hs_next_lv_get #hsz #f #n hs idx =
if idx < 2 then ()
else hs_next_lv_get #_ #f #(n-1) (S.slice hs 2 (S.length hs)) (idx - 2)
val mt_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} ->
Lemma (
(mt_next_lv #_ #f mt).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f mt.[idx] mt.[idx + 1]
else padded_hash_fun #_ f mt.[idx - 1] mt.[idx]))
let mt_next_lv_get #hsz #f #n mt idx =
hs_next_lv_get #_ #f #(pow2 (n-1)) mt idx
val mt_get_path_ok_:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
t:merkle_tree #hsz n -> i:nat{i < pow2 n} ->
Lemma (mt_verify_ #_ #f (mt_get_path #_ #f t i) i (mt_get t i) == mt_get_root #_ #f t)
let rec mt_get_path_ok_ #hsz #f #n mt idx =
if n = 0 then ()
else begin
assert (S.head (mt_get_path #_ #f mt idx) ==
(if idx % 2 = 0 then mt.[idx + 1] else mt.[idx - 1]));
assert (S.equal (S.tail (mt_get_path #_ #f mt idx))
(mt_get_path #_ #f (mt_next_lv #_ #f mt) (idx / 2)));
mt_get_path_ok_ #_ #f (mt_next_lv #_ #f mt) (idx / 2);
mt_next_lv_get #_ #f mt idx
end
/// Security: we reduce tree collisions to collisions on the hash
/// compression function. Such collisions yield collisions on the SHA2
/// standard (by adding the same length and padding to the
/// accumulators).
///
/// One complication addressed in the proof is the handling of
/// implicit padding.
/// All hashes in a sequence are raw hashes, not padding
val raw_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes #hsz -> Tot Type0 (decreases (S.length hs))
let rec raw_hashes #hsz #f hs =
if S.length hs = 0 then True
else (HRaw? (S.head hs) /\ raw_hashes #_ #f (S.tail hs))
val raw_hashes_raws:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes{raw_hashes #hsz #f hs} ->
Tot (S.seq (hash #hsz)) (decreases (S.length hs))
let rec raw_hashes_raws #hsz #f hs =
if S.length hs = 0 then S.empty
else S.cons (HRaw?.hr (S.head hs)) (raw_hashes_raws #_ #f (S.tail hs))
val raw_hashes_index:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat{i < S.length hs} ->
Lemma (requires raw_hashes #_ #f hs)
(ensures HRaw? #hsz hs.[i])
(decreases i)
let rec raw_hashes_index #hsz #f hs i =
if i = 0 then ()
else raw_hashes_index #_ #f (S.tail hs) (i - 1)
val raw_hashes_slice:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat -> j:nat{i <= j && j <= S.length hs} ->
Lemma (requires raw_hashes #_ #f hs)
(ensures raw_hashes #_ #f (S.slice hs i j))
(decreases (j - i))
let rec raw_hashes_slice #hsz #f hs i j =
if i = j then ()
else (
raw_hashes_index #_ #f hs i;
raw_hashes_slice #_ #f hs (i + 1) j)
/// All hashes in a sequence are just padding
val pad_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes #hsz -> Type0
let pad_hashes #hsz #f hs =
S.equal hs (S.create (S.length hs) HPad)
val pad_hashes_slice:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat -> j:nat{i <= j && j <= S.length hs} ->
Lemma (requires pad_hashes #_ #f hs)
(ensures pad_hashes #_ #f (S.slice hs i j))
(decreases (j - i))
let rec pad_hashes_slice #hsz #f hs i j =
if i = j then ()
else pad_hashes_slice #_ #f hs (i + 1) j
/// Right-padded Merkle tree, a tree refinement
let rpmt (#hsz:pos) (#f:hash_fun_t) (n:nat) (i:nat{i <= pow2 n}) =
mt:merkle_tree #hsz n {
raw_hashes #_ #f (S.slice mt 0 i) /\
pad_hashes #_ #f (S.slice mt i (S.length mt)) }
val rpmt_raws: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #hsz #f n i -> S.seq (hash #hsz)
let rpmt_raws #hsz #f #n #i mt = raw_hashes_raws #_ #f (S.slice mt 0 i)
val rpmt_i_0: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> mt:rpmt #hsz #f n 0 ->
Lemma (S.equal mt (S.create (pow2 n) (HPad #hsz)))
let rpmt_i_0 #hsz #f #n mt = ()
val rpmt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> #i:nat{i <= pow2 n} -> rpmt #hsz #f n i ->
rpmt #hsz #f (n-1) (if i <= pow2 (n-1) then i else pow2 (n-1))
let rpmt_left #hsz #f #n #i mt =
if i <= pow2 (n-1)
then pad_hashes_slice #_ #f (S.slice mt i (S.length mt)) 0 (pow2 (n-1) - i)
else raw_hashes_slice #_ #f (S.slice mt 0 i) 0 (pow2 (n-1));
mt_left mt
#push-options "--z3rlimit 40"
val rpmt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> #i:nat{i <= pow2 n} -> rpmt #hsz #f n i ->
rpmt #_ #f (n-1) (if i <= pow2 (n-1) then 0 else i - pow2 (n-1))
let rpmt_right #hsz #f #n #i mt =
if i <= pow2 (n-1)
then pad_hashes_slice #_ #f (S.slice mt i (S.length mt)) (pow2 (n-1) - i) (pow2 n - i)
else raw_hashes_slice #_ #f (S.slice mt 0 i) (pow2 (n-1)) i;
mt_right mt
/// Two right-padded Merkle trees collide when
/// 1) they have the same height (`n`) and number of raw hashes (`i`),
/// 2) their contents differ, and
/// 3) their roots are same.
// fournet: we may want to work towards removing 1) using a hash prefix
noeq
type mt_collide (#hsz:pos) (#f:hash_fun_t #hsz) (n:nat) (i:nat{i <= pow2 n}) = | Collision:
mt1:rpmt #_ #f n i -> mt2:rpmt #_ #f n i {
mt1 =!= mt2 /\
mt_get_root #_ #f #_ mt1 == mt_get_root #_ #f #_ mt2 } -> mt_collide #_ #f n i
noeq
type hash2_raw_collide = | Collision2:
#hsz:pos -> #f:hash_fun_t #hsz ->
lh1:hash -> rh1:hash ->
lh2:hash -> rh2:hash {
(lh1 =!= lh2 \/ rh1 =!= rh2) /\
f lh1 rh1 == f lh2 rh2 } -> hash2_raw_collide
/// Auxiliary lemmas for the proof
val rpmt_pad_hashes_0:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #_ #f n i ->
Lemma (i = 0 <==> pad_hashes #_ #f mt )
let rpmt_pad_hashes_0 #_ #_ #n #i mt = ()
val rpmt_pad_hashes_index_0:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> #i:nat{i <= pow2 n} ->
mt:rpmt #_ #f n i ->
Lemma (pad_hashes #_ #f mt <==> HPad? mt.[0])
let rpmt_pad_hashes_index_0 #_ #_ #n #i mt = ()
val mt_get_root_pad_index_0:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n ->
Lemma (HPad? mt.[0] <==> HPad? (mt_get_root #_ #f mt))
let rec mt_get_root_pad_index_0 #hsz #f #n (mt:merkle_tree #hsz n) =
if n = 0 then ()
else
let mt:merkle_tree #hsz (n-1) = mt_next_lv #_ #f #n mt in
mt_get_root_pad_index_0 #_ #f #(n-1) mt
#pop-options
val rpmt_get_root_pad_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #_ #f n i ->
Lemma (pad_hashes #_ #f mt <==> HPad? (mt_get_root #_ #f mt))
let rpmt_get_root_pad_hashes #_ #f #n #i mt =
rpmt_pad_hashes_index_0 #_ #f mt;
mt_get_root_pad_index_0 #_ #f mt
val rpmt_get_root_pad:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #_ #f n i -> | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | mt: MerkleTree.Spec.rpmt n i
-> FStar.Pervasives.Lemma (ensures i = 0 <==> HPad? (MerkleTree.Spec.mt_get_root mt)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.pow2",
"MerkleTree.Spec.rpmt",
"MerkleTree.Spec.rpmt_pad_hashes_0",
"Prims.unit",
"MerkleTree.Spec.rpmt_get_root_pad_hashes"
] | [] | true | false | true | false | false | let rpmt_get_root_pad #_ #f #n #i mt =
| rpmt_get_root_pad_hashes #_ #f mt;
rpmt_pad_hashes_0 #_ #f mt | false |
MerkleTree.Spec.fst | MerkleTree.Spec.rpmt_raws | val rpmt_raws: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #hsz #f n i -> S.seq (hash #hsz) | val rpmt_raws: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #hsz #f n i -> S.seq (hash #hsz) | let rpmt_raws #hsz #f #n #i mt = raw_hashes_raws #_ #f (S.slice mt 0 i) | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 71,
"end_line": 388,
"start_col": 0,
"start_line": 388
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1))
val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2)))
let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]);
assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]);
assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i])
val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2))
(S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2)))
let mt_next_lv_equiv #hsz #f j n mt1 mt2 =
hs_next_lv_equiv #_ #f j (pow2 (n-1)) mt1 mt2
val hs_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes #hsz {S.length hs = 2 * n} ->
nhs:hashes #hsz {S.length nhs = n} ->
GTot Type0
let hs_next_rel #hsz #f n hs nhs =
forall (i:nat{i < n}).
S.index nhs i ==
padded_hash_fun #hsz f (S.index hs (2 * i)) (S.index hs (2 * i + 1))
val mt_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
GTot Type0
let mt_next_rel #hsz #f n mt nmt =
hs_next_rel #hsz #f (pow2 (n-1)) mt nmt
val hs_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes{S.length hs = 2 * n} ->
nhs:hashes{S.length nhs = n} ->
Lemma (requires hs_next_rel #_ #f n hs nhs)
(ensures S.equal nhs (hs_next_lv #_ #f #n hs))
let rec hs_next_rel_next_lv #hsz #f n hs nhs =
if n = 0 then ()
else hs_next_rel_next_lv #_ #f (n - 1)
(S.slice hs 2 (S.length hs))
(S.slice nhs 1 (S.length nhs))
val mt_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures S.equal nmt (mt_next_lv #_ #f mt))
let mt_next_rel_next_lv #hsz #f n mt nmt =
hs_next_rel_next_lv #_ #f (pow2 (n-1)) mt nmt
val mt_next_rel_upd_even:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i) v)
(S.upd nmt i (padded_hash_fun #hsz f v (S.index mt (2 * i + 1)))))
let mt_next_rel_upd_even #hsz #f n mt nmt i v = ()
#push-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
val mt_next_rel_upd_even_pad:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash #hsz ->
Lemma (requires (mt_next_rel #_ #f n mt nmt) /\ (S.index mt (2 * i + 1) == HPad))
(ensures (mt_next_rel #_ #f n (S.upd mt (2 * i) v) (S.upd nmt i v)))
let mt_next_rel_upd_even_pad #hsz #f n mt nmt i v = ()
#pop-options
val mt_next_rel_upd_odd:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i + 1) v)
(S.upd nmt i (padded_hash_fun #_ f (S.index mt (2 * i)) v)))
let mt_next_rel_upd_odd #hsz #f n mt nmt i v = ()
// fournet: just [root]?
val mt_get_root:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n -> GTot (padded_hash #hsz)
let rec mt_get_root #hsz #f #n mt =
if n = 0 then mt.[0]
else mt_get_root #_ #f (mt_next_lv #_ #f mt)
#push-options "--initial_fuel 2 --max_fuel 2"
val mt_get_root_step: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (mt_get_root #_ #f mt ==
padded_hash_fun #_ f (mt_get_root #_ #f (mt_left mt)) (mt_get_root #_ #f (mt_right mt)))
let rec mt_get_root_step #hsz #f #n mt =
if n = 1 then ()
else begin
mt_get_root_step #_ #f (mt_next_lv #_ #f mt);
mt_next_lv_mt_left #_ #f mt;
mt_next_lv_mt_right #_ #f mt
end
#pop-options
type path #hsz n = S.lseq (padded_hash #hsz) n
/// We first specify full paths, including padding.
val mt_get_path:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
mt:merkle_tree #hsz n -> i:nat{i < pow2 n} -> GTot (path #hsz n)
let rec mt_get_path #hsz #f #n t i =
if n = 0 then S.empty
else S.cons
(if i % 2 = 0 then t.[i + 1] else t.[i - 1])
(mt_get_path #_ #f (mt_next_lv #_ #f t) (i / 2))
val mt_verify_:
#hsz:pos -> #f:hash_fun_t #hsz ->#n:nat ->
p:path #hsz n -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> GTot (padded_hash #hsz)
let rec mt_verify_ #hsz #f #n p idx h =
if n = 0 then h
else mt_verify_ #_ #f #(n-1) (S.tail p) (idx / 2)
(if idx % 2 = 0
then padded_hash_fun #_ f h (S.head p)
else padded_hash_fun #_ f (S.head p) h)
val mt_verify:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
p:(path #hsz n) -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> padded_hash #hsz -> GTot prop
let mt_verify #hsz #f #n p idx h rt =
rt == mt_verify_ #_ #f p idx h
/// Correctness: the root of a tree is correctly recomputed from any of its paths
val hs_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
hs:hashes{S.length hs = 2 * n} -> idx:nat{idx < 2 * n} ->
Lemma ((hs_next_lv #_ #f #n hs).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f hs.[idx] hs.[idx + 1]
else padded_hash_fun #_ f hs.[idx - 1] hs.[idx]))
let rec hs_next_lv_get #hsz #f #n hs idx =
if idx < 2 then ()
else hs_next_lv_get #_ #f #(n-1) (S.slice hs 2 (S.length hs)) (idx - 2)
val mt_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} ->
Lemma (
(mt_next_lv #_ #f mt).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f mt.[idx] mt.[idx + 1]
else padded_hash_fun #_ f mt.[idx - 1] mt.[idx]))
let mt_next_lv_get #hsz #f #n mt idx =
hs_next_lv_get #_ #f #(pow2 (n-1)) mt idx
val mt_get_path_ok_:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
t:merkle_tree #hsz n -> i:nat{i < pow2 n} ->
Lemma (mt_verify_ #_ #f (mt_get_path #_ #f t i) i (mt_get t i) == mt_get_root #_ #f t)
let rec mt_get_path_ok_ #hsz #f #n mt idx =
if n = 0 then ()
else begin
assert (S.head (mt_get_path #_ #f mt idx) ==
(if idx % 2 = 0 then mt.[idx + 1] else mt.[idx - 1]));
assert (S.equal (S.tail (mt_get_path #_ #f mt idx))
(mt_get_path #_ #f (mt_next_lv #_ #f mt) (idx / 2)));
mt_get_path_ok_ #_ #f (mt_next_lv #_ #f mt) (idx / 2);
mt_next_lv_get #_ #f mt idx
end
/// Security: we reduce tree collisions to collisions on the hash
/// compression function. Such collisions yield collisions on the SHA2
/// standard (by adding the same length and padding to the
/// accumulators).
///
/// One complication addressed in the proof is the handling of
/// implicit padding.
/// All hashes in a sequence are raw hashes, not padding
val raw_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes #hsz -> Tot Type0 (decreases (S.length hs))
let rec raw_hashes #hsz #f hs =
if S.length hs = 0 then True
else (HRaw? (S.head hs) /\ raw_hashes #_ #f (S.tail hs))
val raw_hashes_raws:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes{raw_hashes #hsz #f hs} ->
Tot (S.seq (hash #hsz)) (decreases (S.length hs))
let rec raw_hashes_raws #hsz #f hs =
if S.length hs = 0 then S.empty
else S.cons (HRaw?.hr (S.head hs)) (raw_hashes_raws #_ #f (S.tail hs))
val raw_hashes_index:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat{i < S.length hs} ->
Lemma (requires raw_hashes #_ #f hs)
(ensures HRaw? #hsz hs.[i])
(decreases i)
let rec raw_hashes_index #hsz #f hs i =
if i = 0 then ()
else raw_hashes_index #_ #f (S.tail hs) (i - 1)
val raw_hashes_slice:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat -> j:nat{i <= j && j <= S.length hs} ->
Lemma (requires raw_hashes #_ #f hs)
(ensures raw_hashes #_ #f (S.slice hs i j))
(decreases (j - i))
let rec raw_hashes_slice #hsz #f hs i j =
if i = j then ()
else (
raw_hashes_index #_ #f hs i;
raw_hashes_slice #_ #f hs (i + 1) j)
/// All hashes in a sequence are just padding
val pad_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes #hsz -> Type0
let pad_hashes #hsz #f hs =
S.equal hs (S.create (S.length hs) HPad)
val pad_hashes_slice:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat -> j:nat{i <= j && j <= S.length hs} ->
Lemma (requires pad_hashes #_ #f hs)
(ensures pad_hashes #_ #f (S.slice hs i j))
(decreases (j - i))
let rec pad_hashes_slice #hsz #f hs i j =
if i = j then ()
else pad_hashes_slice #_ #f hs (i + 1) j
/// Right-padded Merkle tree, a tree refinement
let rpmt (#hsz:pos) (#f:hash_fun_t) (n:nat) (i:nat{i <= pow2 n}) =
mt:merkle_tree #hsz n {
raw_hashes #_ #f (S.slice mt 0 i) /\
pad_hashes #_ #f (S.slice mt i (S.length mt)) } | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | mt: MerkleTree.Spec.rpmt n i -> FStar.Seq.Base.seq MerkleTree.Spec.hash | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.pow2",
"MerkleTree.Spec.rpmt",
"MerkleTree.Spec.raw_hashes_raws",
"FStar.Seq.Base.slice",
"MerkleTree.Spec.padded_hash",
"FStar.Seq.Base.seq",
"MerkleTree.Spec.hash"
] | [] | false | false | false | false | false | let rpmt_raws #hsz #f #n #i mt =
| raw_hashes_raws #_ #f (S.slice mt 0 i) | false |
MerkleTree.Spec.fst | MerkleTree.Spec.hs_next_lv_equiv | val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2))) | val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2))) | let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]);
assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]);
assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i]) | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 58,
"end_line": 130,
"start_col": 0,
"start_line": 119
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1))
val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2)) | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
j: Prims.nat ->
n: Prims.pos{j <= 2 * n} ->
hs1: MerkleTree.Spec.hashes{FStar.Seq.Base.length hs1 = 2 * n} ->
hs2: MerkleTree.Spec.hashes{FStar.Seq.Base.length hs2 = 2 * n}
-> FStar.Pervasives.Lemma
(requires FStar.Seq.Base.equal (FStar.Seq.Base.slice hs1 0 j) (FStar.Seq.Base.slice hs2 0 j))
(ensures
FStar.Seq.Base.equal (FStar.Seq.Base.slice (MerkleTree.Spec.hs_next_lv hs1) 0 (j / 2))
(FStar.Seq.Base.slice (MerkleTree.Spec.hs_next_lv hs2) 0 (j / 2))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"MerkleTree.Spec.hashes",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"MerkleTree.Spec.padded_hash",
"Prims._assert",
"Prims.l_Forall",
"Prims.op_LessThan",
"Prims.op_Division",
"Prims.eq2",
"MerkleTree.Spec.op_String_Access",
"Prims.unit",
"Prims.op_Addition",
"FStar.Seq.Base.slice",
"MerkleTree.Spec.padded_hash_fun",
"MerkleTree.Spec.hs_next_lv",
"FStar.Classical.forall_intro",
"MerkleTree.Spec.hs_next_lv_index"
] | [] | false | false | true | false | false | let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
| forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i: nat{i < j / 2}).
hs1'.[ i ] == padded_hash_fun #hsz f hs1.[ 2 * i ] hs1.[ 2 * i + 1 ]);
assert (forall (i: nat{i < j / 2}).
hs2'.[ i ] == padded_hash_fun #hsz f hs2.[ 2 * i ] hs2.[ 2 * i + 1 ]);
assert (forall (i: nat{i < j}). (S.slice hs1 0 j).[ i ] == (S.slice hs2 0 j).[ i ]);
assert (forall (i: nat{i < j}). hs1.[ i ] == hs2.[ i ]);
assert (forall (i: nat{i < j / 2}). hs1.[ 2 * i ] == hs2.[ 2 * i ]);
assert (forall (i: nat{i < j / 2}). hs1.[ 2 * i + 1 ] == hs2.[ 2 * i + 1 ]);
assert (forall (i: nat{i < j / 2}). hs1'.[ i ] == hs2'.[ i ]) | false |
MerkleTree.Spec.fst | MerkleTree.Spec.mt_get_path | val mt_get_path:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
mt:merkle_tree #hsz n -> i:nat{i < pow2 n} -> GTot (path #hsz n) | val mt_get_path:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
mt:merkle_tree #hsz n -> i:nat{i < pow2 n} -> GTot (path #hsz n) | let rec mt_get_path #hsz #f #n t i =
if n = 0 then S.empty
else S.cons
(if i % 2 = 0 then t.[i + 1] else t.[i - 1])
(mt_get_path #_ #f (mt_next_lv #_ #f t) (i / 2)) | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 52,
"end_line": 258,
"start_col": 0,
"start_line": 254
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1))
val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2)))
let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]);
assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]);
assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i])
val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2))
(S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2)))
let mt_next_lv_equiv #hsz #f j n mt1 mt2 =
hs_next_lv_equiv #_ #f j (pow2 (n-1)) mt1 mt2
val hs_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes #hsz {S.length hs = 2 * n} ->
nhs:hashes #hsz {S.length nhs = n} ->
GTot Type0
let hs_next_rel #hsz #f n hs nhs =
forall (i:nat{i < n}).
S.index nhs i ==
padded_hash_fun #hsz f (S.index hs (2 * i)) (S.index hs (2 * i + 1))
val mt_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
GTot Type0
let mt_next_rel #hsz #f n mt nmt =
hs_next_rel #hsz #f (pow2 (n-1)) mt nmt
val hs_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes{S.length hs = 2 * n} ->
nhs:hashes{S.length nhs = n} ->
Lemma (requires hs_next_rel #_ #f n hs nhs)
(ensures S.equal nhs (hs_next_lv #_ #f #n hs))
let rec hs_next_rel_next_lv #hsz #f n hs nhs =
if n = 0 then ()
else hs_next_rel_next_lv #_ #f (n - 1)
(S.slice hs 2 (S.length hs))
(S.slice nhs 1 (S.length nhs))
val mt_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures S.equal nmt (mt_next_lv #_ #f mt))
let mt_next_rel_next_lv #hsz #f n mt nmt =
hs_next_rel_next_lv #_ #f (pow2 (n-1)) mt nmt
val mt_next_rel_upd_even:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i) v)
(S.upd nmt i (padded_hash_fun #hsz f v (S.index mt (2 * i + 1)))))
let mt_next_rel_upd_even #hsz #f n mt nmt i v = ()
#push-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
val mt_next_rel_upd_even_pad:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash #hsz ->
Lemma (requires (mt_next_rel #_ #f n mt nmt) /\ (S.index mt (2 * i + 1) == HPad))
(ensures (mt_next_rel #_ #f n (S.upd mt (2 * i) v) (S.upd nmt i v)))
let mt_next_rel_upd_even_pad #hsz #f n mt nmt i v = ()
#pop-options
val mt_next_rel_upd_odd:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i + 1) v)
(S.upd nmt i (padded_hash_fun #_ f (S.index mt (2 * i)) v)))
let mt_next_rel_upd_odd #hsz #f n mt nmt i v = ()
// fournet: just [root]?
val mt_get_root:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n -> GTot (padded_hash #hsz)
let rec mt_get_root #hsz #f #n mt =
if n = 0 then mt.[0]
else mt_get_root #_ #f (mt_next_lv #_ #f mt)
#push-options "--initial_fuel 2 --max_fuel 2"
val mt_get_root_step: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (mt_get_root #_ #f mt ==
padded_hash_fun #_ f (mt_get_root #_ #f (mt_left mt)) (mt_get_root #_ #f (mt_right mt)))
let rec mt_get_root_step #hsz #f #n mt =
if n = 1 then ()
else begin
mt_get_root_step #_ #f (mt_next_lv #_ #f mt);
mt_next_lv_mt_left #_ #f mt;
mt_next_lv_mt_right #_ #f mt
end
#pop-options
type path #hsz n = S.lseq (padded_hash #hsz) n
/// We first specify full paths, including padding.
val mt_get_path:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | mt: MerkleTree.Spec.merkle_tree n -> i: Prims.nat{i < Prims.pow2 n}
-> Prims.GTot (MerkleTree.Spec.path n) | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"MerkleTree.Spec.merkle_tree",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.empty",
"MerkleTree.Spec.padded_hash",
"Prims.bool",
"FStar.Seq.Base.cons",
"Prims.op_Modulus",
"MerkleTree.Spec.op_String_Access",
"Prims.op_Addition",
"Prims.op_Subtraction",
"MerkleTree.Spec.mt_get_path",
"MerkleTree.Spec.mt_next_lv",
"Prims.op_Division",
"MerkleTree.Spec.path"
] | [
"recursion"
] | false | false | false | false | false | let rec mt_get_path #hsz #f #n t i =
| if n = 0
then S.empty
else
S.cons (if i % 2 = 0 then t.[ i + 1 ] else t.[ i - 1 ])
(mt_get_path #_ #f (mt_next_lv #_ #f t) (i / 2)) | false |
MerkleTree.Spec.fst | MerkleTree.Spec.pad_hashes_slice | val pad_hashes_slice:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat -> j:nat{i <= j && j <= S.length hs} ->
Lemma (requires pad_hashes #_ #f hs)
(ensures pad_hashes #_ #f (S.slice hs i j))
(decreases (j - i)) | val pad_hashes_slice:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat -> j:nat{i <= j && j <= S.length hs} ->
Lemma (requires pad_hashes #_ #f hs)
(ensures pad_hashes #_ #f (S.slice hs i j))
(decreases (j - i)) | let rec pad_hashes_slice #hsz #f hs i j =
if i = j then ()
else pad_hashes_slice #_ #f hs (i + 1) j | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 42,
"end_line": 378,
"start_col": 0,
"start_line": 376
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1))
val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2)))
let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]);
assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]);
assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i])
val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2))
(S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2)))
let mt_next_lv_equiv #hsz #f j n mt1 mt2 =
hs_next_lv_equiv #_ #f j (pow2 (n-1)) mt1 mt2
val hs_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes #hsz {S.length hs = 2 * n} ->
nhs:hashes #hsz {S.length nhs = n} ->
GTot Type0
let hs_next_rel #hsz #f n hs nhs =
forall (i:nat{i < n}).
S.index nhs i ==
padded_hash_fun #hsz f (S.index hs (2 * i)) (S.index hs (2 * i + 1))
val mt_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
GTot Type0
let mt_next_rel #hsz #f n mt nmt =
hs_next_rel #hsz #f (pow2 (n-1)) mt nmt
val hs_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes{S.length hs = 2 * n} ->
nhs:hashes{S.length nhs = n} ->
Lemma (requires hs_next_rel #_ #f n hs nhs)
(ensures S.equal nhs (hs_next_lv #_ #f #n hs))
let rec hs_next_rel_next_lv #hsz #f n hs nhs =
if n = 0 then ()
else hs_next_rel_next_lv #_ #f (n - 1)
(S.slice hs 2 (S.length hs))
(S.slice nhs 1 (S.length nhs))
val mt_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures S.equal nmt (mt_next_lv #_ #f mt))
let mt_next_rel_next_lv #hsz #f n mt nmt =
hs_next_rel_next_lv #_ #f (pow2 (n-1)) mt nmt
val mt_next_rel_upd_even:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i) v)
(S.upd nmt i (padded_hash_fun #hsz f v (S.index mt (2 * i + 1)))))
let mt_next_rel_upd_even #hsz #f n mt nmt i v = ()
#push-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
val mt_next_rel_upd_even_pad:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash #hsz ->
Lemma (requires (mt_next_rel #_ #f n mt nmt) /\ (S.index mt (2 * i + 1) == HPad))
(ensures (mt_next_rel #_ #f n (S.upd mt (2 * i) v) (S.upd nmt i v)))
let mt_next_rel_upd_even_pad #hsz #f n mt nmt i v = ()
#pop-options
val mt_next_rel_upd_odd:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i + 1) v)
(S.upd nmt i (padded_hash_fun #_ f (S.index mt (2 * i)) v)))
let mt_next_rel_upd_odd #hsz #f n mt nmt i v = ()
// fournet: just [root]?
val mt_get_root:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n -> GTot (padded_hash #hsz)
let rec mt_get_root #hsz #f #n mt =
if n = 0 then mt.[0]
else mt_get_root #_ #f (mt_next_lv #_ #f mt)
#push-options "--initial_fuel 2 --max_fuel 2"
val mt_get_root_step: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (mt_get_root #_ #f mt ==
padded_hash_fun #_ f (mt_get_root #_ #f (mt_left mt)) (mt_get_root #_ #f (mt_right mt)))
let rec mt_get_root_step #hsz #f #n mt =
if n = 1 then ()
else begin
mt_get_root_step #_ #f (mt_next_lv #_ #f mt);
mt_next_lv_mt_left #_ #f mt;
mt_next_lv_mt_right #_ #f mt
end
#pop-options
type path #hsz n = S.lseq (padded_hash #hsz) n
/// We first specify full paths, including padding.
val mt_get_path:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
mt:merkle_tree #hsz n -> i:nat{i < pow2 n} -> GTot (path #hsz n)
let rec mt_get_path #hsz #f #n t i =
if n = 0 then S.empty
else S.cons
(if i % 2 = 0 then t.[i + 1] else t.[i - 1])
(mt_get_path #_ #f (mt_next_lv #_ #f t) (i / 2))
val mt_verify_:
#hsz:pos -> #f:hash_fun_t #hsz ->#n:nat ->
p:path #hsz n -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> GTot (padded_hash #hsz)
let rec mt_verify_ #hsz #f #n p idx h =
if n = 0 then h
else mt_verify_ #_ #f #(n-1) (S.tail p) (idx / 2)
(if idx % 2 = 0
then padded_hash_fun #_ f h (S.head p)
else padded_hash_fun #_ f (S.head p) h)
val mt_verify:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
p:(path #hsz n) -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> padded_hash #hsz -> GTot prop
let mt_verify #hsz #f #n p idx h rt =
rt == mt_verify_ #_ #f p idx h
/// Correctness: the root of a tree is correctly recomputed from any of its paths
val hs_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
hs:hashes{S.length hs = 2 * n} -> idx:nat{idx < 2 * n} ->
Lemma ((hs_next_lv #_ #f #n hs).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f hs.[idx] hs.[idx + 1]
else padded_hash_fun #_ f hs.[idx - 1] hs.[idx]))
let rec hs_next_lv_get #hsz #f #n hs idx =
if idx < 2 then ()
else hs_next_lv_get #_ #f #(n-1) (S.slice hs 2 (S.length hs)) (idx - 2)
val mt_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} ->
Lemma (
(mt_next_lv #_ #f mt).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f mt.[idx] mt.[idx + 1]
else padded_hash_fun #_ f mt.[idx - 1] mt.[idx]))
let mt_next_lv_get #hsz #f #n mt idx =
hs_next_lv_get #_ #f #(pow2 (n-1)) mt idx
val mt_get_path_ok_:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
t:merkle_tree #hsz n -> i:nat{i < pow2 n} ->
Lemma (mt_verify_ #_ #f (mt_get_path #_ #f t i) i (mt_get t i) == mt_get_root #_ #f t)
let rec mt_get_path_ok_ #hsz #f #n mt idx =
if n = 0 then ()
else begin
assert (S.head (mt_get_path #_ #f mt idx) ==
(if idx % 2 = 0 then mt.[idx + 1] else mt.[idx - 1]));
assert (S.equal (S.tail (mt_get_path #_ #f mt idx))
(mt_get_path #_ #f (mt_next_lv #_ #f mt) (idx / 2)));
mt_get_path_ok_ #_ #f (mt_next_lv #_ #f mt) (idx / 2);
mt_next_lv_get #_ #f mt idx
end
/// Security: we reduce tree collisions to collisions on the hash
/// compression function. Such collisions yield collisions on the SHA2
/// standard (by adding the same length and padding to the
/// accumulators).
///
/// One complication addressed in the proof is the handling of
/// implicit padding.
/// All hashes in a sequence are raw hashes, not padding
val raw_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes #hsz -> Tot Type0 (decreases (S.length hs))
let rec raw_hashes #hsz #f hs =
if S.length hs = 0 then True
else (HRaw? (S.head hs) /\ raw_hashes #_ #f (S.tail hs))
val raw_hashes_raws:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes{raw_hashes #hsz #f hs} ->
Tot (S.seq (hash #hsz)) (decreases (S.length hs))
let rec raw_hashes_raws #hsz #f hs =
if S.length hs = 0 then S.empty
else S.cons (HRaw?.hr (S.head hs)) (raw_hashes_raws #_ #f (S.tail hs))
val raw_hashes_index:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat{i < S.length hs} ->
Lemma (requires raw_hashes #_ #f hs)
(ensures HRaw? #hsz hs.[i])
(decreases i)
let rec raw_hashes_index #hsz #f hs i =
if i = 0 then ()
else raw_hashes_index #_ #f (S.tail hs) (i - 1)
val raw_hashes_slice:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat -> j:nat{i <= j && j <= S.length hs} ->
Lemma (requires raw_hashes #_ #f hs)
(ensures raw_hashes #_ #f (S.slice hs i j))
(decreases (j - i))
let rec raw_hashes_slice #hsz #f hs i j =
if i = j then ()
else (
raw_hashes_index #_ #f hs i;
raw_hashes_slice #_ #f hs (i + 1) j)
/// All hashes in a sequence are just padding
val pad_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes #hsz -> Type0
let pad_hashes #hsz #f hs =
S.equal hs (S.create (S.length hs) HPad)
val pad_hashes_slice:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat -> j:nat{i <= j && j <= S.length hs} ->
Lemma (requires pad_hashes #_ #f hs)
(ensures pad_hashes #_ #f (S.slice hs i j)) | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | hs: MerkleTree.Spec.hashes -> i: Prims.nat -> j: Prims.nat{i <= j && j <= FStar.Seq.Base.length hs}
-> FStar.Pervasives.Lemma (requires MerkleTree.Spec.pad_hashes hs)
(ensures MerkleTree.Spec.pad_hashes (FStar.Seq.Base.slice hs i j))
(decreases j - i) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"MerkleTree.Spec.hashes",
"Prims.nat",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"MerkleTree.Spec.padded_hash",
"Prims.op_Equality",
"Prims.bool",
"MerkleTree.Spec.pad_hashes_slice",
"Prims.op_Addition",
"Prims.unit"
] | [
"recursion"
] | false | false | true | false | false | let rec pad_hashes_slice #hsz #f hs i j =
| if i = j then () else pad_hashes_slice #_ #f hs (i + 1) j | false |
MerkleTree.Spec.fst | MerkleTree.Spec.mt_get_root_step | val mt_get_root_step: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (mt_get_root #_ #f mt ==
padded_hash_fun #_ f (mt_get_root #_ #f (mt_left mt)) (mt_get_root #_ #f (mt_right mt))) | val mt_get_root_step: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (mt_get_root #_ #f mt ==
padded_hash_fun #_ f (mt_get_root #_ #f (mt_left mt)) (mt_get_root #_ #f (mt_right mt))) | let rec mt_get_root_step #hsz #f #n mt =
if n = 1 then ()
else begin
mt_get_root_step #_ #f (mt_next_lv #_ #f mt);
mt_next_lv_mt_left #_ #f mt;
mt_next_lv_mt_right #_ #f mt
end | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 5,
"end_line": 243,
"start_col": 0,
"start_line": 237
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1))
val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2)))
let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]);
assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]);
assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i])
val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2))
(S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2)))
let mt_next_lv_equiv #hsz #f j n mt1 mt2 =
hs_next_lv_equiv #_ #f j (pow2 (n-1)) mt1 mt2
val hs_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes #hsz {S.length hs = 2 * n} ->
nhs:hashes #hsz {S.length nhs = n} ->
GTot Type0
let hs_next_rel #hsz #f n hs nhs =
forall (i:nat{i < n}).
S.index nhs i ==
padded_hash_fun #hsz f (S.index hs (2 * i)) (S.index hs (2 * i + 1))
val mt_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
GTot Type0
let mt_next_rel #hsz #f n mt nmt =
hs_next_rel #hsz #f (pow2 (n-1)) mt nmt
val hs_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes{S.length hs = 2 * n} ->
nhs:hashes{S.length nhs = n} ->
Lemma (requires hs_next_rel #_ #f n hs nhs)
(ensures S.equal nhs (hs_next_lv #_ #f #n hs))
let rec hs_next_rel_next_lv #hsz #f n hs nhs =
if n = 0 then ()
else hs_next_rel_next_lv #_ #f (n - 1)
(S.slice hs 2 (S.length hs))
(S.slice nhs 1 (S.length nhs))
val mt_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures S.equal nmt (mt_next_lv #_ #f mt))
let mt_next_rel_next_lv #hsz #f n mt nmt =
hs_next_rel_next_lv #_ #f (pow2 (n-1)) mt nmt
val mt_next_rel_upd_even:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i) v)
(S.upd nmt i (padded_hash_fun #hsz f v (S.index mt (2 * i + 1)))))
let mt_next_rel_upd_even #hsz #f n mt nmt i v = ()
#push-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
val mt_next_rel_upd_even_pad:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash #hsz ->
Lemma (requires (mt_next_rel #_ #f n mt nmt) /\ (S.index mt (2 * i + 1) == HPad))
(ensures (mt_next_rel #_ #f n (S.upd mt (2 * i) v) (S.upd nmt i v)))
let mt_next_rel_upd_even_pad #hsz #f n mt nmt i v = ()
#pop-options
val mt_next_rel_upd_odd:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i + 1) v)
(S.upd nmt i (padded_hash_fun #_ f (S.index mt (2 * i)) v)))
let mt_next_rel_upd_odd #hsz #f n mt nmt i v = ()
// fournet: just [root]?
val mt_get_root:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n -> GTot (padded_hash #hsz)
let rec mt_get_root #hsz #f #n mt =
if n = 0 then mt.[0]
else mt_get_root #_ #f (mt_next_lv #_ #f mt)
#push-options "--initial_fuel 2 --max_fuel 2"
val mt_get_root_step: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (mt_get_root #_ #f mt == | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | mt: MerkleTree.Spec.merkle_tree n
-> FStar.Pervasives.Lemma
(ensures
MerkleTree.Spec.mt_get_root mt ==
MerkleTree.Spec.padded_hash_fun f
(MerkleTree.Spec.mt_get_root (MerkleTree.Spec.mt_left mt))
(MerkleTree.Spec.mt_get_root (MerkleTree.Spec.mt_right mt))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"MerkleTree.Spec.merkle_tree",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"MerkleTree.Spec.mt_next_lv_mt_right",
"Prims.unit",
"MerkleTree.Spec.mt_next_lv_mt_left",
"MerkleTree.Spec.mt_get_root_step",
"Prims.op_Subtraction",
"MerkleTree.Spec.mt_next_lv"
] | [
"recursion"
] | false | false | true | false | false | let rec mt_get_root_step #hsz #f #n mt =
| if n = 1
then ()
else
(mt_get_root_step #_ #f (mt_next_lv #_ #f mt);
mt_next_lv_mt_left #_ #f mt;
mt_next_lv_mt_right #_ #f mt) | false |
MerkleTree.Spec.fst | MerkleTree.Spec.rpmt_left | val rpmt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> #i:nat{i <= pow2 n} -> rpmt #hsz #f n i ->
rpmt #hsz #f (n-1) (if i <= pow2 (n-1) then i else pow2 (n-1)) | val rpmt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> #i:nat{i <= pow2 n} -> rpmt #hsz #f n i ->
rpmt #hsz #f (n-1) (if i <= pow2 (n-1) then i else pow2 (n-1)) | let rpmt_left #hsz #f #n #i mt =
if i <= pow2 (n-1)
then pad_hashes_slice #_ #f (S.slice mt i (S.length mt)) 0 (pow2 (n-1) - i)
else raw_hashes_slice #_ #f (S.slice mt 0 i) 0 (pow2 (n-1));
mt_left mt | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 12,
"end_line": 400,
"start_col": 0,
"start_line": 396
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1))
val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2)))
let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]);
assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]);
assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i])
val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2))
(S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2)))
let mt_next_lv_equiv #hsz #f j n mt1 mt2 =
hs_next_lv_equiv #_ #f j (pow2 (n-1)) mt1 mt2
val hs_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes #hsz {S.length hs = 2 * n} ->
nhs:hashes #hsz {S.length nhs = n} ->
GTot Type0
let hs_next_rel #hsz #f n hs nhs =
forall (i:nat{i < n}).
S.index nhs i ==
padded_hash_fun #hsz f (S.index hs (2 * i)) (S.index hs (2 * i + 1))
val mt_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
GTot Type0
let mt_next_rel #hsz #f n mt nmt =
hs_next_rel #hsz #f (pow2 (n-1)) mt nmt
val hs_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes{S.length hs = 2 * n} ->
nhs:hashes{S.length nhs = n} ->
Lemma (requires hs_next_rel #_ #f n hs nhs)
(ensures S.equal nhs (hs_next_lv #_ #f #n hs))
let rec hs_next_rel_next_lv #hsz #f n hs nhs =
if n = 0 then ()
else hs_next_rel_next_lv #_ #f (n - 1)
(S.slice hs 2 (S.length hs))
(S.slice nhs 1 (S.length nhs))
val mt_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures S.equal nmt (mt_next_lv #_ #f mt))
let mt_next_rel_next_lv #hsz #f n mt nmt =
hs_next_rel_next_lv #_ #f (pow2 (n-1)) mt nmt
val mt_next_rel_upd_even:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i) v)
(S.upd nmt i (padded_hash_fun #hsz f v (S.index mt (2 * i + 1)))))
let mt_next_rel_upd_even #hsz #f n mt nmt i v = ()
#push-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
val mt_next_rel_upd_even_pad:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash #hsz ->
Lemma (requires (mt_next_rel #_ #f n mt nmt) /\ (S.index mt (2 * i + 1) == HPad))
(ensures (mt_next_rel #_ #f n (S.upd mt (2 * i) v) (S.upd nmt i v)))
let mt_next_rel_upd_even_pad #hsz #f n mt nmt i v = ()
#pop-options
val mt_next_rel_upd_odd:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i + 1) v)
(S.upd nmt i (padded_hash_fun #_ f (S.index mt (2 * i)) v)))
let mt_next_rel_upd_odd #hsz #f n mt nmt i v = ()
// fournet: just [root]?
val mt_get_root:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n -> GTot (padded_hash #hsz)
let rec mt_get_root #hsz #f #n mt =
if n = 0 then mt.[0]
else mt_get_root #_ #f (mt_next_lv #_ #f mt)
#push-options "--initial_fuel 2 --max_fuel 2"
val mt_get_root_step: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (mt_get_root #_ #f mt ==
padded_hash_fun #_ f (mt_get_root #_ #f (mt_left mt)) (mt_get_root #_ #f (mt_right mt)))
let rec mt_get_root_step #hsz #f #n mt =
if n = 1 then ()
else begin
mt_get_root_step #_ #f (mt_next_lv #_ #f mt);
mt_next_lv_mt_left #_ #f mt;
mt_next_lv_mt_right #_ #f mt
end
#pop-options
type path #hsz n = S.lseq (padded_hash #hsz) n
/// We first specify full paths, including padding.
val mt_get_path:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
mt:merkle_tree #hsz n -> i:nat{i < pow2 n} -> GTot (path #hsz n)
let rec mt_get_path #hsz #f #n t i =
if n = 0 then S.empty
else S.cons
(if i % 2 = 0 then t.[i + 1] else t.[i - 1])
(mt_get_path #_ #f (mt_next_lv #_ #f t) (i / 2))
val mt_verify_:
#hsz:pos -> #f:hash_fun_t #hsz ->#n:nat ->
p:path #hsz n -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> GTot (padded_hash #hsz)
let rec mt_verify_ #hsz #f #n p idx h =
if n = 0 then h
else mt_verify_ #_ #f #(n-1) (S.tail p) (idx / 2)
(if idx % 2 = 0
then padded_hash_fun #_ f h (S.head p)
else padded_hash_fun #_ f (S.head p) h)
val mt_verify:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
p:(path #hsz n) -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> padded_hash #hsz -> GTot prop
let mt_verify #hsz #f #n p idx h rt =
rt == mt_verify_ #_ #f p idx h
/// Correctness: the root of a tree is correctly recomputed from any of its paths
val hs_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
hs:hashes{S.length hs = 2 * n} -> idx:nat{idx < 2 * n} ->
Lemma ((hs_next_lv #_ #f #n hs).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f hs.[idx] hs.[idx + 1]
else padded_hash_fun #_ f hs.[idx - 1] hs.[idx]))
let rec hs_next_lv_get #hsz #f #n hs idx =
if idx < 2 then ()
else hs_next_lv_get #_ #f #(n-1) (S.slice hs 2 (S.length hs)) (idx - 2)
val mt_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} ->
Lemma (
(mt_next_lv #_ #f mt).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f mt.[idx] mt.[idx + 1]
else padded_hash_fun #_ f mt.[idx - 1] mt.[idx]))
let mt_next_lv_get #hsz #f #n mt idx =
hs_next_lv_get #_ #f #(pow2 (n-1)) mt idx
val mt_get_path_ok_:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
t:merkle_tree #hsz n -> i:nat{i < pow2 n} ->
Lemma (mt_verify_ #_ #f (mt_get_path #_ #f t i) i (mt_get t i) == mt_get_root #_ #f t)
let rec mt_get_path_ok_ #hsz #f #n mt idx =
if n = 0 then ()
else begin
assert (S.head (mt_get_path #_ #f mt idx) ==
(if idx % 2 = 0 then mt.[idx + 1] else mt.[idx - 1]));
assert (S.equal (S.tail (mt_get_path #_ #f mt idx))
(mt_get_path #_ #f (mt_next_lv #_ #f mt) (idx / 2)));
mt_get_path_ok_ #_ #f (mt_next_lv #_ #f mt) (idx / 2);
mt_next_lv_get #_ #f mt idx
end
/// Security: we reduce tree collisions to collisions on the hash
/// compression function. Such collisions yield collisions on the SHA2
/// standard (by adding the same length and padding to the
/// accumulators).
///
/// One complication addressed in the proof is the handling of
/// implicit padding.
/// All hashes in a sequence are raw hashes, not padding
val raw_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes #hsz -> Tot Type0 (decreases (S.length hs))
let rec raw_hashes #hsz #f hs =
if S.length hs = 0 then True
else (HRaw? (S.head hs) /\ raw_hashes #_ #f (S.tail hs))
val raw_hashes_raws:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes{raw_hashes #hsz #f hs} ->
Tot (S.seq (hash #hsz)) (decreases (S.length hs))
let rec raw_hashes_raws #hsz #f hs =
if S.length hs = 0 then S.empty
else S.cons (HRaw?.hr (S.head hs)) (raw_hashes_raws #_ #f (S.tail hs))
val raw_hashes_index:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat{i < S.length hs} ->
Lemma (requires raw_hashes #_ #f hs)
(ensures HRaw? #hsz hs.[i])
(decreases i)
let rec raw_hashes_index #hsz #f hs i =
if i = 0 then ()
else raw_hashes_index #_ #f (S.tail hs) (i - 1)
val raw_hashes_slice:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat -> j:nat{i <= j && j <= S.length hs} ->
Lemma (requires raw_hashes #_ #f hs)
(ensures raw_hashes #_ #f (S.slice hs i j))
(decreases (j - i))
let rec raw_hashes_slice #hsz #f hs i j =
if i = j then ()
else (
raw_hashes_index #_ #f hs i;
raw_hashes_slice #_ #f hs (i + 1) j)
/// All hashes in a sequence are just padding
val pad_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes #hsz -> Type0
let pad_hashes #hsz #f hs =
S.equal hs (S.create (S.length hs) HPad)
val pad_hashes_slice:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat -> j:nat{i <= j && j <= S.length hs} ->
Lemma (requires pad_hashes #_ #f hs)
(ensures pad_hashes #_ #f (S.slice hs i j))
(decreases (j - i))
let rec pad_hashes_slice #hsz #f hs i j =
if i = j then ()
else pad_hashes_slice #_ #f hs (i + 1) j
/// Right-padded Merkle tree, a tree refinement
let rpmt (#hsz:pos) (#f:hash_fun_t) (n:nat) (i:nat{i <= pow2 n}) =
mt:merkle_tree #hsz n {
raw_hashes #_ #f (S.slice mt 0 i) /\
pad_hashes #_ #f (S.slice mt i (S.length mt)) }
val rpmt_raws: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #hsz #f n i -> S.seq (hash #hsz)
let rpmt_raws #hsz #f #n #i mt = raw_hashes_raws #_ #f (S.slice mt 0 i)
val rpmt_i_0: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> mt:rpmt #hsz #f n 0 ->
Lemma (S.equal mt (S.create (pow2 n) (HPad #hsz)))
let rpmt_i_0 #hsz #f #n mt = ()
val rpmt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> #i:nat{i <= pow2 n} -> rpmt #hsz #f n i -> | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | mt: MerkleTree.Spec.rpmt n i
-> MerkleTree.Spec.rpmt (n - 1)
(match i <= Prims.pow2 (n - 1) with
| true -> i
| _ -> Prims.pow2 (n - 1)) | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.pow2",
"MerkleTree.Spec.rpmt",
"MerkleTree.Spec.mt_left",
"Prims.unit",
"Prims.op_Subtraction",
"MerkleTree.Spec.pad_hashes_slice",
"FStar.Seq.Base.slice",
"MerkleTree.Spec.padded_hash",
"FStar.Seq.Base.length",
"Prims.bool",
"MerkleTree.Spec.raw_hashes_slice"
] | [] | false | false | false | false | false | let rpmt_left #hsz #f #n #i mt =
| if i <= pow2 (n - 1)
then pad_hashes_slice #_ #f (S.slice mt i (S.length mt)) 0 (pow2 (n - 1) - i)
else raw_hashes_slice #_ #f (S.slice mt 0 i) 0 (pow2 (n - 1));
mt_left mt | false |
MerkleTree.Spec.fst | MerkleTree.Spec.mt_next_lv_get | val mt_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} ->
Lemma (
(mt_next_lv #_ #f mt).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f mt.[idx] mt.[idx + 1]
else padded_hash_fun #_ f mt.[idx - 1] mt.[idx])) | val mt_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} ->
Lemma (
(mt_next_lv #_ #f mt).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f mt.[idx] mt.[idx + 1]
else padded_hash_fun #_ f mt.[idx - 1] mt.[idx])) | let mt_next_lv_get #hsz #f #n mt idx =
hs_next_lv_get #_ #f #(pow2 (n-1)) mt idx | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 43,
"end_line": 299,
"start_col": 0,
"start_line": 298
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1))
val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2)))
let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]);
assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]);
assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i])
val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2))
(S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2)))
let mt_next_lv_equiv #hsz #f j n mt1 mt2 =
hs_next_lv_equiv #_ #f j (pow2 (n-1)) mt1 mt2
val hs_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes #hsz {S.length hs = 2 * n} ->
nhs:hashes #hsz {S.length nhs = n} ->
GTot Type0
let hs_next_rel #hsz #f n hs nhs =
forall (i:nat{i < n}).
S.index nhs i ==
padded_hash_fun #hsz f (S.index hs (2 * i)) (S.index hs (2 * i + 1))
val mt_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
GTot Type0
let mt_next_rel #hsz #f n mt nmt =
hs_next_rel #hsz #f (pow2 (n-1)) mt nmt
val hs_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes{S.length hs = 2 * n} ->
nhs:hashes{S.length nhs = n} ->
Lemma (requires hs_next_rel #_ #f n hs nhs)
(ensures S.equal nhs (hs_next_lv #_ #f #n hs))
let rec hs_next_rel_next_lv #hsz #f n hs nhs =
if n = 0 then ()
else hs_next_rel_next_lv #_ #f (n - 1)
(S.slice hs 2 (S.length hs))
(S.slice nhs 1 (S.length nhs))
val mt_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures S.equal nmt (mt_next_lv #_ #f mt))
let mt_next_rel_next_lv #hsz #f n mt nmt =
hs_next_rel_next_lv #_ #f (pow2 (n-1)) mt nmt
val mt_next_rel_upd_even:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i) v)
(S.upd nmt i (padded_hash_fun #hsz f v (S.index mt (2 * i + 1)))))
let mt_next_rel_upd_even #hsz #f n mt nmt i v = ()
#push-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
val mt_next_rel_upd_even_pad:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash #hsz ->
Lemma (requires (mt_next_rel #_ #f n mt nmt) /\ (S.index mt (2 * i + 1) == HPad))
(ensures (mt_next_rel #_ #f n (S.upd mt (2 * i) v) (S.upd nmt i v)))
let mt_next_rel_upd_even_pad #hsz #f n mt nmt i v = ()
#pop-options
val mt_next_rel_upd_odd:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i + 1) v)
(S.upd nmt i (padded_hash_fun #_ f (S.index mt (2 * i)) v)))
let mt_next_rel_upd_odd #hsz #f n mt nmt i v = ()
// fournet: just [root]?
val mt_get_root:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n -> GTot (padded_hash #hsz)
let rec mt_get_root #hsz #f #n mt =
if n = 0 then mt.[0]
else mt_get_root #_ #f (mt_next_lv #_ #f mt)
#push-options "--initial_fuel 2 --max_fuel 2"
val mt_get_root_step: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (mt_get_root #_ #f mt ==
padded_hash_fun #_ f (mt_get_root #_ #f (mt_left mt)) (mt_get_root #_ #f (mt_right mt)))
let rec mt_get_root_step #hsz #f #n mt =
if n = 1 then ()
else begin
mt_get_root_step #_ #f (mt_next_lv #_ #f mt);
mt_next_lv_mt_left #_ #f mt;
mt_next_lv_mt_right #_ #f mt
end
#pop-options
type path #hsz n = S.lseq (padded_hash #hsz) n
/// We first specify full paths, including padding.
val mt_get_path:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
mt:merkle_tree #hsz n -> i:nat{i < pow2 n} -> GTot (path #hsz n)
let rec mt_get_path #hsz #f #n t i =
if n = 0 then S.empty
else S.cons
(if i % 2 = 0 then t.[i + 1] else t.[i - 1])
(mt_get_path #_ #f (mt_next_lv #_ #f t) (i / 2))
val mt_verify_:
#hsz:pos -> #f:hash_fun_t #hsz ->#n:nat ->
p:path #hsz n -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> GTot (padded_hash #hsz)
let rec mt_verify_ #hsz #f #n p idx h =
if n = 0 then h
else mt_verify_ #_ #f #(n-1) (S.tail p) (idx / 2)
(if idx % 2 = 0
then padded_hash_fun #_ f h (S.head p)
else padded_hash_fun #_ f (S.head p) h)
val mt_verify:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
p:(path #hsz n) -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> padded_hash #hsz -> GTot prop
let mt_verify #hsz #f #n p idx h rt =
rt == mt_verify_ #_ #f p idx h
/// Correctness: the root of a tree is correctly recomputed from any of its paths
val hs_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
hs:hashes{S.length hs = 2 * n} -> idx:nat{idx < 2 * n} ->
Lemma ((hs_next_lv #_ #f #n hs).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f hs.[idx] hs.[idx + 1]
else padded_hash_fun #_ f hs.[idx - 1] hs.[idx]))
let rec hs_next_lv_get #hsz #f #n hs idx =
if idx < 2 then ()
else hs_next_lv_get #_ #f #(n-1) (S.slice hs 2 (S.length hs)) (idx - 2)
val mt_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} ->
Lemma (
(mt_next_lv #_ #f mt).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f mt.[idx] mt.[idx + 1] | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | mt: MerkleTree.Spec.merkle_tree n -> idx: Prims.nat{idx < Prims.pow2 n}
-> FStar.Pervasives.Lemma
(ensures
(MerkleTree.Spec.mt_next_lv mt).[ idx / 2 ] ==
(match idx % 2 = 0 with
| true -> MerkleTree.Spec.padded_hash_fun f mt.[ idx ] mt.[ idx + 1 ]
| _ -> MerkleTree.Spec.padded_hash_fun f mt.[ idx - 1 ] mt.[ idx ])) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"MerkleTree.Spec.merkle_tree",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"MerkleTree.Spec.hs_next_lv_get",
"Prims.op_Subtraction",
"Prims.unit"
] | [] | true | false | true | false | false | let mt_next_lv_get #hsz #f #n mt idx =
| hs_next_lv_get #_ #f #(pow2 (n - 1)) mt idx | false |
MerkleTree.Spec.fst | MerkleTree.Spec.hs_next_lv_slice | val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i)) | val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i)) | let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 5,
"end_line": 96,
"start_col": 0,
"start_line": 87
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j)) | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
hs: MerkleTree.Spec.hashes{FStar.Seq.Base.length hs = 2 * n} ->
i: Prims.nat ->
j: Prims.nat{i <= j && j <= n}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.equal (MerkleTree.Spec.hs_next_lv (FStar.Seq.Base.slice hs (2 * i) (2 * j)))
(FStar.Seq.Base.slice (MerkleTree.Spec.hs_next_lv hs) i j)) (decreases j - i) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"MerkleTree.Spec.hashes",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"MerkleTree.Spec.padded_hash",
"FStar.Mul.op_Star",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.bool",
"MerkleTree.Spec.hs_next_lv_index",
"Prims.unit",
"MerkleTree.Spec.hs_next_lv_slice",
"Prims.op_Addition",
"Prims._assert",
"FStar.Seq.Base.equal",
"MerkleTree.Spec.hs_next_lv",
"Prims.op_Subtraction",
"FStar.Seq.Base.cons",
"MerkleTree.Spec.padded_hash_fun",
"MerkleTree.Spec.op_String_Access",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.seq"
] | [
"recursion"
] | false | false | true | false | false | let rec hs_next_lv_slice #hsz #f #n hs i j =
| if i = j
then ()
else
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[ 0 ] x.[ 1 ])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i | false |
MerkleTree.Spec.fst | MerkleTree.Spec.mt_get_path_ok_ | val mt_get_path_ok_:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
t:merkle_tree #hsz n -> i:nat{i < pow2 n} ->
Lemma (mt_verify_ #_ #f (mt_get_path #_ #f t i) i (mt_get t i) == mt_get_root #_ #f t) | val mt_get_path_ok_:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
t:merkle_tree #hsz n -> i:nat{i < pow2 n} ->
Lemma (mt_verify_ #_ #f (mt_get_path #_ #f t i) i (mt_get t i) == mt_get_root #_ #f t) | let rec mt_get_path_ok_ #hsz #f #n mt idx =
if n = 0 then ()
else begin
assert (S.head (mt_get_path #_ #f mt idx) ==
(if idx % 2 = 0 then mt.[idx + 1] else mt.[idx - 1]));
assert (S.equal (S.tail (mt_get_path #_ #f mt idx))
(mt_get_path #_ #f (mt_next_lv #_ #f mt) (idx / 2)));
mt_get_path_ok_ #_ #f (mt_next_lv #_ #f mt) (idx / 2);
mt_next_lv_get #_ #f mt idx
end | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 5,
"end_line": 314,
"start_col": 0,
"start_line": 305
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1))
val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2)))
let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]);
assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]);
assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i])
val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2))
(S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2)))
let mt_next_lv_equiv #hsz #f j n mt1 mt2 =
hs_next_lv_equiv #_ #f j (pow2 (n-1)) mt1 mt2
val hs_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes #hsz {S.length hs = 2 * n} ->
nhs:hashes #hsz {S.length nhs = n} ->
GTot Type0
let hs_next_rel #hsz #f n hs nhs =
forall (i:nat{i < n}).
S.index nhs i ==
padded_hash_fun #hsz f (S.index hs (2 * i)) (S.index hs (2 * i + 1))
val mt_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
GTot Type0
let mt_next_rel #hsz #f n mt nmt =
hs_next_rel #hsz #f (pow2 (n-1)) mt nmt
val hs_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes{S.length hs = 2 * n} ->
nhs:hashes{S.length nhs = n} ->
Lemma (requires hs_next_rel #_ #f n hs nhs)
(ensures S.equal nhs (hs_next_lv #_ #f #n hs))
let rec hs_next_rel_next_lv #hsz #f n hs nhs =
if n = 0 then ()
else hs_next_rel_next_lv #_ #f (n - 1)
(S.slice hs 2 (S.length hs))
(S.slice nhs 1 (S.length nhs))
val mt_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures S.equal nmt (mt_next_lv #_ #f mt))
let mt_next_rel_next_lv #hsz #f n mt nmt =
hs_next_rel_next_lv #_ #f (pow2 (n-1)) mt nmt
val mt_next_rel_upd_even:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i) v)
(S.upd nmt i (padded_hash_fun #hsz f v (S.index mt (2 * i + 1)))))
let mt_next_rel_upd_even #hsz #f n mt nmt i v = ()
#push-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
val mt_next_rel_upd_even_pad:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash #hsz ->
Lemma (requires (mt_next_rel #_ #f n mt nmt) /\ (S.index mt (2 * i + 1) == HPad))
(ensures (mt_next_rel #_ #f n (S.upd mt (2 * i) v) (S.upd nmt i v)))
let mt_next_rel_upd_even_pad #hsz #f n mt nmt i v = ()
#pop-options
val mt_next_rel_upd_odd:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i + 1) v)
(S.upd nmt i (padded_hash_fun #_ f (S.index mt (2 * i)) v)))
let mt_next_rel_upd_odd #hsz #f n mt nmt i v = ()
// fournet: just [root]?
val mt_get_root:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n -> GTot (padded_hash #hsz)
let rec mt_get_root #hsz #f #n mt =
if n = 0 then mt.[0]
else mt_get_root #_ #f (mt_next_lv #_ #f mt)
#push-options "--initial_fuel 2 --max_fuel 2"
val mt_get_root_step: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (mt_get_root #_ #f mt ==
padded_hash_fun #_ f (mt_get_root #_ #f (mt_left mt)) (mt_get_root #_ #f (mt_right mt)))
let rec mt_get_root_step #hsz #f #n mt =
if n = 1 then ()
else begin
mt_get_root_step #_ #f (mt_next_lv #_ #f mt);
mt_next_lv_mt_left #_ #f mt;
mt_next_lv_mt_right #_ #f mt
end
#pop-options
type path #hsz n = S.lseq (padded_hash #hsz) n
/// We first specify full paths, including padding.
val mt_get_path:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
mt:merkle_tree #hsz n -> i:nat{i < pow2 n} -> GTot (path #hsz n)
let rec mt_get_path #hsz #f #n t i =
if n = 0 then S.empty
else S.cons
(if i % 2 = 0 then t.[i + 1] else t.[i - 1])
(mt_get_path #_ #f (mt_next_lv #_ #f t) (i / 2))
val mt_verify_:
#hsz:pos -> #f:hash_fun_t #hsz ->#n:nat ->
p:path #hsz n -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> GTot (padded_hash #hsz)
let rec mt_verify_ #hsz #f #n p idx h =
if n = 0 then h
else mt_verify_ #_ #f #(n-1) (S.tail p) (idx / 2)
(if idx % 2 = 0
then padded_hash_fun #_ f h (S.head p)
else padded_hash_fun #_ f (S.head p) h)
val mt_verify:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
p:(path #hsz n) -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> padded_hash #hsz -> GTot prop
let mt_verify #hsz #f #n p idx h rt =
rt == mt_verify_ #_ #f p idx h
/// Correctness: the root of a tree is correctly recomputed from any of its paths
val hs_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
hs:hashes{S.length hs = 2 * n} -> idx:nat{idx < 2 * n} ->
Lemma ((hs_next_lv #_ #f #n hs).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f hs.[idx] hs.[idx + 1]
else padded_hash_fun #_ f hs.[idx - 1] hs.[idx]))
let rec hs_next_lv_get #hsz #f #n hs idx =
if idx < 2 then ()
else hs_next_lv_get #_ #f #(n-1) (S.slice hs 2 (S.length hs)) (idx - 2)
val mt_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} ->
Lemma (
(mt_next_lv #_ #f mt).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f mt.[idx] mt.[idx + 1]
else padded_hash_fun #_ f mt.[idx - 1] mt.[idx]))
let mt_next_lv_get #hsz #f #n mt idx =
hs_next_lv_get #_ #f #(pow2 (n-1)) mt idx
val mt_get_path_ok_:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
t:merkle_tree #hsz n -> i:nat{i < pow2 n} -> | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | t: MerkleTree.Spec.merkle_tree n -> i: Prims.nat{i < Prims.pow2 n}
-> FStar.Pervasives.Lemma
(ensures
MerkleTree.Spec.mt_verify_ (MerkleTree.Spec.mt_get_path t i) i (MerkleTree.Spec.mt_get t i) ==
MerkleTree.Spec.mt_get_root t) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"MerkleTree.Spec.merkle_tree",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"MerkleTree.Spec.mt_next_lv_get",
"Prims.unit",
"MerkleTree.Spec.mt_get_path_ok_",
"Prims.op_Subtraction",
"MerkleTree.Spec.mt_next_lv",
"Prims.op_Division",
"Prims._assert",
"FStar.Seq.Base.equal",
"MerkleTree.Spec.padded_hash",
"FStar.Seq.Properties.tail",
"MerkleTree.Spec.mt_get_path",
"Prims.eq2",
"FStar.Seq.Properties.head",
"Prims.op_Modulus",
"MerkleTree.Spec.op_String_Access",
"Prims.op_Addition"
] | [
"recursion"
] | false | false | true | false | false | let rec mt_get_path_ok_ #hsz #f #n mt idx =
| if n = 0
then ()
else
(assert (S.head (mt_get_path #_ #f mt idx) ==
(if idx % 2 = 0 then mt.[ idx + 1 ] else mt.[ idx - 1 ]));
assert (S.equal (S.tail (mt_get_path #_ #f mt idx))
(mt_get_path #_ #f (mt_next_lv #_ #f mt) (idx / 2)));
mt_get_path_ok_ #_ #f (mt_next_lv #_ #f mt) (idx / 2);
mt_next_lv_get #_ #f mt idx) | false |
MerkleTree.Spec.fst | MerkleTree.Spec.hs_next_rel_next_lv | val hs_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes{S.length hs = 2 * n} ->
nhs:hashes{S.length nhs = n} ->
Lemma (requires hs_next_rel #_ #f n hs nhs)
(ensures S.equal nhs (hs_next_lv #_ #f #n hs)) | val hs_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes{S.length hs = 2 * n} ->
nhs:hashes{S.length nhs = n} ->
Lemma (requires hs_next_rel #_ #f n hs nhs)
(ensures S.equal nhs (hs_next_lv #_ #f #n hs)) | let rec hs_next_rel_next_lv #hsz #f n hs nhs =
if n = 0 then ()
else hs_next_rel_next_lv #_ #f (n - 1)
(S.slice hs 2 (S.length hs))
(S.slice nhs 1 (S.length nhs)) | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 39,
"end_line": 173,
"start_col": 0,
"start_line": 169
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1))
val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2)))
let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]);
assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]);
assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i])
val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2))
(S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2)))
let mt_next_lv_equiv #hsz #f j n mt1 mt2 =
hs_next_lv_equiv #_ #f j (pow2 (n-1)) mt1 mt2
val hs_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes #hsz {S.length hs = 2 * n} ->
nhs:hashes #hsz {S.length nhs = n} ->
GTot Type0
let hs_next_rel #hsz #f n hs nhs =
forall (i:nat{i < n}).
S.index nhs i ==
padded_hash_fun #hsz f (S.index hs (2 * i)) (S.index hs (2 * i + 1))
val mt_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
GTot Type0
let mt_next_rel #hsz #f n mt nmt =
hs_next_rel #hsz #f (pow2 (n-1)) mt nmt
val hs_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes{S.length hs = 2 * n} ->
nhs:hashes{S.length nhs = n} ->
Lemma (requires hs_next_rel #_ #f n hs nhs) | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
n: Prims.nat ->
hs: MerkleTree.Spec.hashes{FStar.Seq.Base.length hs = 2 * n} ->
nhs: MerkleTree.Spec.hashes{FStar.Seq.Base.length nhs = n}
-> FStar.Pervasives.Lemma (requires MerkleTree.Spec.hs_next_rel n hs nhs)
(ensures FStar.Seq.Base.equal nhs (MerkleTree.Spec.hs_next_lv hs)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"MerkleTree.Spec.hashes",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"MerkleTree.Spec.padded_hash",
"FStar.Mul.op_Star",
"Prims.bool",
"MerkleTree.Spec.hs_next_rel_next_lv",
"Prims.op_Subtraction",
"FStar.Seq.Base.slice",
"Prims.unit"
] | [
"recursion"
] | false | false | true | false | false | let rec hs_next_rel_next_lv #hsz #f n hs nhs =
| if n = 0
then ()
else hs_next_rel_next_lv #_ #f (n - 1) (S.slice hs 2 (S.length hs)) (S.slice nhs 1 (S.length nhs)) | false |
MerkleTree.Spec.fst | MerkleTree.Spec.rpmt_right | val rpmt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> #i:nat{i <= pow2 n} -> rpmt #hsz #f n i ->
rpmt #_ #f (n-1) (if i <= pow2 (n-1) then 0 else i - pow2 (n-1)) | val rpmt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> #i:nat{i <= pow2 n} -> rpmt #hsz #f n i ->
rpmt #_ #f (n-1) (if i <= pow2 (n-1) then 0 else i - pow2 (n-1)) | let rpmt_right #hsz #f #n #i mt =
if i <= pow2 (n-1)
then pad_hashes_slice #_ #f (S.slice mt i (S.length mt)) (pow2 (n-1) - i) (pow2 n - i)
else raw_hashes_slice #_ #f (S.slice mt 0 i) (pow2 (n-1)) i;
mt_right mt | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 13,
"end_line": 410,
"start_col": 0,
"start_line": 406
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1))
val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2)))
let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]);
assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]);
assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i])
val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2))
(S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2)))
let mt_next_lv_equiv #hsz #f j n mt1 mt2 =
hs_next_lv_equiv #_ #f j (pow2 (n-1)) mt1 mt2
val hs_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes #hsz {S.length hs = 2 * n} ->
nhs:hashes #hsz {S.length nhs = n} ->
GTot Type0
let hs_next_rel #hsz #f n hs nhs =
forall (i:nat{i < n}).
S.index nhs i ==
padded_hash_fun #hsz f (S.index hs (2 * i)) (S.index hs (2 * i + 1))
val mt_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
GTot Type0
let mt_next_rel #hsz #f n mt nmt =
hs_next_rel #hsz #f (pow2 (n-1)) mt nmt
val hs_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes{S.length hs = 2 * n} ->
nhs:hashes{S.length nhs = n} ->
Lemma (requires hs_next_rel #_ #f n hs nhs)
(ensures S.equal nhs (hs_next_lv #_ #f #n hs))
let rec hs_next_rel_next_lv #hsz #f n hs nhs =
if n = 0 then ()
else hs_next_rel_next_lv #_ #f (n - 1)
(S.slice hs 2 (S.length hs))
(S.slice nhs 1 (S.length nhs))
val mt_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures S.equal nmt (mt_next_lv #_ #f mt))
let mt_next_rel_next_lv #hsz #f n mt nmt =
hs_next_rel_next_lv #_ #f (pow2 (n-1)) mt nmt
val mt_next_rel_upd_even:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i) v)
(S.upd nmt i (padded_hash_fun #hsz f v (S.index mt (2 * i + 1)))))
let mt_next_rel_upd_even #hsz #f n mt nmt i v = ()
#push-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
val mt_next_rel_upd_even_pad:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash #hsz ->
Lemma (requires (mt_next_rel #_ #f n mt nmt) /\ (S.index mt (2 * i + 1) == HPad))
(ensures (mt_next_rel #_ #f n (S.upd mt (2 * i) v) (S.upd nmt i v)))
let mt_next_rel_upd_even_pad #hsz #f n mt nmt i v = ()
#pop-options
val mt_next_rel_upd_odd:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i + 1) v)
(S.upd nmt i (padded_hash_fun #_ f (S.index mt (2 * i)) v)))
let mt_next_rel_upd_odd #hsz #f n mt nmt i v = ()
// fournet: just [root]?
val mt_get_root:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n -> GTot (padded_hash #hsz)
let rec mt_get_root #hsz #f #n mt =
if n = 0 then mt.[0]
else mt_get_root #_ #f (mt_next_lv #_ #f mt)
#push-options "--initial_fuel 2 --max_fuel 2"
val mt_get_root_step: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (mt_get_root #_ #f mt ==
padded_hash_fun #_ f (mt_get_root #_ #f (mt_left mt)) (mt_get_root #_ #f (mt_right mt)))
let rec mt_get_root_step #hsz #f #n mt =
if n = 1 then ()
else begin
mt_get_root_step #_ #f (mt_next_lv #_ #f mt);
mt_next_lv_mt_left #_ #f mt;
mt_next_lv_mt_right #_ #f mt
end
#pop-options
type path #hsz n = S.lseq (padded_hash #hsz) n
/// We first specify full paths, including padding.
val mt_get_path:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
mt:merkle_tree #hsz n -> i:nat{i < pow2 n} -> GTot (path #hsz n)
let rec mt_get_path #hsz #f #n t i =
if n = 0 then S.empty
else S.cons
(if i % 2 = 0 then t.[i + 1] else t.[i - 1])
(mt_get_path #_ #f (mt_next_lv #_ #f t) (i / 2))
val mt_verify_:
#hsz:pos -> #f:hash_fun_t #hsz ->#n:nat ->
p:path #hsz n -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> GTot (padded_hash #hsz)
let rec mt_verify_ #hsz #f #n p idx h =
if n = 0 then h
else mt_verify_ #_ #f #(n-1) (S.tail p) (idx / 2)
(if idx % 2 = 0
then padded_hash_fun #_ f h (S.head p)
else padded_hash_fun #_ f (S.head p) h)
val mt_verify:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
p:(path #hsz n) -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> padded_hash #hsz -> GTot prop
let mt_verify #hsz #f #n p idx h rt =
rt == mt_verify_ #_ #f p idx h
/// Correctness: the root of a tree is correctly recomputed from any of its paths
val hs_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
hs:hashes{S.length hs = 2 * n} -> idx:nat{idx < 2 * n} ->
Lemma ((hs_next_lv #_ #f #n hs).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f hs.[idx] hs.[idx + 1]
else padded_hash_fun #_ f hs.[idx - 1] hs.[idx]))
let rec hs_next_lv_get #hsz #f #n hs idx =
if idx < 2 then ()
else hs_next_lv_get #_ #f #(n-1) (S.slice hs 2 (S.length hs)) (idx - 2)
val mt_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} ->
Lemma (
(mt_next_lv #_ #f mt).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f mt.[idx] mt.[idx + 1]
else padded_hash_fun #_ f mt.[idx - 1] mt.[idx]))
let mt_next_lv_get #hsz #f #n mt idx =
hs_next_lv_get #_ #f #(pow2 (n-1)) mt idx
val mt_get_path_ok_:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
t:merkle_tree #hsz n -> i:nat{i < pow2 n} ->
Lemma (mt_verify_ #_ #f (mt_get_path #_ #f t i) i (mt_get t i) == mt_get_root #_ #f t)
let rec mt_get_path_ok_ #hsz #f #n mt idx =
if n = 0 then ()
else begin
assert (S.head (mt_get_path #_ #f mt idx) ==
(if idx % 2 = 0 then mt.[idx + 1] else mt.[idx - 1]));
assert (S.equal (S.tail (mt_get_path #_ #f mt idx))
(mt_get_path #_ #f (mt_next_lv #_ #f mt) (idx / 2)));
mt_get_path_ok_ #_ #f (mt_next_lv #_ #f mt) (idx / 2);
mt_next_lv_get #_ #f mt idx
end
/// Security: we reduce tree collisions to collisions on the hash
/// compression function. Such collisions yield collisions on the SHA2
/// standard (by adding the same length and padding to the
/// accumulators).
///
/// One complication addressed in the proof is the handling of
/// implicit padding.
/// All hashes in a sequence are raw hashes, not padding
val raw_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes #hsz -> Tot Type0 (decreases (S.length hs))
let rec raw_hashes #hsz #f hs =
if S.length hs = 0 then True
else (HRaw? (S.head hs) /\ raw_hashes #_ #f (S.tail hs))
val raw_hashes_raws:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes{raw_hashes #hsz #f hs} ->
Tot (S.seq (hash #hsz)) (decreases (S.length hs))
let rec raw_hashes_raws #hsz #f hs =
if S.length hs = 0 then S.empty
else S.cons (HRaw?.hr (S.head hs)) (raw_hashes_raws #_ #f (S.tail hs))
val raw_hashes_index:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat{i < S.length hs} ->
Lemma (requires raw_hashes #_ #f hs)
(ensures HRaw? #hsz hs.[i])
(decreases i)
let rec raw_hashes_index #hsz #f hs i =
if i = 0 then ()
else raw_hashes_index #_ #f (S.tail hs) (i - 1)
val raw_hashes_slice:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat -> j:nat{i <= j && j <= S.length hs} ->
Lemma (requires raw_hashes #_ #f hs)
(ensures raw_hashes #_ #f (S.slice hs i j))
(decreases (j - i))
let rec raw_hashes_slice #hsz #f hs i j =
if i = j then ()
else (
raw_hashes_index #_ #f hs i;
raw_hashes_slice #_ #f hs (i + 1) j)
/// All hashes in a sequence are just padding
val pad_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes #hsz -> Type0
let pad_hashes #hsz #f hs =
S.equal hs (S.create (S.length hs) HPad)
val pad_hashes_slice:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat -> j:nat{i <= j && j <= S.length hs} ->
Lemma (requires pad_hashes #_ #f hs)
(ensures pad_hashes #_ #f (S.slice hs i j))
(decreases (j - i))
let rec pad_hashes_slice #hsz #f hs i j =
if i = j then ()
else pad_hashes_slice #_ #f hs (i + 1) j
/// Right-padded Merkle tree, a tree refinement
let rpmt (#hsz:pos) (#f:hash_fun_t) (n:nat) (i:nat{i <= pow2 n}) =
mt:merkle_tree #hsz n {
raw_hashes #_ #f (S.slice mt 0 i) /\
pad_hashes #_ #f (S.slice mt i (S.length mt)) }
val rpmt_raws: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #hsz #f n i -> S.seq (hash #hsz)
let rpmt_raws #hsz #f #n #i mt = raw_hashes_raws #_ #f (S.slice mt 0 i)
val rpmt_i_0: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> mt:rpmt #hsz #f n 0 ->
Lemma (S.equal mt (S.create (pow2 n) (HPad #hsz)))
let rpmt_i_0 #hsz #f #n mt = ()
val rpmt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> #i:nat{i <= pow2 n} -> rpmt #hsz #f n i ->
rpmt #hsz #f (n-1) (if i <= pow2 (n-1) then i else pow2 (n-1))
let rpmt_left #hsz #f #n #i mt =
if i <= pow2 (n-1)
then pad_hashes_slice #_ #f (S.slice mt i (S.length mt)) 0 (pow2 (n-1) - i)
else raw_hashes_slice #_ #f (S.slice mt 0 i) 0 (pow2 (n-1));
mt_left mt
#push-options "--z3rlimit 40"
val rpmt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> #i:nat{i <= pow2 n} -> rpmt #hsz #f n i -> | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 40,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | mt: MerkleTree.Spec.rpmt n i
-> MerkleTree.Spec.rpmt (n - 1)
(match i <= Prims.pow2 (n - 1) with
| true -> 0
| _ -> i - Prims.pow2 (n - 1)) | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.pow2",
"MerkleTree.Spec.rpmt",
"MerkleTree.Spec.mt_right",
"Prims.unit",
"Prims.op_Subtraction",
"MerkleTree.Spec.pad_hashes_slice",
"FStar.Seq.Base.slice",
"MerkleTree.Spec.padded_hash",
"FStar.Seq.Base.length",
"Prims.bool",
"MerkleTree.Spec.raw_hashes_slice"
] | [] | false | false | false | false | false | let rpmt_right #hsz #f #n #i mt =
| if i <= pow2 (n - 1)
then pad_hashes_slice #_ #f (S.slice mt i (S.length mt)) (pow2 (n - 1) - i) (pow2 n - i)
else raw_hashes_slice #_ #f (S.slice mt 0 i) (pow2 (n - 1)) i;
mt_right mt | false |
MerkleTree.Spec.fst | MerkleTree.Spec.mt_get_root_pad_index_0 | val mt_get_root_pad_index_0:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n ->
Lemma (HPad? mt.[0] <==> HPad? (mt_get_root #_ #f mt)) | val mt_get_root_pad_index_0:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n ->
Lemma (HPad? mt.[0] <==> HPad? (mt_get_root #_ #f mt)) | let rec mt_get_root_pad_index_0 #hsz #f #n (mt:merkle_tree #hsz n) =
if n = 0 then ()
else
let mt:merkle_tree #hsz (n-1) = mt_next_lv #_ #f #n mt in
mt_get_root_pad_index_0 #_ #f #(n-1) mt | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 43,
"end_line": 455,
"start_col": 0,
"start_line": 451
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1))
val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2)))
let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]);
assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]);
assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i])
val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2))
(S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2)))
let mt_next_lv_equiv #hsz #f j n mt1 mt2 =
hs_next_lv_equiv #_ #f j (pow2 (n-1)) mt1 mt2
val hs_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes #hsz {S.length hs = 2 * n} ->
nhs:hashes #hsz {S.length nhs = n} ->
GTot Type0
let hs_next_rel #hsz #f n hs nhs =
forall (i:nat{i < n}).
S.index nhs i ==
padded_hash_fun #hsz f (S.index hs (2 * i)) (S.index hs (2 * i + 1))
val mt_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
GTot Type0
let mt_next_rel #hsz #f n mt nmt =
hs_next_rel #hsz #f (pow2 (n-1)) mt nmt
val hs_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes{S.length hs = 2 * n} ->
nhs:hashes{S.length nhs = n} ->
Lemma (requires hs_next_rel #_ #f n hs nhs)
(ensures S.equal nhs (hs_next_lv #_ #f #n hs))
let rec hs_next_rel_next_lv #hsz #f n hs nhs =
if n = 0 then ()
else hs_next_rel_next_lv #_ #f (n - 1)
(S.slice hs 2 (S.length hs))
(S.slice nhs 1 (S.length nhs))
val mt_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures S.equal nmt (mt_next_lv #_ #f mt))
let mt_next_rel_next_lv #hsz #f n mt nmt =
hs_next_rel_next_lv #_ #f (pow2 (n-1)) mt nmt
val mt_next_rel_upd_even:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i) v)
(S.upd nmt i (padded_hash_fun #hsz f v (S.index mt (2 * i + 1)))))
let mt_next_rel_upd_even #hsz #f n mt nmt i v = ()
#push-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
val mt_next_rel_upd_even_pad:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash #hsz ->
Lemma (requires (mt_next_rel #_ #f n mt nmt) /\ (S.index mt (2 * i + 1) == HPad))
(ensures (mt_next_rel #_ #f n (S.upd mt (2 * i) v) (S.upd nmt i v)))
let mt_next_rel_upd_even_pad #hsz #f n mt nmt i v = ()
#pop-options
val mt_next_rel_upd_odd:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i + 1) v)
(S.upd nmt i (padded_hash_fun #_ f (S.index mt (2 * i)) v)))
let mt_next_rel_upd_odd #hsz #f n mt nmt i v = ()
// fournet: just [root]?
val mt_get_root:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n -> GTot (padded_hash #hsz)
let rec mt_get_root #hsz #f #n mt =
if n = 0 then mt.[0]
else mt_get_root #_ #f (mt_next_lv #_ #f mt)
#push-options "--initial_fuel 2 --max_fuel 2"
val mt_get_root_step: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (mt_get_root #_ #f mt ==
padded_hash_fun #_ f (mt_get_root #_ #f (mt_left mt)) (mt_get_root #_ #f (mt_right mt)))
let rec mt_get_root_step #hsz #f #n mt =
if n = 1 then ()
else begin
mt_get_root_step #_ #f (mt_next_lv #_ #f mt);
mt_next_lv_mt_left #_ #f mt;
mt_next_lv_mt_right #_ #f mt
end
#pop-options
type path #hsz n = S.lseq (padded_hash #hsz) n
/// We first specify full paths, including padding.
val mt_get_path:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
mt:merkle_tree #hsz n -> i:nat{i < pow2 n} -> GTot (path #hsz n)
let rec mt_get_path #hsz #f #n t i =
if n = 0 then S.empty
else S.cons
(if i % 2 = 0 then t.[i + 1] else t.[i - 1])
(mt_get_path #_ #f (mt_next_lv #_ #f t) (i / 2))
val mt_verify_:
#hsz:pos -> #f:hash_fun_t #hsz ->#n:nat ->
p:path #hsz n -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> GTot (padded_hash #hsz)
let rec mt_verify_ #hsz #f #n p idx h =
if n = 0 then h
else mt_verify_ #_ #f #(n-1) (S.tail p) (idx / 2)
(if idx % 2 = 0
then padded_hash_fun #_ f h (S.head p)
else padded_hash_fun #_ f (S.head p) h)
val mt_verify:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
p:(path #hsz n) -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> padded_hash #hsz -> GTot prop
let mt_verify #hsz #f #n p idx h rt =
rt == mt_verify_ #_ #f p idx h
/// Correctness: the root of a tree is correctly recomputed from any of its paths
val hs_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
hs:hashes{S.length hs = 2 * n} -> idx:nat{idx < 2 * n} ->
Lemma ((hs_next_lv #_ #f #n hs).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f hs.[idx] hs.[idx + 1]
else padded_hash_fun #_ f hs.[idx - 1] hs.[idx]))
let rec hs_next_lv_get #hsz #f #n hs idx =
if idx < 2 then ()
else hs_next_lv_get #_ #f #(n-1) (S.slice hs 2 (S.length hs)) (idx - 2)
val mt_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} ->
Lemma (
(mt_next_lv #_ #f mt).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f mt.[idx] mt.[idx + 1]
else padded_hash_fun #_ f mt.[idx - 1] mt.[idx]))
let mt_next_lv_get #hsz #f #n mt idx =
hs_next_lv_get #_ #f #(pow2 (n-1)) mt idx
val mt_get_path_ok_:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
t:merkle_tree #hsz n -> i:nat{i < pow2 n} ->
Lemma (mt_verify_ #_ #f (mt_get_path #_ #f t i) i (mt_get t i) == mt_get_root #_ #f t)
let rec mt_get_path_ok_ #hsz #f #n mt idx =
if n = 0 then ()
else begin
assert (S.head (mt_get_path #_ #f mt idx) ==
(if idx % 2 = 0 then mt.[idx + 1] else mt.[idx - 1]));
assert (S.equal (S.tail (mt_get_path #_ #f mt idx))
(mt_get_path #_ #f (mt_next_lv #_ #f mt) (idx / 2)));
mt_get_path_ok_ #_ #f (mt_next_lv #_ #f mt) (idx / 2);
mt_next_lv_get #_ #f mt idx
end
/// Security: we reduce tree collisions to collisions on the hash
/// compression function. Such collisions yield collisions on the SHA2
/// standard (by adding the same length and padding to the
/// accumulators).
///
/// One complication addressed in the proof is the handling of
/// implicit padding.
/// All hashes in a sequence are raw hashes, not padding
val raw_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes #hsz -> Tot Type0 (decreases (S.length hs))
let rec raw_hashes #hsz #f hs =
if S.length hs = 0 then True
else (HRaw? (S.head hs) /\ raw_hashes #_ #f (S.tail hs))
val raw_hashes_raws:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes{raw_hashes #hsz #f hs} ->
Tot (S.seq (hash #hsz)) (decreases (S.length hs))
let rec raw_hashes_raws #hsz #f hs =
if S.length hs = 0 then S.empty
else S.cons (HRaw?.hr (S.head hs)) (raw_hashes_raws #_ #f (S.tail hs))
val raw_hashes_index:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat{i < S.length hs} ->
Lemma (requires raw_hashes #_ #f hs)
(ensures HRaw? #hsz hs.[i])
(decreases i)
let rec raw_hashes_index #hsz #f hs i =
if i = 0 then ()
else raw_hashes_index #_ #f (S.tail hs) (i - 1)
val raw_hashes_slice:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat -> j:nat{i <= j && j <= S.length hs} ->
Lemma (requires raw_hashes #_ #f hs)
(ensures raw_hashes #_ #f (S.slice hs i j))
(decreases (j - i))
let rec raw_hashes_slice #hsz #f hs i j =
if i = j then ()
else (
raw_hashes_index #_ #f hs i;
raw_hashes_slice #_ #f hs (i + 1) j)
/// All hashes in a sequence are just padding
val pad_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes #hsz -> Type0
let pad_hashes #hsz #f hs =
S.equal hs (S.create (S.length hs) HPad)
val pad_hashes_slice:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat -> j:nat{i <= j && j <= S.length hs} ->
Lemma (requires pad_hashes #_ #f hs)
(ensures pad_hashes #_ #f (S.slice hs i j))
(decreases (j - i))
let rec pad_hashes_slice #hsz #f hs i j =
if i = j then ()
else pad_hashes_slice #_ #f hs (i + 1) j
/// Right-padded Merkle tree, a tree refinement
let rpmt (#hsz:pos) (#f:hash_fun_t) (n:nat) (i:nat{i <= pow2 n}) =
mt:merkle_tree #hsz n {
raw_hashes #_ #f (S.slice mt 0 i) /\
pad_hashes #_ #f (S.slice mt i (S.length mt)) }
val rpmt_raws: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #hsz #f n i -> S.seq (hash #hsz)
let rpmt_raws #hsz #f #n #i mt = raw_hashes_raws #_ #f (S.slice mt 0 i)
val rpmt_i_0: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> mt:rpmt #hsz #f n 0 ->
Lemma (S.equal mt (S.create (pow2 n) (HPad #hsz)))
let rpmt_i_0 #hsz #f #n mt = ()
val rpmt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> #i:nat{i <= pow2 n} -> rpmt #hsz #f n i ->
rpmt #hsz #f (n-1) (if i <= pow2 (n-1) then i else pow2 (n-1))
let rpmt_left #hsz #f #n #i mt =
if i <= pow2 (n-1)
then pad_hashes_slice #_ #f (S.slice mt i (S.length mt)) 0 (pow2 (n-1) - i)
else raw_hashes_slice #_ #f (S.slice mt 0 i) 0 (pow2 (n-1));
mt_left mt
#push-options "--z3rlimit 40"
val rpmt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> #i:nat{i <= pow2 n} -> rpmt #hsz #f n i ->
rpmt #_ #f (n-1) (if i <= pow2 (n-1) then 0 else i - pow2 (n-1))
let rpmt_right #hsz #f #n #i mt =
if i <= pow2 (n-1)
then pad_hashes_slice #_ #f (S.slice mt i (S.length mt)) (pow2 (n-1) - i) (pow2 n - i)
else raw_hashes_slice #_ #f (S.slice mt 0 i) (pow2 (n-1)) i;
mt_right mt
/// Two right-padded Merkle trees collide when
/// 1) they have the same height (`n`) and number of raw hashes (`i`),
/// 2) their contents differ, and
/// 3) their roots are same.
// fournet: we may want to work towards removing 1) using a hash prefix
noeq
type mt_collide (#hsz:pos) (#f:hash_fun_t #hsz) (n:nat) (i:nat{i <= pow2 n}) = | Collision:
mt1:rpmt #_ #f n i -> mt2:rpmt #_ #f n i {
mt1 =!= mt2 /\
mt_get_root #_ #f #_ mt1 == mt_get_root #_ #f #_ mt2 } -> mt_collide #_ #f n i
noeq
type hash2_raw_collide = | Collision2:
#hsz:pos -> #f:hash_fun_t #hsz ->
lh1:hash -> rh1:hash ->
lh2:hash -> rh2:hash {
(lh1 =!= lh2 \/ rh1 =!= rh2) /\
f lh1 rh1 == f lh2 rh2 } -> hash2_raw_collide
/// Auxiliary lemmas for the proof
val rpmt_pad_hashes_0:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #_ #f n i ->
Lemma (i = 0 <==> pad_hashes #_ #f mt )
let rpmt_pad_hashes_0 #_ #_ #n #i mt = ()
val rpmt_pad_hashes_index_0:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> #i:nat{i <= pow2 n} ->
mt:rpmt #_ #f n i ->
Lemma (pad_hashes #_ #f mt <==> HPad? mt.[0])
let rpmt_pad_hashes_index_0 #_ #_ #n #i mt = ()
val mt_get_root_pad_index_0:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n -> | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 40,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | mt: MerkleTree.Spec.merkle_tree n
-> FStar.Pervasives.Lemma (ensures HPad? mt.[ 0 ] <==> HPad? (MerkleTree.Spec.mt_get_root mt)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"MerkleTree.Spec.merkle_tree",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"MerkleTree.Spec.mt_get_root_pad_index_0",
"Prims.op_Subtraction",
"MerkleTree.Spec.mt_next_lv",
"Prims.unit"
] | [
"recursion"
] | false | false | true | false | false | let rec mt_get_root_pad_index_0 #hsz #f #n (mt: merkle_tree #hsz n) =
| if n = 0
then ()
else
let mt:merkle_tree #hsz (n - 1) = mt_next_lv #_ #f #n mt in
mt_get_root_pad_index_0 #_ #f #(n - 1) mt | false |
Vale.Inline.X64.Fswap_inline.fst | Vale.Inline.X64.Fswap_inline.of_reg | val of_reg (r: MS.reg_64) : option (IX64.reg_nat 3) | val of_reg (r: MS.reg_64) : option (IX64.reg_nat 3) | let of_reg (r:MS.reg_64) : option (IX64.reg_nat 3) = match r with
| 5 -> Some 0 // rdi
| 4 -> Some 1 // rsi
| 3 -> Some 2 // rdx
| _ -> None | {
"file_name": "vale/code/arch/x64/interop/Vale.Inline.X64.Fswap_inline.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 13,
"end_line": 114,
"start_col": 0,
"start_line": 110
} | module Vale.Inline.X64.Fswap_inline
open FStar.Mul
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LSig = Vale.AsLowStar.LowStarSig
module ME = Vale.X64.Memory
module V = Vale.X64.Decls
module IA = Vale.Interop.Assumptions
module W = Vale.AsLowStar.Wrapper
open Vale.X64.MemoryAdapters
module VS = Vale.X64.State
module MS = Vale.X64.Machine_s
module PR = Vale.X64.Print_Inline_s
module FU = Vale.Curve25519.X64.FastUtil
let uint64 = UInt64.t
(* A little utility to trigger normalization in types *)
let as_t (#a:Type) (x:normal a) : a = x
let as_normal_t (#a:Type) (x:a) : normal a = x
[@__reduce__]
let b64 = buf_t TUInt64 TUInt64
[@__reduce__]
let t64_mod = TD_Buffer TUInt64 TUInt64 default_bq
[@__reduce__]
let t64_no_mod = TD_Buffer TUInt64 TUInt64 ({modified=false; strict_disjointness=false; taint=MS.Secret})
[@__reduce__]
let tuint64 = TD_Base TUInt64
[@__reduce__]
let cswap_dom: IX64.arity_ok 3 td =
let y = [tuint64; t64_mod; t64_mod] in
assert_norm (List.length y = 3);
y
(* Need to rearrange the order of arguments *)
[@__reduce__]
let cswap_pre : VSig.vale_pre cswap_dom =
fun (c:V.va_code)
(bit:uint64)
(p0:b64)
(p1:b64)
(va_s0:V.va_state) ->
FU.va_req_Cswap2 c va_s0
(UInt64.v bit) (as_vale_buffer p0) (as_vale_buffer p1)
[@__reduce__]
let cswap_post : VSig.vale_post cswap_dom =
fun (c:V.va_code)
(bit:uint64)
(p0:b64)
(p1:b64)
(va_s0:V.va_state)
(va_s1:V.va_state)
(f:V.va_fuel) ->
FU.va_ens_Cswap2 c va_s0 (UInt64.v bit) (as_vale_buffer p0) (as_vale_buffer p1) va_s1 f
#set-options "--z3rlimit 50"
let cswap_regs_modified: MS.reg_64 -> bool = fun (r:MS.reg_64) ->
let open MS in
if r = rRdi || r = rR8 || r = rR9 || r = rR10 then true
else false
let cswap_xmms_modified = fun _ -> false
[@__reduce__]
let cswap_lemma'
(code:V.va_code)
(_win:bool)
(bit:uint64)
(p0:b64)
(p1:b64)
(va_s0:V.va_state)
: Ghost (V.va_state & V.va_fuel)
(requires
cswap_pre code bit p0 p1 va_s0)
(ensures (fun (va_s1, f) ->
V.eval_code code va_s0 f va_s1 /\
VSig.vale_calling_conventions va_s0 va_s1 cswap_regs_modified cswap_xmms_modified /\
cswap_post code bit p0 p1 va_s0 va_s1 f /\
ME.buffer_readable (VS.vs_get_vale_heap va_s1) (as_vale_buffer p0) /\
ME.buffer_readable (VS.vs_get_vale_heap va_s1) (as_vale_buffer p1) /\
ME.buffer_writeable (as_vale_buffer p0) /\
ME.buffer_writeable (as_vale_buffer p1) /\
ME.modifies (ME.loc_union (ME.loc_buffer (as_vale_buffer p0))
(ME.loc_union (ME.loc_buffer (as_vale_buffer p1))
ME.loc_none)) (VS.vs_get_vale_heap va_s0) (VS.vs_get_vale_heap va_s1)
)) =
let va_s1, f = FU.va_lemma_Cswap2 code va_s0 (UInt64.v bit) (as_vale_buffer p0) (as_vale_buffer p1) in
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt64 ME.TUInt64 p0;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt64 ME.TUInt64 p1;
(va_s1, f)
(* Prove that cswap_lemma' has the required type *)
let cswap_lemma = as_t #(VSig.vale_sig cswap_regs_modified cswap_xmms_modified cswap_pre cswap_post) cswap_lemma'
let code_cswap = FU.va_code_Cswap2 () | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Print_Inline_s.fst.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Interop.Assumptions.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.X64.FastUtil.fsti.checked",
"Vale.AsLowStar.Wrapper.fsti.checked",
"Vale.AsLowStar.ValeSig.fst.checked",
"Vale.AsLowStar.MemoryHelpers.fsti.checked",
"Vale.AsLowStar.LowStarSig.fst.checked",
"prims.fst.checked",
"LowStar.BufferView.Down.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Inline.X64.Fswap_inline.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
{
"abbrev": true,
"full_module": "Vale.X64.Print_Inline_s",
"short_module": "PR"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_module": "Vale.X64.State",
"short_module": "VS"
},
{
"abbrev": false,
"full_module": "Vale.X64.MemoryAdapters",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.Wrapper",
"short_module": "W"
},
{
"abbrev": true,
"full_module": "Vale.Interop.Assumptions",
"short_module": "IA"
},
{
"abbrev": true,
"full_module": "Vale.X64.Decls",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Vale.X64.Memory",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.LowStarSig",
"short_module": "LSig"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.ValeSig",
"short_module": "VSig"
},
{
"abbrev": true,
"full_module": "Vale.Interop.X64",
"short_module": "IX64"
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.BufferView.Down",
"short_module": "DV"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Vale.X64.Machine_s.reg_64 -> FStar.Pervasives.Native.option (Vale.Interop.X64.reg_nat 3) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Machine_s.reg_64",
"FStar.Pervasives.Native.Some",
"Vale.Interop.X64.reg_nat",
"Prims.int",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.option"
] | [] | false | false | false | false | false | let of_reg (r: MS.reg_64) : option (IX64.reg_nat 3) =
| match r with
| 5 -> Some 0
| 4 -> Some 1
| 3 -> Some 2
| _ -> None | false |
Vale.Inline.X64.Fswap_inline.fst | Vale.Inline.X64.Fswap_inline.t64_no_mod | val t64_no_mod : Vale.Interop.Base.td | let t64_no_mod = TD_Buffer TUInt64 TUInt64 ({modified=false; strict_disjointness=false; taint=MS.Secret}) | {
"file_name": "vale/code/arch/x64/interop/Vale.Inline.X64.Fswap_inline.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 105,
"end_line": 36,
"start_col": 0,
"start_line": 36
} | module Vale.Inline.X64.Fswap_inline
open FStar.Mul
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LSig = Vale.AsLowStar.LowStarSig
module ME = Vale.X64.Memory
module V = Vale.X64.Decls
module IA = Vale.Interop.Assumptions
module W = Vale.AsLowStar.Wrapper
open Vale.X64.MemoryAdapters
module VS = Vale.X64.State
module MS = Vale.X64.Machine_s
module PR = Vale.X64.Print_Inline_s
module FU = Vale.Curve25519.X64.FastUtil
let uint64 = UInt64.t
(* A little utility to trigger normalization in types *)
let as_t (#a:Type) (x:normal a) : a = x
let as_normal_t (#a:Type) (x:a) : normal a = x
[@__reduce__]
let b64 = buf_t TUInt64 TUInt64
[@__reduce__]
let t64_mod = TD_Buffer TUInt64 TUInt64 default_bq | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Print_Inline_s.fst.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Interop.Assumptions.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.X64.FastUtil.fsti.checked",
"Vale.AsLowStar.Wrapper.fsti.checked",
"Vale.AsLowStar.ValeSig.fst.checked",
"Vale.AsLowStar.MemoryHelpers.fsti.checked",
"Vale.AsLowStar.LowStarSig.fst.checked",
"prims.fst.checked",
"LowStar.BufferView.Down.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Inline.X64.Fswap_inline.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
{
"abbrev": true,
"full_module": "Vale.X64.Print_Inline_s",
"short_module": "PR"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_module": "Vale.X64.State",
"short_module": "VS"
},
{
"abbrev": false,
"full_module": "Vale.X64.MemoryAdapters",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.Wrapper",
"short_module": "W"
},
{
"abbrev": true,
"full_module": "Vale.Interop.Assumptions",
"short_module": "IA"
},
{
"abbrev": true,
"full_module": "Vale.X64.Decls",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Vale.X64.Memory",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.LowStarSig",
"short_module": "LSig"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.ValeSig",
"short_module": "VSig"
},
{
"abbrev": true,
"full_module": "Vale.Interop.X64",
"short_module": "IX64"
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.BufferView.Down",
"short_module": "DV"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Vale.Interop.Base.td | Prims.Tot | [
"total"
] | [] | [
"Vale.Interop.Base.TD_Buffer",
"Vale.Arch.HeapTypes_s.TUInt64",
"Vale.Interop.Base.Mkbuffer_qualifiers",
"Vale.Arch.HeapTypes_s.Secret"
] | [] | false | false | false | true | false | let t64_no_mod =
| TD_Buffer TUInt64 TUInt64 ({ modified = false; strict_disjointness = false; taint = MS.Secret }) | false |
|
MerkleTree.Spec.fst | MerkleTree.Spec.hs_next_lv_get | val hs_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
hs:hashes{S.length hs = 2 * n} -> idx:nat{idx < 2 * n} ->
Lemma ((hs_next_lv #_ #f #n hs).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f hs.[idx] hs.[idx + 1]
else padded_hash_fun #_ f hs.[idx - 1] hs.[idx])) | val hs_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
hs:hashes{S.length hs = 2 * n} -> idx:nat{idx < 2 * n} ->
Lemma ((hs_next_lv #_ #f #n hs).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f hs.[idx] hs.[idx + 1]
else padded_hash_fun #_ f hs.[idx - 1] hs.[idx])) | let rec hs_next_lv_get #hsz #f #n hs idx =
if idx < 2 then ()
else hs_next_lv_get #_ #f #(n-1) (S.slice hs 2 (S.length hs)) (idx - 2) | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 73,
"end_line": 288,
"start_col": 0,
"start_line": 286
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1))
val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2)))
let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]);
assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]);
assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i])
val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2))
(S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2)))
let mt_next_lv_equiv #hsz #f j n mt1 mt2 =
hs_next_lv_equiv #_ #f j (pow2 (n-1)) mt1 mt2
val hs_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes #hsz {S.length hs = 2 * n} ->
nhs:hashes #hsz {S.length nhs = n} ->
GTot Type0
let hs_next_rel #hsz #f n hs nhs =
forall (i:nat{i < n}).
S.index nhs i ==
padded_hash_fun #hsz f (S.index hs (2 * i)) (S.index hs (2 * i + 1))
val mt_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
GTot Type0
let mt_next_rel #hsz #f n mt nmt =
hs_next_rel #hsz #f (pow2 (n-1)) mt nmt
val hs_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes{S.length hs = 2 * n} ->
nhs:hashes{S.length nhs = n} ->
Lemma (requires hs_next_rel #_ #f n hs nhs)
(ensures S.equal nhs (hs_next_lv #_ #f #n hs))
let rec hs_next_rel_next_lv #hsz #f n hs nhs =
if n = 0 then ()
else hs_next_rel_next_lv #_ #f (n - 1)
(S.slice hs 2 (S.length hs))
(S.slice nhs 1 (S.length nhs))
val mt_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures S.equal nmt (mt_next_lv #_ #f mt))
let mt_next_rel_next_lv #hsz #f n mt nmt =
hs_next_rel_next_lv #_ #f (pow2 (n-1)) mt nmt
val mt_next_rel_upd_even:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i) v)
(S.upd nmt i (padded_hash_fun #hsz f v (S.index mt (2 * i + 1)))))
let mt_next_rel_upd_even #hsz #f n mt nmt i v = ()
#push-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
val mt_next_rel_upd_even_pad:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash #hsz ->
Lemma (requires (mt_next_rel #_ #f n mt nmt) /\ (S.index mt (2 * i + 1) == HPad))
(ensures (mt_next_rel #_ #f n (S.upd mt (2 * i) v) (S.upd nmt i v)))
let mt_next_rel_upd_even_pad #hsz #f n mt nmt i v = ()
#pop-options
val mt_next_rel_upd_odd:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i + 1) v)
(S.upd nmt i (padded_hash_fun #_ f (S.index mt (2 * i)) v)))
let mt_next_rel_upd_odd #hsz #f n mt nmt i v = ()
// fournet: just [root]?
val mt_get_root:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n -> GTot (padded_hash #hsz)
let rec mt_get_root #hsz #f #n mt =
if n = 0 then mt.[0]
else mt_get_root #_ #f (mt_next_lv #_ #f mt)
#push-options "--initial_fuel 2 --max_fuel 2"
val mt_get_root_step: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (mt_get_root #_ #f mt ==
padded_hash_fun #_ f (mt_get_root #_ #f (mt_left mt)) (mt_get_root #_ #f (mt_right mt)))
let rec mt_get_root_step #hsz #f #n mt =
if n = 1 then ()
else begin
mt_get_root_step #_ #f (mt_next_lv #_ #f mt);
mt_next_lv_mt_left #_ #f mt;
mt_next_lv_mt_right #_ #f mt
end
#pop-options
type path #hsz n = S.lseq (padded_hash #hsz) n
/// We first specify full paths, including padding.
val mt_get_path:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
mt:merkle_tree #hsz n -> i:nat{i < pow2 n} -> GTot (path #hsz n)
let rec mt_get_path #hsz #f #n t i =
if n = 0 then S.empty
else S.cons
(if i % 2 = 0 then t.[i + 1] else t.[i - 1])
(mt_get_path #_ #f (mt_next_lv #_ #f t) (i / 2))
val mt_verify_:
#hsz:pos -> #f:hash_fun_t #hsz ->#n:nat ->
p:path #hsz n -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> GTot (padded_hash #hsz)
let rec mt_verify_ #hsz #f #n p idx h =
if n = 0 then h
else mt_verify_ #_ #f #(n-1) (S.tail p) (idx / 2)
(if idx % 2 = 0
then padded_hash_fun #_ f h (S.head p)
else padded_hash_fun #_ f (S.head p) h)
val mt_verify:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
p:(path #hsz n) -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> padded_hash #hsz -> GTot prop
let mt_verify #hsz #f #n p idx h rt =
rt == mt_verify_ #_ #f p idx h
/// Correctness: the root of a tree is correctly recomputed from any of its paths
val hs_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
hs:hashes{S.length hs = 2 * n} -> idx:nat{idx < 2 * n} ->
Lemma ((hs_next_lv #_ #f #n hs).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f hs.[idx] hs.[idx + 1] | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | hs: MerkleTree.Spec.hashes{FStar.Seq.Base.length hs = 2 * n} -> idx: Prims.nat{idx < 2 * n}
-> FStar.Pervasives.Lemma
(ensures
(MerkleTree.Spec.hs_next_lv hs).[ idx / 2 ] ==
(match idx % 2 = 0 with
| true -> MerkleTree.Spec.padded_hash_fun f hs.[ idx ] hs.[ idx + 1 ]
| _ -> MerkleTree.Spec.padded_hash_fun f hs.[ idx - 1 ] hs.[ idx ])) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"MerkleTree.Spec.hashes",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"MerkleTree.Spec.padded_hash",
"FStar.Mul.op_Star",
"Prims.nat",
"Prims.op_LessThan",
"Prims.bool",
"MerkleTree.Spec.hs_next_lv_get",
"Prims.op_Subtraction",
"FStar.Seq.Base.slice",
"Prims.unit"
] | [
"recursion"
] | false | false | true | false | false | let rec hs_next_lv_get #hsz #f #n hs idx =
| if idx < 2 then () else hs_next_lv_get #_ #f #(n - 1) (S.slice hs 2 (S.length hs)) (idx - 2) | false |
Vale.Inline.X64.Fswap_inline.fst | Vale.Inline.X64.Fswap_inline.t64_mod | val t64_mod : Vale.Interop.Base.td | let t64_mod = TD_Buffer TUInt64 TUInt64 default_bq | {
"file_name": "vale/code/arch/x64/interop/Vale.Inline.X64.Fswap_inline.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 50,
"end_line": 34,
"start_col": 0,
"start_line": 34
} | module Vale.Inline.X64.Fswap_inline
open FStar.Mul
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LSig = Vale.AsLowStar.LowStarSig
module ME = Vale.X64.Memory
module V = Vale.X64.Decls
module IA = Vale.Interop.Assumptions
module W = Vale.AsLowStar.Wrapper
open Vale.X64.MemoryAdapters
module VS = Vale.X64.State
module MS = Vale.X64.Machine_s
module PR = Vale.X64.Print_Inline_s
module FU = Vale.Curve25519.X64.FastUtil
let uint64 = UInt64.t
(* A little utility to trigger normalization in types *)
let as_t (#a:Type) (x:normal a) : a = x
let as_normal_t (#a:Type) (x:a) : normal a = x
[@__reduce__]
let b64 = buf_t TUInt64 TUInt64 | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Print_Inline_s.fst.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Interop.Assumptions.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.X64.FastUtil.fsti.checked",
"Vale.AsLowStar.Wrapper.fsti.checked",
"Vale.AsLowStar.ValeSig.fst.checked",
"Vale.AsLowStar.MemoryHelpers.fsti.checked",
"Vale.AsLowStar.LowStarSig.fst.checked",
"prims.fst.checked",
"LowStar.BufferView.Down.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Inline.X64.Fswap_inline.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
{
"abbrev": true,
"full_module": "Vale.X64.Print_Inline_s",
"short_module": "PR"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_module": "Vale.X64.State",
"short_module": "VS"
},
{
"abbrev": false,
"full_module": "Vale.X64.MemoryAdapters",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.Wrapper",
"short_module": "W"
},
{
"abbrev": true,
"full_module": "Vale.Interop.Assumptions",
"short_module": "IA"
},
{
"abbrev": true,
"full_module": "Vale.X64.Decls",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Vale.X64.Memory",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.LowStarSig",
"short_module": "LSig"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.ValeSig",
"short_module": "VSig"
},
{
"abbrev": true,
"full_module": "Vale.Interop.X64",
"short_module": "IX64"
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.BufferView.Down",
"short_module": "DV"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Vale.Interop.Base.td | Prims.Tot | [
"total"
] | [] | [
"Vale.Interop.Base.TD_Buffer",
"Vale.Arch.HeapTypes_s.TUInt64",
"Vale.Interop.Base.default_bq"
] | [] | false | false | false | true | false | let t64_mod =
| TD_Buffer TUInt64 TUInt64 default_bq | false |
|
Vale.Inline.X64.Fswap_inline.fst | Vale.Inline.X64.Fswap_inline.uint64 | val uint64 : Prims.eqtype | let uint64 = UInt64.t | {
"file_name": "vale/code/arch/x64/interop/Vale.Inline.X64.Fswap_inline.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 21,
"end_line": 25,
"start_col": 0,
"start_line": 25
} | module Vale.Inline.X64.Fswap_inline
open FStar.Mul
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LSig = Vale.AsLowStar.LowStarSig
module ME = Vale.X64.Memory
module V = Vale.X64.Decls
module IA = Vale.Interop.Assumptions
module W = Vale.AsLowStar.Wrapper
open Vale.X64.MemoryAdapters
module VS = Vale.X64.State
module MS = Vale.X64.Machine_s
module PR = Vale.X64.Print_Inline_s
module FU = Vale.Curve25519.X64.FastUtil | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Print_Inline_s.fst.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Interop.Assumptions.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.X64.FastUtil.fsti.checked",
"Vale.AsLowStar.Wrapper.fsti.checked",
"Vale.AsLowStar.ValeSig.fst.checked",
"Vale.AsLowStar.MemoryHelpers.fsti.checked",
"Vale.AsLowStar.LowStarSig.fst.checked",
"prims.fst.checked",
"LowStar.BufferView.Down.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Inline.X64.Fswap_inline.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
{
"abbrev": true,
"full_module": "Vale.X64.Print_Inline_s",
"short_module": "PR"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_module": "Vale.X64.State",
"short_module": "VS"
},
{
"abbrev": false,
"full_module": "Vale.X64.MemoryAdapters",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.Wrapper",
"short_module": "W"
},
{
"abbrev": true,
"full_module": "Vale.Interop.Assumptions",
"short_module": "IA"
},
{
"abbrev": true,
"full_module": "Vale.X64.Decls",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Vale.X64.Memory",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.LowStarSig",
"short_module": "LSig"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.ValeSig",
"short_module": "VSig"
},
{
"abbrev": true,
"full_module": "Vale.Interop.X64",
"short_module": "IX64"
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.BufferView.Down",
"short_module": "DV"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Prims.eqtype | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt64.t"
] | [] | false | false | false | true | false | let uint64 =
| UInt64.t | false |
|
Vale.Inline.X64.Fswap_inline.fst | Vale.Inline.X64.Fswap_inline.tuint64 | val tuint64 : Vale.Interop.Base.td | let tuint64 = TD_Base TUInt64 | {
"file_name": "vale/code/arch/x64/interop/Vale.Inline.X64.Fswap_inline.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 29,
"end_line": 38,
"start_col": 0,
"start_line": 38
} | module Vale.Inline.X64.Fswap_inline
open FStar.Mul
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LSig = Vale.AsLowStar.LowStarSig
module ME = Vale.X64.Memory
module V = Vale.X64.Decls
module IA = Vale.Interop.Assumptions
module W = Vale.AsLowStar.Wrapper
open Vale.X64.MemoryAdapters
module VS = Vale.X64.State
module MS = Vale.X64.Machine_s
module PR = Vale.X64.Print_Inline_s
module FU = Vale.Curve25519.X64.FastUtil
let uint64 = UInt64.t
(* A little utility to trigger normalization in types *)
let as_t (#a:Type) (x:normal a) : a = x
let as_normal_t (#a:Type) (x:a) : normal a = x
[@__reduce__]
let b64 = buf_t TUInt64 TUInt64
[@__reduce__]
let t64_mod = TD_Buffer TUInt64 TUInt64 default_bq
[@__reduce__]
let t64_no_mod = TD_Buffer TUInt64 TUInt64 ({modified=false; strict_disjointness=false; taint=MS.Secret}) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Print_Inline_s.fst.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Interop.Assumptions.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.X64.FastUtil.fsti.checked",
"Vale.AsLowStar.Wrapper.fsti.checked",
"Vale.AsLowStar.ValeSig.fst.checked",
"Vale.AsLowStar.MemoryHelpers.fsti.checked",
"Vale.AsLowStar.LowStarSig.fst.checked",
"prims.fst.checked",
"LowStar.BufferView.Down.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Inline.X64.Fswap_inline.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
{
"abbrev": true,
"full_module": "Vale.X64.Print_Inline_s",
"short_module": "PR"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_module": "Vale.X64.State",
"short_module": "VS"
},
{
"abbrev": false,
"full_module": "Vale.X64.MemoryAdapters",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.Wrapper",
"short_module": "W"
},
{
"abbrev": true,
"full_module": "Vale.Interop.Assumptions",
"short_module": "IA"
},
{
"abbrev": true,
"full_module": "Vale.X64.Decls",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Vale.X64.Memory",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.LowStarSig",
"short_module": "LSig"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.ValeSig",
"short_module": "VSig"
},
{
"abbrev": true,
"full_module": "Vale.Interop.X64",
"short_module": "IX64"
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.BufferView.Down",
"short_module": "DV"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Vale.Interop.Base.td | Prims.Tot | [
"total"
] | [] | [
"Vale.Interop.Base.TD_Base",
"Vale.Arch.HeapTypes_s.TUInt64"
] | [] | false | false | false | true | false | let tuint64 =
| TD_Base TUInt64 | false |
|
Vale.Inline.X64.Fswap_inline.fst | Vale.Inline.X64.Fswap_inline.cswap_xmms_modified | val cswap_xmms_modified : _: _ -> Prims.bool | let cswap_xmms_modified = fun _ -> false | {
"file_name": "vale/code/arch/x64/interop/Vale.Inline.X64.Fswap_inline.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 40,
"end_line": 75,
"start_col": 0,
"start_line": 75
} | module Vale.Inline.X64.Fswap_inline
open FStar.Mul
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LSig = Vale.AsLowStar.LowStarSig
module ME = Vale.X64.Memory
module V = Vale.X64.Decls
module IA = Vale.Interop.Assumptions
module W = Vale.AsLowStar.Wrapper
open Vale.X64.MemoryAdapters
module VS = Vale.X64.State
module MS = Vale.X64.Machine_s
module PR = Vale.X64.Print_Inline_s
module FU = Vale.Curve25519.X64.FastUtil
let uint64 = UInt64.t
(* A little utility to trigger normalization in types *)
let as_t (#a:Type) (x:normal a) : a = x
let as_normal_t (#a:Type) (x:a) : normal a = x
[@__reduce__]
let b64 = buf_t TUInt64 TUInt64
[@__reduce__]
let t64_mod = TD_Buffer TUInt64 TUInt64 default_bq
[@__reduce__]
let t64_no_mod = TD_Buffer TUInt64 TUInt64 ({modified=false; strict_disjointness=false; taint=MS.Secret})
[@__reduce__]
let tuint64 = TD_Base TUInt64
[@__reduce__]
let cswap_dom: IX64.arity_ok 3 td =
let y = [tuint64; t64_mod; t64_mod] in
assert_norm (List.length y = 3);
y
(* Need to rearrange the order of arguments *)
[@__reduce__]
let cswap_pre : VSig.vale_pre cswap_dom =
fun (c:V.va_code)
(bit:uint64)
(p0:b64)
(p1:b64)
(va_s0:V.va_state) ->
FU.va_req_Cswap2 c va_s0
(UInt64.v bit) (as_vale_buffer p0) (as_vale_buffer p1)
[@__reduce__]
let cswap_post : VSig.vale_post cswap_dom =
fun (c:V.va_code)
(bit:uint64)
(p0:b64)
(p1:b64)
(va_s0:V.va_state)
(va_s1:V.va_state)
(f:V.va_fuel) ->
FU.va_ens_Cswap2 c va_s0 (UInt64.v bit) (as_vale_buffer p0) (as_vale_buffer p1) va_s1 f
#set-options "--z3rlimit 50"
let cswap_regs_modified: MS.reg_64 -> bool = fun (r:MS.reg_64) ->
let open MS in
if r = rRdi || r = rR8 || r = rR9 || r = rR10 then true
else false | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Print_Inline_s.fst.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Interop.Assumptions.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.X64.FastUtil.fsti.checked",
"Vale.AsLowStar.Wrapper.fsti.checked",
"Vale.AsLowStar.ValeSig.fst.checked",
"Vale.AsLowStar.MemoryHelpers.fsti.checked",
"Vale.AsLowStar.LowStarSig.fst.checked",
"prims.fst.checked",
"LowStar.BufferView.Down.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Inline.X64.Fswap_inline.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
{
"abbrev": true,
"full_module": "Vale.X64.Print_Inline_s",
"short_module": "PR"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_module": "Vale.X64.State",
"short_module": "VS"
},
{
"abbrev": false,
"full_module": "Vale.X64.MemoryAdapters",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.Wrapper",
"short_module": "W"
},
{
"abbrev": true,
"full_module": "Vale.Interop.Assumptions",
"short_module": "IA"
},
{
"abbrev": true,
"full_module": "Vale.X64.Decls",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Vale.X64.Memory",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.LowStarSig",
"short_module": "LSig"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.ValeSig",
"short_module": "VSig"
},
{
"abbrev": true,
"full_module": "Vale.Interop.X64",
"short_module": "IX64"
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.BufferView.Down",
"short_module": "DV"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: _ -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Prims.bool"
] | [] | false | false | false | true | false | let cswap_xmms_modified =
| fun _ -> false | false |
|
Vale.Inline.X64.Fswap_inline.fst | Vale.Inline.X64.Fswap_inline.b64 | val b64 : Type0 | let b64 = buf_t TUInt64 TUInt64 | {
"file_name": "vale/code/arch/x64/interop/Vale.Inline.X64.Fswap_inline.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 31,
"end_line": 32,
"start_col": 0,
"start_line": 32
} | module Vale.Inline.X64.Fswap_inline
open FStar.Mul
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LSig = Vale.AsLowStar.LowStarSig
module ME = Vale.X64.Memory
module V = Vale.X64.Decls
module IA = Vale.Interop.Assumptions
module W = Vale.AsLowStar.Wrapper
open Vale.X64.MemoryAdapters
module VS = Vale.X64.State
module MS = Vale.X64.Machine_s
module PR = Vale.X64.Print_Inline_s
module FU = Vale.Curve25519.X64.FastUtil
let uint64 = UInt64.t
(* A little utility to trigger normalization in types *)
let as_t (#a:Type) (x:normal a) : a = x
let as_normal_t (#a:Type) (x:a) : normal a = x | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Print_Inline_s.fst.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Interop.Assumptions.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.X64.FastUtil.fsti.checked",
"Vale.AsLowStar.Wrapper.fsti.checked",
"Vale.AsLowStar.ValeSig.fst.checked",
"Vale.AsLowStar.MemoryHelpers.fsti.checked",
"Vale.AsLowStar.LowStarSig.fst.checked",
"prims.fst.checked",
"LowStar.BufferView.Down.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Inline.X64.Fswap_inline.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
{
"abbrev": true,
"full_module": "Vale.X64.Print_Inline_s",
"short_module": "PR"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_module": "Vale.X64.State",
"short_module": "VS"
},
{
"abbrev": false,
"full_module": "Vale.X64.MemoryAdapters",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.Wrapper",
"short_module": "W"
},
{
"abbrev": true,
"full_module": "Vale.Interop.Assumptions",
"short_module": "IA"
},
{
"abbrev": true,
"full_module": "Vale.X64.Decls",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Vale.X64.Memory",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.LowStarSig",
"short_module": "LSig"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.ValeSig",
"short_module": "VSig"
},
{
"abbrev": true,
"full_module": "Vale.Interop.X64",
"short_module": "IX64"
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.BufferView.Down",
"short_module": "DV"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.Interop.Base.buf_t",
"Vale.Arch.HeapTypes_s.TUInt64"
] | [] | false | false | false | true | true | let b64 =
| buf_t TUInt64 TUInt64 | false |
|
Vale.Inline.X64.Fswap_inline.fst | Vale.Inline.X64.Fswap_inline.code_cswap | val code_cswap : Vale.X64.Decls.va_code | let code_cswap = FU.va_code_Cswap2 () | {
"file_name": "vale/code/arch/x64/interop/Vale.Inline.X64.Fswap_inline.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 37,
"end_line": 108,
"start_col": 0,
"start_line": 108
} | module Vale.Inline.X64.Fswap_inline
open FStar.Mul
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LSig = Vale.AsLowStar.LowStarSig
module ME = Vale.X64.Memory
module V = Vale.X64.Decls
module IA = Vale.Interop.Assumptions
module W = Vale.AsLowStar.Wrapper
open Vale.X64.MemoryAdapters
module VS = Vale.X64.State
module MS = Vale.X64.Machine_s
module PR = Vale.X64.Print_Inline_s
module FU = Vale.Curve25519.X64.FastUtil
let uint64 = UInt64.t
(* A little utility to trigger normalization in types *)
let as_t (#a:Type) (x:normal a) : a = x
let as_normal_t (#a:Type) (x:a) : normal a = x
[@__reduce__]
let b64 = buf_t TUInt64 TUInt64
[@__reduce__]
let t64_mod = TD_Buffer TUInt64 TUInt64 default_bq
[@__reduce__]
let t64_no_mod = TD_Buffer TUInt64 TUInt64 ({modified=false; strict_disjointness=false; taint=MS.Secret})
[@__reduce__]
let tuint64 = TD_Base TUInt64
[@__reduce__]
let cswap_dom: IX64.arity_ok 3 td =
let y = [tuint64; t64_mod; t64_mod] in
assert_norm (List.length y = 3);
y
(* Need to rearrange the order of arguments *)
[@__reduce__]
let cswap_pre : VSig.vale_pre cswap_dom =
fun (c:V.va_code)
(bit:uint64)
(p0:b64)
(p1:b64)
(va_s0:V.va_state) ->
FU.va_req_Cswap2 c va_s0
(UInt64.v bit) (as_vale_buffer p0) (as_vale_buffer p1)
[@__reduce__]
let cswap_post : VSig.vale_post cswap_dom =
fun (c:V.va_code)
(bit:uint64)
(p0:b64)
(p1:b64)
(va_s0:V.va_state)
(va_s1:V.va_state)
(f:V.va_fuel) ->
FU.va_ens_Cswap2 c va_s0 (UInt64.v bit) (as_vale_buffer p0) (as_vale_buffer p1) va_s1 f
#set-options "--z3rlimit 50"
let cswap_regs_modified: MS.reg_64 -> bool = fun (r:MS.reg_64) ->
let open MS in
if r = rRdi || r = rR8 || r = rR9 || r = rR10 then true
else false
let cswap_xmms_modified = fun _ -> false
[@__reduce__]
let cswap_lemma'
(code:V.va_code)
(_win:bool)
(bit:uint64)
(p0:b64)
(p1:b64)
(va_s0:V.va_state)
: Ghost (V.va_state & V.va_fuel)
(requires
cswap_pre code bit p0 p1 va_s0)
(ensures (fun (va_s1, f) ->
V.eval_code code va_s0 f va_s1 /\
VSig.vale_calling_conventions va_s0 va_s1 cswap_regs_modified cswap_xmms_modified /\
cswap_post code bit p0 p1 va_s0 va_s1 f /\
ME.buffer_readable (VS.vs_get_vale_heap va_s1) (as_vale_buffer p0) /\
ME.buffer_readable (VS.vs_get_vale_heap va_s1) (as_vale_buffer p1) /\
ME.buffer_writeable (as_vale_buffer p0) /\
ME.buffer_writeable (as_vale_buffer p1) /\
ME.modifies (ME.loc_union (ME.loc_buffer (as_vale_buffer p0))
(ME.loc_union (ME.loc_buffer (as_vale_buffer p1))
ME.loc_none)) (VS.vs_get_vale_heap va_s0) (VS.vs_get_vale_heap va_s1)
)) =
let va_s1, f = FU.va_lemma_Cswap2 code va_s0 (UInt64.v bit) (as_vale_buffer p0) (as_vale_buffer p1) in
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt64 ME.TUInt64 p0;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt64 ME.TUInt64 p1;
(va_s1, f)
(* Prove that cswap_lemma' has the required type *)
let cswap_lemma = as_t #(VSig.vale_sig cswap_regs_modified cswap_xmms_modified cswap_pre cswap_post) cswap_lemma' | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Print_Inline_s.fst.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Interop.Assumptions.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.X64.FastUtil.fsti.checked",
"Vale.AsLowStar.Wrapper.fsti.checked",
"Vale.AsLowStar.ValeSig.fst.checked",
"Vale.AsLowStar.MemoryHelpers.fsti.checked",
"Vale.AsLowStar.LowStarSig.fst.checked",
"prims.fst.checked",
"LowStar.BufferView.Down.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Inline.X64.Fswap_inline.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
{
"abbrev": true,
"full_module": "Vale.X64.Print_Inline_s",
"short_module": "PR"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_module": "Vale.X64.State",
"short_module": "VS"
},
{
"abbrev": false,
"full_module": "Vale.X64.MemoryAdapters",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.Wrapper",
"short_module": "W"
},
{
"abbrev": true,
"full_module": "Vale.Interop.Assumptions",
"short_module": "IA"
},
{
"abbrev": true,
"full_module": "Vale.X64.Decls",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Vale.X64.Memory",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.LowStarSig",
"short_module": "LSig"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.ValeSig",
"short_module": "VSig"
},
{
"abbrev": true,
"full_module": "Vale.Interop.X64",
"short_module": "IX64"
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.BufferView.Down",
"short_module": "DV"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.Curve25519.X64.FastUtil.va_code_Cswap2"
] | [] | false | false | false | true | false | let code_cswap =
| FU.va_code_Cswap2 () | false |
|
Vale.Inline.X64.Fswap_inline.fst | Vale.Inline.X64.Fswap_inline.cswap_comments | val cswap_comments:list string | val cswap_comments:list string | let cswap_comments : list string =
["Computes p1 <- bit ? p2 : p1 in constant time"] | {
"file_name": "vale/code/arch/x64/interop/Vale.Inline.X64.Fswap_inline.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 51,
"end_line": 164,
"start_col": 0,
"start_line": 163
} | module Vale.Inline.X64.Fswap_inline
open FStar.Mul
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LSig = Vale.AsLowStar.LowStarSig
module ME = Vale.X64.Memory
module V = Vale.X64.Decls
module IA = Vale.Interop.Assumptions
module W = Vale.AsLowStar.Wrapper
open Vale.X64.MemoryAdapters
module VS = Vale.X64.State
module MS = Vale.X64.Machine_s
module PR = Vale.X64.Print_Inline_s
module FU = Vale.Curve25519.X64.FastUtil
let uint64 = UInt64.t
(* A little utility to trigger normalization in types *)
let as_t (#a:Type) (x:normal a) : a = x
let as_normal_t (#a:Type) (x:a) : normal a = x
[@__reduce__]
let b64 = buf_t TUInt64 TUInt64
[@__reduce__]
let t64_mod = TD_Buffer TUInt64 TUInt64 default_bq
[@__reduce__]
let t64_no_mod = TD_Buffer TUInt64 TUInt64 ({modified=false; strict_disjointness=false; taint=MS.Secret})
[@__reduce__]
let tuint64 = TD_Base TUInt64
[@__reduce__]
let cswap_dom: IX64.arity_ok 3 td =
let y = [tuint64; t64_mod; t64_mod] in
assert_norm (List.length y = 3);
y
(* Need to rearrange the order of arguments *)
[@__reduce__]
let cswap_pre : VSig.vale_pre cswap_dom =
fun (c:V.va_code)
(bit:uint64)
(p0:b64)
(p1:b64)
(va_s0:V.va_state) ->
FU.va_req_Cswap2 c va_s0
(UInt64.v bit) (as_vale_buffer p0) (as_vale_buffer p1)
[@__reduce__]
let cswap_post : VSig.vale_post cswap_dom =
fun (c:V.va_code)
(bit:uint64)
(p0:b64)
(p1:b64)
(va_s0:V.va_state)
(va_s1:V.va_state)
(f:V.va_fuel) ->
FU.va_ens_Cswap2 c va_s0 (UInt64.v bit) (as_vale_buffer p0) (as_vale_buffer p1) va_s1 f
#set-options "--z3rlimit 50"
let cswap_regs_modified: MS.reg_64 -> bool = fun (r:MS.reg_64) ->
let open MS in
if r = rRdi || r = rR8 || r = rR9 || r = rR10 then true
else false
let cswap_xmms_modified = fun _ -> false
[@__reduce__]
let cswap_lemma'
(code:V.va_code)
(_win:bool)
(bit:uint64)
(p0:b64)
(p1:b64)
(va_s0:V.va_state)
: Ghost (V.va_state & V.va_fuel)
(requires
cswap_pre code bit p0 p1 va_s0)
(ensures (fun (va_s1, f) ->
V.eval_code code va_s0 f va_s1 /\
VSig.vale_calling_conventions va_s0 va_s1 cswap_regs_modified cswap_xmms_modified /\
cswap_post code bit p0 p1 va_s0 va_s1 f /\
ME.buffer_readable (VS.vs_get_vale_heap va_s1) (as_vale_buffer p0) /\
ME.buffer_readable (VS.vs_get_vale_heap va_s1) (as_vale_buffer p1) /\
ME.buffer_writeable (as_vale_buffer p0) /\
ME.buffer_writeable (as_vale_buffer p1) /\
ME.modifies (ME.loc_union (ME.loc_buffer (as_vale_buffer p0))
(ME.loc_union (ME.loc_buffer (as_vale_buffer p1))
ME.loc_none)) (VS.vs_get_vale_heap va_s0) (VS.vs_get_vale_heap va_s1)
)) =
let va_s1, f = FU.va_lemma_Cswap2 code va_s0 (UInt64.v bit) (as_vale_buffer p0) (as_vale_buffer p1) in
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt64 ME.TUInt64 p0;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt64 ME.TUInt64 p1;
(va_s1, f)
(* Prove that cswap_lemma' has the required type *)
let cswap_lemma = as_t #(VSig.vale_sig cswap_regs_modified cswap_xmms_modified cswap_pre cswap_post) cswap_lemma'
let code_cswap = FU.va_code_Cswap2 ()
let of_reg (r:MS.reg_64) : option (IX64.reg_nat 3) = match r with
| 5 -> Some 0 // rdi
| 4 -> Some 1 // rsi
| 3 -> Some 2 // rdx
| _ -> None
let of_arg (i:IX64.reg_nat 3) : MS.reg_64 = match i with
| 0 -> MS.rRdi
| 1 -> MS.rRsi
| 2 -> MS.rRdx
let arg_reg : IX64.arg_reg_relation 3 = IX64.Rel of_reg of_arg
(* Here's the type expected for the cswap wrapper *)
[@__reduce__]
let lowstar_cswap_t =
assert_norm (List.length cswap_dom + List.length ([]<:list arg) <= 3);
IX64.as_lowstar_sig_t_weak
3
arg_reg
cswap_regs_modified
cswap_xmms_modified
code_cswap
cswap_dom
[]
_
_
// The boolean here doesn't matter
(W.mk_prediction code_cswap cswap_dom [] (cswap_lemma code_cswap IA.win))
(* And here's the cswap wrapper itself *)
let lowstar_cswap : lowstar_cswap_t =
assert_norm (List.length cswap_dom + List.length ([]<:list arg) <= 3);
IX64.wrap_weak
3
arg_reg
cswap_regs_modified
cswap_xmms_modified
code_cswap
cswap_dom
(W.mk_prediction code_cswap cswap_dom [] (cswap_lemma code_cswap IA.win))
let lowstar_cswap_normal_t : normal lowstar_cswap_t
= as_normal_t #lowstar_cswap_t lowstar_cswap
open Vale.AsLowStar.MemoryHelpers
let cswap2 bit p0 p1
= DV.length_eq (get_downview p0);
DV.length_eq (get_downview p1);
let (x, _) = lowstar_cswap_normal_t bit p0 p1 () in
() | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Print_Inline_s.fst.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Interop.Assumptions.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.X64.FastUtil.fsti.checked",
"Vale.AsLowStar.Wrapper.fsti.checked",
"Vale.AsLowStar.ValeSig.fst.checked",
"Vale.AsLowStar.MemoryHelpers.fsti.checked",
"Vale.AsLowStar.LowStarSig.fst.checked",
"prims.fst.checked",
"LowStar.BufferView.Down.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Inline.X64.Fswap_inline.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.AsLowStar.MemoryHelpers",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
{
"abbrev": true,
"full_module": "Vale.X64.Print_Inline_s",
"short_module": "PR"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_module": "Vale.X64.State",
"short_module": "VS"
},
{
"abbrev": false,
"full_module": "Vale.X64.MemoryAdapters",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.Wrapper",
"short_module": "W"
},
{
"abbrev": true,
"full_module": "Vale.Interop.Assumptions",
"short_module": "IA"
},
{
"abbrev": true,
"full_module": "Vale.X64.Decls",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Vale.X64.Memory",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.LowStarSig",
"short_module": "LSig"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.ValeSig",
"short_module": "VSig"
},
{
"abbrev": true,
"full_module": "Vale.Interop.X64",
"short_module": "IX64"
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.BufferView.Down",
"short_module": "DV"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Prims.list Prims.string | Prims.Tot | [
"total"
] | [] | [
"Prims.Cons",
"Prims.string",
"Prims.Nil"
] | [] | false | false | false | true | false | let cswap_comments:list string =
| ["Computes p1 <- bit ? p2 : p1 in constant time"] | false |
Vale.Inline.X64.Fswap_inline.fst | Vale.Inline.X64.Fswap_inline.cswap_names | val cswap_names (n: nat) : string | val cswap_names (n: nat) : string | let cswap_names (n:nat) : string =
match n with
| 0 -> "bit"
| 1 -> "p1"
| 2 -> "p2"
| _ -> "" | {
"file_name": "vale/code/arch/x64/interop/Vale.Inline.X64.Fswap_inline.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 171,
"start_col": 0,
"start_line": 166
} | module Vale.Inline.X64.Fswap_inline
open FStar.Mul
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LSig = Vale.AsLowStar.LowStarSig
module ME = Vale.X64.Memory
module V = Vale.X64.Decls
module IA = Vale.Interop.Assumptions
module W = Vale.AsLowStar.Wrapper
open Vale.X64.MemoryAdapters
module VS = Vale.X64.State
module MS = Vale.X64.Machine_s
module PR = Vale.X64.Print_Inline_s
module FU = Vale.Curve25519.X64.FastUtil
let uint64 = UInt64.t
(* A little utility to trigger normalization in types *)
let as_t (#a:Type) (x:normal a) : a = x
let as_normal_t (#a:Type) (x:a) : normal a = x
[@__reduce__]
let b64 = buf_t TUInt64 TUInt64
[@__reduce__]
let t64_mod = TD_Buffer TUInt64 TUInt64 default_bq
[@__reduce__]
let t64_no_mod = TD_Buffer TUInt64 TUInt64 ({modified=false; strict_disjointness=false; taint=MS.Secret})
[@__reduce__]
let tuint64 = TD_Base TUInt64
[@__reduce__]
let cswap_dom: IX64.arity_ok 3 td =
let y = [tuint64; t64_mod; t64_mod] in
assert_norm (List.length y = 3);
y
(* Need to rearrange the order of arguments *)
[@__reduce__]
let cswap_pre : VSig.vale_pre cswap_dom =
fun (c:V.va_code)
(bit:uint64)
(p0:b64)
(p1:b64)
(va_s0:V.va_state) ->
FU.va_req_Cswap2 c va_s0
(UInt64.v bit) (as_vale_buffer p0) (as_vale_buffer p1)
[@__reduce__]
let cswap_post : VSig.vale_post cswap_dom =
fun (c:V.va_code)
(bit:uint64)
(p0:b64)
(p1:b64)
(va_s0:V.va_state)
(va_s1:V.va_state)
(f:V.va_fuel) ->
FU.va_ens_Cswap2 c va_s0 (UInt64.v bit) (as_vale_buffer p0) (as_vale_buffer p1) va_s1 f
#set-options "--z3rlimit 50"
let cswap_regs_modified: MS.reg_64 -> bool = fun (r:MS.reg_64) ->
let open MS in
if r = rRdi || r = rR8 || r = rR9 || r = rR10 then true
else false
let cswap_xmms_modified = fun _ -> false
[@__reduce__]
let cswap_lemma'
(code:V.va_code)
(_win:bool)
(bit:uint64)
(p0:b64)
(p1:b64)
(va_s0:V.va_state)
: Ghost (V.va_state & V.va_fuel)
(requires
cswap_pre code bit p0 p1 va_s0)
(ensures (fun (va_s1, f) ->
V.eval_code code va_s0 f va_s1 /\
VSig.vale_calling_conventions va_s0 va_s1 cswap_regs_modified cswap_xmms_modified /\
cswap_post code bit p0 p1 va_s0 va_s1 f /\
ME.buffer_readable (VS.vs_get_vale_heap va_s1) (as_vale_buffer p0) /\
ME.buffer_readable (VS.vs_get_vale_heap va_s1) (as_vale_buffer p1) /\
ME.buffer_writeable (as_vale_buffer p0) /\
ME.buffer_writeable (as_vale_buffer p1) /\
ME.modifies (ME.loc_union (ME.loc_buffer (as_vale_buffer p0))
(ME.loc_union (ME.loc_buffer (as_vale_buffer p1))
ME.loc_none)) (VS.vs_get_vale_heap va_s0) (VS.vs_get_vale_heap va_s1)
)) =
let va_s1, f = FU.va_lemma_Cswap2 code va_s0 (UInt64.v bit) (as_vale_buffer p0) (as_vale_buffer p1) in
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt64 ME.TUInt64 p0;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt64 ME.TUInt64 p1;
(va_s1, f)
(* Prove that cswap_lemma' has the required type *)
let cswap_lemma = as_t #(VSig.vale_sig cswap_regs_modified cswap_xmms_modified cswap_pre cswap_post) cswap_lemma'
let code_cswap = FU.va_code_Cswap2 ()
let of_reg (r:MS.reg_64) : option (IX64.reg_nat 3) = match r with
| 5 -> Some 0 // rdi
| 4 -> Some 1 // rsi
| 3 -> Some 2 // rdx
| _ -> None
let of_arg (i:IX64.reg_nat 3) : MS.reg_64 = match i with
| 0 -> MS.rRdi
| 1 -> MS.rRsi
| 2 -> MS.rRdx
let arg_reg : IX64.arg_reg_relation 3 = IX64.Rel of_reg of_arg
(* Here's the type expected for the cswap wrapper *)
[@__reduce__]
let lowstar_cswap_t =
assert_norm (List.length cswap_dom + List.length ([]<:list arg) <= 3);
IX64.as_lowstar_sig_t_weak
3
arg_reg
cswap_regs_modified
cswap_xmms_modified
code_cswap
cswap_dom
[]
_
_
// The boolean here doesn't matter
(W.mk_prediction code_cswap cswap_dom [] (cswap_lemma code_cswap IA.win))
(* And here's the cswap wrapper itself *)
let lowstar_cswap : lowstar_cswap_t =
assert_norm (List.length cswap_dom + List.length ([]<:list arg) <= 3);
IX64.wrap_weak
3
arg_reg
cswap_regs_modified
cswap_xmms_modified
code_cswap
cswap_dom
(W.mk_prediction code_cswap cswap_dom [] (cswap_lemma code_cswap IA.win))
let lowstar_cswap_normal_t : normal lowstar_cswap_t
= as_normal_t #lowstar_cswap_t lowstar_cswap
open Vale.AsLowStar.MemoryHelpers
let cswap2 bit p0 p1
= DV.length_eq (get_downview p0);
DV.length_eq (get_downview p1);
let (x, _) = lowstar_cswap_normal_t bit p0 p1 () in
()
let cswap_comments : list string =
["Computes p1 <- bit ? p2 : p1 in constant time"] | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Print_Inline_s.fst.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Interop.Assumptions.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.X64.FastUtil.fsti.checked",
"Vale.AsLowStar.Wrapper.fsti.checked",
"Vale.AsLowStar.ValeSig.fst.checked",
"Vale.AsLowStar.MemoryHelpers.fsti.checked",
"Vale.AsLowStar.LowStarSig.fst.checked",
"prims.fst.checked",
"LowStar.BufferView.Down.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Inline.X64.Fswap_inline.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.AsLowStar.MemoryHelpers",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
{
"abbrev": true,
"full_module": "Vale.X64.Print_Inline_s",
"short_module": "PR"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_module": "Vale.X64.State",
"short_module": "VS"
},
{
"abbrev": false,
"full_module": "Vale.X64.MemoryAdapters",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.Wrapper",
"short_module": "W"
},
{
"abbrev": true,
"full_module": "Vale.Interop.Assumptions",
"short_module": "IA"
},
{
"abbrev": true,
"full_module": "Vale.X64.Decls",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Vale.X64.Memory",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.LowStarSig",
"short_module": "LSig"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.ValeSig",
"short_module": "VSig"
},
{
"abbrev": true,
"full_module": "Vale.Interop.X64",
"short_module": "IX64"
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.BufferView.Down",
"short_module": "DV"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | n: Prims.nat -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Prims.int",
"Prims.string"
] | [] | false | false | false | true | false | let cswap_names (n: nat) : string =
| match n with
| 0 -> "bit"
| 1 -> "p1"
| 2 -> "p2"
| _ -> "" | false |
Vale.Curve25519.FastHybrid_helpers.fst | Vale.Curve25519.FastHybrid_helpers.lemma_mul_pow256_sub | val lemma_mul_pow256_sub (x y: nat) : Lemma ((x - y * pow2_256) % prime == (x - y * 38) % prime) | val lemma_mul_pow256_sub (x y: nat) : Lemma ((x - y * pow2_256) % prime == (x - y * 38) % prime) | let lemma_mul_pow256_sub (x y:nat) :
Lemma ((x - y * pow2_256) % prime == (x - y * 38) % prime)
=
assert_norm (pow2_256 % prime == 38);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (-y) pow2_256 prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (-y) 38 prime;
assert ((-y * pow2_256) % prime == (- y * 38) % prime);
FStar.Math.Lemmas.modulo_add prime x (- (y * pow2_256)) (- (y * 38)) | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.FastHybrid_helpers.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 70,
"end_line": 131,
"start_col": 0,
"start_line": 123
} | module Vale.Curve25519.FastHybrid_helpers
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
open FStar.Tactics
open FStar.Tactics.CanonCommSemiring
open Vale.Curve25519.Fast_defs
open Vale.Curve25519.Fast_lemmas_internal
#reset-options "--max_fuel 0 --max_ifuel 0 --using_facts_from '* -FStar.Tactics -FStar.Reflection'"
let lemma_carry_prime (a0 a1 a2 a3 a0' a1' a2' a3' carry_in:nat64) (carry:bit) : Lemma
(requires pow2_five a0' a1' a2' a3' carry == pow2_four a0 a1 a2 a3 + carry_in * 38 /\
carry_in * 38 - 1 + 38 < pow2_64)
(ensures a0' + carry * 38 < pow2_64 /\
(pow2_four (a0' + carry * 38) a1' a2' a3') % prime == (pow2_four a0 a1 a2 a3 + carry_in * pow2_256) % prime)
=
assert (a0' + carry * 38 < pow2_64);
calc (==) {
(pow2_four a0 a1 a2 a3 + carry_in * pow2_256) % prime;
== { lemma_mul_pow256_add (pow2_four a0 a1 a2 a3) carry_in }
(pow2_four a0 a1 a2 a3 + carry_in * 38) % prime;
== {}
(pow2_five a0' a1' a2' a3' carry) % prime;
== { _ by (int_canon()) }
(pow2_four a0' a1' a2' a3' + (carry * pow2_256)) % prime;
== { lemma_mul_pow256_add (pow2_four a0' a1' a2' a3') carry }
(pow2_four a0' a1' a2' a3' + (carry * 38)) % prime;
== { calc (==) {
(pow2_four a0' a1' a2' a3') + (carry * 38);
== { _ by (int_canon()) }
pow2_four (a0' + carry * 38) a1' a2' a3';
}
}
(pow2_four (a0' + carry * 38) a1' a2' a3') % prime;
};
()
#reset-options "--z3rlimit 30 --max_fuel 0 --max_ifuel 0 --using_facts_from '* -FStar.Tactics -FStar.Reflection'"
let lemma_fast_mul1 (a:nat)
(b a0 a1 a2 a3
ba0_hi ba0_lo
ba1_hi ba1_lo
ba2_hi ba2_lo
ba3_hi ba3_lo
s1 s2 s3 s4:nat64) : Lemma
(requires a = pow2_four a0 a1 a2 a3 /\
pow2_64 * ba0_hi + ba0_lo == b * a0 /\
pow2_64 * ba1_hi + ba1_lo == b * a1 /\
pow2_64 * ba2_hi + ba2_lo == b * a2 /\
pow2_64 * ba3_hi + ba3_lo == b * a3 /\
(let s1', c1 = add_carry ba1_lo ba0_hi 0 in
let s2', c2 = add_carry ba2_lo ba1_hi c1 in
let s3', c3 = add_carry ba3_lo ba2_hi c2 in
let s4', c4 = add_carry ba3_hi 0 c3 in
s1 == s1' /\
s2 == s2' /\
s3 == s3' /\
s4 == s4' /\
c4 == 0)
)
(ensures pow2_five ba0_lo s1 s2 s3 s4 == a * b)
=
assert_by_tactic (b * pow2_four a0 a1 a2 a3 == pow2_four (b*a0) (b*a1) (b*a2) (b*a3)) int_canon;
//lemma_prod_bounds ba0_hi ba0_lo b a0;
//lemma_prod_bounds ba1_hi ba1_lo b a1;
//lemma_prod_bounds ba2_hi ba2_lo b a2;
//lemma_prod_bounds ba3_hi ba3_lo b a3;
()
let lemma_addition (a d:nat) (a0 a1 a2 a3 d0 d1 d2 d3 d4:nat64)
(s0 s1 s2 s3 s4:nat64) : Lemma
(requires a = pow2_four a0 a1 a2 a3 /\
d = pow2_five d0 d1 d2 d3 d4 /\
(let s0', c0 = add_carry a0 d0 0 in
let s1', c1 = add_carry a1 d1 c0 in
let s2', c2 = add_carry a2 d2 c1 in
let s3', c3 = add_carry a3 d3 c2 in
let s4', c4 = add_carry d4 0 c3 in
s0 == s0' /\
s1 == s1' /\
s2 == s2' /\
s3 == s3' /\
s4 == s4' /\
c4 == 0))
(ensures a + d == pow2_five s0 s1 s2 s3 s4)
=
()
let lemma_carry_wide (a0 a1 a2 a3 a4 a5 a6 a7
d0 d1 d2 d3 carry
d0' d1' d2' d3':nat64) : Lemma
(requires pow2_five d0 d1 d2 d3 carry == 38 * pow2_four a4 a5 a6 a7 + pow2_four a0 a1 a2 a3 /\
pow2_four d0' d1' d2' d3' % prime == ((pow2_four d0 d1 d2 d3) + carry * pow2_256) % prime)
(ensures (pow2_four d0' d1' d2' d3') % prime == (pow2_eight a0 a1 a2 a3 a4 a5 a6 a7) % prime)
=
calc (==) {
pow2_four d0' d1' d2' d3' % prime;
== { calc (==) {
(pow2_four d0 d1 d2 d3) + carry * pow2_256;
== { _ by (int_canon()) }
pow2_five d0 d1 d2 d3 carry;
}
}
pow2_five d0 d1 d2 d3 carry % prime;
== {}
(pow2_four a0 a1 a2 a3 + 38 * pow2_four a4 a5 a6 a7) % prime;
== { lemma_mul_pow256_add (pow2_four a0 a1 a2 a3) (pow2_four a4 a5 a6 a7) }
(pow2_four a0 a1 a2 a3 + pow2_256 * pow2_four a4 a5 a6 a7) % prime;
== { _ by (int_canon()) }
(pow2_eight a0 a1 a2 a3 a4 a5 a6 a7) % prime;
}
let pow2int_four (c0 c1 c2 c3:int) : int = c0 + c1 * pow2_64 + c2 * pow2_128 + c3 * pow2_192 | {
"checked_file": "/",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_lemmas_internal.fsti.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Curve25519.FastHybrid_helpers.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_internal",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": 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": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x: Prims.nat -> y: Prims.nat
-> FStar.Pervasives.Lemma
(ensures
(x - y * Vale.Curve25519.Fast_defs.pow2_256) % Vale.Curve25519.Fast_defs.prime ==
(x - y * 38) % Vale.Curve25519.Fast_defs.prime) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"FStar.Math.Lemmas.modulo_add",
"Vale.Curve25519.Fast_defs.prime",
"Prims.op_Minus",
"FStar.Mul.op_Star",
"Vale.Curve25519.Fast_defs.pow2_256",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"FStar.Math.Lemmas.lemma_mod_mul_distr_r",
"FStar.Pervasives.assert_norm",
"Prims.l_True",
"Prims.squash",
"Prims.op_Subtraction",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let lemma_mul_pow256_sub (x y: nat) : Lemma ((x - y * pow2_256) % prime == (x - y * 38) % prime) =
| assert_norm (pow2_256 % prime == 38);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (- y) pow2_256 prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (- y) 38 prime;
assert ((- y * pow2_256) % prime == (- y * 38) % prime);
FStar.Math.Lemmas.modulo_add prime x (- (y * pow2_256)) (- (y * 38)) | false |
Vale.Inline.X64.Fswap_inline.fst | Vale.Inline.X64.Fswap_inline.lowstar_cswap_normal_t | val lowstar_cswap_normal_t:normal lowstar_cswap_t | val lowstar_cswap_normal_t:normal lowstar_cswap_t | let lowstar_cswap_normal_t : normal lowstar_cswap_t
= as_normal_t #lowstar_cswap_t lowstar_cswap | {
"file_name": "vale/code/arch/x64/interop/Vale.Inline.X64.Fswap_inline.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 46,
"end_line": 153,
"start_col": 0,
"start_line": 152
} | module Vale.Inline.X64.Fswap_inline
open FStar.Mul
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LSig = Vale.AsLowStar.LowStarSig
module ME = Vale.X64.Memory
module V = Vale.X64.Decls
module IA = Vale.Interop.Assumptions
module W = Vale.AsLowStar.Wrapper
open Vale.X64.MemoryAdapters
module VS = Vale.X64.State
module MS = Vale.X64.Machine_s
module PR = Vale.X64.Print_Inline_s
module FU = Vale.Curve25519.X64.FastUtil
let uint64 = UInt64.t
(* A little utility to trigger normalization in types *)
let as_t (#a:Type) (x:normal a) : a = x
let as_normal_t (#a:Type) (x:a) : normal a = x
[@__reduce__]
let b64 = buf_t TUInt64 TUInt64
[@__reduce__]
let t64_mod = TD_Buffer TUInt64 TUInt64 default_bq
[@__reduce__]
let t64_no_mod = TD_Buffer TUInt64 TUInt64 ({modified=false; strict_disjointness=false; taint=MS.Secret})
[@__reduce__]
let tuint64 = TD_Base TUInt64
[@__reduce__]
let cswap_dom: IX64.arity_ok 3 td =
let y = [tuint64; t64_mod; t64_mod] in
assert_norm (List.length y = 3);
y
(* Need to rearrange the order of arguments *)
[@__reduce__]
let cswap_pre : VSig.vale_pre cswap_dom =
fun (c:V.va_code)
(bit:uint64)
(p0:b64)
(p1:b64)
(va_s0:V.va_state) ->
FU.va_req_Cswap2 c va_s0
(UInt64.v bit) (as_vale_buffer p0) (as_vale_buffer p1)
[@__reduce__]
let cswap_post : VSig.vale_post cswap_dom =
fun (c:V.va_code)
(bit:uint64)
(p0:b64)
(p1:b64)
(va_s0:V.va_state)
(va_s1:V.va_state)
(f:V.va_fuel) ->
FU.va_ens_Cswap2 c va_s0 (UInt64.v bit) (as_vale_buffer p0) (as_vale_buffer p1) va_s1 f
#set-options "--z3rlimit 50"
let cswap_regs_modified: MS.reg_64 -> bool = fun (r:MS.reg_64) ->
let open MS in
if r = rRdi || r = rR8 || r = rR9 || r = rR10 then true
else false
let cswap_xmms_modified = fun _ -> false
[@__reduce__]
let cswap_lemma'
(code:V.va_code)
(_win:bool)
(bit:uint64)
(p0:b64)
(p1:b64)
(va_s0:V.va_state)
: Ghost (V.va_state & V.va_fuel)
(requires
cswap_pre code bit p0 p1 va_s0)
(ensures (fun (va_s1, f) ->
V.eval_code code va_s0 f va_s1 /\
VSig.vale_calling_conventions va_s0 va_s1 cswap_regs_modified cswap_xmms_modified /\
cswap_post code bit p0 p1 va_s0 va_s1 f /\
ME.buffer_readable (VS.vs_get_vale_heap va_s1) (as_vale_buffer p0) /\
ME.buffer_readable (VS.vs_get_vale_heap va_s1) (as_vale_buffer p1) /\
ME.buffer_writeable (as_vale_buffer p0) /\
ME.buffer_writeable (as_vale_buffer p1) /\
ME.modifies (ME.loc_union (ME.loc_buffer (as_vale_buffer p0))
(ME.loc_union (ME.loc_buffer (as_vale_buffer p1))
ME.loc_none)) (VS.vs_get_vale_heap va_s0) (VS.vs_get_vale_heap va_s1)
)) =
let va_s1, f = FU.va_lemma_Cswap2 code va_s0 (UInt64.v bit) (as_vale_buffer p0) (as_vale_buffer p1) in
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt64 ME.TUInt64 p0;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt64 ME.TUInt64 p1;
(va_s1, f)
(* Prove that cswap_lemma' has the required type *)
let cswap_lemma = as_t #(VSig.vale_sig cswap_regs_modified cswap_xmms_modified cswap_pre cswap_post) cswap_lemma'
let code_cswap = FU.va_code_Cswap2 ()
let of_reg (r:MS.reg_64) : option (IX64.reg_nat 3) = match r with
| 5 -> Some 0 // rdi
| 4 -> Some 1 // rsi
| 3 -> Some 2 // rdx
| _ -> None
let of_arg (i:IX64.reg_nat 3) : MS.reg_64 = match i with
| 0 -> MS.rRdi
| 1 -> MS.rRsi
| 2 -> MS.rRdx
let arg_reg : IX64.arg_reg_relation 3 = IX64.Rel of_reg of_arg
(* Here's the type expected for the cswap wrapper *)
[@__reduce__]
let lowstar_cswap_t =
assert_norm (List.length cswap_dom + List.length ([]<:list arg) <= 3);
IX64.as_lowstar_sig_t_weak
3
arg_reg
cswap_regs_modified
cswap_xmms_modified
code_cswap
cswap_dom
[]
_
_
// The boolean here doesn't matter
(W.mk_prediction code_cswap cswap_dom [] (cswap_lemma code_cswap IA.win))
(* And here's the cswap wrapper itself *)
let lowstar_cswap : lowstar_cswap_t =
assert_norm (List.length cswap_dom + List.length ([]<:list arg) <= 3);
IX64.wrap_weak
3
arg_reg
cswap_regs_modified
cswap_xmms_modified
code_cswap
cswap_dom
(W.mk_prediction code_cswap cswap_dom [] (cswap_lemma code_cswap IA.win)) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Print_Inline_s.fst.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Interop.Assumptions.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.X64.FastUtil.fsti.checked",
"Vale.AsLowStar.Wrapper.fsti.checked",
"Vale.AsLowStar.ValeSig.fst.checked",
"Vale.AsLowStar.MemoryHelpers.fsti.checked",
"Vale.AsLowStar.LowStarSig.fst.checked",
"prims.fst.checked",
"LowStar.BufferView.Down.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Inline.X64.Fswap_inline.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
{
"abbrev": true,
"full_module": "Vale.X64.Print_Inline_s",
"short_module": "PR"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_module": "Vale.X64.State",
"short_module": "VS"
},
{
"abbrev": false,
"full_module": "Vale.X64.MemoryAdapters",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.Wrapper",
"short_module": "W"
},
{
"abbrev": true,
"full_module": "Vale.Interop.Assumptions",
"short_module": "IA"
},
{
"abbrev": true,
"full_module": "Vale.X64.Decls",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Vale.X64.Memory",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.LowStarSig",
"short_module": "LSig"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.ValeSig",
"short_module": "VSig"
},
{
"abbrev": true,
"full_module": "Vale.Interop.X64",
"short_module": "IX64"
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.BufferView.Down",
"short_module": "DV"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | FStar.Pervasives.norm [
FStar.Pervasives.iota;
FStar.Pervasives.zeta;
FStar.Pervasives.delta_attr ["Vale.Arch.HeapTypes_s.__reduce__"; "FStar.BigOps.__reduce__"];
FStar.Pervasives.delta_only [
"Vale.Interop.Base.uu___is_TD_Buffer";
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_ok";
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_regs";
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_flags";
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_heap";
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_stack";
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_stackTaint";
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_trace";
"FStar.FunctionalExtensionality.on_dom"; "FStar.FunctionalExtensionality.on";
"FStar.List.Tot.Base.fold_right_gtot"; "FStar.List.Tot.Base.map_gtot";
"FStar.List.Tot.Base.length"; "FStar.Pervasives.Native.fst"; "FStar.Pervasives.Native.snd";
"FStar.Pervasives.Native.__proj__Mktuple2__item___1";
"FStar.Pervasives.Native.__proj__Mktuple2__item___2"
];
FStar.Pervasives.primops;
FStar.Pervasives.simplify
]
Vale.Inline.X64.Fswap_inline.lowstar_cswap_t
<:
Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.Inline.X64.Fswap_inline.as_normal_t",
"Vale.Inline.X64.Fswap_inline.lowstar_cswap_t",
"Vale.Inline.X64.Fswap_inline.lowstar_cswap"
] | [] | false | false | false | false | false | let lowstar_cswap_normal_t:normal lowstar_cswap_t =
| as_normal_t #lowstar_cswap_t lowstar_cswap | false |
Steel.GhostPCMReference.fst | Steel.GhostPCMReference.pts_to | val pts_to (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (v:a)
: vprop | val pts_to (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (v:a)
: vprop | let pts_to (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) ([@@@smt_fallback]v:a)
= to_vprop (Steel.Memory.pts_to r v) | {
"file_name": "lib/steel/Steel.GhostPCMReference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 38,
"end_line": 32,
"start_col": 0,
"start_line": 31
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.GhostPCMReference
(* A ghost variant of Steel.PCMReference *)
open FStar.PCM
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module P = Steel.PCMReference
let ref (a:Type) (p:pcm a) = erased (Steel.Memory.ref a p)
/// Its selector is non-informative (it is unit) | {
"checked_file": "/",
"dependencies": [
"Steel.Preorder.fst.checked",
"Steel.PCMReference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.GhostPCMReference.fst"
} | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.GhostPCMReference.ref a pcm -> v: a -> Steel.Effect.Common.vprop | Prims.Tot | [
"total"
] | [] | [
"FStar.PCM.pcm",
"Steel.GhostPCMReference.ref",
"Steel.Effect.Common.to_vprop",
"Steel.Memory.pts_to",
"FStar.Ghost.reveal",
"Steel.Memory.ref",
"Steel.Effect.Common.vprop"
] | [] | false | false | false | false | false | let pts_to (#a: Type u#1) (#pcm: pcm a) (r: ref a pcm) ([@@@ smt_fallback]v: a) =
| to_vprop (Steel.Memory.pts_to r v) | false |
Vale.Curve25519.FastHybrid_helpers.fst | Vale.Curve25519.FastHybrid_helpers.lemma_fmul | val lemma_fmul (a0 a1 a2 a3 b d0 d1 d2 d3 carry:nat64) : Lemma
(requires pow2_five d0 d1 d2 d3 carry == (pow2_four a0 a1 a2 a3) * b /\
b < 131072)
(ensures carry * 38 < pow2_63) | val lemma_fmul (a0 a1 a2 a3 b d0 d1 d2 d3 carry:nat64) : Lemma
(requires pow2_five d0 d1 d2 d3 carry == (pow2_four a0 a1 a2 a3) * b /\
b < 131072)
(ensures carry * 38 < pow2_63) | let lemma_fmul (a0 a1 a2 a3 b d0 d1 d2 d3 carry:nat64) : Lemma
(requires pow2_five d0 d1 d2 d3 carry == (pow2_four a0 a1 a2 a3) * b /\
b < 131072)
(ensures carry * 38 < pow2_63)
=
assert (pow2_four a0 a1 a2 a3 < pow2_256);
assert_norm (131072 == pow2 17);
lemma_mul_bounds_le (pow2_four a0 a1 a2 a3) pow2_256 b (pow2 17);
assert ((pow2_four a0 a1 a2 a3) * b <= pow2_256 * pow2 17);
lemma_mul_bounds_le b b (pow2_four a0 a1 a2 a3) (pow2_four a0 a1 a2 a3);
assert ((pow2_four a0 a1 a2 a3) * b <= pow2_256 * pow2 17) | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.FastHybrid_helpers.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 60,
"end_line": 171,
"start_col": 0,
"start_line": 161
} | module Vale.Curve25519.FastHybrid_helpers
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
open FStar.Tactics
open FStar.Tactics.CanonCommSemiring
open Vale.Curve25519.Fast_defs
open Vale.Curve25519.Fast_lemmas_internal
#reset-options "--max_fuel 0 --max_ifuel 0 --using_facts_from '* -FStar.Tactics -FStar.Reflection'"
let lemma_carry_prime (a0 a1 a2 a3 a0' a1' a2' a3' carry_in:nat64) (carry:bit) : Lemma
(requires pow2_five a0' a1' a2' a3' carry == pow2_four a0 a1 a2 a3 + carry_in * 38 /\
carry_in * 38 - 1 + 38 < pow2_64)
(ensures a0' + carry * 38 < pow2_64 /\
(pow2_four (a0' + carry * 38) a1' a2' a3') % prime == (pow2_four a0 a1 a2 a3 + carry_in * pow2_256) % prime)
=
assert (a0' + carry * 38 < pow2_64);
calc (==) {
(pow2_four a0 a1 a2 a3 + carry_in * pow2_256) % prime;
== { lemma_mul_pow256_add (pow2_four a0 a1 a2 a3) carry_in }
(pow2_four a0 a1 a2 a3 + carry_in * 38) % prime;
== {}
(pow2_five a0' a1' a2' a3' carry) % prime;
== { _ by (int_canon()) }
(pow2_four a0' a1' a2' a3' + (carry * pow2_256)) % prime;
== { lemma_mul_pow256_add (pow2_four a0' a1' a2' a3') carry }
(pow2_four a0' a1' a2' a3' + (carry * 38)) % prime;
== { calc (==) {
(pow2_four a0' a1' a2' a3') + (carry * 38);
== { _ by (int_canon()) }
pow2_four (a0' + carry * 38) a1' a2' a3';
}
}
(pow2_four (a0' + carry * 38) a1' a2' a3') % prime;
};
()
#reset-options "--z3rlimit 30 --max_fuel 0 --max_ifuel 0 --using_facts_from '* -FStar.Tactics -FStar.Reflection'"
let lemma_fast_mul1 (a:nat)
(b a0 a1 a2 a3
ba0_hi ba0_lo
ba1_hi ba1_lo
ba2_hi ba2_lo
ba3_hi ba3_lo
s1 s2 s3 s4:nat64) : Lemma
(requires a = pow2_four a0 a1 a2 a3 /\
pow2_64 * ba0_hi + ba0_lo == b * a0 /\
pow2_64 * ba1_hi + ba1_lo == b * a1 /\
pow2_64 * ba2_hi + ba2_lo == b * a2 /\
pow2_64 * ba3_hi + ba3_lo == b * a3 /\
(let s1', c1 = add_carry ba1_lo ba0_hi 0 in
let s2', c2 = add_carry ba2_lo ba1_hi c1 in
let s3', c3 = add_carry ba3_lo ba2_hi c2 in
let s4', c4 = add_carry ba3_hi 0 c3 in
s1 == s1' /\
s2 == s2' /\
s3 == s3' /\
s4 == s4' /\
c4 == 0)
)
(ensures pow2_five ba0_lo s1 s2 s3 s4 == a * b)
=
assert_by_tactic (b * pow2_four a0 a1 a2 a3 == pow2_four (b*a0) (b*a1) (b*a2) (b*a3)) int_canon;
//lemma_prod_bounds ba0_hi ba0_lo b a0;
//lemma_prod_bounds ba1_hi ba1_lo b a1;
//lemma_prod_bounds ba2_hi ba2_lo b a2;
//lemma_prod_bounds ba3_hi ba3_lo b a3;
()
let lemma_addition (a d:nat) (a0 a1 a2 a3 d0 d1 d2 d3 d4:nat64)
(s0 s1 s2 s3 s4:nat64) : Lemma
(requires a = pow2_four a0 a1 a2 a3 /\
d = pow2_five d0 d1 d2 d3 d4 /\
(let s0', c0 = add_carry a0 d0 0 in
let s1', c1 = add_carry a1 d1 c0 in
let s2', c2 = add_carry a2 d2 c1 in
let s3', c3 = add_carry a3 d3 c2 in
let s4', c4 = add_carry d4 0 c3 in
s0 == s0' /\
s1 == s1' /\
s2 == s2' /\
s3 == s3' /\
s4 == s4' /\
c4 == 0))
(ensures a + d == pow2_five s0 s1 s2 s3 s4)
=
()
let lemma_carry_wide (a0 a1 a2 a3 a4 a5 a6 a7
d0 d1 d2 d3 carry
d0' d1' d2' d3':nat64) : Lemma
(requires pow2_five d0 d1 d2 d3 carry == 38 * pow2_four a4 a5 a6 a7 + pow2_four a0 a1 a2 a3 /\
pow2_four d0' d1' d2' d3' % prime == ((pow2_four d0 d1 d2 d3) + carry * pow2_256) % prime)
(ensures (pow2_four d0' d1' d2' d3') % prime == (pow2_eight a0 a1 a2 a3 a4 a5 a6 a7) % prime)
=
calc (==) {
pow2_four d0' d1' d2' d3' % prime;
== { calc (==) {
(pow2_four d0 d1 d2 d3) + carry * pow2_256;
== { _ by (int_canon()) }
pow2_five d0 d1 d2 d3 carry;
}
}
pow2_five d0 d1 d2 d3 carry % prime;
== {}
(pow2_four a0 a1 a2 a3 + 38 * pow2_four a4 a5 a6 a7) % prime;
== { lemma_mul_pow256_add (pow2_four a0 a1 a2 a3) (pow2_four a4 a5 a6 a7) }
(pow2_four a0 a1 a2 a3 + pow2_256 * pow2_four a4 a5 a6 a7) % prime;
== { _ by (int_canon()) }
(pow2_eight a0 a1 a2 a3 a4 a5 a6 a7) % prime;
}
let pow2int_four (c0 c1 c2 c3:int) : int = c0 + c1 * pow2_64 + c2 * pow2_128 + c3 * pow2_192
#reset-options "--z3rlimit 10 --fuel 0 --ifuel 0"
let lemma_mul_pow256_sub (x y:nat) :
Lemma ((x - y * pow2_256) % prime == (x - y * 38) % prime)
=
assert_norm (pow2_256 % prime == 38);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (-y) pow2_256 prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (-y) 38 prime;
assert ((-y * pow2_256) % prime == (- y * 38) % prime);
FStar.Math.Lemmas.modulo_add prime x (- (y * pow2_256)) (- (y * 38))
#reset-options "--z3rlimit 30 --max_fuel 0 --max_ifuel 0 --using_facts_from '* -FStar.Tactics -FStar.Reflection'"
let lemma_carry_sub_prime (a0 a1 a2 a3 a0' a1' a2' a3' carry_in:nat64) (carry:bit) : Lemma
(requires pow2_four a0' a1' a2' a3' - carry * pow2_256 == pow2_four a0 a1 a2 a3 - carry_in * 38 /\
carry_in * 38 - 1 + 38 < pow2_64)
(ensures a0' - carry * 38 >= 0 /\
(pow2_four (a0' - carry * 38) a1' a2' a3') % prime == (pow2_four a0 a1 a2 a3 - carry_in * pow2_256) % prime)
=
assert (a0' - carry * 38 >= 0);
calc (==) {
(pow2_four a0 a1 a2 a3 - carry_in * pow2_256) % prime;
== { lemma_mul_pow256_sub (pow2_four a0 a1 a2 a3) carry_in }
(pow2_four a0 a1 a2 a3 - carry_in * 38) % prime;
== {}
(pow2_four a0' a1' a2' a3' - (carry * pow2_256)) % prime;
== { lemma_mul_pow256_sub (pow2_four a0' a1' a2' a3') carry }
(pow2_four a0' a1' a2' a3' - (carry * 38)) % prime;
== { calc (==) {
(pow2_four a0' a1' a2' a3') - (carry * 38);
== { _ by (int_canon()) }
pow2int_four (a0' - carry * 38) a1' a2' a3';
}
}
(pow2_four (a0' - carry * 38) a1' a2' a3') % prime;
};
() | {
"checked_file": "/",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_lemmas_internal.fsti.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Curve25519.FastHybrid_helpers.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_internal",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 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": 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"
} | false |
a0: Vale.Def.Types_s.nat64 ->
a1: Vale.Def.Types_s.nat64 ->
a2: Vale.Def.Types_s.nat64 ->
a3: Vale.Def.Types_s.nat64 ->
b: Vale.Def.Types_s.nat64 ->
d0: Vale.Def.Types_s.nat64 ->
d1: Vale.Def.Types_s.nat64 ->
d2: Vale.Def.Types_s.nat64 ->
d3: Vale.Def.Types_s.nat64 ->
carry: Vale.Def.Types_s.nat64
-> FStar.Pervasives.Lemma
(requires
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 carry ==
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 * b /\ b < 131072)
(ensures carry * 38 < Vale.Curve25519.FastHybrid_helpers.pow2_63) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Types_s.nat64",
"Prims._assert",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Vale.Curve25519.Fast_defs.pow2_four",
"Vale.Curve25519.Fast_defs.pow2_256",
"Prims.pow2",
"Prims.unit",
"Vale.Curve25519.Fast_lemmas_internal.lemma_mul_bounds_le",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"Prims.op_LessThan",
"Prims.l_and",
"Vale.Curve25519.Fast_defs.pow2_five",
"Prims.squash",
"Vale.Curve25519.FastHybrid_helpers.pow2_63",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let lemma_fmul (a0 a1 a2 a3 b d0 d1 d2 d3 carry: nat64)
: Lemma (requires pow2_five d0 d1 d2 d3 carry == (pow2_four a0 a1 a2 a3) * b /\ b < 131072)
(ensures carry * 38 < pow2_63) =
| assert (pow2_four a0 a1 a2 a3 < pow2_256);
assert_norm (131072 == pow2 17);
lemma_mul_bounds_le (pow2_four a0 a1 a2 a3) pow2_256 b (pow2 17);
assert ((pow2_four a0 a1 a2 a3) * b <= pow2_256 * pow2 17);
lemma_mul_bounds_le b b (pow2_four a0 a1 a2 a3) (pow2_four a0 a1 a2 a3);
assert ((pow2_four a0 a1 a2 a3) * b <= pow2_256 * pow2 17) | false |
Steel.GhostPCMReference.fst | Steel.GhostPCMReference.ref | val ref (a:Type) (p:pcm a) : Type0 | val ref (a:Type) (p:pcm a) : Type0 | let ref (a:Type) (p:pcm a) = erased (Steel.Memory.ref a p) | {
"file_name": "lib/steel/Steel.GhostPCMReference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 58,
"end_line": 27,
"start_col": 0,
"start_line": 27
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.GhostPCMReference
(* A ghost variant of Steel.PCMReference *)
open FStar.PCM
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module P = Steel.PCMReference | {
"checked_file": "/",
"dependencies": [
"Steel.Preorder.fst.checked",
"Steel.PCMReference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.GhostPCMReference.fst"
} | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Type -> p: FStar.PCM.pcm a -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.PCM.pcm",
"FStar.Ghost.erased",
"Steel.Memory.ref"
] | [] | false | false | false | true | true | let ref (a: Type) (p: pcm a) =
| erased (Steel.Memory.ref a p) | false |
Steel.GhostPCMReference.fst | Steel.GhostPCMReference.witnessed | val witnessed (#a:Type u#1) (#p:pcm a) (r:ref a p) (fact:property a)
: Type0 | val witnessed (#a:Type u#1) (#p:pcm a) (r:ref a p) (fact:property a)
: Type0 | let witnessed (#a:Type) (#p:pcm a) (r:ref a p) (fact:property a)
: Type0
= Steel.Memory.witnessed r fact | {
"file_name": "lib/steel/Steel.GhostPCMReference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 33,
"end_line": 115,
"start_col": 0,
"start_line": 113
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.GhostPCMReference
(* A ghost variant of Steel.PCMReference *)
open FStar.PCM
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module P = Steel.PCMReference
let ref (a:Type) (p:pcm a) = erased (Steel.Memory.ref a p)
/// Its selector is non-informative (it is unit)
[@@__reduce__]
let pts_to (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) ([@@@smt_fallback]v:a)
= to_vprop (Steel.Memory.pts_to r v)
let alloc (#o:inames)
(#a:Type)
(#pcm:pcm a)
(x:a)
: SteelGhost
(ref a pcm) o
(emp)
(fun r -> pts_to r x)
(requires fun _ -> pcm.refine x)
(ensures fun _ _ _ -> True)
= rewrite_slprop emp (to_vprop Mem.emp) (fun _ -> reveal_emp ());
FStar.PCM.compatible_refl pcm x;
let r = as_atomic_action_ghost (alloc_action o x) in
r
let read (#o:inames)
(#a:Type)
(#pcm:pcm a)
(#v0:a)
(r:ref a pcm)
: SteelGhost a o
(pts_to r v0)
(fun _ -> pts_to r v0)
(requires fun _ -> True)
(ensures fun _ v _ -> compatible pcm v0 v)
= let v = as_atomic_action_ghost (sel_action o r v0) in
v
let write (#o:inames)
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:a)
(v1:a)
: SteelGhost unit o
(pts_to r v0)
(fun _ -> pts_to r v1)
(requires fun _ -> frame_preserving pcm v0 v1 /\ pcm.refine v1)
(ensures fun _ _ _ -> True)
= as_atomic_action_ghost (upd_action o r v0 v1)
let upd_gen (#o:inames)
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x y:a)
(f:frame_preserving_upd p x y)
: SteelGhostT unit o
(pts_to r x)
(fun _ -> pts_to r y)
= as_atomic_action_ghost (Steel.Memory.upd_gen o r x y f)
let share (#o:inames)
(#a:Type)
(#p:pcm a)
(r:ref a p)
(v:a)
(v0:a)
(v1:a)
: SteelGhost unit o
(pts_to r v)
(fun _ -> pts_to r v0 `star` pts_to r v1)
(requires fun _ ->
composable p v0 v1 /\
v == op p v0 v1)
(ensures fun _ _ _ -> True)
= P.split r v v0 v1
let gather (#o:inames)
(#a:Type)
(#p:FStar.PCM.pcm a)
(r:ref a p)
(v0:a)
(v1:a)
: SteelGhostT (_:unit{composable p v0 v1}) o
(pts_to r v0 `star` pts_to r v1)
(fun _ -> pts_to r (op p v0 v1))
= P.gather r v0 v1 | {
"checked_file": "/",
"dependencies": [
"Steel.Preorder.fst.checked",
"Steel.PCMReference.fsti.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.GhostPCMReference.fst"
} | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.GhostPCMReference.ref a p -> fact: Steel.Memory.property a -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.PCM.pcm",
"Steel.GhostPCMReference.ref",
"Steel.Memory.property",
"Steel.Memory.witnessed",
"FStar.Ghost.reveal",
"Steel.Memory.ref"
] | [] | false | false | false | false | true | let witnessed (#a: Type) (#p: pcm a) (r: ref a p) (fact: property a) : Type0 =
| Steel.Memory.witnessed r fact | false |
Vale.Curve25519.FastHybrid_helpers.fst | Vale.Curve25519.FastHybrid_helpers.lemma_carry_sub_prime | val lemma_carry_sub_prime (a0 a1 a2 a3 a0' a1' a2' a3' carry_in:nat64) (carry:bit) : Lemma
(requires pow2_four a0' a1' a2' a3' - carry * pow2_256 == pow2_four a0 a1 a2 a3 - carry_in * 38 /\
carry_in * 38 - 1 + 38 < pow2_64)
(ensures a0' - carry * 38 >= 0 /\
(pow2_four (a0' - carry * 38) a1' a2' a3') % prime == (pow2_four a0 a1 a2 a3 - carry_in * pow2_256) % prime) | val lemma_carry_sub_prime (a0 a1 a2 a3 a0' a1' a2' a3' carry_in:nat64) (carry:bit) : Lemma
(requires pow2_four a0' a1' a2' a3' - carry * pow2_256 == pow2_four a0 a1 a2 a3 - carry_in * 38 /\
carry_in * 38 - 1 + 38 < pow2_64)
(ensures a0' - carry * 38 >= 0 /\
(pow2_four (a0' - carry * 38) a1' a2' a3') % prime == (pow2_four a0 a1 a2 a3 - carry_in * pow2_256) % prime) | let lemma_carry_sub_prime (a0 a1 a2 a3 a0' a1' a2' a3' carry_in:nat64) (carry:bit) : Lemma
(requires pow2_four a0' a1' a2' a3' - carry * pow2_256 == pow2_four a0 a1 a2 a3 - carry_in * 38 /\
carry_in * 38 - 1 + 38 < pow2_64)
(ensures a0' - carry * 38 >= 0 /\
(pow2_four (a0' - carry * 38) a1' a2' a3') % prime == (pow2_four a0 a1 a2 a3 - carry_in * pow2_256) % prime)
=
assert (a0' - carry * 38 >= 0);
calc (==) {
(pow2_four a0 a1 a2 a3 - carry_in * pow2_256) % prime;
== { lemma_mul_pow256_sub (pow2_four a0 a1 a2 a3) carry_in }
(pow2_four a0 a1 a2 a3 - carry_in * 38) % prime;
== {}
(pow2_four a0' a1' a2' a3' - (carry * pow2_256)) % prime;
== { lemma_mul_pow256_sub (pow2_four a0' a1' a2' a3') carry }
(pow2_four a0' a1' a2' a3' - (carry * 38)) % prime;
== { calc (==) {
(pow2_four a0' a1' a2' a3') - (carry * 38);
== { _ by (int_canon()) }
pow2int_four (a0' - carry * 38) a1' a2' a3';
}
}
(pow2_four (a0' - carry * 38) a1' a2' a3') % prime;
};
() | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.FastHybrid_helpers.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 158,
"start_col": 0,
"start_line": 134
} | module Vale.Curve25519.FastHybrid_helpers
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
open FStar.Tactics
open FStar.Tactics.CanonCommSemiring
open Vale.Curve25519.Fast_defs
open Vale.Curve25519.Fast_lemmas_internal
#reset-options "--max_fuel 0 --max_ifuel 0 --using_facts_from '* -FStar.Tactics -FStar.Reflection'"
let lemma_carry_prime (a0 a1 a2 a3 a0' a1' a2' a3' carry_in:nat64) (carry:bit) : Lemma
(requires pow2_five a0' a1' a2' a3' carry == pow2_four a0 a1 a2 a3 + carry_in * 38 /\
carry_in * 38 - 1 + 38 < pow2_64)
(ensures a0' + carry * 38 < pow2_64 /\
(pow2_four (a0' + carry * 38) a1' a2' a3') % prime == (pow2_four a0 a1 a2 a3 + carry_in * pow2_256) % prime)
=
assert (a0' + carry * 38 < pow2_64);
calc (==) {
(pow2_four a0 a1 a2 a3 + carry_in * pow2_256) % prime;
== { lemma_mul_pow256_add (pow2_four a0 a1 a2 a3) carry_in }
(pow2_four a0 a1 a2 a3 + carry_in * 38) % prime;
== {}
(pow2_five a0' a1' a2' a3' carry) % prime;
== { _ by (int_canon()) }
(pow2_four a0' a1' a2' a3' + (carry * pow2_256)) % prime;
== { lemma_mul_pow256_add (pow2_four a0' a1' a2' a3') carry }
(pow2_four a0' a1' a2' a3' + (carry * 38)) % prime;
== { calc (==) {
(pow2_four a0' a1' a2' a3') + (carry * 38);
== { _ by (int_canon()) }
pow2_four (a0' + carry * 38) a1' a2' a3';
}
}
(pow2_four (a0' + carry * 38) a1' a2' a3') % prime;
};
()
#reset-options "--z3rlimit 30 --max_fuel 0 --max_ifuel 0 --using_facts_from '* -FStar.Tactics -FStar.Reflection'"
let lemma_fast_mul1 (a:nat)
(b a0 a1 a2 a3
ba0_hi ba0_lo
ba1_hi ba1_lo
ba2_hi ba2_lo
ba3_hi ba3_lo
s1 s2 s3 s4:nat64) : Lemma
(requires a = pow2_four a0 a1 a2 a3 /\
pow2_64 * ba0_hi + ba0_lo == b * a0 /\
pow2_64 * ba1_hi + ba1_lo == b * a1 /\
pow2_64 * ba2_hi + ba2_lo == b * a2 /\
pow2_64 * ba3_hi + ba3_lo == b * a3 /\
(let s1', c1 = add_carry ba1_lo ba0_hi 0 in
let s2', c2 = add_carry ba2_lo ba1_hi c1 in
let s3', c3 = add_carry ba3_lo ba2_hi c2 in
let s4', c4 = add_carry ba3_hi 0 c3 in
s1 == s1' /\
s2 == s2' /\
s3 == s3' /\
s4 == s4' /\
c4 == 0)
)
(ensures pow2_five ba0_lo s1 s2 s3 s4 == a * b)
=
assert_by_tactic (b * pow2_four a0 a1 a2 a3 == pow2_four (b*a0) (b*a1) (b*a2) (b*a3)) int_canon;
//lemma_prod_bounds ba0_hi ba0_lo b a0;
//lemma_prod_bounds ba1_hi ba1_lo b a1;
//lemma_prod_bounds ba2_hi ba2_lo b a2;
//lemma_prod_bounds ba3_hi ba3_lo b a3;
()
let lemma_addition (a d:nat) (a0 a1 a2 a3 d0 d1 d2 d3 d4:nat64)
(s0 s1 s2 s3 s4:nat64) : Lemma
(requires a = pow2_four a0 a1 a2 a3 /\
d = pow2_five d0 d1 d2 d3 d4 /\
(let s0', c0 = add_carry a0 d0 0 in
let s1', c1 = add_carry a1 d1 c0 in
let s2', c2 = add_carry a2 d2 c1 in
let s3', c3 = add_carry a3 d3 c2 in
let s4', c4 = add_carry d4 0 c3 in
s0 == s0' /\
s1 == s1' /\
s2 == s2' /\
s3 == s3' /\
s4 == s4' /\
c4 == 0))
(ensures a + d == pow2_five s0 s1 s2 s3 s4)
=
()
let lemma_carry_wide (a0 a1 a2 a3 a4 a5 a6 a7
d0 d1 d2 d3 carry
d0' d1' d2' d3':nat64) : Lemma
(requires pow2_five d0 d1 d2 d3 carry == 38 * pow2_four a4 a5 a6 a7 + pow2_four a0 a1 a2 a3 /\
pow2_four d0' d1' d2' d3' % prime == ((pow2_four d0 d1 d2 d3) + carry * pow2_256) % prime)
(ensures (pow2_four d0' d1' d2' d3') % prime == (pow2_eight a0 a1 a2 a3 a4 a5 a6 a7) % prime)
=
calc (==) {
pow2_four d0' d1' d2' d3' % prime;
== { calc (==) {
(pow2_four d0 d1 d2 d3) + carry * pow2_256;
== { _ by (int_canon()) }
pow2_five d0 d1 d2 d3 carry;
}
}
pow2_five d0 d1 d2 d3 carry % prime;
== {}
(pow2_four a0 a1 a2 a3 + 38 * pow2_four a4 a5 a6 a7) % prime;
== { lemma_mul_pow256_add (pow2_four a0 a1 a2 a3) (pow2_four a4 a5 a6 a7) }
(pow2_four a0 a1 a2 a3 + pow2_256 * pow2_four a4 a5 a6 a7) % prime;
== { _ by (int_canon()) }
(pow2_eight a0 a1 a2 a3 a4 a5 a6 a7) % prime;
}
let pow2int_four (c0 c1 c2 c3:int) : int = c0 + c1 * pow2_64 + c2 * pow2_128 + c3 * pow2_192
#reset-options "--z3rlimit 10 --fuel 0 --ifuel 0"
let lemma_mul_pow256_sub (x y:nat) :
Lemma ((x - y * pow2_256) % prime == (x - y * 38) % prime)
=
assert_norm (pow2_256 % prime == 38);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (-y) pow2_256 prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (-y) 38 prime;
assert ((-y * pow2_256) % prime == (- y * 38) % prime);
FStar.Math.Lemmas.modulo_add prime x (- (y * pow2_256)) (- (y * 38)) | {
"checked_file": "/",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_lemmas_internal.fsti.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Curve25519.FastHybrid_helpers.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_internal",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 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": 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"
} | false |
a0: Vale.Def.Types_s.nat64 ->
a1: Vale.Def.Types_s.nat64 ->
a2: Vale.Def.Types_s.nat64 ->
a3: Vale.Def.Types_s.nat64 ->
a0': Vale.Def.Types_s.nat64 ->
a1': Vale.Def.Types_s.nat64 ->
a2': Vale.Def.Types_s.nat64 ->
a3': Vale.Def.Types_s.nat64 ->
carry_in: Vale.Def.Types_s.nat64 ->
carry: Vale.Curve25519.Fast_defs.bit
-> FStar.Pervasives.Lemma
(requires
Vale.Curve25519.Fast_defs.pow2_four a0' a1' a2' a3' -
carry * Vale.Curve25519.Fast_defs.pow2_256 ==
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 - carry_in * 38 /\
carry_in * 38 - 1 + 38 < Vale.Def.Words_s.pow2_64)
(ensures
a0' - carry * 38 >= 0 /\
Vale.Curve25519.Fast_defs.pow2_four (a0' - carry * 38) a1' a2' a3' %
Vale.Curve25519.Fast_defs.prime ==
(Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 -
carry_in * Vale.Curve25519.Fast_defs.pow2_256) %
Vale.Curve25519.Fast_defs.prime) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Types_s.nat64",
"Vale.Curve25519.Fast_defs.bit",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Modulus",
"Prims.op_Subtraction",
"Vale.Curve25519.Fast_defs.pow2_four",
"FStar.Mul.op_Star",
"Vale.Curve25519.Fast_defs.pow2_256",
"Vale.Curve25519.Fast_defs.prime",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Vale.Curve25519.FastHybrid_helpers.lemma_mul_pow256_sub",
"Prims.squash",
"Vale.Curve25519.FastHybrid_helpers.pow2int_four",
"FStar.Tactics.CanonCommSemiring.semiring_reflect",
"FStar.Tactics.CanonCommSemiring.int_cr",
"FStar.Pervasives.Native.Mktuple2",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.nat",
"FStar.Pervasives.Native.snd",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Prims.op_Multiply",
"Prims.op_Addition",
"FStar.Stubs.Reflection.V2.Data.var",
"FStar.Tactics.CanonCommSemiring.Pvar",
"FStar.Tactics.CanonCommSemiring.Pplus",
"FStar.Tactics.CanonCommSemiring.Pmult",
"FStar.Tactics.CanonCommSemiring.Pconst",
"Prims._assert",
"Prims.l_and",
"Prims.op_LessThan",
"Vale.Def.Words_s.pow2_64",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let lemma_carry_sub_prime (a0 a1 a2 a3 a0' a1' a2' a3' carry_in: nat64) (carry: bit)
: Lemma
(requires
pow2_four a0' a1' a2' a3' - carry * pow2_256 == pow2_four a0 a1 a2 a3 - carry_in * 38 /\
carry_in * 38 - 1 + 38 < pow2_64)
(ensures
a0' - carry * 38 >= 0 /\
(pow2_four (a0' - carry * 38) a1' a2' a3') % prime ==
(pow2_four a0 a1 a2 a3 - carry_in * pow2_256) % prime) =
| assert (a0' - carry * 38 >= 0);
calc ( == ) {
(pow2_four a0 a1 a2 a3 - carry_in * pow2_256) % prime;
( == ) { lemma_mul_pow256_sub (pow2_four a0 a1 a2 a3) carry_in }
(pow2_four a0 a1 a2 a3 - carry_in * 38) % prime;
( == ) { () }
(pow2_four a0' a1' a2' a3' - (carry * pow2_256)) % prime;
( == ) { lemma_mul_pow256_sub (pow2_four a0' a1' a2' a3') carry }
(pow2_four a0' a1' a2' a3' - (carry * 38)) % prime;
( == ) { calc ( == ) {
(pow2_four a0' a1' a2' a3') - (carry * 38);
( == ) { FStar.Tactics.Effect.synth_by_tactic (fun _ -> (int_canon ())) }
pow2int_four (a0' - carry * 38) a1' a2' a3';
} }
(pow2_four (a0' - carry * 38) a1' a2' a3') % prime;
};
() | false |
Vale.SHA.PPC64LE.SHA_helpers.fsti | Vale.SHA.PPC64LE.SHA_helpers.size_k_w_256 | val size_k_w_256 : Prims.int | let size_k_w_256 = 64 | {
"file_name": "vale/code/crypto/sha/Vale.SHA.PPC64LE.SHA_helpers.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 28,
"end_line": 20,
"start_col": 7,
"start_line": 20
} | module Vale.SHA.PPC64LE.SHA_helpers
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open FStar.Seq
open Vale.Arch.Types
open Vale.Def.Sel
open Vale.SHA2.Wrapper
open Vale.Def.Words.Four_s
unfold let (.[]) = FStar.Seq.index
#reset-options "--max_fuel 0 --max_ifuel 0" | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Spec.Loops.fst.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.SHA.PPC64LE.SHA_helpers.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Prims.int | Prims.Tot | [
"total"
] | [] | [] | [] | false | false | false | true | false | let size_k_w_256 =
| 64 | false |
|
Vale.SHA.PPC64LE.SHA_helpers.fsti | Vale.SHA.PPC64LE.SHA_helpers.block_length | val block_length : Prims.int | let block_length =
4 (*word_length a*) * size_block_w_256 | {
"file_name": "vale/code/crypto/sha/Vale.SHA.PPC64LE.SHA_helpers.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 40,
"end_line": 26,
"start_col": 0,
"start_line": 25
} | module Vale.SHA.PPC64LE.SHA_helpers
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open FStar.Seq
open Vale.Arch.Types
open Vale.Def.Sel
open Vale.SHA2.Wrapper
open Vale.Def.Words.Four_s
unfold let (.[]) = FStar.Seq.index
#reset-options "--max_fuel 0 --max_ifuel 0"
// Specialize these definitions (from Spec.SHA2.fst) for SHA256
unfold let size_k_w_256 = 64
val word:Type0
(* Number of words for a block size *)
let size_block_w_256 = 16 | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Spec.Loops.fst.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.SHA.PPC64LE.SHA_helpers.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.Hash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Prims.int | Prims.Tot | [
"total"
] | [] | [
"FStar.Mul.op_Star",
"Vale.SHA.PPC64LE.SHA_helpers.size_block_w_256"
] | [] | false | false | false | true | false | let block_length =
| 4 * size_block_w_256 | false |
|
Vale.SHA.PPC64LE.SHA_helpers.fsti | Vale.SHA.PPC64LE.SHA_helpers.size_block_w_256 | val size_block_w_256 : Prims.int | let size_block_w_256 = 16 | {
"file_name": "vale/code/crypto/sha/Vale.SHA.PPC64LE.SHA_helpers.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 25,
"end_line": 23,
"start_col": 0,
"start_line": 23
} | module Vale.SHA.PPC64LE.SHA_helpers
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open FStar.Seq
open Vale.Arch.Types
open Vale.Def.Sel
open Vale.SHA2.Wrapper
open Vale.Def.Words.Four_s
unfold let (.[]) = FStar.Seq.index
#reset-options "--max_fuel 0 --max_ifuel 0"
// Specialize these definitions (from Spec.SHA2.fst) for SHA256
unfold let size_k_w_256 = 64
val word:Type0 | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Spec.Loops.fst.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.SHA.PPC64LE.SHA_helpers.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.Hash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Prims.int | Prims.Tot | [
"total"
] | [] | [] | [] | false | false | false | true | false | let size_block_w_256 =
| 16 | false |
|
Vale.SHA.PPC64LE.SHA_helpers.fsti | Vale.SHA.PPC64LE.SHA_helpers.block_w | val block_w : Type0 | let block_w = m:seq word {length m = size_block_w_256} | {
"file_name": "vale/code/crypto/sha/Vale.SHA.PPC64LE.SHA_helpers.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 55,
"end_line": 27,
"start_col": 0,
"start_line": 27
} | module Vale.SHA.PPC64LE.SHA_helpers
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open FStar.Seq
open Vale.Arch.Types
open Vale.Def.Sel
open Vale.SHA2.Wrapper
open Vale.Def.Words.Four_s
unfold let (.[]) = FStar.Seq.index
#reset-options "--max_fuel 0 --max_ifuel 0"
// Specialize these definitions (from Spec.SHA2.fst) for SHA256
unfold let size_k_w_256 = 64
val word:Type0
(* Number of words for a block size *)
let size_block_w_256 = 16
(* Define the size block in bytes *)
let block_length = | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Spec.Loops.fst.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.SHA.PPC64LE.SHA_helpers.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.Hash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Vale.SHA.PPC64LE.SHA_helpers.word",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Vale.SHA.PPC64LE.SHA_helpers.size_block_w_256"
] | [] | false | false | false | true | true | let block_w =
| m: seq word {length m = size_block_w_256} | false |
|
Vale.Curve25519.FastHybrid_helpers.fst | Vale.Curve25519.FastHybrid_helpers.lemma_carry_wide | val lemma_carry_wide (a0 a1 a2 a3 a4 a5 a6 a7
d0 d1 d2 d3 carry
d0' d1' d2' d3':nat64) : Lemma
(requires pow2_five d0 d1 d2 d3 carry == 38 * pow2_four a4 a5 a6 a7 + pow2_four a0 a1 a2 a3 /\
pow2_four d0' d1' d2' d3' % prime == ((pow2_four d0 d1 d2 d3) + carry * pow2_256) % prime)
(ensures (pow2_four d0' d1' d2' d3') % prime == (pow2_eight a0 a1 a2 a3 a4 a5 a6 a7) % prime) | val lemma_carry_wide (a0 a1 a2 a3 a4 a5 a6 a7
d0 d1 d2 d3 carry
d0' d1' d2' d3':nat64) : Lemma
(requires pow2_five d0 d1 d2 d3 carry == 38 * pow2_four a4 a5 a6 a7 + pow2_four a0 a1 a2 a3 /\
pow2_four d0' d1' d2' d3' % prime == ((pow2_four d0 d1 d2 d3) + carry * pow2_256) % prime)
(ensures (pow2_four d0' d1' d2' d3') % prime == (pow2_eight a0 a1 a2 a3 a4 a5 a6 a7) % prime) | let lemma_carry_wide (a0 a1 a2 a3 a4 a5 a6 a7
d0 d1 d2 d3 carry
d0' d1' d2' d3':nat64) : Lemma
(requires pow2_five d0 d1 d2 d3 carry == 38 * pow2_four a4 a5 a6 a7 + pow2_four a0 a1 a2 a3 /\
pow2_four d0' d1' d2' d3' % prime == ((pow2_four d0 d1 d2 d3) + carry * pow2_256) % prime)
(ensures (pow2_four d0' d1' d2' d3') % prime == (pow2_eight a0 a1 a2 a3 a4 a5 a6 a7) % prime)
=
calc (==) {
pow2_four d0' d1' d2' d3' % prime;
== { calc (==) {
(pow2_four d0 d1 d2 d3) + carry * pow2_256;
== { _ by (int_canon()) }
pow2_five d0 d1 d2 d3 carry;
}
}
pow2_five d0 d1 d2 d3 carry % prime;
== {}
(pow2_four a0 a1 a2 a3 + 38 * pow2_four a4 a5 a6 a7) % prime;
== { lemma_mul_pow256_add (pow2_four a0 a1 a2 a3) (pow2_four a4 a5 a6 a7) }
(pow2_four a0 a1 a2 a3 + pow2_256 * pow2_four a4 a5 a6 a7) % prime;
== { _ by (int_canon()) }
(pow2_eight a0 a1 a2 a3 a4 a5 a6 a7) % prime;
} | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.FastHybrid_helpers.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 117,
"start_col": 0,
"start_line": 95
} | module Vale.Curve25519.FastHybrid_helpers
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
open FStar.Tactics
open FStar.Tactics.CanonCommSemiring
open Vale.Curve25519.Fast_defs
open Vale.Curve25519.Fast_lemmas_internal
#reset-options "--max_fuel 0 --max_ifuel 0 --using_facts_from '* -FStar.Tactics -FStar.Reflection'"
let lemma_carry_prime (a0 a1 a2 a3 a0' a1' a2' a3' carry_in:nat64) (carry:bit) : Lemma
(requires pow2_five a0' a1' a2' a3' carry == pow2_four a0 a1 a2 a3 + carry_in * 38 /\
carry_in * 38 - 1 + 38 < pow2_64)
(ensures a0' + carry * 38 < pow2_64 /\
(pow2_four (a0' + carry * 38) a1' a2' a3') % prime == (pow2_four a0 a1 a2 a3 + carry_in * pow2_256) % prime)
=
assert (a0' + carry * 38 < pow2_64);
calc (==) {
(pow2_four a0 a1 a2 a3 + carry_in * pow2_256) % prime;
== { lemma_mul_pow256_add (pow2_four a0 a1 a2 a3) carry_in }
(pow2_four a0 a1 a2 a3 + carry_in * 38) % prime;
== {}
(pow2_five a0' a1' a2' a3' carry) % prime;
== { _ by (int_canon()) }
(pow2_four a0' a1' a2' a3' + (carry * pow2_256)) % prime;
== { lemma_mul_pow256_add (pow2_four a0' a1' a2' a3') carry }
(pow2_four a0' a1' a2' a3' + (carry * 38)) % prime;
== { calc (==) {
(pow2_four a0' a1' a2' a3') + (carry * 38);
== { _ by (int_canon()) }
pow2_four (a0' + carry * 38) a1' a2' a3';
}
}
(pow2_four (a0' + carry * 38) a1' a2' a3') % prime;
};
()
#reset-options "--z3rlimit 30 --max_fuel 0 --max_ifuel 0 --using_facts_from '* -FStar.Tactics -FStar.Reflection'"
let lemma_fast_mul1 (a:nat)
(b a0 a1 a2 a3
ba0_hi ba0_lo
ba1_hi ba1_lo
ba2_hi ba2_lo
ba3_hi ba3_lo
s1 s2 s3 s4:nat64) : Lemma
(requires a = pow2_four a0 a1 a2 a3 /\
pow2_64 * ba0_hi + ba0_lo == b * a0 /\
pow2_64 * ba1_hi + ba1_lo == b * a1 /\
pow2_64 * ba2_hi + ba2_lo == b * a2 /\
pow2_64 * ba3_hi + ba3_lo == b * a3 /\
(let s1', c1 = add_carry ba1_lo ba0_hi 0 in
let s2', c2 = add_carry ba2_lo ba1_hi c1 in
let s3', c3 = add_carry ba3_lo ba2_hi c2 in
let s4', c4 = add_carry ba3_hi 0 c3 in
s1 == s1' /\
s2 == s2' /\
s3 == s3' /\
s4 == s4' /\
c4 == 0)
)
(ensures pow2_five ba0_lo s1 s2 s3 s4 == a * b)
=
assert_by_tactic (b * pow2_four a0 a1 a2 a3 == pow2_four (b*a0) (b*a1) (b*a2) (b*a3)) int_canon;
//lemma_prod_bounds ba0_hi ba0_lo b a0;
//lemma_prod_bounds ba1_hi ba1_lo b a1;
//lemma_prod_bounds ba2_hi ba2_lo b a2;
//lemma_prod_bounds ba3_hi ba3_lo b a3;
()
let lemma_addition (a d:nat) (a0 a1 a2 a3 d0 d1 d2 d3 d4:nat64)
(s0 s1 s2 s3 s4:nat64) : Lemma
(requires a = pow2_four a0 a1 a2 a3 /\
d = pow2_five d0 d1 d2 d3 d4 /\
(let s0', c0 = add_carry a0 d0 0 in
let s1', c1 = add_carry a1 d1 c0 in
let s2', c2 = add_carry a2 d2 c1 in
let s3', c3 = add_carry a3 d3 c2 in
let s4', c4 = add_carry d4 0 c3 in
s0 == s0' /\
s1 == s1' /\
s2 == s2' /\
s3 == s3' /\
s4 == s4' /\
c4 == 0))
(ensures a + d == pow2_five s0 s1 s2 s3 s4)
=
() | {
"checked_file": "/",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_lemmas_internal.fsti.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Curve25519.FastHybrid_helpers.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_internal",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 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": 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"
} | false |
a0: Vale.Def.Types_s.nat64 ->
a1: Vale.Def.Types_s.nat64 ->
a2: Vale.Def.Types_s.nat64 ->
a3: Vale.Def.Types_s.nat64 ->
a4: Vale.Def.Types_s.nat64 ->
a5: Vale.Def.Types_s.nat64 ->
a6: Vale.Def.Types_s.nat64 ->
a7: Vale.Def.Types_s.nat64 ->
d0: Vale.Def.Types_s.nat64 ->
d1: Vale.Def.Types_s.nat64 ->
d2: Vale.Def.Types_s.nat64 ->
d3: Vale.Def.Types_s.nat64 ->
carry: Vale.Def.Types_s.nat64 ->
d0': Vale.Def.Types_s.nat64 ->
d1': Vale.Def.Types_s.nat64 ->
d2': Vale.Def.Types_s.nat64 ->
d3': Vale.Def.Types_s.nat64
-> FStar.Pervasives.Lemma
(requires
Vale.Curve25519.Fast_defs.pow2_five d0 d1 d2 d3 carry ==
38 * Vale.Curve25519.Fast_defs.pow2_four a4 a5 a6 a7 +
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 /\
Vale.Curve25519.Fast_defs.pow2_four d0' d1' d2' d3' % Vale.Curve25519.Fast_defs.prime ==
(Vale.Curve25519.Fast_defs.pow2_four d0 d1 d2 d3 +
carry * Vale.Curve25519.Fast_defs.pow2_256) %
Vale.Curve25519.Fast_defs.prime)
(ensures
Vale.Curve25519.Fast_defs.pow2_four d0' d1' d2' d3' % Vale.Curve25519.Fast_defs.prime ==
Vale.Curve25519.Fast_defs.pow2_eight a0 a1 a2 a3 a4 a5 a6 a7 %
Vale.Curve25519.Fast_defs.prime) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Types_s.nat64",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Modulus",
"Vale.Curve25519.Fast_defs.pow2_four",
"Vale.Curve25519.Fast_defs.prime",
"Vale.Curve25519.Fast_defs.pow2_eight",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Vale.Curve25519.Fast_defs.pow2_256",
"Vale.Curve25519.Fast_defs.pow2_five",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Tactics.CanonCommSemiring.semiring_reflect",
"FStar.Tactics.CanonCommSemiring.int_cr",
"FStar.Pervasives.Native.Mktuple2",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.nat",
"FStar.Pervasives.Native.snd",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.Stubs.Reflection.V2.Data.var",
"FStar.Tactics.CanonCommSemiring.Pplus",
"FStar.Tactics.CanonCommSemiring.Pvar",
"FStar.Tactics.CanonCommSemiring.Pmult",
"FStar.Tactics.CanonCommSemiring.Pconst",
"Prims.op_Multiply",
"Prims.squash",
"Vale.Curve25519.FastHybrid_helpers.lemma_mul_pow256_add",
"Prims.l_and",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let lemma_carry_wide (a0 a1 a2 a3 a4 a5 a6 a7 d0 d1 d2 d3 carry d0' d1' d2' d3': nat64)
: Lemma
(requires
pow2_five d0 d1 d2 d3 carry == 38 * pow2_four a4 a5 a6 a7 + pow2_four a0 a1 a2 a3 /\
pow2_four d0' d1' d2' d3' % prime == ((pow2_four d0 d1 d2 d3) + carry * pow2_256) % prime)
(ensures (pow2_four d0' d1' d2' d3') % prime == (pow2_eight a0 a1 a2 a3 a4 a5 a6 a7) % prime) =
| calc ( == ) {
pow2_four d0' d1' d2' d3' % prime;
( == ) { calc ( == ) {
(pow2_four d0 d1 d2 d3) + carry * pow2_256;
( == ) { FStar.Tactics.Effect.synth_by_tactic (fun _ -> (int_canon ())) }
pow2_five d0 d1 d2 d3 carry;
} }
pow2_five d0 d1 d2 d3 carry % prime;
( == ) { () }
(pow2_four a0 a1 a2 a3 + 38 * pow2_four a4 a5 a6 a7) % prime;
( == ) { lemma_mul_pow256_add (pow2_four a0 a1 a2 a3) (pow2_four a4 a5 a6 a7) }
(pow2_four a0 a1 a2 a3 + pow2_256 * pow2_four a4 a5 a6 a7) % prime;
( == ) { FStar.Tactics.Effect.synth_by_tactic (fun _ -> (int_canon ())) }
(pow2_eight a0 a1 a2 a3 a4 a5 a6 a7) % prime;
} | false |
Vale.SHA.PPC64LE.SHA_helpers.fsti | Vale.SHA.PPC64LE.SHA_helpers.hash256 | val hash256 : Type0 | let hash256 = m:Seq.seq word {Seq.length m = 8} | {
"file_name": "vale/code/crypto/sha/Vale.SHA.PPC64LE.SHA_helpers.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 47,
"end_line": 30,
"start_col": 0,
"start_line": 30
} | module Vale.SHA.PPC64LE.SHA_helpers
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open FStar.Seq
open Vale.Arch.Types
open Vale.Def.Sel
open Vale.SHA2.Wrapper
open Vale.Def.Words.Four_s
unfold let (.[]) = FStar.Seq.index
#reset-options "--max_fuel 0 --max_ifuel 0"
// Specialize these definitions (from Spec.SHA2.fst) for SHA256
unfold let size_k_w_256 = 64
val word:Type0
(* Number of words for a block size *)
let size_block_w_256 = 16
(* Define the size block in bytes *)
let block_length =
4 (*word_length a*) * size_block_w_256
let block_w = m:seq word {length m = size_block_w_256}
let counter = nat | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Spec.Loops.fst.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.SHA.PPC64LE.SHA_helpers.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.Hash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Vale.SHA.PPC64LE.SHA_helpers.word",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length"
] | [] | false | false | false | true | true | let hash256 =
| m: Seq.seq word {Seq.length m = 8} | false |
|
Vale.SHA.PPC64LE.SHA_helpers.fsti | Vale.SHA.PPC64LE.SHA_helpers.counter | val counter : Type0 | let counter = nat | {
"file_name": "vale/code/crypto/sha/Vale.SHA.PPC64LE.SHA_helpers.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 17,
"end_line": 28,
"start_col": 0,
"start_line": 28
} | module Vale.SHA.PPC64LE.SHA_helpers
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open FStar.Seq
open Vale.Arch.Types
open Vale.Def.Sel
open Vale.SHA2.Wrapper
open Vale.Def.Words.Four_s
unfold let (.[]) = FStar.Seq.index
#reset-options "--max_fuel 0 --max_ifuel 0"
// Specialize these definitions (from Spec.SHA2.fst) for SHA256
unfold let size_k_w_256 = 64
val word:Type0
(* Number of words for a block size *)
let size_block_w_256 = 16
(* Define the size block in bytes *)
let block_length =
4 (*word_length a*) * size_block_w_256 | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Spec.Loops.fst.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.SHA.PPC64LE.SHA_helpers.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.Hash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.nat"
] | [] | false | false | false | true | true | let counter =
| nat | false |
|
Vale.SHA.PPC64LE.SHA_helpers.fsti | Vale.SHA.PPC64LE.SHA_helpers.sigma_0_0_partial | val sigma_0_0_partial : _: Vale.SHA.PPC64LE.SHA_helpers.counter -> _: Vale.SHA.PPC64LE.SHA_helpers.block_w
-> Vale.Def.Words_s.nat32 | let sigma_0_0_partial = opaque_make sigma_0_0_partial_def | {
"file_name": "vale/code/crypto/sha/Vale.SHA.PPC64LE.SHA_helpers.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 76,
"end_line": 77,
"start_col": 19,
"start_line": 77
} | module Vale.SHA.PPC64LE.SHA_helpers
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open FStar.Seq
open Vale.Arch.Types
open Vale.Def.Sel
open Vale.SHA2.Wrapper
open Vale.Def.Words.Four_s
unfold let (.[]) = FStar.Seq.index
#reset-options "--max_fuel 0 --max_ifuel 0"
// Specialize these definitions (from Spec.SHA2.fst) for SHA256
unfold let size_k_w_256 = 64
val word:Type0
(* Number of words for a block size *)
let size_block_w_256 = 16
(* Define the size block in bytes *)
let block_length =
4 (*word_length a*) * size_block_w_256
let block_w = m:seq word {length m = size_block_w_256}
let counter = nat
val k : (s:seq word {length s = size_k_w_256})
let hash256 = m:Seq.seq word {Seq.length m = 8}
(* Input data. *)
type byte = UInt8.t
type bytes = Seq.seq byte
(* Input data, multiple of a block length. *)
let bytes_blocks =
l:bytes { Seq.length l % block_length = 0 }
// Hide various SHA2 definitions
val ws_opaque (b:block_w) (t:counter{t < size_k_w_256}):nat32
val shuffle_core_opaque (block:block_w) (hash:hash256) (t:counter{t < size_k_w_256}):hash256
val update_multi_opaque (hash:hash256) (blocks:bytes_blocks):hash256
val update_multi_transparent (hash:hash256) (blocks:bytes_blocks):hash256
// Hide some functions that operate on words & bytes
val word_to_nat32 (x:word) : nat32
val nat32_to_word (x:nat32) : word
//unfold let bytes_blocks256 = bytes_blocks SHA2_256
let repeat_range_vale (max:nat { max < size_k_w_256}) (block:block_w) (hash:hash256) =
Spec.Loops.repeat_range 0 max (shuffle_core_opaque block) hash
let update_multi_opaque_vale (hash:hash256) (blocks:bytes) : hash256 =
if length blocks % size_k_w_256 = 0 then let b:bytes_blocks = blocks in update_multi_opaque hash b else hash
val make_ordered_hash (abcd efgh:quad32): Pure (hash256)
(requires True)
(ensures fun hash ->
length hash == 8 /\
hash.[0] == nat32_to_word abcd.lo0 /\
hash.[1] == nat32_to_word abcd.lo1 /\
hash.[2] == nat32_to_word abcd.hi2 /\
hash.[3] == nat32_to_word abcd.hi3 /\
hash.[4] == nat32_to_word efgh.lo0 /\
hash.[5] == nat32_to_word efgh.lo1 /\
hash.[6] == nat32_to_word efgh.hi2 /\
hash.[7] == nat32_to_word efgh.hi3
)
val update_block (hash:hash256) (block:block_w): hash256
val lemma_update_multi_opaque_vale_is_update_multi (hash:hash256) (blocks:bytes) : Lemma
(requires length blocks % 64 = 0)
(ensures update_multi_opaque_vale hash blocks == update_multi_transparent hash blocks) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Spec.Loops.fst.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.SHA.PPC64LE.SHA_helpers.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.Hash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Vale.SHA.PPC64LE.SHA_helpers.counter -> _: Vale.SHA.PPC64LE.SHA_helpers.block_w
-> Vale.Def.Words_s.nat32 | Prims.Tot | [
"total"
] | [] | [
"Vale.Def.Opaque_s.opaque_make",
"Vale.SHA.PPC64LE.SHA_helpers.counter",
"Vale.SHA.PPC64LE.SHA_helpers.block_w",
"Vale.Def.Words_s.nat32",
"Vale.SHA.PPC64LE.SHA_helpers.sigma_0_0_partial_def"
] | [] | false | false | false | true | false | let sigma_0_0_partial =
| opaque_make sigma_0_0_partial_def | false |
|
Vale.Curve25519.FastHybrid_helpers.fst | Vale.Curve25519.FastHybrid_helpers.lemma_carry_prime | val lemma_carry_prime (a0 a1 a2 a3 a0' a1' a2' a3' carry_in:nat64) (carry:bit) : Lemma
(requires pow2_five a0' a1' a2' a3' carry == pow2_four a0 a1 a2 a3 + carry_in * 38 /\
carry_in * 38 - 1 + 38 < pow2_64)
(ensures a0' + carry * 38 < pow2_64 /\
(pow2_four (a0' + carry * 38) a1' a2' a3') % prime == (pow2_four a0 a1 a2 a3 + carry_in * pow2_256) % prime) | val lemma_carry_prime (a0 a1 a2 a3 a0' a1' a2' a3' carry_in:nat64) (carry:bit) : Lemma
(requires pow2_five a0' a1' a2' a3' carry == pow2_four a0 a1 a2 a3 + carry_in * 38 /\
carry_in * 38 - 1 + 38 < pow2_64)
(ensures a0' + carry * 38 < pow2_64 /\
(pow2_four (a0' + carry * 38) a1' a2' a3') % prime == (pow2_four a0 a1 a2 a3 + carry_in * pow2_256) % prime) | let lemma_carry_prime (a0 a1 a2 a3 a0' a1' a2' a3' carry_in:nat64) (carry:bit) : Lemma
(requires pow2_five a0' a1' a2' a3' carry == pow2_four a0 a1 a2 a3 + carry_in * 38 /\
carry_in * 38 - 1 + 38 < pow2_64)
(ensures a0' + carry * 38 < pow2_64 /\
(pow2_four (a0' + carry * 38) a1' a2' a3') % prime == (pow2_four a0 a1 a2 a3 + carry_in * pow2_256) % prime)
=
assert (a0' + carry * 38 < pow2_64);
calc (==) {
(pow2_four a0 a1 a2 a3 + carry_in * pow2_256) % prime;
== { lemma_mul_pow256_add (pow2_four a0 a1 a2 a3) carry_in }
(pow2_four a0 a1 a2 a3 + carry_in * 38) % prime;
== {}
(pow2_five a0' a1' a2' a3' carry) % prime;
== { _ by (int_canon()) }
(pow2_four a0' a1' a2' a3' + (carry * pow2_256)) % prime;
== { lemma_mul_pow256_add (pow2_four a0' a1' a2' a3') carry }
(pow2_four a0' a1' a2' a3' + (carry * 38)) % prime;
== { calc (==) {
(pow2_four a0' a1' a2' a3') + (carry * 38);
== { _ by (int_canon()) }
pow2_four (a0' + carry * 38) a1' a2' a3';
}
}
(pow2_four (a0' + carry * 38) a1' a2' a3') % prime;
};
() | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.FastHybrid_helpers.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 39,
"start_col": 0,
"start_line": 13
} | module Vale.Curve25519.FastHybrid_helpers
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
open FStar.Tactics
open FStar.Tactics.CanonCommSemiring
open Vale.Curve25519.Fast_defs
open Vale.Curve25519.Fast_lemmas_internal
#reset-options "--max_fuel 0 --max_ifuel 0 --using_facts_from '* -FStar.Tactics -FStar.Reflection'" | {
"checked_file": "/",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_lemmas_internal.fsti.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Curve25519.FastHybrid_helpers.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_internal",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 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": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a0: Vale.Def.Types_s.nat64 ->
a1: Vale.Def.Types_s.nat64 ->
a2: Vale.Def.Types_s.nat64 ->
a3: Vale.Def.Types_s.nat64 ->
a0': Vale.Def.Types_s.nat64 ->
a1': Vale.Def.Types_s.nat64 ->
a2': Vale.Def.Types_s.nat64 ->
a3': Vale.Def.Types_s.nat64 ->
carry_in: Vale.Def.Types_s.nat64 ->
carry: Vale.Curve25519.Fast_defs.bit
-> FStar.Pervasives.Lemma
(requires
Vale.Curve25519.Fast_defs.pow2_five a0' a1' a2' a3' carry ==
Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 + carry_in * 38 /\
carry_in * 38 - 1 + 38 < Vale.Def.Words_s.pow2_64)
(ensures
a0' + carry * 38 < Vale.Def.Words_s.pow2_64 /\
Vale.Curve25519.Fast_defs.pow2_four (a0' + carry * 38) a1' a2' a3' %
Vale.Curve25519.Fast_defs.prime ==
(Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 +
carry_in * Vale.Curve25519.Fast_defs.pow2_256) %
Vale.Curve25519.Fast_defs.prime) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Types_s.nat64",
"Vale.Curve25519.Fast_defs.bit",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Modulus",
"Prims.op_Addition",
"Vale.Curve25519.Fast_defs.pow2_four",
"FStar.Mul.op_Star",
"Vale.Curve25519.Fast_defs.pow2_256",
"Vale.Curve25519.Fast_defs.prime",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"Vale.Curve25519.Fast_defs.pow2_five",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Vale.Curve25519.FastHybrid_helpers.lemma_mul_pow256_add",
"Prims.squash",
"FStar.Tactics.CanonCommSemiring.semiring_reflect",
"FStar.Tactics.CanonCommSemiring.int_cr",
"FStar.Pervasives.Native.Mktuple2",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.nat",
"FStar.Pervasives.Native.snd",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Prims.op_Multiply",
"FStar.Stubs.Reflection.V2.Data.var",
"FStar.Tactics.CanonCommSemiring.Pvar",
"FStar.Tactics.CanonCommSemiring.Pplus",
"FStar.Tactics.CanonCommSemiring.Pmult",
"FStar.Tactics.CanonCommSemiring.Pconst",
"Prims._assert",
"Prims.op_LessThan",
"Vale.Def.Words_s.pow2_64",
"Prims.l_and",
"Prims.op_Subtraction",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let lemma_carry_prime (a0 a1 a2 a3 a0' a1' a2' a3' carry_in: nat64) (carry: bit)
: Lemma
(requires
pow2_five a0' a1' a2' a3' carry == pow2_four a0 a1 a2 a3 + carry_in * 38 /\
carry_in * 38 - 1 + 38 < pow2_64)
(ensures
a0' + carry * 38 < pow2_64 /\
(pow2_four (a0' + carry * 38) a1' a2' a3') % prime ==
(pow2_four a0 a1 a2 a3 + carry_in * pow2_256) % prime) =
| assert (a0' + carry * 38 < pow2_64);
calc ( == ) {
(pow2_four a0 a1 a2 a3 + carry_in * pow2_256) % prime;
( == ) { lemma_mul_pow256_add (pow2_four a0 a1 a2 a3) carry_in }
(pow2_four a0 a1 a2 a3 + carry_in * 38) % prime;
( == ) { () }
(pow2_five a0' a1' a2' a3' carry) % prime;
( == ) { FStar.Tactics.Effect.synth_by_tactic (fun _ -> (int_canon ())) }
(pow2_four a0' a1' a2' a3' + (carry * pow2_256)) % prime;
( == ) { lemma_mul_pow256_add (pow2_four a0' a1' a2' a3') carry }
(pow2_four a0' a1' a2' a3' + (carry * 38)) % prime;
( == ) { calc ( == ) {
(pow2_four a0' a1' a2' a3') + (carry * 38);
( == ) { FStar.Tactics.Effect.synth_by_tactic (fun _ -> (int_canon ())) }
pow2_four (a0' + carry * 38) a1' a2' a3';
} }
(pow2_four (a0' + carry * 38) a1' a2' a3') % prime;
};
() | false |
Vale.SHA.PPC64LE.SHA_helpers.fsti | Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial_reveal | val sigma_1_0_partial_reveal : _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial_def) | let sigma_1_0_partial_reveal = opaque_revealer (`%sigma_1_0_partial) sigma_1_0_partial sigma_1_0_partial_def | {
"file_name": "vale/code/crypto/sha/Vale.SHA.PPC64LE.SHA_helpers.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 120,
"end_line": 96,
"start_col": 12,
"start_line": 96
} | module Vale.SHA.PPC64LE.SHA_helpers
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open FStar.Seq
open Vale.Arch.Types
open Vale.Def.Sel
open Vale.SHA2.Wrapper
open Vale.Def.Words.Four_s
unfold let (.[]) = FStar.Seq.index
#reset-options "--max_fuel 0 --max_ifuel 0"
// Specialize these definitions (from Spec.SHA2.fst) for SHA256
unfold let size_k_w_256 = 64
val word:Type0
(* Number of words for a block size *)
let size_block_w_256 = 16
(* Define the size block in bytes *)
let block_length =
4 (*word_length a*) * size_block_w_256
let block_w = m:seq word {length m = size_block_w_256}
let counter = nat
val k : (s:seq word {length s = size_k_w_256})
let hash256 = m:Seq.seq word {Seq.length m = 8}
(* Input data. *)
type byte = UInt8.t
type bytes = Seq.seq byte
(* Input data, multiple of a block length. *)
let bytes_blocks =
l:bytes { Seq.length l % block_length = 0 }
// Hide various SHA2 definitions
val ws_opaque (b:block_w) (t:counter{t < size_k_w_256}):nat32
val shuffle_core_opaque (block:block_w) (hash:hash256) (t:counter{t < size_k_w_256}):hash256
val update_multi_opaque (hash:hash256) (blocks:bytes_blocks):hash256
val update_multi_transparent (hash:hash256) (blocks:bytes_blocks):hash256
// Hide some functions that operate on words & bytes
val word_to_nat32 (x:word) : nat32
val nat32_to_word (x:nat32) : word
//unfold let bytes_blocks256 = bytes_blocks SHA2_256
let repeat_range_vale (max:nat { max < size_k_w_256}) (block:block_w) (hash:hash256) =
Spec.Loops.repeat_range 0 max (shuffle_core_opaque block) hash
let update_multi_opaque_vale (hash:hash256) (blocks:bytes) : hash256 =
if length blocks % size_k_w_256 = 0 then let b:bytes_blocks = blocks in update_multi_opaque hash b else hash
val make_ordered_hash (abcd efgh:quad32): Pure (hash256)
(requires True)
(ensures fun hash ->
length hash == 8 /\
hash.[0] == nat32_to_word abcd.lo0 /\
hash.[1] == nat32_to_word abcd.lo1 /\
hash.[2] == nat32_to_word abcd.hi2 /\
hash.[3] == nat32_to_word abcd.hi3 /\
hash.[4] == nat32_to_word efgh.lo0 /\
hash.[5] == nat32_to_word efgh.lo1 /\
hash.[6] == nat32_to_word efgh.hi2 /\
hash.[7] == nat32_to_word efgh.hi3
)
val update_block (hash:hash256) (block:block_w): hash256
val lemma_update_multi_opaque_vale_is_update_multi (hash:hash256) (blocks:bytes) : Lemma
(requires length blocks % 64 = 0)
(ensures update_multi_opaque_vale hash blocks == update_multi_transparent hash blocks)
val sigma_0_0_partial_def (t:counter) (block:block_w) : nat32
[@"opaque_to_smt"] let sigma_0_0_partial = opaque_make sigma_0_0_partial_def
irreducible let sigma_0_0_partial_reveal = opaque_revealer (`%sigma_0_0_partial) sigma_0_0_partial sigma_0_0_partial_def
val lemma_sha256_sigma0 (src:quad32) (t:counter) (block:block_w) : Lemma
(requires 16 <= t /\ t < size_k_w_256 /\
src.hi3 == ws_opaque block (t-15))
(ensures (sigma256_0_0 src.hi3 == sigma_0_0_partial t block))
val sigma_0_1_partial_def (t:counter) (block:block_w) : nat32
[@"opaque_to_smt"] let sigma_0_1_partial = opaque_make sigma_0_1_partial_def
irreducible let sigma_0_1_partial_reveal = opaque_revealer (`%sigma_0_1_partial) sigma_0_1_partial sigma_0_1_partial_def
val lemma_sha256_sigma1 (src:quad32) (t:counter) (block:block_w) : Lemma
(requires 16 <= t /\ t < size_k_w_256 /\
src.hi3 == ws_opaque block (t-2))
(ensures (sigma256_0_1 src.hi3 == sigma_0_1_partial t block))
val sigma_1_0_partial_def (t:counter) (block:block_w) (hash_orig:hash256) : nat32 | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Spec.Loops.fst.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.SHA.PPC64LE.SHA_helpers.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.Hash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial_def) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Opaque_s.opaque_revealer",
"Vale.SHA.PPC64LE.SHA_helpers.counter",
"Vale.SHA.PPC64LE.SHA_helpers.block_w",
"Vale.SHA.PPC64LE.SHA_helpers.hash256",
"Vale.Def.Words_s.nat32",
"Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial",
"Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial_def"
] | [] | true | false | true | false | false | let sigma_1_0_partial_reveal =
| opaque_revealer (`%sigma_1_0_partial) sigma_1_0_partial sigma_1_0_partial_def | false |
|
Vale.SHA.PPC64LE.SHA_helpers.fsti | Vale.SHA.PPC64LE.SHA_helpers.sigma_0_1_partial_reveal | val sigma_0_1_partial_reveal : _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
Vale.SHA.PPC64LE.SHA_helpers.sigma_0_1_partial ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_0_1_partial_def) | let sigma_0_1_partial_reveal = opaque_revealer (`%sigma_0_1_partial) sigma_0_1_partial sigma_0_1_partial_def | {
"file_name": "vale/code/crypto/sha/Vale.SHA.PPC64LE.SHA_helpers.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 120,
"end_line": 87,
"start_col": 12,
"start_line": 87
} | module Vale.SHA.PPC64LE.SHA_helpers
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open FStar.Seq
open Vale.Arch.Types
open Vale.Def.Sel
open Vale.SHA2.Wrapper
open Vale.Def.Words.Four_s
unfold let (.[]) = FStar.Seq.index
#reset-options "--max_fuel 0 --max_ifuel 0"
// Specialize these definitions (from Spec.SHA2.fst) for SHA256
unfold let size_k_w_256 = 64
val word:Type0
(* Number of words for a block size *)
let size_block_w_256 = 16
(* Define the size block in bytes *)
let block_length =
4 (*word_length a*) * size_block_w_256
let block_w = m:seq word {length m = size_block_w_256}
let counter = nat
val k : (s:seq word {length s = size_k_w_256})
let hash256 = m:Seq.seq word {Seq.length m = 8}
(* Input data. *)
type byte = UInt8.t
type bytes = Seq.seq byte
(* Input data, multiple of a block length. *)
let bytes_blocks =
l:bytes { Seq.length l % block_length = 0 }
// Hide various SHA2 definitions
val ws_opaque (b:block_w) (t:counter{t < size_k_w_256}):nat32
val shuffle_core_opaque (block:block_w) (hash:hash256) (t:counter{t < size_k_w_256}):hash256
val update_multi_opaque (hash:hash256) (blocks:bytes_blocks):hash256
val update_multi_transparent (hash:hash256) (blocks:bytes_blocks):hash256
// Hide some functions that operate on words & bytes
val word_to_nat32 (x:word) : nat32
val nat32_to_word (x:nat32) : word
//unfold let bytes_blocks256 = bytes_blocks SHA2_256
let repeat_range_vale (max:nat { max < size_k_w_256}) (block:block_w) (hash:hash256) =
Spec.Loops.repeat_range 0 max (shuffle_core_opaque block) hash
let update_multi_opaque_vale (hash:hash256) (blocks:bytes) : hash256 =
if length blocks % size_k_w_256 = 0 then let b:bytes_blocks = blocks in update_multi_opaque hash b else hash
val make_ordered_hash (abcd efgh:quad32): Pure (hash256)
(requires True)
(ensures fun hash ->
length hash == 8 /\
hash.[0] == nat32_to_word abcd.lo0 /\
hash.[1] == nat32_to_word abcd.lo1 /\
hash.[2] == nat32_to_word abcd.hi2 /\
hash.[3] == nat32_to_word abcd.hi3 /\
hash.[4] == nat32_to_word efgh.lo0 /\
hash.[5] == nat32_to_word efgh.lo1 /\
hash.[6] == nat32_to_word efgh.hi2 /\
hash.[7] == nat32_to_word efgh.hi3
)
val update_block (hash:hash256) (block:block_w): hash256
val lemma_update_multi_opaque_vale_is_update_multi (hash:hash256) (blocks:bytes) : Lemma
(requires length blocks % 64 = 0)
(ensures update_multi_opaque_vale hash blocks == update_multi_transparent hash blocks)
val sigma_0_0_partial_def (t:counter) (block:block_w) : nat32
[@"opaque_to_smt"] let sigma_0_0_partial = opaque_make sigma_0_0_partial_def
irreducible let sigma_0_0_partial_reveal = opaque_revealer (`%sigma_0_0_partial) sigma_0_0_partial sigma_0_0_partial_def
val lemma_sha256_sigma0 (src:quad32) (t:counter) (block:block_w) : Lemma
(requires 16 <= t /\ t < size_k_w_256 /\
src.hi3 == ws_opaque block (t-15))
(ensures (sigma256_0_0 src.hi3 == sigma_0_0_partial t block))
val sigma_0_1_partial_def (t:counter) (block:block_w) : nat32 | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Spec.Loops.fst.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.SHA.PPC64LE.SHA_helpers.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.Hash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
Vale.SHA.PPC64LE.SHA_helpers.sigma_0_1_partial ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_0_1_partial_def) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Opaque_s.opaque_revealer",
"Vale.SHA.PPC64LE.SHA_helpers.counter",
"Vale.SHA.PPC64LE.SHA_helpers.block_w",
"Vale.Def.Words_s.nat32",
"Vale.SHA.PPC64LE.SHA_helpers.sigma_0_1_partial",
"Vale.SHA.PPC64LE.SHA_helpers.sigma_0_1_partial_def"
] | [] | true | false | true | false | false | let sigma_0_1_partial_reveal =
| opaque_revealer (`%sigma_0_1_partial) sigma_0_1_partial sigma_0_1_partial_def | false |
|
Vale.SHA.PPC64LE.SHA_helpers.fsti | Vale.SHA.PPC64LE.SHA_helpers.sigma_0_0_partial_reveal | val sigma_0_0_partial_reveal : _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
Vale.SHA.PPC64LE.SHA_helpers.sigma_0_0_partial ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_0_0_partial_def) | let sigma_0_0_partial_reveal = opaque_revealer (`%sigma_0_0_partial) sigma_0_0_partial sigma_0_0_partial_def | {
"file_name": "vale/code/crypto/sha/Vale.SHA.PPC64LE.SHA_helpers.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 120,
"end_line": 78,
"start_col": 12,
"start_line": 78
} | module Vale.SHA.PPC64LE.SHA_helpers
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open FStar.Seq
open Vale.Arch.Types
open Vale.Def.Sel
open Vale.SHA2.Wrapper
open Vale.Def.Words.Four_s
unfold let (.[]) = FStar.Seq.index
#reset-options "--max_fuel 0 --max_ifuel 0"
// Specialize these definitions (from Spec.SHA2.fst) for SHA256
unfold let size_k_w_256 = 64
val word:Type0
(* Number of words for a block size *)
let size_block_w_256 = 16
(* Define the size block in bytes *)
let block_length =
4 (*word_length a*) * size_block_w_256
let block_w = m:seq word {length m = size_block_w_256}
let counter = nat
val k : (s:seq word {length s = size_k_w_256})
let hash256 = m:Seq.seq word {Seq.length m = 8}
(* Input data. *)
type byte = UInt8.t
type bytes = Seq.seq byte
(* Input data, multiple of a block length. *)
let bytes_blocks =
l:bytes { Seq.length l % block_length = 0 }
// Hide various SHA2 definitions
val ws_opaque (b:block_w) (t:counter{t < size_k_w_256}):nat32
val shuffle_core_opaque (block:block_w) (hash:hash256) (t:counter{t < size_k_w_256}):hash256
val update_multi_opaque (hash:hash256) (blocks:bytes_blocks):hash256
val update_multi_transparent (hash:hash256) (blocks:bytes_blocks):hash256
// Hide some functions that operate on words & bytes
val word_to_nat32 (x:word) : nat32
val nat32_to_word (x:nat32) : word
//unfold let bytes_blocks256 = bytes_blocks SHA2_256
let repeat_range_vale (max:nat { max < size_k_w_256}) (block:block_w) (hash:hash256) =
Spec.Loops.repeat_range 0 max (shuffle_core_opaque block) hash
let update_multi_opaque_vale (hash:hash256) (blocks:bytes) : hash256 =
if length blocks % size_k_w_256 = 0 then let b:bytes_blocks = blocks in update_multi_opaque hash b else hash
val make_ordered_hash (abcd efgh:quad32): Pure (hash256)
(requires True)
(ensures fun hash ->
length hash == 8 /\
hash.[0] == nat32_to_word abcd.lo0 /\
hash.[1] == nat32_to_word abcd.lo1 /\
hash.[2] == nat32_to_word abcd.hi2 /\
hash.[3] == nat32_to_word abcd.hi3 /\
hash.[4] == nat32_to_word efgh.lo0 /\
hash.[5] == nat32_to_word efgh.lo1 /\
hash.[6] == nat32_to_word efgh.hi2 /\
hash.[7] == nat32_to_word efgh.hi3
)
val update_block (hash:hash256) (block:block_w): hash256
val lemma_update_multi_opaque_vale_is_update_multi (hash:hash256) (blocks:bytes) : Lemma
(requires length blocks % 64 = 0)
(ensures update_multi_opaque_vale hash blocks == update_multi_transparent hash blocks)
val sigma_0_0_partial_def (t:counter) (block:block_w) : nat32 | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Spec.Loops.fst.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.SHA.PPC64LE.SHA_helpers.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.Hash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
Vale.SHA.PPC64LE.SHA_helpers.sigma_0_0_partial ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_0_0_partial_def) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Opaque_s.opaque_revealer",
"Vale.SHA.PPC64LE.SHA_helpers.counter",
"Vale.SHA.PPC64LE.SHA_helpers.block_w",
"Vale.Def.Words_s.nat32",
"Vale.SHA.PPC64LE.SHA_helpers.sigma_0_0_partial",
"Vale.SHA.PPC64LE.SHA_helpers.sigma_0_0_partial_def"
] | [] | true | false | true | false | false | let sigma_0_0_partial_reveal =
| opaque_revealer (`%sigma_0_0_partial) sigma_0_0_partial sigma_0_0_partial_def | false |
|
Vale.Inline.X64.Fswap_inline.fst | Vale.Inline.X64.Fswap_inline.as_normal_t | val as_normal_t (#a: Type) (x: a) : normal a | val as_normal_t (#a: Type) (x: a) : normal a | let as_normal_t (#a:Type) (x:a) : normal a = x | {
"file_name": "vale/code/arch/x64/interop/Vale.Inline.X64.Fswap_inline.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 46,
"end_line": 29,
"start_col": 0,
"start_line": 29
} | module Vale.Inline.X64.Fswap_inline
open FStar.Mul
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LSig = Vale.AsLowStar.LowStarSig
module ME = Vale.X64.Memory
module V = Vale.X64.Decls
module IA = Vale.Interop.Assumptions
module W = Vale.AsLowStar.Wrapper
open Vale.X64.MemoryAdapters
module VS = Vale.X64.State
module MS = Vale.X64.Machine_s
module PR = Vale.X64.Print_Inline_s
module FU = Vale.Curve25519.X64.FastUtil
let uint64 = UInt64.t
(* A little utility to trigger normalization in types *) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Print_Inline_s.fst.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Interop.Assumptions.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.X64.FastUtil.fsti.checked",
"Vale.AsLowStar.Wrapper.fsti.checked",
"Vale.AsLowStar.ValeSig.fst.checked",
"Vale.AsLowStar.MemoryHelpers.fsti.checked",
"Vale.AsLowStar.LowStarSig.fst.checked",
"prims.fst.checked",
"LowStar.BufferView.Down.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Inline.X64.Fswap_inline.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
{
"abbrev": true,
"full_module": "Vale.X64.Print_Inline_s",
"short_module": "PR"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_module": "Vale.X64.State",
"short_module": "VS"
},
{
"abbrev": false,
"full_module": "Vale.X64.MemoryAdapters",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.Wrapper",
"short_module": "W"
},
{
"abbrev": true,
"full_module": "Vale.Interop.Assumptions",
"short_module": "IA"
},
{
"abbrev": true,
"full_module": "Vale.X64.Decls",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Vale.X64.Memory",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.LowStarSig",
"short_module": "LSig"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.ValeSig",
"short_module": "VSig"
},
{
"abbrev": true,
"full_module": "Vale.Interop.X64",
"short_module": "IX64"
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.BufferView.Down",
"short_module": "DV"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x: a -> Vale.Interop.Base.normal a | Prims.Tot | [
"total"
] | [] | [
"Vale.Interop.Base.normal"
] | [] | false | false | false | true | false | let as_normal_t (#a: Type) (x: a) : normal a =
| x | false |
Vale.SHA.PPC64LE.SHA_helpers.fsti | Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial | val sigma_1_0_partial : _: Vale.SHA.PPC64LE.SHA_helpers.counter ->
_: Vale.SHA.PPC64LE.SHA_helpers.block_w ->
_: Vale.SHA.PPC64LE.SHA_helpers.hash256
-> Vale.Def.Words_s.nat32 | let sigma_1_0_partial = opaque_make sigma_1_0_partial_def | {
"file_name": "vale/code/crypto/sha/Vale.SHA.PPC64LE.SHA_helpers.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 76,
"end_line": 95,
"start_col": 19,
"start_line": 95
} | module Vale.SHA.PPC64LE.SHA_helpers
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open FStar.Seq
open Vale.Arch.Types
open Vale.Def.Sel
open Vale.SHA2.Wrapper
open Vale.Def.Words.Four_s
unfold let (.[]) = FStar.Seq.index
#reset-options "--max_fuel 0 --max_ifuel 0"
// Specialize these definitions (from Spec.SHA2.fst) for SHA256
unfold let size_k_w_256 = 64
val word:Type0
(* Number of words for a block size *)
let size_block_w_256 = 16
(* Define the size block in bytes *)
let block_length =
4 (*word_length a*) * size_block_w_256
let block_w = m:seq word {length m = size_block_w_256}
let counter = nat
val k : (s:seq word {length s = size_k_w_256})
let hash256 = m:Seq.seq word {Seq.length m = 8}
(* Input data. *)
type byte = UInt8.t
type bytes = Seq.seq byte
(* Input data, multiple of a block length. *)
let bytes_blocks =
l:bytes { Seq.length l % block_length = 0 }
// Hide various SHA2 definitions
val ws_opaque (b:block_w) (t:counter{t < size_k_w_256}):nat32
val shuffle_core_opaque (block:block_w) (hash:hash256) (t:counter{t < size_k_w_256}):hash256
val update_multi_opaque (hash:hash256) (blocks:bytes_blocks):hash256
val update_multi_transparent (hash:hash256) (blocks:bytes_blocks):hash256
// Hide some functions that operate on words & bytes
val word_to_nat32 (x:word) : nat32
val nat32_to_word (x:nat32) : word
//unfold let bytes_blocks256 = bytes_blocks SHA2_256
let repeat_range_vale (max:nat { max < size_k_w_256}) (block:block_w) (hash:hash256) =
Spec.Loops.repeat_range 0 max (shuffle_core_opaque block) hash
let update_multi_opaque_vale (hash:hash256) (blocks:bytes) : hash256 =
if length blocks % size_k_w_256 = 0 then let b:bytes_blocks = blocks in update_multi_opaque hash b else hash
val make_ordered_hash (abcd efgh:quad32): Pure (hash256)
(requires True)
(ensures fun hash ->
length hash == 8 /\
hash.[0] == nat32_to_word abcd.lo0 /\
hash.[1] == nat32_to_word abcd.lo1 /\
hash.[2] == nat32_to_word abcd.hi2 /\
hash.[3] == nat32_to_word abcd.hi3 /\
hash.[4] == nat32_to_word efgh.lo0 /\
hash.[5] == nat32_to_word efgh.lo1 /\
hash.[6] == nat32_to_word efgh.hi2 /\
hash.[7] == nat32_to_word efgh.hi3
)
val update_block (hash:hash256) (block:block_w): hash256
val lemma_update_multi_opaque_vale_is_update_multi (hash:hash256) (blocks:bytes) : Lemma
(requires length blocks % 64 = 0)
(ensures update_multi_opaque_vale hash blocks == update_multi_transparent hash blocks)
val sigma_0_0_partial_def (t:counter) (block:block_w) : nat32
[@"opaque_to_smt"] let sigma_0_0_partial = opaque_make sigma_0_0_partial_def
irreducible let sigma_0_0_partial_reveal = opaque_revealer (`%sigma_0_0_partial) sigma_0_0_partial sigma_0_0_partial_def
val lemma_sha256_sigma0 (src:quad32) (t:counter) (block:block_w) : Lemma
(requires 16 <= t /\ t < size_k_w_256 /\
src.hi3 == ws_opaque block (t-15))
(ensures (sigma256_0_0 src.hi3 == sigma_0_0_partial t block))
val sigma_0_1_partial_def (t:counter) (block:block_w) : nat32
[@"opaque_to_smt"] let sigma_0_1_partial = opaque_make sigma_0_1_partial_def
irreducible let sigma_0_1_partial_reveal = opaque_revealer (`%sigma_0_1_partial) sigma_0_1_partial sigma_0_1_partial_def
val lemma_sha256_sigma1 (src:quad32) (t:counter) (block:block_w) : Lemma
(requires 16 <= t /\ t < size_k_w_256 /\
src.hi3 == ws_opaque block (t-2))
(ensures (sigma256_0_1 src.hi3 == sigma_0_1_partial t block)) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Spec.Loops.fst.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.SHA.PPC64LE.SHA_helpers.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.Hash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
_: Vale.SHA.PPC64LE.SHA_helpers.counter ->
_: Vale.SHA.PPC64LE.SHA_helpers.block_w ->
_: Vale.SHA.PPC64LE.SHA_helpers.hash256
-> Vale.Def.Words_s.nat32 | Prims.Tot | [
"total"
] | [] | [
"Vale.Def.Opaque_s.opaque_make",
"Vale.SHA.PPC64LE.SHA_helpers.counter",
"Vale.SHA.PPC64LE.SHA_helpers.block_w",
"Vale.SHA.PPC64LE.SHA_helpers.hash256",
"Vale.Def.Words_s.nat32",
"Vale.SHA.PPC64LE.SHA_helpers.sigma_1_0_partial_def"
] | [] | false | false | false | true | false | let sigma_1_0_partial =
| opaque_make sigma_1_0_partial_def | false |
|
Vale.SHA.PPC64LE.SHA_helpers.fsti | Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial | val sigma_1_1_partial : _: Vale.SHA.PPC64LE.SHA_helpers.counter ->
_: Vale.SHA.PPC64LE.SHA_helpers.block_w ->
_: Vale.SHA.PPC64LE.SHA_helpers.hash256
-> Vale.Def.Words_s.nat32 | let sigma_1_1_partial = opaque_make sigma_1_1_partial_def | {
"file_name": "vale/code/crypto/sha/Vale.SHA.PPC64LE.SHA_helpers.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 76,
"end_line": 104,
"start_col": 19,
"start_line": 104
} | module Vale.SHA.PPC64LE.SHA_helpers
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open FStar.Seq
open Vale.Arch.Types
open Vale.Def.Sel
open Vale.SHA2.Wrapper
open Vale.Def.Words.Four_s
unfold let (.[]) = FStar.Seq.index
#reset-options "--max_fuel 0 --max_ifuel 0"
// Specialize these definitions (from Spec.SHA2.fst) for SHA256
unfold let size_k_w_256 = 64
val word:Type0
(* Number of words for a block size *)
let size_block_w_256 = 16
(* Define the size block in bytes *)
let block_length =
4 (*word_length a*) * size_block_w_256
let block_w = m:seq word {length m = size_block_w_256}
let counter = nat
val k : (s:seq word {length s = size_k_w_256})
let hash256 = m:Seq.seq word {Seq.length m = 8}
(* Input data. *)
type byte = UInt8.t
type bytes = Seq.seq byte
(* Input data, multiple of a block length. *)
let bytes_blocks =
l:bytes { Seq.length l % block_length = 0 }
// Hide various SHA2 definitions
val ws_opaque (b:block_w) (t:counter{t < size_k_w_256}):nat32
val shuffle_core_opaque (block:block_w) (hash:hash256) (t:counter{t < size_k_w_256}):hash256
val update_multi_opaque (hash:hash256) (blocks:bytes_blocks):hash256
val update_multi_transparent (hash:hash256) (blocks:bytes_blocks):hash256
// Hide some functions that operate on words & bytes
val word_to_nat32 (x:word) : nat32
val nat32_to_word (x:nat32) : word
//unfold let bytes_blocks256 = bytes_blocks SHA2_256
let repeat_range_vale (max:nat { max < size_k_w_256}) (block:block_w) (hash:hash256) =
Spec.Loops.repeat_range 0 max (shuffle_core_opaque block) hash
let update_multi_opaque_vale (hash:hash256) (blocks:bytes) : hash256 =
if length blocks % size_k_w_256 = 0 then let b:bytes_blocks = blocks in update_multi_opaque hash b else hash
val make_ordered_hash (abcd efgh:quad32): Pure (hash256)
(requires True)
(ensures fun hash ->
length hash == 8 /\
hash.[0] == nat32_to_word abcd.lo0 /\
hash.[1] == nat32_to_word abcd.lo1 /\
hash.[2] == nat32_to_word abcd.hi2 /\
hash.[3] == nat32_to_word abcd.hi3 /\
hash.[4] == nat32_to_word efgh.lo0 /\
hash.[5] == nat32_to_word efgh.lo1 /\
hash.[6] == nat32_to_word efgh.hi2 /\
hash.[7] == nat32_to_word efgh.hi3
)
val update_block (hash:hash256) (block:block_w): hash256
val lemma_update_multi_opaque_vale_is_update_multi (hash:hash256) (blocks:bytes) : Lemma
(requires length blocks % 64 = 0)
(ensures update_multi_opaque_vale hash blocks == update_multi_transparent hash blocks)
val sigma_0_0_partial_def (t:counter) (block:block_w) : nat32
[@"opaque_to_smt"] let sigma_0_0_partial = opaque_make sigma_0_0_partial_def
irreducible let sigma_0_0_partial_reveal = opaque_revealer (`%sigma_0_0_partial) sigma_0_0_partial sigma_0_0_partial_def
val lemma_sha256_sigma0 (src:quad32) (t:counter) (block:block_w) : Lemma
(requires 16 <= t /\ t < size_k_w_256 /\
src.hi3 == ws_opaque block (t-15))
(ensures (sigma256_0_0 src.hi3 == sigma_0_0_partial t block))
val sigma_0_1_partial_def (t:counter) (block:block_w) : nat32
[@"opaque_to_smt"] let sigma_0_1_partial = opaque_make sigma_0_1_partial_def
irreducible let sigma_0_1_partial_reveal = opaque_revealer (`%sigma_0_1_partial) sigma_0_1_partial sigma_0_1_partial_def
val lemma_sha256_sigma1 (src:quad32) (t:counter) (block:block_w) : Lemma
(requires 16 <= t /\ t < size_k_w_256 /\
src.hi3 == ws_opaque block (t-2))
(ensures (sigma256_0_1 src.hi3 == sigma_0_1_partial t block))
val sigma_1_0_partial_def (t:counter) (block:block_w) (hash_orig:hash256) : nat32
[@"opaque_to_smt"] let sigma_1_0_partial = opaque_make sigma_1_0_partial_def
irreducible let sigma_1_0_partial_reveal = opaque_revealer (`%sigma_1_0_partial) sigma_1_0_partial sigma_1_0_partial_def
val lemma_sha256_sigma2 (src:quad32) (t:counter) (block:block_w) (hash_orig:hash256) : Lemma
(requires t < size_k_w_256 /\
src.hi3 == word_to_nat32 ((repeat_range_vale t block hash_orig).[0]))
(ensures (sigma256_1_0 src.hi3 == sigma_1_0_partial t block hash_orig)) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Spec.Loops.fst.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.SHA.PPC64LE.SHA_helpers.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.Hash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
_: Vale.SHA.PPC64LE.SHA_helpers.counter ->
_: Vale.SHA.PPC64LE.SHA_helpers.block_w ->
_: Vale.SHA.PPC64LE.SHA_helpers.hash256
-> Vale.Def.Words_s.nat32 | Prims.Tot | [
"total"
] | [] | [
"Vale.Def.Opaque_s.opaque_make",
"Vale.SHA.PPC64LE.SHA_helpers.counter",
"Vale.SHA.PPC64LE.SHA_helpers.block_w",
"Vale.SHA.PPC64LE.SHA_helpers.hash256",
"Vale.Def.Words_s.nat32",
"Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial_def"
] | [] | false | false | false | true | false | let sigma_1_1_partial =
| opaque_make sigma_1_1_partial_def | false |
|
Vale.SHA.PPC64LE.SHA_helpers.fsti | Vale.SHA.PPC64LE.SHA_helpers.sigma_0_1_partial | val sigma_0_1_partial : _: Vale.SHA.PPC64LE.SHA_helpers.counter -> _: Vale.SHA.PPC64LE.SHA_helpers.block_w
-> Vale.Def.Words_s.nat32 | let sigma_0_1_partial = opaque_make sigma_0_1_partial_def | {
"file_name": "vale/code/crypto/sha/Vale.SHA.PPC64LE.SHA_helpers.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 76,
"end_line": 86,
"start_col": 19,
"start_line": 86
} | module Vale.SHA.PPC64LE.SHA_helpers
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open FStar.Seq
open Vale.Arch.Types
open Vale.Def.Sel
open Vale.SHA2.Wrapper
open Vale.Def.Words.Four_s
unfold let (.[]) = FStar.Seq.index
#reset-options "--max_fuel 0 --max_ifuel 0"
// Specialize these definitions (from Spec.SHA2.fst) for SHA256
unfold let size_k_w_256 = 64
val word:Type0
(* Number of words for a block size *)
let size_block_w_256 = 16
(* Define the size block in bytes *)
let block_length =
4 (*word_length a*) * size_block_w_256
let block_w = m:seq word {length m = size_block_w_256}
let counter = nat
val k : (s:seq word {length s = size_k_w_256})
let hash256 = m:Seq.seq word {Seq.length m = 8}
(* Input data. *)
type byte = UInt8.t
type bytes = Seq.seq byte
(* Input data, multiple of a block length. *)
let bytes_blocks =
l:bytes { Seq.length l % block_length = 0 }
// Hide various SHA2 definitions
val ws_opaque (b:block_w) (t:counter{t < size_k_w_256}):nat32
val shuffle_core_opaque (block:block_w) (hash:hash256) (t:counter{t < size_k_w_256}):hash256
val update_multi_opaque (hash:hash256) (blocks:bytes_blocks):hash256
val update_multi_transparent (hash:hash256) (blocks:bytes_blocks):hash256
// Hide some functions that operate on words & bytes
val word_to_nat32 (x:word) : nat32
val nat32_to_word (x:nat32) : word
//unfold let bytes_blocks256 = bytes_blocks SHA2_256
let repeat_range_vale (max:nat { max < size_k_w_256}) (block:block_w) (hash:hash256) =
Spec.Loops.repeat_range 0 max (shuffle_core_opaque block) hash
let update_multi_opaque_vale (hash:hash256) (blocks:bytes) : hash256 =
if length blocks % size_k_w_256 = 0 then let b:bytes_blocks = blocks in update_multi_opaque hash b else hash
val make_ordered_hash (abcd efgh:quad32): Pure (hash256)
(requires True)
(ensures fun hash ->
length hash == 8 /\
hash.[0] == nat32_to_word abcd.lo0 /\
hash.[1] == nat32_to_word abcd.lo1 /\
hash.[2] == nat32_to_word abcd.hi2 /\
hash.[3] == nat32_to_word abcd.hi3 /\
hash.[4] == nat32_to_word efgh.lo0 /\
hash.[5] == nat32_to_word efgh.lo1 /\
hash.[6] == nat32_to_word efgh.hi2 /\
hash.[7] == nat32_to_word efgh.hi3
)
val update_block (hash:hash256) (block:block_w): hash256
val lemma_update_multi_opaque_vale_is_update_multi (hash:hash256) (blocks:bytes) : Lemma
(requires length blocks % 64 = 0)
(ensures update_multi_opaque_vale hash blocks == update_multi_transparent hash blocks)
val sigma_0_0_partial_def (t:counter) (block:block_w) : nat32
[@"opaque_to_smt"] let sigma_0_0_partial = opaque_make sigma_0_0_partial_def
irreducible let sigma_0_0_partial_reveal = opaque_revealer (`%sigma_0_0_partial) sigma_0_0_partial sigma_0_0_partial_def
val lemma_sha256_sigma0 (src:quad32) (t:counter) (block:block_w) : Lemma
(requires 16 <= t /\ t < size_k_w_256 /\
src.hi3 == ws_opaque block (t-15))
(ensures (sigma256_0_0 src.hi3 == sigma_0_0_partial t block)) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Spec.Loops.fst.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.SHA.PPC64LE.SHA_helpers.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.Hash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Vale.SHA.PPC64LE.SHA_helpers.counter -> _: Vale.SHA.PPC64LE.SHA_helpers.block_w
-> Vale.Def.Words_s.nat32 | Prims.Tot | [
"total"
] | [] | [
"Vale.Def.Opaque_s.opaque_make",
"Vale.SHA.PPC64LE.SHA_helpers.counter",
"Vale.SHA.PPC64LE.SHA_helpers.block_w",
"Vale.Def.Words_s.nat32",
"Vale.SHA.PPC64LE.SHA_helpers.sigma_0_1_partial_def"
] | [] | false | false | false | true | false | let sigma_0_1_partial =
| opaque_make sigma_0_1_partial_def | false |
|
Vale.SHA.PPC64LE.SHA_helpers.fsti | Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial_reveal | val sigma_1_1_partial_reveal : _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial_def) | let sigma_1_1_partial_reveal = opaque_revealer (`%sigma_1_1_partial) sigma_1_1_partial sigma_1_1_partial_def | {
"file_name": "vale/code/crypto/sha/Vale.SHA.PPC64LE.SHA_helpers.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 120,
"end_line": 105,
"start_col": 12,
"start_line": 105
} | module Vale.SHA.PPC64LE.SHA_helpers
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open FStar.Seq
open Vale.Arch.Types
open Vale.Def.Sel
open Vale.SHA2.Wrapper
open Vale.Def.Words.Four_s
unfold let (.[]) = FStar.Seq.index
#reset-options "--max_fuel 0 --max_ifuel 0"
// Specialize these definitions (from Spec.SHA2.fst) for SHA256
unfold let size_k_w_256 = 64
val word:Type0
(* Number of words for a block size *)
let size_block_w_256 = 16
(* Define the size block in bytes *)
let block_length =
4 (*word_length a*) * size_block_w_256
let block_w = m:seq word {length m = size_block_w_256}
let counter = nat
val k : (s:seq word {length s = size_k_w_256})
let hash256 = m:Seq.seq word {Seq.length m = 8}
(* Input data. *)
type byte = UInt8.t
type bytes = Seq.seq byte
(* Input data, multiple of a block length. *)
let bytes_blocks =
l:bytes { Seq.length l % block_length = 0 }
// Hide various SHA2 definitions
val ws_opaque (b:block_w) (t:counter{t < size_k_w_256}):nat32
val shuffle_core_opaque (block:block_w) (hash:hash256) (t:counter{t < size_k_w_256}):hash256
val update_multi_opaque (hash:hash256) (blocks:bytes_blocks):hash256
val update_multi_transparent (hash:hash256) (blocks:bytes_blocks):hash256
// Hide some functions that operate on words & bytes
val word_to_nat32 (x:word) : nat32
val nat32_to_word (x:nat32) : word
//unfold let bytes_blocks256 = bytes_blocks SHA2_256
let repeat_range_vale (max:nat { max < size_k_w_256}) (block:block_w) (hash:hash256) =
Spec.Loops.repeat_range 0 max (shuffle_core_opaque block) hash
let update_multi_opaque_vale (hash:hash256) (blocks:bytes) : hash256 =
if length blocks % size_k_w_256 = 0 then let b:bytes_blocks = blocks in update_multi_opaque hash b else hash
val make_ordered_hash (abcd efgh:quad32): Pure (hash256)
(requires True)
(ensures fun hash ->
length hash == 8 /\
hash.[0] == nat32_to_word abcd.lo0 /\
hash.[1] == nat32_to_word abcd.lo1 /\
hash.[2] == nat32_to_word abcd.hi2 /\
hash.[3] == nat32_to_word abcd.hi3 /\
hash.[4] == nat32_to_word efgh.lo0 /\
hash.[5] == nat32_to_word efgh.lo1 /\
hash.[6] == nat32_to_word efgh.hi2 /\
hash.[7] == nat32_to_word efgh.hi3
)
val update_block (hash:hash256) (block:block_w): hash256
val lemma_update_multi_opaque_vale_is_update_multi (hash:hash256) (blocks:bytes) : Lemma
(requires length blocks % 64 = 0)
(ensures update_multi_opaque_vale hash blocks == update_multi_transparent hash blocks)
val sigma_0_0_partial_def (t:counter) (block:block_w) : nat32
[@"opaque_to_smt"] let sigma_0_0_partial = opaque_make sigma_0_0_partial_def
irreducible let sigma_0_0_partial_reveal = opaque_revealer (`%sigma_0_0_partial) sigma_0_0_partial sigma_0_0_partial_def
val lemma_sha256_sigma0 (src:quad32) (t:counter) (block:block_w) : Lemma
(requires 16 <= t /\ t < size_k_w_256 /\
src.hi3 == ws_opaque block (t-15))
(ensures (sigma256_0_0 src.hi3 == sigma_0_0_partial t block))
val sigma_0_1_partial_def (t:counter) (block:block_w) : nat32
[@"opaque_to_smt"] let sigma_0_1_partial = opaque_make sigma_0_1_partial_def
irreducible let sigma_0_1_partial_reveal = opaque_revealer (`%sigma_0_1_partial) sigma_0_1_partial sigma_0_1_partial_def
val lemma_sha256_sigma1 (src:quad32) (t:counter) (block:block_w) : Lemma
(requires 16 <= t /\ t < size_k_w_256 /\
src.hi3 == ws_opaque block (t-2))
(ensures (sigma256_0_1 src.hi3 == sigma_0_1_partial t block))
val sigma_1_0_partial_def (t:counter) (block:block_w) (hash_orig:hash256) : nat32
[@"opaque_to_smt"] let sigma_1_0_partial = opaque_make sigma_1_0_partial_def
irreducible let sigma_1_0_partial_reveal = opaque_revealer (`%sigma_1_0_partial) sigma_1_0_partial sigma_1_0_partial_def
val lemma_sha256_sigma2 (src:quad32) (t:counter) (block:block_w) (hash_orig:hash256) : Lemma
(requires t < size_k_w_256 /\
src.hi3 == word_to_nat32 ((repeat_range_vale t block hash_orig).[0]))
(ensures (sigma256_1_0 src.hi3 == sigma_1_0_partial t block hash_orig))
val sigma_1_1_partial_def (t:counter) (block:block_w) (hash_orig:hash256) : nat32 | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Spec.Loops.fst.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.SHA.PPC64LE.SHA_helpers.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.Hash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial ==
Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial_def) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Opaque_s.opaque_revealer",
"Vale.SHA.PPC64LE.SHA_helpers.counter",
"Vale.SHA.PPC64LE.SHA_helpers.block_w",
"Vale.SHA.PPC64LE.SHA_helpers.hash256",
"Vale.Def.Words_s.nat32",
"Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial",
"Vale.SHA.PPC64LE.SHA_helpers.sigma_1_1_partial_def"
] | [] | true | false | true | false | false | let sigma_1_1_partial_reveal =
| opaque_revealer (`%sigma_1_1_partial) sigma_1_1_partial sigma_1_1_partial_def | false |
|
Vale.SHA.PPC64LE.SHA_helpers.fsti | Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale_64 | val repeat_range_vale_64 : block: Vale.SHA.PPC64LE.SHA_helpers.block_w -> hash: Vale.SHA.PPC64LE.SHA_helpers.hash256
-> Vale.SHA.PPC64LE.SHA_helpers.hash256 | let repeat_range_vale_64 (block:block_w) (hash:hash256) =
Spec.Loops.repeat_range 0 64 (shuffle_core_opaque block) hash | {
"file_name": "vale/code/crypto/sha/Vale.SHA.PPC64LE.SHA_helpers.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 63,
"end_line": 242,
"start_col": 0,
"start_line": 241
} | module Vale.SHA.PPC64LE.SHA_helpers
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open FStar.Seq
open Vale.Arch.Types
open Vale.Def.Sel
open Vale.SHA2.Wrapper
open Vale.Def.Words.Four_s
unfold let (.[]) = FStar.Seq.index
#reset-options "--max_fuel 0 --max_ifuel 0"
// Specialize these definitions (from Spec.SHA2.fst) for SHA256
unfold let size_k_w_256 = 64
val word:Type0
(* Number of words for a block size *)
let size_block_w_256 = 16
(* Define the size block in bytes *)
let block_length =
4 (*word_length a*) * size_block_w_256
let block_w = m:seq word {length m = size_block_w_256}
let counter = nat
val k : (s:seq word {length s = size_k_w_256})
let hash256 = m:Seq.seq word {Seq.length m = 8}
(* Input data. *)
type byte = UInt8.t
type bytes = Seq.seq byte
(* Input data, multiple of a block length. *)
let bytes_blocks =
l:bytes { Seq.length l % block_length = 0 }
// Hide various SHA2 definitions
val ws_opaque (b:block_w) (t:counter{t < size_k_w_256}):nat32
val shuffle_core_opaque (block:block_w) (hash:hash256) (t:counter{t < size_k_w_256}):hash256
val update_multi_opaque (hash:hash256) (blocks:bytes_blocks):hash256
val update_multi_transparent (hash:hash256) (blocks:bytes_blocks):hash256
// Hide some functions that operate on words & bytes
val word_to_nat32 (x:word) : nat32
val nat32_to_word (x:nat32) : word
//unfold let bytes_blocks256 = bytes_blocks SHA2_256
let repeat_range_vale (max:nat { max < size_k_w_256}) (block:block_w) (hash:hash256) =
Spec.Loops.repeat_range 0 max (shuffle_core_opaque block) hash
let update_multi_opaque_vale (hash:hash256) (blocks:bytes) : hash256 =
if length blocks % size_k_w_256 = 0 then let b:bytes_blocks = blocks in update_multi_opaque hash b else hash
val make_ordered_hash (abcd efgh:quad32): Pure (hash256)
(requires True)
(ensures fun hash ->
length hash == 8 /\
hash.[0] == nat32_to_word abcd.lo0 /\
hash.[1] == nat32_to_word abcd.lo1 /\
hash.[2] == nat32_to_word abcd.hi2 /\
hash.[3] == nat32_to_word abcd.hi3 /\
hash.[4] == nat32_to_word efgh.lo0 /\
hash.[5] == nat32_to_word efgh.lo1 /\
hash.[6] == nat32_to_word efgh.hi2 /\
hash.[7] == nat32_to_word efgh.hi3
)
val update_block (hash:hash256) (block:block_w): hash256
val lemma_update_multi_opaque_vale_is_update_multi (hash:hash256) (blocks:bytes) : Lemma
(requires length blocks % 64 = 0)
(ensures update_multi_opaque_vale hash blocks == update_multi_transparent hash blocks)
val sigma_0_0_partial_def (t:counter) (block:block_w) : nat32
[@"opaque_to_smt"] let sigma_0_0_partial = opaque_make sigma_0_0_partial_def
irreducible let sigma_0_0_partial_reveal = opaque_revealer (`%sigma_0_0_partial) sigma_0_0_partial sigma_0_0_partial_def
val lemma_sha256_sigma0 (src:quad32) (t:counter) (block:block_w) : Lemma
(requires 16 <= t /\ t < size_k_w_256 /\
src.hi3 == ws_opaque block (t-15))
(ensures (sigma256_0_0 src.hi3 == sigma_0_0_partial t block))
val sigma_0_1_partial_def (t:counter) (block:block_w) : nat32
[@"opaque_to_smt"] let sigma_0_1_partial = opaque_make sigma_0_1_partial_def
irreducible let sigma_0_1_partial_reveal = opaque_revealer (`%sigma_0_1_partial) sigma_0_1_partial sigma_0_1_partial_def
val lemma_sha256_sigma1 (src:quad32) (t:counter) (block:block_w) : Lemma
(requires 16 <= t /\ t < size_k_w_256 /\
src.hi3 == ws_opaque block (t-2))
(ensures (sigma256_0_1 src.hi3 == sigma_0_1_partial t block))
val sigma_1_0_partial_def (t:counter) (block:block_w) (hash_orig:hash256) : nat32
[@"opaque_to_smt"] let sigma_1_0_partial = opaque_make sigma_1_0_partial_def
irreducible let sigma_1_0_partial_reveal = opaque_revealer (`%sigma_1_0_partial) sigma_1_0_partial sigma_1_0_partial_def
val lemma_sha256_sigma2 (src:quad32) (t:counter) (block:block_w) (hash_orig:hash256) : Lemma
(requires t < size_k_w_256 /\
src.hi3 == word_to_nat32 ((repeat_range_vale t block hash_orig).[0]))
(ensures (sigma256_1_0 src.hi3 == sigma_1_0_partial t block hash_orig))
val sigma_1_1_partial_def (t:counter) (block:block_w) (hash_orig:hash256) : nat32
[@"opaque_to_smt"] let sigma_1_1_partial = opaque_make sigma_1_1_partial_def
irreducible let sigma_1_1_partial_reveal = opaque_revealer (`%sigma_1_1_partial) sigma_1_1_partial sigma_1_1_partial_def
val lemma_sha256_sigma3 (src:quad32) (t:counter) (block:block_w) (hash_orig:hash256) : Lemma
(requires t < size_k_w_256 /\
src.hi3 == word_to_nat32 ((repeat_range_vale t block hash_orig).[4]))
(ensures (sigma256_1_1 src.hi3 == sigma_1_1_partial t block hash_orig))
val make_seperated_hash (a b c d e f g h:nat32): Pure (hash256)
(requires True)
(ensures fun hash ->
length hash == 8 /\
hash.[0] == nat32_to_word a /\
hash.[1] == nat32_to_word b /\
hash.[2] == nat32_to_word c /\
hash.[3] == nat32_to_word d /\
hash.[4] == nat32_to_word e /\
hash.[5] == nat32_to_word f /\
hash.[6] == nat32_to_word g /\
hash.[7] == nat32_to_word h
)
val make_seperated_hash_quad32 (a b c d e f g h:quad32): Pure (hash256)
(requires True)
(ensures fun hash ->
length hash == 8 /\
hash.[0] == nat32_to_word a.hi3 /\
hash.[1] == nat32_to_word b.hi3 /\
hash.[2] == nat32_to_word c.hi3 /\
hash.[3] == nat32_to_word d.hi3 /\
hash.[4] == nat32_to_word e.hi3 /\
hash.[5] == nat32_to_word f.hi3 /\
hash.[6] == nat32_to_word g.hi3 /\
hash.[7] == nat32_to_word h.hi3
)
val lemma_make_seperated_hash (hash:hash256) (a b c d e f g h:quad32) : Lemma
(requires length hash == 8 /\
a.hi3 == word_to_nat32 hash.[0] /\
b.hi3 == word_to_nat32 hash.[1] /\
c.hi3 == word_to_nat32 hash.[2] /\
d.hi3 == word_to_nat32 hash.[3] /\
e.hi3 == word_to_nat32 hash.[4] /\
f.hi3 == word_to_nat32 hash.[5] /\
g.hi3 == word_to_nat32 hash.[6] /\
h.hi3 == word_to_nat32 hash.[7])
(ensures hash == make_seperated_hash_quad32 a b c d e f g h)
val lemma_vsel32 (a b c:nat32) : Lemma
(ensures (isel32 a b c = (iand32 c a) *^ (iand32 (inot32 c) b)))
val ch_256 (x y z:nat32):Pure(nat32)
(requires True)
(ensures fun a -> a == (iand32 x y) *^ (iand32 (inot32 x) z))
val lemma_eq_maj_xvsel32 (a b c:nat32) : Lemma
(ensures (isel32 c b (a *^ b) = (iand32 a b) *^ ((iand32 a c) *^ (iand32 b c))))
val maj_256 (x y z:nat32):Pure(nat32)
(requires True)
(ensures fun a -> a == (iand32 x y) *^ ((iand32 x z) *^ (iand32 y z)))
val lemma_sigma_0_0_partial (t:counter) (block:block_w) : Lemma
(requires 16 <= t /\ t < size_k_w_256)
(ensures (sigma256_0_0 (ws_opaque block (t-15)) == sigma_0_0_partial t block))
val lemma_sigma_0_1_partial (t:counter) (block:block_w) : Lemma
(requires 16 <= t /\ t < size_k_w_256)
(ensures (sigma256_0_1 (ws_opaque block (t-2)) == sigma_0_1_partial t block))
val lemma_sigma_1_0_partial (t:counter) (block:block_w) (hash_orig:hash256) : Lemma
(requires t < size_k_w_256)
(ensures (sigma256_1_0 (word_to_nat32 ((repeat_range_vale t block hash_orig).[0])) == sigma_1_0_partial t block hash_orig))
val lemma_sigma_1_1_partial (t:counter) (block:block_w) (hash_orig:hash256) : Lemma
(requires t < size_k_w_256)
(ensures (sigma256_1_1 (word_to_nat32 ((repeat_range_vale t block hash_orig).[4])) == sigma_1_1_partial t block hash_orig))
(* Abbreviations and lemmas for the code itself *)
let k_reqs (k_seq:seq quad32) : prop0 =
length k_seq == size_k_w_256 / 4 /\
(forall i . {:pattern (index k_seq i)} 0 <= i /\ i < (size_k_w_256/4) ==>
(k_seq.[i]).lo0 == word_to_nat32 (k.[4 * i]) /\
(k_seq.[i]).lo1 == word_to_nat32 (k.[4 * i + 1]) /\
(k_seq.[i]).hi2 == word_to_nat32 (k.[4 * i + 2]) /\
(k_seq.[i]).hi3 == word_to_nat32 (k.[4 * i + 3]))
let quads_to_block_be (qs:seq quad32) : block_w
=
let nat32_seq = Vale.Def.Words.Seq_s.seq_four_to_seq_BE qs in
let f (n:nat{n < 16}) : word = nat32_to_word (if n < length nat32_seq then nat32_seq.[n] else 0) in
init 16 f
val lemma_quads_to_block_be (qs:seq quad32) : Lemma
(requires length qs == 4)
(ensures
(let block = quads_to_block_be qs in
forall i . {:pattern (index qs i)} 0 <= i /\ i < 4 ==>
(qs.[i]).hi3 == ws_opaque block (4 * i + 0) /\
(qs.[i]).hi2 == ws_opaque block (4 * i + 1) /\
(qs.[i]).lo1 == ws_opaque block (4 * i + 2) /\
(qs.[i]).lo0 == ws_opaque block (4 * i + 3)))
let k_index (ks:seq quad32) (i:nat) : nat32 =
if length ks = size_k_w_256 / 4 && i < size_k_w_256 then four_select ks.[(i/4)] (i % 4)
else 0
val lemma_shuffle_core_properties (t:counter) (block:block_w) (hash_orig:hash256) : Lemma
(requires t < size_k_w_256)
(ensures (let hash = Spec.Loops.repeat_range 0 t (shuffle_core_opaque block) hash_orig in
let h = Spec.Loops.repeat_range 0 (t + 1) (shuffle_core_opaque block) hash_orig in
let a0 = word_to_nat32 hash.[0] in
let b0 = word_to_nat32 hash.[1] in
let c0 = word_to_nat32 hash.[2] in
let d0 = word_to_nat32 hash.[3] in
let e0 = word_to_nat32 hash.[4] in
let f0 = word_to_nat32 hash.[5] in
let g0 = word_to_nat32 hash.[6] in
let h0 = word_to_nat32 hash.[7] in
let t1 = add_wrap (add_wrap (add_wrap (add_wrap h0 (sigma256_1_1 e0)) (ch_256 e0 f0 g0)) (word_to_nat32 k.[t])) (ws_opaque block t) in
let t2 = add_wrap (sigma256_1_0 a0) (maj_256 a0 b0 c0) in
word_to_nat32 h.[0] == add_wrap t1 t2 /\
word_to_nat32 h.[1] == a0 /\
word_to_nat32 h.[2] == b0 /\
word_to_nat32 h.[3] == c0 /\
word_to_nat32 h.[4] == add_wrap d0 t1 /\
word_to_nat32 h.[5] == e0 /\
word_to_nat32 h.[6] == f0 /\
word_to_nat32 h.[7] == g0))
val lemma_ws_opaque (block:block_w) (t:counter) : Lemma
(requires 16 <= t && t < size_k_w_256)
(ensures (let sigma0 = sigma256_0_0 (ws_opaque block (t - 15)) in
let sigma1 = sigma256_0_1 (ws_opaque block (t - 2)) in
ws_opaque block t == add_wrap (add_wrap (add_wrap sigma1 (ws_opaque block (t - 7))) sigma0) (ws_opaque block (t - 16)))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Spec.Loops.fst.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.SHA.PPC64LE.SHA_helpers.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.Hash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | block: Vale.SHA.PPC64LE.SHA_helpers.block_w -> hash: Vale.SHA.PPC64LE.SHA_helpers.hash256
-> Vale.SHA.PPC64LE.SHA_helpers.hash256 | Prims.Tot | [
"total"
] | [] | [
"Vale.SHA.PPC64LE.SHA_helpers.block_w",
"Vale.SHA.PPC64LE.SHA_helpers.hash256",
"Spec.Loops.repeat_range",
"Vale.SHA.PPC64LE.SHA_helpers.shuffle_core_opaque"
] | [] | false | false | false | true | false | let repeat_range_vale_64 (block: block_w) (hash: hash256) =
| Spec.Loops.repeat_range 0 64 (shuffle_core_opaque block) hash | false |
|
MerkleTree.Spec.fst | MerkleTree.Spec.extract | val extract:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> #i:nat{i <= pow2 n} -> mt_collide #_ #f n i -> GTot hash2_raw_collide | val extract:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> #i:nat{i <= pow2 n} -> mt_collide #_ #f n i -> GTot hash2_raw_collide | let rec extract #hsz #f #n #i (Collision t1 t2) =
assert(n = 0 ==> S.equal t1 t2); // excludes n = 0
mt_left_right t1; mt_left_right t2;
mt_get_root_step #_ #f t1;
mt_get_root_step #_ #f t2;
rpmt_get_root_pad t1;
assert(i <> 0);
let l1 = rpmt_left t1 in
let l2 = rpmt_left t2 in
let r1 = rpmt_right t1 in
let r2 = rpmt_right t2 in
if i <= pow2 (n-1)
then (
rpmt_get_root_pad r1; rpmt_get_root_pad r2;
rpmt_i_0 #_ #f r1; rpmt_i_0 #_ #f r2;
extract (Collision l1 l2))
else (
rpmt_get_root_raw l1; rpmt_get_root_raw l2;
rpmt_get_root_raw r1; rpmt_get_root_raw r2;
let HRaw lh1 = mt_get_root #_ #f l1 in
let HRaw lh2 = mt_get_root #_ #f l2 in
let HRaw rh1 = mt_get_root #_ #f r1 in
let HRaw rh2 = mt_get_root #_ #f r2 in
if StrongExcludedMiddle.strong_excluded_middle (lh1 =!= lh2) ||
StrongExcludedMiddle.strong_excluded_middle (rh1 =!= rh2)
then Collision2 #_ #f lh1 rh1 lh2 rh2
else if StrongExcludedMiddle.strong_excluded_middle (l1 == l2)
then extract (Collision r1 r2)
else extract (Collision l1 l2)) | {
"file_name": "src/MerkleTree.Spec.fst",
"git_rev": "7d7bdc20f2033171e279c176b26e84f9069d23c6",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | {
"end_col": 37,
"end_line": 516,
"start_col": 0,
"start_line": 488
} | module MerkleTree.Spec
open FStar.Classical
open FStar.Mul
open FStar.Seq
module S = FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10"
// For SHA2_256, this is is a sequence of 32 bytes
// These are secret bytes, hence not an eqtype
type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz }
type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz)
val sha256_compress: hash_fun_t #32
let sha256_compress src1 src2 =
let sz = Spec.Hash.Definitions.SHA2_256 in
let hash_alg = Spec.Hash.Definitions.SHA2_256 in
let acc = Spec.Agile.Hash.init hash_alg in
let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in
Spec.Agile.Hash.finish hash_alg acc ()
/// For simplicity, we will specify the root for a sequence of [i]
/// tags where [i <= 2^n] as the root of a full binary tree with [2^n]
/// leaves obtained by padding the sequence with dummies. This
/// requires extending the definitions of hashes and hash functions. Our
/// extended definition of hash justifies skipping any concrete
/// computation on dummies.
noeq
type padded_hash #hsz =
| HRaw: hr:hash #hsz -> padded_hash #hsz
| HPad // right padding to make the size of a Merkle tree a power of 2
val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz)
let padded_hash_fun #hsz f lh rh =
allow_inversion (padded_hash #hsz);
match lh, rh with
| HPad , _ -> HPad
| _ , HPad -> lh
| HRaw lhr, HRaw rhr -> HRaw (f lhr rhr)
noextract
val hashes (#hsz:pos): Type0
let hashes #hsz = S.seq (padded_hash #hsz)
type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n}
val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz)
let mt_get #_ #_ mt idx = S.index mt idx
unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)
#push-options "--max_fuel 1"
val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1))
val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1)
let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n)
val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (S.equal mt (mt_left mt @| mt_right mt))
let mt_left_right #_ #_ mt = ()
val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n})
let rec hs_next_lv #hsz #f #n hs =
if n = 0 then S.empty
else S.cons
(padded_hash_fun #hsz f hs.[0] hs.[1])
(hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs)))
val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} ->
Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1])
let rec hs_next_lv_index #hsz #f #n hs i =
if n = 0 || i = 0 then ()
else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1)
val hs_next_lv_slice:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} ->
Lemma (requires True)
(ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j)))
(S.slice (hs_next_lv #hsz #f #n hs) i j))
(decreases (j - i))
let rec hs_next_lv_slice #hsz #f #n hs i j =
if i = j then ()
else begin
let x = S.slice hs (2 * i) (2 * j) in
assert (S.equal (hs_next_lv #hsz #f #(j - i) x)
(S.cons (padded_hash_fun #hsz f x.[0] x.[1])
(hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x)))));
hs_next_lv_slice #hsz #f #n hs (i + 1) j;
hs_next_lv_index #hsz #f #n hs i
end
val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1))
let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt
val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_left #hsz #f #n mt =
hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2))
val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n ->
Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt)))
let mt_next_lv_mt_right #hsz #f #n mt =
hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1))
val hs_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= 2 * n} ->
hs1:hashes{S.length hs1 = 2 * n} ->
hs2:hashes{S.length hs2 = 2 * n} ->
Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j))
(ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2))
(S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2)))
let hs_next_lv_equiv #hsz #f j n hs1 hs2 =
forall_intro (hs_next_lv_index #_ #f #n hs1);
forall_intro (hs_next_lv_index #_ #f #n hs2);
let hs1' = hs_next_lv #_ #f #n hs1 in
let hs2' = hs_next_lv #_ #f #n hs2 in
assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]);
assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]);
assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]);
assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]);
assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i])
val mt_next_lv_equiv:
#hsz:pos -> #f:hash_fun_t #hsz ->
j:nat -> n:pos{j <= pow2 n} ->
mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n ->
Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j))
(ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2))
(S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2)))
let mt_next_lv_equiv #hsz #f j n mt1 mt2 =
hs_next_lv_equiv #_ #f j (pow2 (n-1)) mt1 mt2
val hs_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes #hsz {S.length hs = 2 * n} ->
nhs:hashes #hsz {S.length nhs = n} ->
GTot Type0
let hs_next_rel #hsz #f n hs nhs =
forall (i:nat{i < n}).
S.index nhs i ==
padded_hash_fun #hsz f (S.index hs (2 * i)) (S.index hs (2 * i + 1))
val mt_next_rel:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
GTot Type0
let mt_next_rel #hsz #f n mt nmt =
hs_next_rel #hsz #f (pow2 (n-1)) mt nmt
val hs_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:nat ->
hs:hashes{S.length hs = 2 * n} ->
nhs:hashes{S.length nhs = n} ->
Lemma (requires hs_next_rel #_ #f n hs nhs)
(ensures S.equal nhs (hs_next_lv #_ #f #n hs))
let rec hs_next_rel_next_lv #hsz #f n hs nhs =
if n = 0 then ()
else hs_next_rel_next_lv #_ #f (n - 1)
(S.slice hs 2 (S.length hs))
(S.slice nhs 1 (S.length nhs))
val mt_next_rel_next_lv:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures S.equal nmt (mt_next_lv #_ #f mt))
let mt_next_rel_next_lv #hsz #f n mt nmt =
hs_next_rel_next_lv #_ #f (pow2 (n-1)) mt nmt
val mt_next_rel_upd_even:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i) v)
(S.upd nmt i (padded_hash_fun #hsz f v (S.index mt (2 * i + 1)))))
let mt_next_rel_upd_even #hsz #f n mt nmt i v = ()
#push-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
val mt_next_rel_upd_even_pad:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree #hsz (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash #hsz ->
Lemma (requires (mt_next_rel #_ #f n mt nmt) /\ (S.index mt (2 * i + 1) == HPad))
(ensures (mt_next_rel #_ #f n (S.upd mt (2 * i) v) (S.upd nmt i v)))
let mt_next_rel_upd_even_pad #hsz #f n mt nmt i v = ()
#pop-options
val mt_next_rel_upd_odd:
#hsz:pos -> #f:hash_fun_t #hsz ->
n:pos ->
mt:merkle_tree #hsz n ->
nmt:merkle_tree (n - 1) ->
i:nat{i < pow2 (n-1)} ->
v:padded_hash ->
Lemma (requires mt_next_rel #_ #f n mt nmt)
(ensures mt_next_rel #_ #f n
(S.upd mt (2 * i + 1) v)
(S.upd nmt i (padded_hash_fun #_ f (S.index mt (2 * i)) v)))
let mt_next_rel_upd_odd #hsz #f n mt nmt i v = ()
// fournet: just [root]?
val mt_get_root:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n -> GTot (padded_hash #hsz)
let rec mt_get_root #hsz #f #n mt =
if n = 0 then mt.[0]
else mt_get_root #_ #f (mt_next_lv #_ #f mt)
#push-options "--initial_fuel 2 --max_fuel 2"
val mt_get_root_step: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n ->
Lemma (mt_get_root #_ #f mt ==
padded_hash_fun #_ f (mt_get_root #_ #f (mt_left mt)) (mt_get_root #_ #f (mt_right mt)))
let rec mt_get_root_step #hsz #f #n mt =
if n = 1 then ()
else begin
mt_get_root_step #_ #f (mt_next_lv #_ #f mt);
mt_next_lv_mt_left #_ #f mt;
mt_next_lv_mt_right #_ #f mt
end
#pop-options
type path #hsz n = S.lseq (padded_hash #hsz) n
/// We first specify full paths, including padding.
val mt_get_path:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
mt:merkle_tree #hsz n -> i:nat{i < pow2 n} -> GTot (path #hsz n)
let rec mt_get_path #hsz #f #n t i =
if n = 0 then S.empty
else S.cons
(if i % 2 = 0 then t.[i + 1] else t.[i - 1])
(mt_get_path #_ #f (mt_next_lv #_ #f t) (i / 2))
val mt_verify_:
#hsz:pos -> #f:hash_fun_t #hsz ->#n:nat ->
p:path #hsz n -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> GTot (padded_hash #hsz)
let rec mt_verify_ #hsz #f #n p idx h =
if n = 0 then h
else mt_verify_ #_ #f #(n-1) (S.tail p) (idx / 2)
(if idx % 2 = 0
then padded_hash_fun #_ f h (S.head p)
else padded_hash_fun #_ f (S.head p) h)
val mt_verify:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
p:(path #hsz n) -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> padded_hash #hsz -> GTot prop
let mt_verify #hsz #f #n p idx h rt =
rt == mt_verify_ #_ #f p idx h
/// Correctness: the root of a tree is correctly recomputed from any of its paths
val hs_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
hs:hashes{S.length hs = 2 * n} -> idx:nat{idx < 2 * n} ->
Lemma ((hs_next_lv #_ #f #n hs).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f hs.[idx] hs.[idx + 1]
else padded_hash_fun #_ f hs.[idx - 1] hs.[idx]))
let rec hs_next_lv_get #hsz #f #n hs idx =
if idx < 2 then ()
else hs_next_lv_get #_ #f #(n-1) (S.slice hs 2 (S.length hs)) (idx - 2)
val mt_next_lv_get:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:pos ->
mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} ->
Lemma (
(mt_next_lv #_ #f mt).[idx / 2] ==
(if idx % 2 = 0
then padded_hash_fun #_ f mt.[idx] mt.[idx + 1]
else padded_hash_fun #_ f mt.[idx - 1] mt.[idx]))
let mt_next_lv_get #hsz #f #n mt idx =
hs_next_lv_get #_ #f #(pow2 (n-1)) mt idx
val mt_get_path_ok_:
#hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->
t:merkle_tree #hsz n -> i:nat{i < pow2 n} ->
Lemma (mt_verify_ #_ #f (mt_get_path #_ #f t i) i (mt_get t i) == mt_get_root #_ #f t)
let rec mt_get_path_ok_ #hsz #f #n mt idx =
if n = 0 then ()
else begin
assert (S.head (mt_get_path #_ #f mt idx) ==
(if idx % 2 = 0 then mt.[idx + 1] else mt.[idx - 1]));
assert (S.equal (S.tail (mt_get_path #_ #f mt idx))
(mt_get_path #_ #f (mt_next_lv #_ #f mt) (idx / 2)));
mt_get_path_ok_ #_ #f (mt_next_lv #_ #f mt) (idx / 2);
mt_next_lv_get #_ #f mt idx
end
/// Security: we reduce tree collisions to collisions on the hash
/// compression function. Such collisions yield collisions on the SHA2
/// standard (by adding the same length and padding to the
/// accumulators).
///
/// One complication addressed in the proof is the handling of
/// implicit padding.
/// All hashes in a sequence are raw hashes, not padding
val raw_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes #hsz -> Tot Type0 (decreases (S.length hs))
let rec raw_hashes #hsz #f hs =
if S.length hs = 0 then True
else (HRaw? (S.head hs) /\ raw_hashes #_ #f (S.tail hs))
val raw_hashes_raws:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes{raw_hashes #hsz #f hs} ->
Tot (S.seq (hash #hsz)) (decreases (S.length hs))
let rec raw_hashes_raws #hsz #f hs =
if S.length hs = 0 then S.empty
else S.cons (HRaw?.hr (S.head hs)) (raw_hashes_raws #_ #f (S.tail hs))
val raw_hashes_index:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat{i < S.length hs} ->
Lemma (requires raw_hashes #_ #f hs)
(ensures HRaw? #hsz hs.[i])
(decreases i)
let rec raw_hashes_index #hsz #f hs i =
if i = 0 then ()
else raw_hashes_index #_ #f (S.tail hs) (i - 1)
val raw_hashes_slice:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat -> j:nat{i <= j && j <= S.length hs} ->
Lemma (requires raw_hashes #_ #f hs)
(ensures raw_hashes #_ #f (S.slice hs i j))
(decreases (j - i))
let rec raw_hashes_slice #hsz #f hs i j =
if i = j then ()
else (
raw_hashes_index #_ #f hs i;
raw_hashes_slice #_ #f hs (i + 1) j)
/// All hashes in a sequence are just padding
val pad_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes #hsz -> Type0
let pad_hashes #hsz #f hs =
S.equal hs (S.create (S.length hs) HPad)
val pad_hashes_slice:
#hsz:pos -> #f:hash_fun_t #hsz ->
hs:hashes -> i:nat -> j:nat{i <= j && j <= S.length hs} ->
Lemma (requires pad_hashes #_ #f hs)
(ensures pad_hashes #_ #f (S.slice hs i j))
(decreases (j - i))
let rec pad_hashes_slice #hsz #f hs i j =
if i = j then ()
else pad_hashes_slice #_ #f hs (i + 1) j
/// Right-padded Merkle tree, a tree refinement
let rpmt (#hsz:pos) (#f:hash_fun_t) (n:nat) (i:nat{i <= pow2 n}) =
mt:merkle_tree #hsz n {
raw_hashes #_ #f (S.slice mt 0 i) /\
pad_hashes #_ #f (S.slice mt i (S.length mt)) }
val rpmt_raws: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #hsz #f n i -> S.seq (hash #hsz)
let rpmt_raws #hsz #f #n #i mt = raw_hashes_raws #_ #f (S.slice mt 0 i)
val rpmt_i_0: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> mt:rpmt #hsz #f n 0 ->
Lemma (S.equal mt (S.create (pow2 n) (HPad #hsz)))
let rpmt_i_0 #hsz #f #n mt = ()
val rpmt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> #i:nat{i <= pow2 n} -> rpmt #hsz #f n i ->
rpmt #hsz #f (n-1) (if i <= pow2 (n-1) then i else pow2 (n-1))
let rpmt_left #hsz #f #n #i mt =
if i <= pow2 (n-1)
then pad_hashes_slice #_ #f (S.slice mt i (S.length mt)) 0 (pow2 (n-1) - i)
else raw_hashes_slice #_ #f (S.slice mt 0 i) 0 (pow2 (n-1));
mt_left mt
#push-options "--z3rlimit 40"
val rpmt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> #i:nat{i <= pow2 n} -> rpmt #hsz #f n i ->
rpmt #_ #f (n-1) (if i <= pow2 (n-1) then 0 else i - pow2 (n-1))
let rpmt_right #hsz #f #n #i mt =
if i <= pow2 (n-1)
then pad_hashes_slice #_ #f (S.slice mt i (S.length mt)) (pow2 (n-1) - i) (pow2 n - i)
else raw_hashes_slice #_ #f (S.slice mt 0 i) (pow2 (n-1)) i;
mt_right mt
/// Two right-padded Merkle trees collide when
/// 1) they have the same height (`n`) and number of raw hashes (`i`),
/// 2) their contents differ, and
/// 3) their roots are same.
// fournet: we may want to work towards removing 1) using a hash prefix
noeq
type mt_collide (#hsz:pos) (#f:hash_fun_t #hsz) (n:nat) (i:nat{i <= pow2 n}) = | Collision:
mt1:rpmt #_ #f n i -> mt2:rpmt #_ #f n i {
mt1 =!= mt2 /\
mt_get_root #_ #f #_ mt1 == mt_get_root #_ #f #_ mt2 } -> mt_collide #_ #f n i
noeq
type hash2_raw_collide = | Collision2:
#hsz:pos -> #f:hash_fun_t #hsz ->
lh1:hash -> rh1:hash ->
lh2:hash -> rh2:hash {
(lh1 =!= lh2 \/ rh1 =!= rh2) /\
f lh1 rh1 == f lh2 rh2 } -> hash2_raw_collide
/// Auxiliary lemmas for the proof
val rpmt_pad_hashes_0:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #_ #f n i ->
Lemma (i = 0 <==> pad_hashes #_ #f mt )
let rpmt_pad_hashes_0 #_ #_ #n #i mt = ()
val rpmt_pad_hashes_index_0:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> #i:nat{i <= pow2 n} ->
mt:rpmt #_ #f n i ->
Lemma (pad_hashes #_ #f mt <==> HPad? mt.[0])
let rpmt_pad_hashes_index_0 #_ #_ #n #i mt = ()
val mt_get_root_pad_index_0:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> mt:merkle_tree #hsz n ->
Lemma (HPad? mt.[0] <==> HPad? (mt_get_root #_ #f mt))
let rec mt_get_root_pad_index_0 #hsz #f #n (mt:merkle_tree #hsz n) =
if n = 0 then ()
else
let mt:merkle_tree #hsz (n-1) = mt_next_lv #_ #f #n mt in
mt_get_root_pad_index_0 #_ #f #(n-1) mt
#pop-options
val rpmt_get_root_pad_hashes:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #_ #f n i ->
Lemma (pad_hashes #_ #f mt <==> HPad? (mt_get_root #_ #f mt))
let rpmt_get_root_pad_hashes #_ #f #n #i mt =
rpmt_pad_hashes_index_0 #_ #f mt;
mt_get_root_pad_index_0 #_ #f mt
val rpmt_get_root_pad:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #_ #f n i ->
Lemma (i = 0 <==> HPad? (mt_get_root #_ #f mt))
let rpmt_get_root_pad #_ #f #n #i mt =
rpmt_get_root_pad_hashes #_ #f mt;
rpmt_pad_hashes_0 #_ #f mt
val rpmt_get_root_raw:
#hsz:pos -> #f:hash_fun_t #hsz ->
#n:nat -> #i:nat{i <= pow2 n} -> mt:rpmt #_ #f n i ->
Lemma (i > 0 <==> HRaw? (mt_get_root #_ #f mt))
let rpmt_get_root_raw #hsz #f #n #i mt =
allow_inversion (padded_hash #hsz);
rpmt_get_root_pad #_ #f mt
#push-options "--z3rlimit 100"
val extract:
#hsz:pos -> #f:hash_fun_t #hsz -> | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Spec.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: MerkleTree.Spec.mt_collide n i -> Prims.GTot MerkleTree.Spec.hash2_raw_collide | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.pos",
"MerkleTree.Spec.hash_fun_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.pow2",
"MerkleTree.Spec.mt_collide",
"MerkleTree.Spec.rpmt",
"Prims.l_and",
"Prims.l_not",
"Prims.eq2",
"MerkleTree.Spec.padded_hash",
"MerkleTree.Spec.mt_get_root",
"Prims.op_Subtraction",
"MerkleTree.Spec.extract",
"Prims.bool",
"MerkleTree.Spec.Collision",
"Prims.unit",
"MerkleTree.Spec.rpmt_i_0",
"MerkleTree.Spec.rpmt_get_root_pad",
"MerkleTree.Spec.hash",
"Prims.op_BarBar",
"FStar.StrongExcludedMiddle.strong_excluded_middle",
"MerkleTree.Spec.Collision2",
"MerkleTree.Spec.hash2_raw_collide",
"MerkleTree.Spec.rpmt_get_root_raw",
"MerkleTree.Spec.rpmt_right",
"MerkleTree.Spec.rpmt_left",
"Prims._assert",
"Prims.op_disEquality",
"Prims.int",
"MerkleTree.Spec.mt_get_root_step",
"MerkleTree.Spec.mt_left_right",
"Prims.l_imp",
"Prims.op_Equality",
"FStar.Seq.Base.equal"
] | [
"recursion"
] | false | false | false | false | false | let rec extract #hsz #f #n #i (Collision t1 t2) =
| assert (n = 0 ==> S.equal t1 t2);
mt_left_right t1;
mt_left_right t2;
mt_get_root_step #_ #f t1;
mt_get_root_step #_ #f t2;
rpmt_get_root_pad t1;
assert (i <> 0);
let l1 = rpmt_left t1 in
let l2 = rpmt_left t2 in
let r1 = rpmt_right t1 in
let r2 = rpmt_right t2 in
if i <= pow2 (n - 1)
then
(rpmt_get_root_pad r1;
rpmt_get_root_pad r2;
rpmt_i_0 #_ #f r1;
rpmt_i_0 #_ #f r2;
extract (Collision l1 l2))
else
(rpmt_get_root_raw l1;
rpmt_get_root_raw l2;
rpmt_get_root_raw r1;
rpmt_get_root_raw r2;
let HRaw lh1 = mt_get_root #_ #f l1 in
let HRaw lh2 = mt_get_root #_ #f l2 in
let HRaw rh1 = mt_get_root #_ #f r1 in
let HRaw rh2 = mt_get_root #_ #f r2 in
if
StrongExcludedMiddle.strong_excluded_middle (lh1 =!= lh2) ||
StrongExcludedMiddle.strong_excluded_middle (rh1 =!= rh2)
then Collision2 #_ #f lh1 rh1 lh2 rh2
else
if StrongExcludedMiddle.strong_excluded_middle (l1 == l2)
then extract (Collision r1 r2)
else extract (Collision l1 l2)) | false |
Vale.Curve25519.FastHybrid_helpers.fst | Vale.Curve25519.FastHybrid_helpers.lemma_fast_mul1 | val lemma_fast_mul1 (a:nat)
(b a0 a1 a2 a3
ba0_hi ba0_lo
ba1_hi ba1_lo
ba2_hi ba2_lo
ba3_hi ba3_lo
s1 s2 s3 s4:nat64) : Lemma
(requires a = pow2_four a0 a1 a2 a3 /\
pow2_64 * ba0_hi + ba0_lo == b * a0 /\
pow2_64 * ba1_hi + ba1_lo == b * a1 /\
pow2_64 * ba2_hi + ba2_lo == b * a2 /\
pow2_64 * ba3_hi + ba3_lo == b * a3 /\
(let s1', c1 = add_carry ba1_lo ba0_hi 0 in
let s2', c2 = add_carry ba2_lo ba1_hi c1 in
let s3', c3 = add_carry ba3_lo ba2_hi c2 in
let s4', c4 = add_carry ba3_hi 0 c3 in
s1 == s1' /\
s2 == s2' /\
s3 == s3' /\
s4 == s4' /\
c4 == 0)
)
(ensures pow2_five ba0_lo s1 s2 s3 s4 == a * b) | val lemma_fast_mul1 (a:nat)
(b a0 a1 a2 a3
ba0_hi ba0_lo
ba1_hi ba1_lo
ba2_hi ba2_lo
ba3_hi ba3_lo
s1 s2 s3 s4:nat64) : Lemma
(requires a = pow2_four a0 a1 a2 a3 /\
pow2_64 * ba0_hi + ba0_lo == b * a0 /\
pow2_64 * ba1_hi + ba1_lo == b * a1 /\
pow2_64 * ba2_hi + ba2_lo == b * a2 /\
pow2_64 * ba3_hi + ba3_lo == b * a3 /\
(let s1', c1 = add_carry ba1_lo ba0_hi 0 in
let s2', c2 = add_carry ba2_lo ba1_hi c1 in
let s3', c3 = add_carry ba3_lo ba2_hi c2 in
let s4', c4 = add_carry ba3_hi 0 c3 in
s1 == s1' /\
s2 == s2' /\
s3 == s3' /\
s4 == s4' /\
c4 == 0)
)
(ensures pow2_five ba0_lo s1 s2 s3 s4 == a * b) | let lemma_fast_mul1 (a:nat)
(b a0 a1 a2 a3
ba0_hi ba0_lo
ba1_hi ba1_lo
ba2_hi ba2_lo
ba3_hi ba3_lo
s1 s2 s3 s4:nat64) : Lemma
(requires a = pow2_four a0 a1 a2 a3 /\
pow2_64 * ba0_hi + ba0_lo == b * a0 /\
pow2_64 * ba1_hi + ba1_lo == b * a1 /\
pow2_64 * ba2_hi + ba2_lo == b * a2 /\
pow2_64 * ba3_hi + ba3_lo == b * a3 /\
(let s1', c1 = add_carry ba1_lo ba0_hi 0 in
let s2', c2 = add_carry ba2_lo ba1_hi c1 in
let s3', c3 = add_carry ba3_lo ba2_hi c2 in
let s4', c4 = add_carry ba3_hi 0 c3 in
s1 == s1' /\
s2 == s2' /\
s3 == s3' /\
s4 == s4' /\
c4 == 0)
)
(ensures pow2_five ba0_lo s1 s2 s3 s4 == a * b)
=
assert_by_tactic (b * pow2_four a0 a1 a2 a3 == pow2_four (b*a0) (b*a1) (b*a2) (b*a3)) int_canon;
//lemma_prod_bounds ba0_hi ba0_lo b a0;
//lemma_prod_bounds ba1_hi ba1_lo b a1;
//lemma_prod_bounds ba2_hi ba2_lo b a2;
//lemma_prod_bounds ba3_hi ba3_lo b a3;
() | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.FastHybrid_helpers.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 73,
"start_col": 0,
"start_line": 42
} | module Vale.Curve25519.FastHybrid_helpers
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
open FStar.Tactics
open FStar.Tactics.CanonCommSemiring
open Vale.Curve25519.Fast_defs
open Vale.Curve25519.Fast_lemmas_internal
#reset-options "--max_fuel 0 --max_ifuel 0 --using_facts_from '* -FStar.Tactics -FStar.Reflection'"
let lemma_carry_prime (a0 a1 a2 a3 a0' a1' a2' a3' carry_in:nat64) (carry:bit) : Lemma
(requires pow2_five a0' a1' a2' a3' carry == pow2_four a0 a1 a2 a3 + carry_in * 38 /\
carry_in * 38 - 1 + 38 < pow2_64)
(ensures a0' + carry * 38 < pow2_64 /\
(pow2_four (a0' + carry * 38) a1' a2' a3') % prime == (pow2_four a0 a1 a2 a3 + carry_in * pow2_256) % prime)
=
assert (a0' + carry * 38 < pow2_64);
calc (==) {
(pow2_four a0 a1 a2 a3 + carry_in * pow2_256) % prime;
== { lemma_mul_pow256_add (pow2_four a0 a1 a2 a3) carry_in }
(pow2_four a0 a1 a2 a3 + carry_in * 38) % prime;
== {}
(pow2_five a0' a1' a2' a3' carry) % prime;
== { _ by (int_canon()) }
(pow2_four a0' a1' a2' a3' + (carry * pow2_256)) % prime;
== { lemma_mul_pow256_add (pow2_four a0' a1' a2' a3') carry }
(pow2_four a0' a1' a2' a3' + (carry * 38)) % prime;
== { calc (==) {
(pow2_four a0' a1' a2' a3') + (carry * 38);
== { _ by (int_canon()) }
pow2_four (a0' + carry * 38) a1' a2' a3';
}
}
(pow2_four (a0' + carry * 38) a1' a2' a3') % prime;
};
() | {
"checked_file": "/",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_lemmas_internal.fsti.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"prims.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Curve25519.FastHybrid_helpers.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_internal",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 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": 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"
} | false |
a: Prims.nat ->
b: Vale.Def.Types_s.nat64 ->
a0: Vale.Def.Types_s.nat64 ->
a1: Vale.Def.Types_s.nat64 ->
a2: Vale.Def.Types_s.nat64 ->
a3: Vale.Def.Types_s.nat64 ->
ba0_hi: Vale.Def.Types_s.nat64 ->
ba0_lo: Vale.Def.Types_s.nat64 ->
ba1_hi: Vale.Def.Types_s.nat64 ->
ba1_lo: Vale.Def.Types_s.nat64 ->
ba2_hi: Vale.Def.Types_s.nat64 ->
ba2_lo: Vale.Def.Types_s.nat64 ->
ba3_hi: Vale.Def.Types_s.nat64 ->
ba3_lo: Vale.Def.Types_s.nat64 ->
s1: Vale.Def.Types_s.nat64 ->
s2: Vale.Def.Types_s.nat64 ->
s3: Vale.Def.Types_s.nat64 ->
s4: Vale.Def.Types_s.nat64
-> FStar.Pervasives.Lemma
(requires
a = Vale.Curve25519.Fast_defs.pow2_four a0 a1 a2 a3 /\
Vale.Def.Words_s.pow2_64 * ba0_hi + ba0_lo == b * a0 /\
Vale.Def.Words_s.pow2_64 * ba1_hi + ba1_lo == b * a1 /\
Vale.Def.Words_s.pow2_64 * ba2_hi + ba2_lo == b * a2 /\
Vale.Def.Words_s.pow2_64 * ba3_hi + ba3_lo == b * a3 /\
(let _ = Vale.Curve25519.Fast_defs.add_carry ba1_lo ba0_hi 0 in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ s1' c1 = _ in
let _ = Vale.Curve25519.Fast_defs.add_carry ba2_lo ba1_hi c1 in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ s2' c2 = _ in
let _ = Vale.Curve25519.Fast_defs.add_carry ba3_lo ba2_hi c2 in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ s3' c3 = _ in
let _ = Vale.Curve25519.Fast_defs.add_carry ba3_hi 0 c3 in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ s4' c4 = _ in
s1 == s1' /\ s2 == s2' /\ s3 == s3' /\ s4 == s4' /\ c4 == 0)
<:
Prims.logical)
<:
Prims.logical)
<:
Prims.logical)
<:
Prims.logical)) (ensures Vale.Curve25519.Fast_defs.pow2_five ba0_lo s1 s2 s3 s4 == a * b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Vale.Def.Types_s.nat64",
"Prims.unit",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"Prims.int",
"FStar.Mul.op_Star",
"Vale.Curve25519.Fast_defs.pow2_four",
"Vale.Curve25519.FastHybrid_helpers.int_canon",
"Prims.l_and",
"Prims.b2t",
"Prims.op_Equality",
"Prims.op_Addition",
"Vale.Def.Words_s.pow2_64",
"Prims.op_BarBar",
"Prims.logical",
"FStar.Pervasives.Native.tuple2",
"Vale.Def.Words_s.nat64",
"Vale.Curve25519.Fast_defs.add_carry",
"Prims.squash",
"Vale.Curve25519.Fast_defs.pow2_five",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let lemma_fast_mul1
(a: nat)
(b a0 a1 a2 a3 ba0_hi ba0_lo ba1_hi ba1_lo ba2_hi ba2_lo ba3_hi ba3_lo s1 s2 s3 s4: nat64)
: Lemma
(requires
a = pow2_four a0 a1 a2 a3 /\ pow2_64 * ba0_hi + ba0_lo == b * a0 /\
pow2_64 * ba1_hi + ba1_lo == b * a1 /\ pow2_64 * ba2_hi + ba2_lo == b * a2 /\
pow2_64 * ba3_hi + ba3_lo == b * a3 /\
(let s1', c1 = add_carry ba1_lo ba0_hi 0 in
let s2', c2 = add_carry ba2_lo ba1_hi c1 in
let s3', c3 = add_carry ba3_lo ba2_hi c2 in
let s4', c4 = add_carry ba3_hi 0 c3 in
s1 == s1' /\ s2 == s2' /\ s3 == s3' /\ s4 == s4' /\ c4 == 0))
(ensures pow2_five ba0_lo s1 s2 s3 s4 == a * b) =
| assert_by_tactic (b * pow2_four a0 a1 a2 a3 == pow2_four (b * a0) (b * a1) (b * a2) (b * a3))
int_canon;
() | false |
Vale.SHA.PPC64LE.SHA_helpers.fsti | Vale.SHA.PPC64LE.SHA_helpers.repeat_range_vale | val repeat_range_vale : max: Prims.nat{max < Vale.SHA.PPC64LE.SHA_helpers.size_k_w_256} ->
block: Vale.SHA.PPC64LE.SHA_helpers.block_w ->
hash: Vale.SHA.PPC64LE.SHA_helpers.hash256
-> Vale.SHA.PPC64LE.SHA_helpers.hash256 | let repeat_range_vale (max:nat { max < size_k_w_256}) (block:block_w) (hash:hash256) =
Spec.Loops.repeat_range 0 max (shuffle_core_opaque block) hash | {
"file_name": "vale/code/crypto/sha/Vale.SHA.PPC64LE.SHA_helpers.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 64,
"end_line": 52,
"start_col": 0,
"start_line": 51
} | module Vale.SHA.PPC64LE.SHA_helpers
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open FStar.Seq
open Vale.Arch.Types
open Vale.Def.Sel
open Vale.SHA2.Wrapper
open Vale.Def.Words.Four_s
unfold let (.[]) = FStar.Seq.index
#reset-options "--max_fuel 0 --max_ifuel 0"
// Specialize these definitions (from Spec.SHA2.fst) for SHA256
unfold let size_k_w_256 = 64
val word:Type0
(* Number of words for a block size *)
let size_block_w_256 = 16
(* Define the size block in bytes *)
let block_length =
4 (*word_length a*) * size_block_w_256
let block_w = m:seq word {length m = size_block_w_256}
let counter = nat
val k : (s:seq word {length s = size_k_w_256})
let hash256 = m:Seq.seq word {Seq.length m = 8}
(* Input data. *)
type byte = UInt8.t
type bytes = Seq.seq byte
(* Input data, multiple of a block length. *)
let bytes_blocks =
l:bytes { Seq.length l % block_length = 0 }
// Hide various SHA2 definitions
val ws_opaque (b:block_w) (t:counter{t < size_k_w_256}):nat32
val shuffle_core_opaque (block:block_w) (hash:hash256) (t:counter{t < size_k_w_256}):hash256
val update_multi_opaque (hash:hash256) (blocks:bytes_blocks):hash256
val update_multi_transparent (hash:hash256) (blocks:bytes_blocks):hash256
// Hide some functions that operate on words & bytes
val word_to_nat32 (x:word) : nat32
val nat32_to_word (x:nat32) : word | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Spec.Loops.fst.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.SHA.PPC64LE.SHA_helpers.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.Hash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
max: Prims.nat{max < Vale.SHA.PPC64LE.SHA_helpers.size_k_w_256} ->
block: Vale.SHA.PPC64LE.SHA_helpers.block_w ->
hash: Vale.SHA.PPC64LE.SHA_helpers.hash256
-> Vale.SHA.PPC64LE.SHA_helpers.hash256 | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Vale.SHA.PPC64LE.SHA_helpers.size_k_w_256",
"Vale.SHA.PPC64LE.SHA_helpers.block_w",
"Vale.SHA.PPC64LE.SHA_helpers.hash256",
"Spec.Loops.repeat_range",
"Vale.SHA.PPC64LE.SHA_helpers.shuffle_core_opaque"
] | [] | false | false | false | false | false | let repeat_range_vale (max: nat{max < size_k_w_256}) (block: block_w) (hash: hash256) =
| Spec.Loops.repeat_range 0 max (shuffle_core_opaque block) hash | false |
|
Vale.SHA.PPC64LE.SHA_helpers.fsti | Vale.SHA.PPC64LE.SHA_helpers.bytes_blocks | val bytes_blocks : Type0 | let bytes_blocks =
l:bytes { Seq.length l % block_length = 0 } | {
"file_name": "vale/code/crypto/sha/Vale.SHA.PPC64LE.SHA_helpers.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 45,
"end_line": 38,
"start_col": 0,
"start_line": 37
} | module Vale.SHA.PPC64LE.SHA_helpers
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open FStar.Seq
open Vale.Arch.Types
open Vale.Def.Sel
open Vale.SHA2.Wrapper
open Vale.Def.Words.Four_s
unfold let (.[]) = FStar.Seq.index
#reset-options "--max_fuel 0 --max_ifuel 0"
// Specialize these definitions (from Spec.SHA2.fst) for SHA256
unfold let size_k_w_256 = 64
val word:Type0
(* Number of words for a block size *)
let size_block_w_256 = 16
(* Define the size block in bytes *)
let block_length =
4 (*word_length a*) * size_block_w_256
let block_w = m:seq word {length m = size_block_w_256}
let counter = nat
val k : (s:seq word {length s = size_k_w_256})
let hash256 = m:Seq.seq word {Seq.length m = 8}
(* Input data. *)
type byte = UInt8.t
type bytes = Seq.seq byte | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Spec.Loops.fst.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.SHA.PPC64LE.SHA_helpers.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.Hash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.SHA.PPC64LE.SHA_helpers.bytes",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"FStar.Seq.Base.length",
"Vale.SHA.PPC64LE.SHA_helpers.byte",
"Vale.SHA.PPC64LE.SHA_helpers.block_length"
] | [] | false | false | false | true | true | let bytes_blocks =
| l: bytes{Seq.length l % block_length = 0} | false |
|
Vale.Inline.X64.Fswap_inline.fst | Vale.Inline.X64.Fswap_inline.as_t | val as_t (#a: Type) (x: normal a) : a | val as_t (#a: Type) (x: normal a) : a | let as_t (#a:Type) (x:normal a) : a = x | {
"file_name": "vale/code/arch/x64/interop/Vale.Inline.X64.Fswap_inline.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 39,
"end_line": 28,
"start_col": 0,
"start_line": 28
} | module Vale.Inline.X64.Fswap_inline
open FStar.Mul
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LSig = Vale.AsLowStar.LowStarSig
module ME = Vale.X64.Memory
module V = Vale.X64.Decls
module IA = Vale.Interop.Assumptions
module W = Vale.AsLowStar.Wrapper
open Vale.X64.MemoryAdapters
module VS = Vale.X64.State
module MS = Vale.X64.Machine_s
module PR = Vale.X64.Print_Inline_s
module FU = Vale.Curve25519.X64.FastUtil
let uint64 = UInt64.t | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Print_Inline_s.fst.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Interop.Assumptions.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.X64.FastUtil.fsti.checked",
"Vale.AsLowStar.Wrapper.fsti.checked",
"Vale.AsLowStar.ValeSig.fst.checked",
"Vale.AsLowStar.MemoryHelpers.fsti.checked",
"Vale.AsLowStar.LowStarSig.fst.checked",
"prims.fst.checked",
"LowStar.BufferView.Down.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Inline.X64.Fswap_inline.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
{
"abbrev": true,
"full_module": "Vale.X64.Print_Inline_s",
"short_module": "PR"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_module": "Vale.X64.State",
"short_module": "VS"
},
{
"abbrev": false,
"full_module": "Vale.X64.MemoryAdapters",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.Wrapper",
"short_module": "W"
},
{
"abbrev": true,
"full_module": "Vale.Interop.Assumptions",
"short_module": "IA"
},
{
"abbrev": true,
"full_module": "Vale.X64.Decls",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Vale.X64.Memory",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.LowStarSig",
"short_module": "LSig"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.ValeSig",
"short_module": "VSig"
},
{
"abbrev": true,
"full_module": "Vale.Interop.X64",
"short_module": "IX64"
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.BufferView.Down",
"short_module": "DV"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x: Vale.Interop.Base.normal a -> a | Prims.Tot | [
"total"
] | [] | [
"Vale.Interop.Base.normal"
] | [] | false | false | false | true | false | let as_t (#a: Type) (x: normal a) : a =
| x | false |
Pulse.Steel.Wrapper.Typing.fsti | Pulse.Steel.Wrapper.Typing.return_post_with_eq | val return_post_with_eq (u: universe) (a e p: term) (x: var) : term | val return_post_with_eq (u: universe) (a e p: term) (x: var) : term | let return_post_with_eq (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
let x_tm = RT.var_as_term x in
let eq2_tm = mk_eq2 u a x_tm e in
let p_app_x = pack_ln (Tv_App p (x_tm, Q_Explicit)) in
let star_tm = mk_star p_app_x (mk_pure eq2_tm) in
mk_abs a Q_Explicit (RT.subst_term star_tm [ RT.ND x 0 ]) | {
"file_name": "lib/steel/pulse/Pulse.Steel.Wrapper.Typing.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 59,
"end_line": 29,
"start_col": 0,
"start_line": 24
} | (*
Copyright 2023 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 Pulse.Steel.Wrapper.Typing
open FStar.Reflection.V2
open Pulse.Reflection.Util
module RT = FStar.Reflection.Typing | {
"checked_file": "/",
"dependencies": [
"Pulse.Reflection.Util.fst.checked",
"prims.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.Steel.Wrapper.Typing.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse.Reflection.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Steel.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Steel.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
u10: FStar.Stubs.Reflection.Types.universe ->
a: FStar.Stubs.Reflection.Types.term ->
e: FStar.Stubs.Reflection.Types.term ->
p: FStar.Stubs.Reflection.Types.term ->
x: FStar.Stubs.Reflection.V2.Data.var
-> FStar.Stubs.Reflection.Types.term | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.universe",
"FStar.Stubs.Reflection.Types.term",
"FStar.Stubs.Reflection.V2.Data.var",
"Pulse.Reflection.Util.mk_abs",
"FStar.Stubs.Reflection.V2.Data.Q_Explicit",
"FStar.Reflection.Typing.subst_term",
"Prims.Cons",
"FStar.Reflection.Typing.subst_elt",
"FStar.Reflection.Typing.ND",
"Prims.Nil",
"Pulse.Reflection.Util.mk_star",
"Pulse.Reflection.Util.mk_pure",
"FStar.Stubs.Reflection.V2.Builtins.pack_ln",
"FStar.Stubs.Reflection.V2.Data.Tv_App",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Stubs.Reflection.V2.Data.aqualv",
"Pulse.Reflection.Util.mk_eq2",
"FStar.Reflection.Typing.var_as_term"
] | [] | false | false | false | true | false | let return_post_with_eq (u: universe) (a e p: term) (x: var) : term =
| let x_tm = RT.var_as_term x in
let eq2_tm = mk_eq2 u a x_tm e in
let p_app_x = pack_ln (Tv_App p (x_tm, Q_Explicit)) in
let star_tm = mk_star p_app_x (mk_pure eq2_tm) in
mk_abs a Q_Explicit (RT.subst_term star_tm [RT.ND x 0]) | false |
Pulse.Steel.Wrapper.Typing.fsti | Pulse.Steel.Wrapper.Typing.return_stt_comp | val return_stt_comp (u: universe) (a e p: term) (x: var) : term | val return_stt_comp (u: universe) (a e p: term) (x: var) : term | let return_stt_comp (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
mk_stt_comp u a
(pack_ln (Tv_App p (e, Q_Explicit)))
(return_post_with_eq u a e p x) | {
"file_name": "lib/steel/pulse/Pulse.Steel.Wrapper.Typing.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 35,
"end_line": 34,
"start_col": 0,
"start_line": 31
} | (*
Copyright 2023 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 Pulse.Steel.Wrapper.Typing
open FStar.Reflection.V2
open Pulse.Reflection.Util
module RT = FStar.Reflection.Typing
let return_post_with_eq (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
let x_tm = RT.var_as_term x in
let eq2_tm = mk_eq2 u a x_tm e in
let p_app_x = pack_ln (Tv_App p (x_tm, Q_Explicit)) in
let star_tm = mk_star p_app_x (mk_pure eq2_tm) in
mk_abs a Q_Explicit (RT.subst_term star_tm [ RT.ND x 0 ]) | {
"checked_file": "/",
"dependencies": [
"Pulse.Reflection.Util.fst.checked",
"prims.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.Steel.Wrapper.Typing.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse.Reflection.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Steel.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Steel.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
u20: FStar.Stubs.Reflection.Types.universe ->
a: FStar.Stubs.Reflection.Types.term ->
e: FStar.Stubs.Reflection.Types.term ->
p: FStar.Stubs.Reflection.Types.term ->
x: FStar.Stubs.Reflection.V2.Data.var
-> FStar.Stubs.Reflection.Types.term | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.universe",
"FStar.Stubs.Reflection.Types.term",
"FStar.Stubs.Reflection.V2.Data.var",
"Pulse.Reflection.Util.mk_stt_comp",
"FStar.Stubs.Reflection.V2.Builtins.pack_ln",
"FStar.Stubs.Reflection.V2.Data.Tv_App",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Stubs.Reflection.V2.Data.aqualv",
"FStar.Stubs.Reflection.V2.Data.Q_Explicit",
"Pulse.Steel.Wrapper.Typing.return_post_with_eq"
] | [] | false | false | false | true | false | let return_stt_comp (u: universe) (a e p: term) (x: var) : term =
| mk_stt_comp u a (pack_ln (Tv_App p (e, Q_Explicit))) (return_post_with_eq u a e p x) | false |
Pulse.Steel.Wrapper.Typing.fsti | Pulse.Steel.Wrapper.Typing.neutral_fv | val neutral_fv : FStar.Stubs.Reflection.Types.term | let neutral_fv = pack_ln (Tv_FVar (pack_fv neutral_lid)) | {
"file_name": "lib/steel/pulse/Pulse.Steel.Wrapper.Typing.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 56,
"end_line": 68,
"start_col": 0,
"start_line": 68
} | (*
Copyright 2023 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 Pulse.Steel.Wrapper.Typing
open FStar.Reflection.V2
open Pulse.Reflection.Util
module RT = FStar.Reflection.Typing
let return_post_with_eq (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
let x_tm = RT.var_as_term x in
let eq2_tm = mk_eq2 u a x_tm e in
let p_app_x = pack_ln (Tv_App p (x_tm, Q_Explicit)) in
let star_tm = mk_star p_app_x (mk_pure eq2_tm) in
mk_abs a Q_Explicit (RT.subst_term star_tm [ RT.ND x 0 ])
let return_stt_comp (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
mk_stt_comp u a
(pack_ln (Tv_App p (e, Q_Explicit)))
(return_post_with_eq u a e p x)
val return_stt_typing
(#g:env)
(#u:universe)
(#a:term)
(#e:term)
(#p:term)
(x:var{None? (RT.lookup_bvar g x)})
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(e_typing:RT.tot_typing g e a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_return u a e p)
(return_stt_comp u a e p x))
let return_stt_noeq_comp (u:universe) (a:term) (x:term) (p:term) : term =
mk_stt_comp u a (pack_ln (Tv_App p (x, Q_Explicit))) p
val return_stt_noeq_typing
(#g:env)
(#u:universe)
(#a:term)
(#x:term)
(#p:term)
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(x_typing:RT.tot_typing g x a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_return_noeq u a x p)
(return_stt_noeq_comp u a x p)) | {
"checked_file": "/",
"dependencies": [
"Pulse.Reflection.Util.fst.checked",
"prims.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.Steel.Wrapper.Typing.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse.Reflection.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse.Reflection.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Steel.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Steel.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | FStar.Stubs.Reflection.Types.term | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.V2.Builtins.pack_ln",
"FStar.Stubs.Reflection.V2.Data.Tv_FVar",
"FStar.Stubs.Reflection.V2.Builtins.pack_fv",
"Pulse.Reflection.Util.neutral_lid"
] | [] | false | false | false | true | false | let neutral_fv =
| pack_ln (Tv_FVar (pack_fv neutral_lid)) | false |
|
Vale.SHA.PPC64LE.SHA_helpers.fsti | Vale.SHA.PPC64LE.SHA_helpers.update_multi_opaque_vale | val update_multi_opaque_vale (hash: hash256) (blocks: bytes) : hash256 | val update_multi_opaque_vale (hash: hash256) (blocks: bytes) : hash256 | let update_multi_opaque_vale (hash:hash256) (blocks:bytes) : hash256 =
if length blocks % size_k_w_256 = 0 then let b:bytes_blocks = blocks in update_multi_opaque hash b else hash | {
"file_name": "vale/code/crypto/sha/Vale.SHA.PPC64LE.SHA_helpers.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 110,
"end_line": 54,
"start_col": 0,
"start_line": 53
} | module Vale.SHA.PPC64LE.SHA_helpers
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open FStar.Seq
open Vale.Arch.Types
open Vale.Def.Sel
open Vale.SHA2.Wrapper
open Vale.Def.Words.Four_s
unfold let (.[]) = FStar.Seq.index
#reset-options "--max_fuel 0 --max_ifuel 0"
// Specialize these definitions (from Spec.SHA2.fst) for SHA256
unfold let size_k_w_256 = 64
val word:Type0
(* Number of words for a block size *)
let size_block_w_256 = 16
(* Define the size block in bytes *)
let block_length =
4 (*word_length a*) * size_block_w_256
let block_w = m:seq word {length m = size_block_w_256}
let counter = nat
val k : (s:seq word {length s = size_k_w_256})
let hash256 = m:Seq.seq word {Seq.length m = 8}
(* Input data. *)
type byte = UInt8.t
type bytes = Seq.seq byte
(* Input data, multiple of a block length. *)
let bytes_blocks =
l:bytes { Seq.length l % block_length = 0 }
// Hide various SHA2 definitions
val ws_opaque (b:block_w) (t:counter{t < size_k_w_256}):nat32
val shuffle_core_opaque (block:block_w) (hash:hash256) (t:counter{t < size_k_w_256}):hash256
val update_multi_opaque (hash:hash256) (blocks:bytes_blocks):hash256
val update_multi_transparent (hash:hash256) (blocks:bytes_blocks):hash256
// Hide some functions that operate on words & bytes
val word_to_nat32 (x:word) : nat32
val nat32_to_word (x:nat32) : word
//unfold let bytes_blocks256 = bytes_blocks SHA2_256
let repeat_range_vale (max:nat { max < size_k_w_256}) (block:block_w) (hash:hash256) = | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Spec.Loops.fst.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.SHA.PPC64LE.SHA_helpers.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.Hash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | hash: Vale.SHA.PPC64LE.SHA_helpers.hash256 -> blocks: Vale.SHA.PPC64LE.SHA_helpers.bytes
-> Vale.SHA.PPC64LE.SHA_helpers.hash256 | Prims.Tot | [
"total"
] | [] | [
"Vale.SHA.PPC64LE.SHA_helpers.hash256",
"Vale.SHA.PPC64LE.SHA_helpers.bytes",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"FStar.Seq.Base.length",
"Vale.SHA.PPC64LE.SHA_helpers.byte",
"Vale.SHA.PPC64LE.SHA_helpers.size_k_w_256",
"Vale.SHA.PPC64LE.SHA_helpers.update_multi_opaque",
"Vale.SHA.PPC64LE.SHA_helpers.bytes_blocks",
"Prims.bool"
] | [] | false | false | false | true | false | let update_multi_opaque_vale (hash: hash256) (blocks: bytes) : hash256 =
| if length blocks % size_k_w_256 = 0
then
let b:bytes_blocks = blocks in
update_multi_opaque hash b
else hash | false |
Pulse.Steel.Wrapper.Typing.fsti | Pulse.Steel.Wrapper.Typing.return_stt_noeq_comp | val return_stt_noeq_comp (u: universe) (a x p: term) : term | val return_stt_noeq_comp (u: universe) (a x p: term) : term | let return_stt_noeq_comp (u:universe) (a:term) (x:term) (p:term) : term =
mk_stt_comp u a (pack_ln (Tv_App p (x, Q_Explicit))) p | {
"file_name": "lib/steel/pulse/Pulse.Steel.Wrapper.Typing.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 56,
"end_line": 52,
"start_col": 0,
"start_line": 51
} | (*
Copyright 2023 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 Pulse.Steel.Wrapper.Typing
open FStar.Reflection.V2
open Pulse.Reflection.Util
module RT = FStar.Reflection.Typing
let return_post_with_eq (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
let x_tm = RT.var_as_term x in
let eq2_tm = mk_eq2 u a x_tm e in
let p_app_x = pack_ln (Tv_App p (x_tm, Q_Explicit)) in
let star_tm = mk_star p_app_x (mk_pure eq2_tm) in
mk_abs a Q_Explicit (RT.subst_term star_tm [ RT.ND x 0 ])
let return_stt_comp (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
mk_stt_comp u a
(pack_ln (Tv_App p (e, Q_Explicit)))
(return_post_with_eq u a e p x)
val return_stt_typing
(#g:env)
(#u:universe)
(#a:term)
(#e:term)
(#p:term)
(x:var{None? (RT.lookup_bvar g x)})
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(e_typing:RT.tot_typing g e a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_return u a e p)
(return_stt_comp u a e p x)) | {
"checked_file": "/",
"dependencies": [
"Pulse.Reflection.Util.fst.checked",
"prims.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.Steel.Wrapper.Typing.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse.Reflection.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse.Reflection.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Steel.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Steel.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
u37: FStar.Stubs.Reflection.Types.universe ->
a: FStar.Stubs.Reflection.Types.term ->
x: FStar.Stubs.Reflection.Types.term ->
p: FStar.Stubs.Reflection.Types.term
-> FStar.Stubs.Reflection.Types.term | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.universe",
"FStar.Stubs.Reflection.Types.term",
"Pulse.Reflection.Util.mk_stt_comp",
"FStar.Stubs.Reflection.V2.Builtins.pack_ln",
"FStar.Stubs.Reflection.V2.Data.Tv_App",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Stubs.Reflection.V2.Data.aqualv",
"FStar.Stubs.Reflection.V2.Data.Q_Explicit"
] | [] | false | false | false | true | false | let return_stt_noeq_comp (u: universe) (a x p: term) : term =
| mk_stt_comp u a (pack_ln (Tv_App p (x, Q_Explicit))) p | false |
Vale.SHA.PPC64LE.SHA_helpers.fsti | Vale.SHA.PPC64LE.SHA_helpers.k_index | val k_index (ks: seq quad32) (i: nat) : nat32 | val k_index (ks: seq quad32) (i: nat) : nat32 | let k_index (ks:seq quad32) (i:nat) : nat32 =
if length ks = size_k_w_256 / 4 && i < size_k_w_256 then four_select ks.[(i/4)] (i % 4)
else 0 | {
"file_name": "vale/code/crypto/sha/Vale.SHA.PPC64LE.SHA_helpers.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 8,
"end_line": 209,
"start_col": 0,
"start_line": 207
} | module Vale.SHA.PPC64LE.SHA_helpers
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open FStar.Seq
open Vale.Arch.Types
open Vale.Def.Sel
open Vale.SHA2.Wrapper
open Vale.Def.Words.Four_s
unfold let (.[]) = FStar.Seq.index
#reset-options "--max_fuel 0 --max_ifuel 0"
// Specialize these definitions (from Spec.SHA2.fst) for SHA256
unfold let size_k_w_256 = 64
val word:Type0
(* Number of words for a block size *)
let size_block_w_256 = 16
(* Define the size block in bytes *)
let block_length =
4 (*word_length a*) * size_block_w_256
let block_w = m:seq word {length m = size_block_w_256}
let counter = nat
val k : (s:seq word {length s = size_k_w_256})
let hash256 = m:Seq.seq word {Seq.length m = 8}
(* Input data. *)
type byte = UInt8.t
type bytes = Seq.seq byte
(* Input data, multiple of a block length. *)
let bytes_blocks =
l:bytes { Seq.length l % block_length = 0 }
// Hide various SHA2 definitions
val ws_opaque (b:block_w) (t:counter{t < size_k_w_256}):nat32
val shuffle_core_opaque (block:block_w) (hash:hash256) (t:counter{t < size_k_w_256}):hash256
val update_multi_opaque (hash:hash256) (blocks:bytes_blocks):hash256
val update_multi_transparent (hash:hash256) (blocks:bytes_blocks):hash256
// Hide some functions that operate on words & bytes
val word_to_nat32 (x:word) : nat32
val nat32_to_word (x:nat32) : word
//unfold let bytes_blocks256 = bytes_blocks SHA2_256
let repeat_range_vale (max:nat { max < size_k_w_256}) (block:block_w) (hash:hash256) =
Spec.Loops.repeat_range 0 max (shuffle_core_opaque block) hash
let update_multi_opaque_vale (hash:hash256) (blocks:bytes) : hash256 =
if length blocks % size_k_w_256 = 0 then let b:bytes_blocks = blocks in update_multi_opaque hash b else hash
val make_ordered_hash (abcd efgh:quad32): Pure (hash256)
(requires True)
(ensures fun hash ->
length hash == 8 /\
hash.[0] == nat32_to_word abcd.lo0 /\
hash.[1] == nat32_to_word abcd.lo1 /\
hash.[2] == nat32_to_word abcd.hi2 /\
hash.[3] == nat32_to_word abcd.hi3 /\
hash.[4] == nat32_to_word efgh.lo0 /\
hash.[5] == nat32_to_word efgh.lo1 /\
hash.[6] == nat32_to_word efgh.hi2 /\
hash.[7] == nat32_to_word efgh.hi3
)
val update_block (hash:hash256) (block:block_w): hash256
val lemma_update_multi_opaque_vale_is_update_multi (hash:hash256) (blocks:bytes) : Lemma
(requires length blocks % 64 = 0)
(ensures update_multi_opaque_vale hash blocks == update_multi_transparent hash blocks)
val sigma_0_0_partial_def (t:counter) (block:block_w) : nat32
[@"opaque_to_smt"] let sigma_0_0_partial = opaque_make sigma_0_0_partial_def
irreducible let sigma_0_0_partial_reveal = opaque_revealer (`%sigma_0_0_partial) sigma_0_0_partial sigma_0_0_partial_def
val lemma_sha256_sigma0 (src:quad32) (t:counter) (block:block_w) : Lemma
(requires 16 <= t /\ t < size_k_w_256 /\
src.hi3 == ws_opaque block (t-15))
(ensures (sigma256_0_0 src.hi3 == sigma_0_0_partial t block))
val sigma_0_1_partial_def (t:counter) (block:block_w) : nat32
[@"opaque_to_smt"] let sigma_0_1_partial = opaque_make sigma_0_1_partial_def
irreducible let sigma_0_1_partial_reveal = opaque_revealer (`%sigma_0_1_partial) sigma_0_1_partial sigma_0_1_partial_def
val lemma_sha256_sigma1 (src:quad32) (t:counter) (block:block_w) : Lemma
(requires 16 <= t /\ t < size_k_w_256 /\
src.hi3 == ws_opaque block (t-2))
(ensures (sigma256_0_1 src.hi3 == sigma_0_1_partial t block))
val sigma_1_0_partial_def (t:counter) (block:block_w) (hash_orig:hash256) : nat32
[@"opaque_to_smt"] let sigma_1_0_partial = opaque_make sigma_1_0_partial_def
irreducible let sigma_1_0_partial_reveal = opaque_revealer (`%sigma_1_0_partial) sigma_1_0_partial sigma_1_0_partial_def
val lemma_sha256_sigma2 (src:quad32) (t:counter) (block:block_w) (hash_orig:hash256) : Lemma
(requires t < size_k_w_256 /\
src.hi3 == word_to_nat32 ((repeat_range_vale t block hash_orig).[0]))
(ensures (sigma256_1_0 src.hi3 == sigma_1_0_partial t block hash_orig))
val sigma_1_1_partial_def (t:counter) (block:block_w) (hash_orig:hash256) : nat32
[@"opaque_to_smt"] let sigma_1_1_partial = opaque_make sigma_1_1_partial_def
irreducible let sigma_1_1_partial_reveal = opaque_revealer (`%sigma_1_1_partial) sigma_1_1_partial sigma_1_1_partial_def
val lemma_sha256_sigma3 (src:quad32) (t:counter) (block:block_w) (hash_orig:hash256) : Lemma
(requires t < size_k_w_256 /\
src.hi3 == word_to_nat32 ((repeat_range_vale t block hash_orig).[4]))
(ensures (sigma256_1_1 src.hi3 == sigma_1_1_partial t block hash_orig))
val make_seperated_hash (a b c d e f g h:nat32): Pure (hash256)
(requires True)
(ensures fun hash ->
length hash == 8 /\
hash.[0] == nat32_to_word a /\
hash.[1] == nat32_to_word b /\
hash.[2] == nat32_to_word c /\
hash.[3] == nat32_to_word d /\
hash.[4] == nat32_to_word e /\
hash.[5] == nat32_to_word f /\
hash.[6] == nat32_to_word g /\
hash.[7] == nat32_to_word h
)
val make_seperated_hash_quad32 (a b c d e f g h:quad32): Pure (hash256)
(requires True)
(ensures fun hash ->
length hash == 8 /\
hash.[0] == nat32_to_word a.hi3 /\
hash.[1] == nat32_to_word b.hi3 /\
hash.[2] == nat32_to_word c.hi3 /\
hash.[3] == nat32_to_word d.hi3 /\
hash.[4] == nat32_to_word e.hi3 /\
hash.[5] == nat32_to_word f.hi3 /\
hash.[6] == nat32_to_word g.hi3 /\
hash.[7] == nat32_to_word h.hi3
)
val lemma_make_seperated_hash (hash:hash256) (a b c d e f g h:quad32) : Lemma
(requires length hash == 8 /\
a.hi3 == word_to_nat32 hash.[0] /\
b.hi3 == word_to_nat32 hash.[1] /\
c.hi3 == word_to_nat32 hash.[2] /\
d.hi3 == word_to_nat32 hash.[3] /\
e.hi3 == word_to_nat32 hash.[4] /\
f.hi3 == word_to_nat32 hash.[5] /\
g.hi3 == word_to_nat32 hash.[6] /\
h.hi3 == word_to_nat32 hash.[7])
(ensures hash == make_seperated_hash_quad32 a b c d e f g h)
val lemma_vsel32 (a b c:nat32) : Lemma
(ensures (isel32 a b c = (iand32 c a) *^ (iand32 (inot32 c) b)))
val ch_256 (x y z:nat32):Pure(nat32)
(requires True)
(ensures fun a -> a == (iand32 x y) *^ (iand32 (inot32 x) z))
val lemma_eq_maj_xvsel32 (a b c:nat32) : Lemma
(ensures (isel32 c b (a *^ b) = (iand32 a b) *^ ((iand32 a c) *^ (iand32 b c))))
val maj_256 (x y z:nat32):Pure(nat32)
(requires True)
(ensures fun a -> a == (iand32 x y) *^ ((iand32 x z) *^ (iand32 y z)))
val lemma_sigma_0_0_partial (t:counter) (block:block_w) : Lemma
(requires 16 <= t /\ t < size_k_w_256)
(ensures (sigma256_0_0 (ws_opaque block (t-15)) == sigma_0_0_partial t block))
val lemma_sigma_0_1_partial (t:counter) (block:block_w) : Lemma
(requires 16 <= t /\ t < size_k_w_256)
(ensures (sigma256_0_1 (ws_opaque block (t-2)) == sigma_0_1_partial t block))
val lemma_sigma_1_0_partial (t:counter) (block:block_w) (hash_orig:hash256) : Lemma
(requires t < size_k_w_256)
(ensures (sigma256_1_0 (word_to_nat32 ((repeat_range_vale t block hash_orig).[0])) == sigma_1_0_partial t block hash_orig))
val lemma_sigma_1_1_partial (t:counter) (block:block_w) (hash_orig:hash256) : Lemma
(requires t < size_k_w_256)
(ensures (sigma256_1_1 (word_to_nat32 ((repeat_range_vale t block hash_orig).[4])) == sigma_1_1_partial t block hash_orig))
(* Abbreviations and lemmas for the code itself *)
let k_reqs (k_seq:seq quad32) : prop0 =
length k_seq == size_k_w_256 / 4 /\
(forall i . {:pattern (index k_seq i)} 0 <= i /\ i < (size_k_w_256/4) ==>
(k_seq.[i]).lo0 == word_to_nat32 (k.[4 * i]) /\
(k_seq.[i]).lo1 == word_to_nat32 (k.[4 * i + 1]) /\
(k_seq.[i]).hi2 == word_to_nat32 (k.[4 * i + 2]) /\
(k_seq.[i]).hi3 == word_to_nat32 (k.[4 * i + 3]))
let quads_to_block_be (qs:seq quad32) : block_w
=
let nat32_seq = Vale.Def.Words.Seq_s.seq_four_to_seq_BE qs in
let f (n:nat{n < 16}) : word = nat32_to_word (if n < length nat32_seq then nat32_seq.[n] else 0) in
init 16 f
val lemma_quads_to_block_be (qs:seq quad32) : Lemma
(requires length qs == 4)
(ensures
(let block = quads_to_block_be qs in
forall i . {:pattern (index qs i)} 0 <= i /\ i < 4 ==>
(qs.[i]).hi3 == ws_opaque block (4 * i + 0) /\
(qs.[i]).hi2 == ws_opaque block (4 * i + 1) /\
(qs.[i]).lo1 == ws_opaque block (4 * i + 2) /\
(qs.[i]).lo0 == ws_opaque block (4 * i + 3))) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Spec.Loops.fst.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.SHA.PPC64LE.SHA_helpers.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.Hash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | ks: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 -> i: Prims.nat -> Vale.Def.Words_s.nat32 | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Prims.nat",
"Prims.op_AmpAmp",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.op_Division",
"Vale.SHA.PPC64LE.SHA_helpers.size_k_w_256",
"Prims.op_LessThan",
"Vale.Def.Words.Four_s.four_select",
"Vale.Def.Types_s.nat32",
"Vale.SHA.PPC64LE.SHA_helpers.op_String_Access",
"Prims.op_Modulus",
"Prims.bool",
"Vale.Def.Words_s.nat32"
] | [] | false | false | false | true | false | let k_index (ks: seq quad32) (i: nat) : nat32 =
| if length ks = size_k_w_256 / 4 && i < size_k_w_256 then four_select ks.[ (i / 4) ] (i % 4) else 0 | false |
Pulse.Steel.Wrapper.Typing.fsti | Pulse.Steel.Wrapper.Typing.return_stt_atomic_comp | val return_stt_atomic_comp (u: universe) (a e p: term) (x: var) : term | val return_stt_atomic_comp (u: universe) (a e p: term) (x: var) : term | let return_stt_atomic_comp (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
mk_stt_atomic_comp neutral_fv u a emp_inames_tm
(pack_ln (Tv_App p (e, Q_Explicit)))
(return_post_with_eq u a e p x) | {
"file_name": "lib/steel/pulse/Pulse.Steel.Wrapper.Typing.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 35,
"end_line": 72,
"start_col": 0,
"start_line": 69
} | (*
Copyright 2023 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 Pulse.Steel.Wrapper.Typing
open FStar.Reflection.V2
open Pulse.Reflection.Util
module RT = FStar.Reflection.Typing
let return_post_with_eq (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
let x_tm = RT.var_as_term x in
let eq2_tm = mk_eq2 u a x_tm e in
let p_app_x = pack_ln (Tv_App p (x_tm, Q_Explicit)) in
let star_tm = mk_star p_app_x (mk_pure eq2_tm) in
mk_abs a Q_Explicit (RT.subst_term star_tm [ RT.ND x 0 ])
let return_stt_comp (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
mk_stt_comp u a
(pack_ln (Tv_App p (e, Q_Explicit)))
(return_post_with_eq u a e p x)
val return_stt_typing
(#g:env)
(#u:universe)
(#a:term)
(#e:term)
(#p:term)
(x:var{None? (RT.lookup_bvar g x)})
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(e_typing:RT.tot_typing g e a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_return u a e p)
(return_stt_comp u a e p x))
let return_stt_noeq_comp (u:universe) (a:term) (x:term) (p:term) : term =
mk_stt_comp u a (pack_ln (Tv_App p (x, Q_Explicit))) p
val return_stt_noeq_typing
(#g:env)
(#u:universe)
(#a:term)
(#x:term)
(#p:term)
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(x_typing:RT.tot_typing g x a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_return_noeq u a x p)
(return_stt_noeq_comp u a x p)) | {
"checked_file": "/",
"dependencies": [
"Pulse.Reflection.Util.fst.checked",
"prims.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.Steel.Wrapper.Typing.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse.Reflection.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse.Reflection.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Steel.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Steel.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
u55: FStar.Stubs.Reflection.Types.universe ->
a: FStar.Stubs.Reflection.Types.term ->
e: FStar.Stubs.Reflection.Types.term ->
p: FStar.Stubs.Reflection.Types.term ->
x: FStar.Stubs.Reflection.V2.Data.var
-> FStar.Stubs.Reflection.Types.term | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.universe",
"FStar.Stubs.Reflection.Types.term",
"FStar.Stubs.Reflection.V2.Data.var",
"Pulse.Reflection.Util.mk_stt_atomic_comp",
"Pulse.Steel.Wrapper.Typing.neutral_fv",
"Pulse.Reflection.Util.emp_inames_tm",
"FStar.Stubs.Reflection.V2.Builtins.pack_ln",
"FStar.Stubs.Reflection.V2.Data.Tv_App",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Stubs.Reflection.V2.Data.aqualv",
"FStar.Stubs.Reflection.V2.Data.Q_Explicit",
"Pulse.Steel.Wrapper.Typing.return_post_with_eq"
] | [] | false | false | false | true | false | let return_stt_atomic_comp (u: universe) (a e p: term) (x: var) : term =
| mk_stt_atomic_comp neutral_fv
u
a
emp_inames_tm
(pack_ln (Tv_App p (e, Q_Explicit)))
(return_post_with_eq u a e p x) | false |
Vale.Inline.X64.Fswap_inline.fst | Vale.Inline.X64.Fswap_inline.of_arg | val of_arg (i: IX64.reg_nat 3) : MS.reg_64 | val of_arg (i: IX64.reg_nat 3) : MS.reg_64 | let of_arg (i:IX64.reg_nat 3) : MS.reg_64 = match i with
| 0 -> MS.rRdi
| 1 -> MS.rRsi
| 2 -> MS.rRdx | {
"file_name": "vale/code/arch/x64/interop/Vale.Inline.X64.Fswap_inline.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 119,
"start_col": 0,
"start_line": 116
} | module Vale.Inline.X64.Fswap_inline
open FStar.Mul
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LSig = Vale.AsLowStar.LowStarSig
module ME = Vale.X64.Memory
module V = Vale.X64.Decls
module IA = Vale.Interop.Assumptions
module W = Vale.AsLowStar.Wrapper
open Vale.X64.MemoryAdapters
module VS = Vale.X64.State
module MS = Vale.X64.Machine_s
module PR = Vale.X64.Print_Inline_s
module FU = Vale.Curve25519.X64.FastUtil
let uint64 = UInt64.t
(* A little utility to trigger normalization in types *)
let as_t (#a:Type) (x:normal a) : a = x
let as_normal_t (#a:Type) (x:a) : normal a = x
[@__reduce__]
let b64 = buf_t TUInt64 TUInt64
[@__reduce__]
let t64_mod = TD_Buffer TUInt64 TUInt64 default_bq
[@__reduce__]
let t64_no_mod = TD_Buffer TUInt64 TUInt64 ({modified=false; strict_disjointness=false; taint=MS.Secret})
[@__reduce__]
let tuint64 = TD_Base TUInt64
[@__reduce__]
let cswap_dom: IX64.arity_ok 3 td =
let y = [tuint64; t64_mod; t64_mod] in
assert_norm (List.length y = 3);
y
(* Need to rearrange the order of arguments *)
[@__reduce__]
let cswap_pre : VSig.vale_pre cswap_dom =
fun (c:V.va_code)
(bit:uint64)
(p0:b64)
(p1:b64)
(va_s0:V.va_state) ->
FU.va_req_Cswap2 c va_s0
(UInt64.v bit) (as_vale_buffer p0) (as_vale_buffer p1)
[@__reduce__]
let cswap_post : VSig.vale_post cswap_dom =
fun (c:V.va_code)
(bit:uint64)
(p0:b64)
(p1:b64)
(va_s0:V.va_state)
(va_s1:V.va_state)
(f:V.va_fuel) ->
FU.va_ens_Cswap2 c va_s0 (UInt64.v bit) (as_vale_buffer p0) (as_vale_buffer p1) va_s1 f
#set-options "--z3rlimit 50"
let cswap_regs_modified: MS.reg_64 -> bool = fun (r:MS.reg_64) ->
let open MS in
if r = rRdi || r = rR8 || r = rR9 || r = rR10 then true
else false
let cswap_xmms_modified = fun _ -> false
[@__reduce__]
let cswap_lemma'
(code:V.va_code)
(_win:bool)
(bit:uint64)
(p0:b64)
(p1:b64)
(va_s0:V.va_state)
: Ghost (V.va_state & V.va_fuel)
(requires
cswap_pre code bit p0 p1 va_s0)
(ensures (fun (va_s1, f) ->
V.eval_code code va_s0 f va_s1 /\
VSig.vale_calling_conventions va_s0 va_s1 cswap_regs_modified cswap_xmms_modified /\
cswap_post code bit p0 p1 va_s0 va_s1 f /\
ME.buffer_readable (VS.vs_get_vale_heap va_s1) (as_vale_buffer p0) /\
ME.buffer_readable (VS.vs_get_vale_heap va_s1) (as_vale_buffer p1) /\
ME.buffer_writeable (as_vale_buffer p0) /\
ME.buffer_writeable (as_vale_buffer p1) /\
ME.modifies (ME.loc_union (ME.loc_buffer (as_vale_buffer p0))
(ME.loc_union (ME.loc_buffer (as_vale_buffer p1))
ME.loc_none)) (VS.vs_get_vale_heap va_s0) (VS.vs_get_vale_heap va_s1)
)) =
let va_s1, f = FU.va_lemma_Cswap2 code va_s0 (UInt64.v bit) (as_vale_buffer p0) (as_vale_buffer p1) in
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt64 ME.TUInt64 p0;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt64 ME.TUInt64 p1;
(va_s1, f)
(* Prove that cswap_lemma' has the required type *)
let cswap_lemma = as_t #(VSig.vale_sig cswap_regs_modified cswap_xmms_modified cswap_pre cswap_post) cswap_lemma'
let code_cswap = FU.va_code_Cswap2 ()
let of_reg (r:MS.reg_64) : option (IX64.reg_nat 3) = match r with
| 5 -> Some 0 // rdi
| 4 -> Some 1 // rsi
| 3 -> Some 2 // rdx
| _ -> None | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Print_Inline_s.fst.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Interop.Assumptions.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.X64.FastUtil.fsti.checked",
"Vale.AsLowStar.Wrapper.fsti.checked",
"Vale.AsLowStar.ValeSig.fst.checked",
"Vale.AsLowStar.MemoryHelpers.fsti.checked",
"Vale.AsLowStar.LowStarSig.fst.checked",
"prims.fst.checked",
"LowStar.BufferView.Down.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Inline.X64.Fswap_inline.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
{
"abbrev": true,
"full_module": "Vale.X64.Print_Inline_s",
"short_module": "PR"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_module": "Vale.X64.State",
"short_module": "VS"
},
{
"abbrev": false,
"full_module": "Vale.X64.MemoryAdapters",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.Wrapper",
"short_module": "W"
},
{
"abbrev": true,
"full_module": "Vale.Interop.Assumptions",
"short_module": "IA"
},
{
"abbrev": true,
"full_module": "Vale.X64.Decls",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Vale.X64.Memory",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.LowStarSig",
"short_module": "LSig"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.ValeSig",
"short_module": "VSig"
},
{
"abbrev": true,
"full_module": "Vale.Interop.X64",
"short_module": "IX64"
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.BufferView.Down",
"short_module": "DV"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | i: Vale.Interop.X64.reg_nat 3 -> Vale.X64.Machine_s.reg_64 | Prims.Tot | [
"total"
] | [] | [
"Vale.Interop.X64.reg_nat",
"Vale.X64.Machine_s.rRdi",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.reg_64"
] | [] | false | false | false | false | false | let of_arg (i: IX64.reg_nat 3) : MS.reg_64 =
| match i with
| 0 -> MS.rRdi
| 1 -> MS.rRsi
| 2 -> MS.rRdx | false |
Pulse.Steel.Wrapper.Typing.fsti | Pulse.Steel.Wrapper.Typing.with_local_body_post | val with_local_body_post (post a ret_t x: term) : term | val with_local_body_post (post a ret_t x: term) : term | let with_local_body_post (post:term) (a:term) (ret_t:term) (x:term) : term =
mk_abs ret_t Q_Explicit (with_local_body_post_body post a x) | {
"file_name": "lib/steel/pulse/Pulse.Steel.Wrapper.Typing.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 62,
"end_line": 362,
"start_col": 0,
"start_line": 361
} | (*
Copyright 2023 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 Pulse.Steel.Wrapper.Typing
open FStar.Reflection.V2
open Pulse.Reflection.Util
module RT = FStar.Reflection.Typing
let return_post_with_eq (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
let x_tm = RT.var_as_term x in
let eq2_tm = mk_eq2 u a x_tm e in
let p_app_x = pack_ln (Tv_App p (x_tm, Q_Explicit)) in
let star_tm = mk_star p_app_x (mk_pure eq2_tm) in
mk_abs a Q_Explicit (RT.subst_term star_tm [ RT.ND x 0 ])
let return_stt_comp (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
mk_stt_comp u a
(pack_ln (Tv_App p (e, Q_Explicit)))
(return_post_with_eq u a e p x)
val return_stt_typing
(#g:env)
(#u:universe)
(#a:term)
(#e:term)
(#p:term)
(x:var{None? (RT.lookup_bvar g x)})
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(e_typing:RT.tot_typing g e a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_return u a e p)
(return_stt_comp u a e p x))
let return_stt_noeq_comp (u:universe) (a:term) (x:term) (p:term) : term =
mk_stt_comp u a (pack_ln (Tv_App p (x, Q_Explicit))) p
val return_stt_noeq_typing
(#g:env)
(#u:universe)
(#a:term)
(#x:term)
(#p:term)
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(x_typing:RT.tot_typing g x a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_return_noeq u a x p)
(return_stt_noeq_comp u a x p))
let neutral_fv = pack_ln (Tv_FVar (pack_fv neutral_lid))
let return_stt_atomic_comp (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
mk_stt_atomic_comp neutral_fv u a emp_inames_tm
(pack_ln (Tv_App p (e, Q_Explicit)))
(return_post_with_eq u a e p x)
val return_stt_atomic_typing
(#g:env)
(#u:universe)
(#a:term)
(#e:term)
(#p:term)
(x:var{None? (RT.lookup_bvar g x)})
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(e_typing:RT.tot_typing g e a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_atomic_return u a e p)
(return_stt_atomic_comp u a e p x))
let return_stt_atomic_noeq_comp (u:universe) (a:term) (x:term) (p:term) : term =
mk_stt_atomic_comp neutral_fv u a emp_inames_tm (pack_ln (Tv_App p (x, Q_Explicit))) p
val return_stt_atomic_noeq_typing
(#g:env)
(#u:universe)
(#a:term)
(#x:term)
(#p:term)
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(x_typing:RT.tot_typing g x a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_atomic_return_noeq u a x p)
(return_stt_atomic_noeq_comp u a x p))
let return_stt_ghost_comp (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
mk_stt_ghost_comp u a
(pack_ln (Tv_App p (e, Q_Explicit)))
(return_post_with_eq u a e p x)
val return_stt_ghost_typing
(#g:env)
(#u:universe)
(#a:term)
(#e:term)
(#p:term)
(x:var{None? (RT.lookup_bvar g x)})
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(e_typing:RT.ghost_typing g e a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_ghost_return u a e p)
(return_stt_ghost_comp u a e p x))
let return_stt_ghost_noeq_comp (u:universe) (a:term) (x:term) (p:term) : term =
mk_stt_ghost_comp u a (pack_ln (Tv_App p (x, Q_Explicit))) p
val return_stt_ghost_noeq_typing
(#g:env)
(#u:universe)
(#a:term)
(#x:term)
(#p:term)
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(x_typing:RT.ghost_typing g x a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_ghost_return_noeq u a x p)
(return_stt_ghost_noeq_comp u a x p))
(*
g |- inv : bool -> vprop
g |- cond : stt<0> bool (exists_ inv) inv
g |- body : stt<0> unit (inv true) (fun _ -> exists_ inv)
-------------------------------------------------------------------------
g |- while inv cond body : stt<0> unit (exists_ inv) (fun _ -> inv false)
*)
val while_typing
(#g:env)
(#inv:term)
(#cond:term)
(#body:term)
(inv_typing:RT.tot_typing g
inv
(mk_arrow (bool_tm, Q_Explicit) vprop_tm))
(cond_typing:RT.tot_typing g
cond
(mk_stt_comp uzero bool_tm (mk_exists uzero bool_tm inv) inv))
(body_typing:RT.tot_typing g
body
(mk_stt_comp uzero unit_tm
(pack_ln (Tv_App inv (true_tm, Q_Explicit)))
(mk_abs unit_tm Q_Explicit (mk_exists uzero bool_tm inv))))
: RT.tot_typing g
(mk_while inv cond body)
(mk_stt_comp uzero unit_tm (mk_exists uzero bool_tm inv)
(mk_abs unit_tm Q_Explicit (pack_ln (Tv_App inv (false_tm, Q_Explicit)))))
let par_post (u:universe) (aL aR:term) (postL postR:term) (x:var) : term =
let x_tm = RT.var_as_term x in
let postL = pack_ln (Tv_App postL (mk_fst u u aL aR x_tm, Q_Explicit)) in
let postR = pack_ln (Tv_App postR (mk_snd u u aL aR x_tm, Q_Explicit)) in
let post = mk_star postL postR in
RT.subst_term post [ RT.ND x 0 ]
val par_typing
(#g:env)
(#u:universe)
(#aL #aR:term)
(#preL #postL:term)
(#preR #postR:term)
(#eL #eR:term)
(x:var{None? (RT.lookup_bvar g x)})
(aL_typing:RT.tot_typing g aL (pack_ln (Tv_Type u)))
(aR_typing:RT.tot_typing g aR (pack_ln (Tv_Type u)))
(preL_typing:RT.tot_typing g preL vprop_tm)
(postL_typing:RT.tot_typing g postL (mk_arrow (aL, Q_Explicit) vprop_tm))
(preR_typing:RT.tot_typing g preR vprop_tm)
(postR_typing:RT.tot_typing g postR (mk_arrow (aR, Q_Explicit) vprop_tm))
(eL_typing:RT.tot_typing g eL (mk_stt_comp u aL preL postL))
(eR_typing:RT.tot_typing g eR (mk_stt_comp u aR preR postR))
: GTot (RT.tot_typing g
(mk_par u aL aR preL postL preR postR eL eR)
(mk_stt_comp u (mk_tuple2 u u aL aR)
(mk_star preL preR)
(mk_abs (mk_tuple2 u u aL aR) Q_Explicit (par_post u aL aR postL postR x))))
val exists_inversion
(#g:env)
(#u:universe)
(#a:term)
(#p:term)
(e_typing:RT.tot_typing g
(mk_exists u a p)
vprop_tm)
: GTot (RT.tot_typing g
p
(mk_arrow (a, Q_Explicit) vprop_tm))
(*
g |- a : Type u
g |- p : a -> vprop
----------------------------------------------------------------
g |- elim_exists<u> #a p : stt_ghost<u> a empty (exists_<u> p) (fun x -> p (reveal x))
*)
let elim_exists_post_body (u:universe) (a:term) (p:term) (x:var) =
let x_tm = RT.var_as_term x in
let reveal_x = mk_reveal u a x_tm in
let post = pack_ln (Tv_App p (reveal_x, Q_Explicit)) in
RT.subst_term post [ RT.ND x 0 ]
let elim_exists_post (u:universe) (a:term) (p:term) (x:var) =
let erased_a = mk_erased u a in
mk_abs erased_a Q_Explicit (elim_exists_post_body u a p x)
val elim_exists_typing
(#g:env)
(#u:universe)
(#a:term)
(#p:term)
(x:var{None? (RT.lookup_bvar g x)})
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_elim_exists u a p)
(mk_stt_ghost_comp
u
(mk_erased u a)
(mk_exists u a p)
(elim_exists_post u a p x)))
(*
g |- a : Type u
g |- p : a -> vprop
g |- e : vprop
-------------------------------------------------------------------------
g |- intro_exists<u> #a p e : stt_ghost<0> unit empty (p e) (fun _ -> exists_ p)
*)
val intro_exists_typing
(#g:env)
(#u:universe)
(#a:term)
(#p:term)
(#e:term)
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
(e_typing:RT.ghost_typing g e a)
: GTot (RT.tot_typing g
(mk_intro_exists u a p e)
(mk_stt_ghost_comp uzero unit_tm
(pack_ln (Tv_App p (e, Q_Explicit)))
(mk_abs unit_tm Q_Explicit (mk_exists u a p))))
(*
g |- a : Type u
g |- p : vprop
g |- q : a -> vprop
------------------------------------------
g |- stt_admit a p q : stt a p q
*)
val stt_admit_typing
(#g:env)
(#u:universe)
(#a:term)
(#p:term)
(#q:term)
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(p_typing:RT.tot_typing g p vprop_tm)
(q_typing:RT.tot_typing g q (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_admit u a p q)
(mk_stt_comp u a p q))
val stt_atomic_admit_typing
(#g:env)
(#u:universe)
(#a:term)
(#p:term)
(#q:term)
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(p_typing:RT.tot_typing g p vprop_tm)
(q_typing:RT.tot_typing g q (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_atomic_admit u a p q)
(mk_stt_atomic_comp neutral_fv u a emp_inames_tm p q))
val stt_ghost_admit_typing
(#g:env)
(#u:universe)
(#a:term)
(#p:term)
(#q:term)
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(p_typing:RT.tot_typing g p vprop_tm)
(q_typing:RT.tot_typing g q (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_ghost_admit u a p q)
(mk_stt_ghost_comp u a p q))
val rewrite_typing
(#g:env)
(#p:term)
(#q:term)
(p_typing:RT.tot_typing g p vprop_tm)
(q_typing:RT.tot_typing g q vprop_tm)
(equiv:RT.tot_typing g (`()) (stt_vprop_equiv p q))
: GTot (RT.tot_typing g
(mk_rewrite p q)
(mk_stt_ghost_comp
uzero
unit_tm
p
(mk_abs unit_tm Q_Explicit q)))
// mk_star pre (mk_pts_to a (RT.bound_var 0) full_perm_tm init
let with_local_body_pre (pre:term) (a:term) (x:term) (init:term) : term =
let pts_to : term =
mk_pts_to a x full_perm_tm init in
mk_star pre pts_to
//
// post has 0 db index free
//
let with_local_body_post_body (post:term) (a:term) (x:term) : term =
// exists_ (R.pts_to r full_perm)
let exists_tm =
mk_exists (pack_universe Uv_Zero) a
(mk_abs a Q_Explicit
(mk_pts_to a x full_perm_tm (RT.bound_var 0))) in
mk_star post exists_tm | {
"checked_file": "/",
"dependencies": [
"Pulse.Reflection.Util.fst.checked",
"prims.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.Steel.Wrapper.Typing.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse.Reflection.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse.Reflection.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Steel.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Steel.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
post: FStar.Stubs.Reflection.Types.term ->
a: FStar.Stubs.Reflection.Types.term ->
ret_t: FStar.Stubs.Reflection.Types.term ->
x: FStar.Stubs.Reflection.Types.term
-> FStar.Stubs.Reflection.Types.term | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.term",
"Pulse.Reflection.Util.mk_abs",
"FStar.Stubs.Reflection.V2.Data.Q_Explicit",
"Pulse.Steel.Wrapper.Typing.with_local_body_post_body"
] | [] | false | false | false | true | false | let with_local_body_post (post a ret_t x: term) : term =
| mk_abs ret_t Q_Explicit (with_local_body_post_body post a x) | false |
Pulse.Steel.Wrapper.Typing.fsti | Pulse.Steel.Wrapper.Typing.par_post | val par_post (u: universe) (aL aR postL postR: term) (x: var) : term | val par_post (u: universe) (aL aR postL postR: term) (x: var) : term | let par_post (u:universe) (aL aR:term) (postL postR:term) (x:var) : term =
let x_tm = RT.var_as_term x in
let postL = pack_ln (Tv_App postL (mk_fst u u aL aR x_tm, Q_Explicit)) in
let postR = pack_ln (Tv_App postR (mk_snd u u aL aR x_tm, Q_Explicit)) in
let post = mk_star postL postR in
RT.subst_term post [ RT.ND x 0 ] | {
"file_name": "lib/steel/pulse/Pulse.Steel.Wrapper.Typing.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 34,
"end_line": 180,
"start_col": 0,
"start_line": 175
} | (*
Copyright 2023 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 Pulse.Steel.Wrapper.Typing
open FStar.Reflection.V2
open Pulse.Reflection.Util
module RT = FStar.Reflection.Typing
let return_post_with_eq (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
let x_tm = RT.var_as_term x in
let eq2_tm = mk_eq2 u a x_tm e in
let p_app_x = pack_ln (Tv_App p (x_tm, Q_Explicit)) in
let star_tm = mk_star p_app_x (mk_pure eq2_tm) in
mk_abs a Q_Explicit (RT.subst_term star_tm [ RT.ND x 0 ])
let return_stt_comp (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
mk_stt_comp u a
(pack_ln (Tv_App p (e, Q_Explicit)))
(return_post_with_eq u a e p x)
val return_stt_typing
(#g:env)
(#u:universe)
(#a:term)
(#e:term)
(#p:term)
(x:var{None? (RT.lookup_bvar g x)})
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(e_typing:RT.tot_typing g e a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_return u a e p)
(return_stt_comp u a e p x))
let return_stt_noeq_comp (u:universe) (a:term) (x:term) (p:term) : term =
mk_stt_comp u a (pack_ln (Tv_App p (x, Q_Explicit))) p
val return_stt_noeq_typing
(#g:env)
(#u:universe)
(#a:term)
(#x:term)
(#p:term)
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(x_typing:RT.tot_typing g x a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_return_noeq u a x p)
(return_stt_noeq_comp u a x p))
let neutral_fv = pack_ln (Tv_FVar (pack_fv neutral_lid))
let return_stt_atomic_comp (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
mk_stt_atomic_comp neutral_fv u a emp_inames_tm
(pack_ln (Tv_App p (e, Q_Explicit)))
(return_post_with_eq u a e p x)
val return_stt_atomic_typing
(#g:env)
(#u:universe)
(#a:term)
(#e:term)
(#p:term)
(x:var{None? (RT.lookup_bvar g x)})
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(e_typing:RT.tot_typing g e a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_atomic_return u a e p)
(return_stt_atomic_comp u a e p x))
let return_stt_atomic_noeq_comp (u:universe) (a:term) (x:term) (p:term) : term =
mk_stt_atomic_comp neutral_fv u a emp_inames_tm (pack_ln (Tv_App p (x, Q_Explicit))) p
val return_stt_atomic_noeq_typing
(#g:env)
(#u:universe)
(#a:term)
(#x:term)
(#p:term)
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(x_typing:RT.tot_typing g x a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_atomic_return_noeq u a x p)
(return_stt_atomic_noeq_comp u a x p))
let return_stt_ghost_comp (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
mk_stt_ghost_comp u a
(pack_ln (Tv_App p (e, Q_Explicit)))
(return_post_with_eq u a e p x)
val return_stt_ghost_typing
(#g:env)
(#u:universe)
(#a:term)
(#e:term)
(#p:term)
(x:var{None? (RT.lookup_bvar g x)})
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(e_typing:RT.ghost_typing g e a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_ghost_return u a e p)
(return_stt_ghost_comp u a e p x))
let return_stt_ghost_noeq_comp (u:universe) (a:term) (x:term) (p:term) : term =
mk_stt_ghost_comp u a (pack_ln (Tv_App p (x, Q_Explicit))) p
val return_stt_ghost_noeq_typing
(#g:env)
(#u:universe)
(#a:term)
(#x:term)
(#p:term)
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(x_typing:RT.ghost_typing g x a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_ghost_return_noeq u a x p)
(return_stt_ghost_noeq_comp u a x p))
(*
g |- inv : bool -> vprop
g |- cond : stt<0> bool (exists_ inv) inv
g |- body : stt<0> unit (inv true) (fun _ -> exists_ inv)
-------------------------------------------------------------------------
g |- while inv cond body : stt<0> unit (exists_ inv) (fun _ -> inv false)
*)
val while_typing
(#g:env)
(#inv:term)
(#cond:term)
(#body:term)
(inv_typing:RT.tot_typing g
inv
(mk_arrow (bool_tm, Q_Explicit) vprop_tm))
(cond_typing:RT.tot_typing g
cond
(mk_stt_comp uzero bool_tm (mk_exists uzero bool_tm inv) inv))
(body_typing:RT.tot_typing g
body
(mk_stt_comp uzero unit_tm
(pack_ln (Tv_App inv (true_tm, Q_Explicit)))
(mk_abs unit_tm Q_Explicit (mk_exists uzero bool_tm inv))))
: RT.tot_typing g
(mk_while inv cond body)
(mk_stt_comp uzero unit_tm (mk_exists uzero bool_tm inv)
(mk_abs unit_tm Q_Explicit (pack_ln (Tv_App inv (false_tm, Q_Explicit))))) | {
"checked_file": "/",
"dependencies": [
"Pulse.Reflection.Util.fst.checked",
"prims.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.Steel.Wrapper.Typing.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse.Reflection.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse.Reflection.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Steel.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Steel.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
u134: FStar.Stubs.Reflection.Types.universe ->
aL: FStar.Stubs.Reflection.Types.term ->
aR: FStar.Stubs.Reflection.Types.term ->
postL: FStar.Stubs.Reflection.Types.term ->
postR: FStar.Stubs.Reflection.Types.term ->
x: FStar.Stubs.Reflection.V2.Data.var
-> FStar.Stubs.Reflection.Types.term | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.universe",
"FStar.Stubs.Reflection.Types.term",
"FStar.Stubs.Reflection.V2.Data.var",
"FStar.Reflection.Typing.subst_term",
"Prims.Cons",
"FStar.Reflection.Typing.subst_elt",
"FStar.Reflection.Typing.ND",
"Prims.Nil",
"Pulse.Reflection.Util.mk_star",
"FStar.Stubs.Reflection.V2.Builtins.pack_ln",
"FStar.Stubs.Reflection.V2.Data.Tv_App",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Stubs.Reflection.V2.Data.aqualv",
"Pulse.Reflection.Util.mk_snd",
"FStar.Stubs.Reflection.V2.Data.Q_Explicit",
"Pulse.Reflection.Util.mk_fst",
"FStar.Reflection.Typing.var_as_term"
] | [] | false | false | false | true | false | let par_post (u: universe) (aL aR postL postR: term) (x: var) : term =
| let x_tm = RT.var_as_term x in
let postL = pack_ln (Tv_App postL (mk_fst u u aL aR x_tm, Q_Explicit)) in
let postR = pack_ln (Tv_App postR (mk_snd u u aL aR x_tm, Q_Explicit)) in
let post = mk_star postL postR in
RT.subst_term post [RT.ND x 0] | false |
Pulse.Steel.Wrapper.Typing.fsti | Pulse.Steel.Wrapper.Typing.return_stt_atomic_noeq_comp | val return_stt_atomic_noeq_comp (u: universe) (a x p: term) : term | val return_stt_atomic_noeq_comp (u: universe) (a x p: term) : term | let return_stt_atomic_noeq_comp (u:universe) (a:term) (x:term) (p:term) : term =
mk_stt_atomic_comp neutral_fv u a emp_inames_tm (pack_ln (Tv_App p (x, Q_Explicit))) p | {
"file_name": "lib/steel/pulse/Pulse.Steel.Wrapper.Typing.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 88,
"end_line": 90,
"start_col": 0,
"start_line": 89
} | (*
Copyright 2023 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 Pulse.Steel.Wrapper.Typing
open FStar.Reflection.V2
open Pulse.Reflection.Util
module RT = FStar.Reflection.Typing
let return_post_with_eq (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
let x_tm = RT.var_as_term x in
let eq2_tm = mk_eq2 u a x_tm e in
let p_app_x = pack_ln (Tv_App p (x_tm, Q_Explicit)) in
let star_tm = mk_star p_app_x (mk_pure eq2_tm) in
mk_abs a Q_Explicit (RT.subst_term star_tm [ RT.ND x 0 ])
let return_stt_comp (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
mk_stt_comp u a
(pack_ln (Tv_App p (e, Q_Explicit)))
(return_post_with_eq u a e p x)
val return_stt_typing
(#g:env)
(#u:universe)
(#a:term)
(#e:term)
(#p:term)
(x:var{None? (RT.lookup_bvar g x)})
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(e_typing:RT.tot_typing g e a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_return u a e p)
(return_stt_comp u a e p x))
let return_stt_noeq_comp (u:universe) (a:term) (x:term) (p:term) : term =
mk_stt_comp u a (pack_ln (Tv_App p (x, Q_Explicit))) p
val return_stt_noeq_typing
(#g:env)
(#u:universe)
(#a:term)
(#x:term)
(#p:term)
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(x_typing:RT.tot_typing g x a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_return_noeq u a x p)
(return_stt_noeq_comp u a x p))
let neutral_fv = pack_ln (Tv_FVar (pack_fv neutral_lid))
let return_stt_atomic_comp (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
mk_stt_atomic_comp neutral_fv u a emp_inames_tm
(pack_ln (Tv_App p (e, Q_Explicit)))
(return_post_with_eq u a e p x)
val return_stt_atomic_typing
(#g:env)
(#u:universe)
(#a:term)
(#e:term)
(#p:term)
(x:var{None? (RT.lookup_bvar g x)})
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(e_typing:RT.tot_typing g e a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_atomic_return u a e p)
(return_stt_atomic_comp u a e p x)) | {
"checked_file": "/",
"dependencies": [
"Pulse.Reflection.Util.fst.checked",
"prims.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.Steel.Wrapper.Typing.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse.Reflection.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse.Reflection.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Steel.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Steel.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
u72: FStar.Stubs.Reflection.Types.universe ->
a: FStar.Stubs.Reflection.Types.term ->
x: FStar.Stubs.Reflection.Types.term ->
p: FStar.Stubs.Reflection.Types.term
-> FStar.Stubs.Reflection.Types.term | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.universe",
"FStar.Stubs.Reflection.Types.term",
"Pulse.Reflection.Util.mk_stt_atomic_comp",
"Pulse.Steel.Wrapper.Typing.neutral_fv",
"Pulse.Reflection.Util.emp_inames_tm",
"FStar.Stubs.Reflection.V2.Builtins.pack_ln",
"FStar.Stubs.Reflection.V2.Data.Tv_App",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Stubs.Reflection.V2.Data.aqualv",
"FStar.Stubs.Reflection.V2.Data.Q_Explicit"
] | [] | false | false | false | true | false | let return_stt_atomic_noeq_comp (u: universe) (a x p: term) : term =
| mk_stt_atomic_comp neutral_fv u a emp_inames_tm (pack_ln (Tv_App p (x, Q_Explicit))) p | false |
Pulse.Steel.Wrapper.Typing.fsti | Pulse.Steel.Wrapper.Typing.return_stt_ghost_noeq_comp | val return_stt_ghost_noeq_comp (u: universe) (a x p: term) : term | val return_stt_ghost_noeq_comp (u: universe) (a x p: term) : term | let return_stt_ghost_noeq_comp (u:universe) (a:term) (x:term) (p:term) : term =
mk_stt_ghost_comp u a (pack_ln (Tv_App p (x, Q_Explicit))) p | {
"file_name": "lib/steel/pulse/Pulse.Steel.Wrapper.Typing.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 62,
"end_line": 127,
"start_col": 0,
"start_line": 126
} | (*
Copyright 2023 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 Pulse.Steel.Wrapper.Typing
open FStar.Reflection.V2
open Pulse.Reflection.Util
module RT = FStar.Reflection.Typing
let return_post_with_eq (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
let x_tm = RT.var_as_term x in
let eq2_tm = mk_eq2 u a x_tm e in
let p_app_x = pack_ln (Tv_App p (x_tm, Q_Explicit)) in
let star_tm = mk_star p_app_x (mk_pure eq2_tm) in
mk_abs a Q_Explicit (RT.subst_term star_tm [ RT.ND x 0 ])
let return_stt_comp (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
mk_stt_comp u a
(pack_ln (Tv_App p (e, Q_Explicit)))
(return_post_with_eq u a e p x)
val return_stt_typing
(#g:env)
(#u:universe)
(#a:term)
(#e:term)
(#p:term)
(x:var{None? (RT.lookup_bvar g x)})
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(e_typing:RT.tot_typing g e a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_return u a e p)
(return_stt_comp u a e p x))
let return_stt_noeq_comp (u:universe) (a:term) (x:term) (p:term) : term =
mk_stt_comp u a (pack_ln (Tv_App p (x, Q_Explicit))) p
val return_stt_noeq_typing
(#g:env)
(#u:universe)
(#a:term)
(#x:term)
(#p:term)
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(x_typing:RT.tot_typing g x a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_return_noeq u a x p)
(return_stt_noeq_comp u a x p))
let neutral_fv = pack_ln (Tv_FVar (pack_fv neutral_lid))
let return_stt_atomic_comp (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
mk_stt_atomic_comp neutral_fv u a emp_inames_tm
(pack_ln (Tv_App p (e, Q_Explicit)))
(return_post_with_eq u a e p x)
val return_stt_atomic_typing
(#g:env)
(#u:universe)
(#a:term)
(#e:term)
(#p:term)
(x:var{None? (RT.lookup_bvar g x)})
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(e_typing:RT.tot_typing g e a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_atomic_return u a e p)
(return_stt_atomic_comp u a e p x))
let return_stt_atomic_noeq_comp (u:universe) (a:term) (x:term) (p:term) : term =
mk_stt_atomic_comp neutral_fv u a emp_inames_tm (pack_ln (Tv_App p (x, Q_Explicit))) p
val return_stt_atomic_noeq_typing
(#g:env)
(#u:universe)
(#a:term)
(#x:term)
(#p:term)
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(x_typing:RT.tot_typing g x a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_atomic_return_noeq u a x p)
(return_stt_atomic_noeq_comp u a x p))
let return_stt_ghost_comp (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
mk_stt_ghost_comp u a
(pack_ln (Tv_App p (e, Q_Explicit)))
(return_post_with_eq u a e p x)
val return_stt_ghost_typing
(#g:env)
(#u:universe)
(#a:term)
(#e:term)
(#p:term)
(x:var{None? (RT.lookup_bvar g x)})
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(e_typing:RT.ghost_typing g e a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_ghost_return u a e p)
(return_stt_ghost_comp u a e p x)) | {
"checked_file": "/",
"dependencies": [
"Pulse.Reflection.Util.fst.checked",
"prims.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.Steel.Wrapper.Typing.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse.Reflection.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse.Reflection.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Steel.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Steel.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
u107: FStar.Stubs.Reflection.Types.universe ->
a: FStar.Stubs.Reflection.Types.term ->
x: FStar.Stubs.Reflection.Types.term ->
p: FStar.Stubs.Reflection.Types.term
-> FStar.Stubs.Reflection.Types.term | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.universe",
"FStar.Stubs.Reflection.Types.term",
"Pulse.Reflection.Util.mk_stt_ghost_comp",
"FStar.Stubs.Reflection.V2.Builtins.pack_ln",
"FStar.Stubs.Reflection.V2.Data.Tv_App",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Stubs.Reflection.V2.Data.aqualv",
"FStar.Stubs.Reflection.V2.Data.Q_Explicit"
] | [] | false | false | false | true | false | let return_stt_ghost_noeq_comp (u: universe) (a x p: term) : term =
| mk_stt_ghost_comp u a (pack_ln (Tv_App p (x, Q_Explicit))) p | false |
Pulse.Steel.Wrapper.Typing.fsti | Pulse.Steel.Wrapper.Typing.elim_exists_post | val elim_exists_post : u174: FStar.Stubs.Reflection.Types.universe ->
a: FStar.Stubs.Reflection.Types.term ->
p: FStar.Stubs.Reflection.Types.term ->
x: FStar.Stubs.Reflection.V2.Data.var
-> FStar.Stubs.Reflection.Types.term | let elim_exists_post (u:universe) (a:term) (p:term) (x:var) =
let erased_a = mk_erased u a in
mk_abs erased_a Q_Explicit (elim_exists_post_body u a p x) | {
"file_name": "lib/steel/pulse/Pulse.Steel.Wrapper.Typing.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 60,
"end_line": 234,
"start_col": 0,
"start_line": 232
} | (*
Copyright 2023 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 Pulse.Steel.Wrapper.Typing
open FStar.Reflection.V2
open Pulse.Reflection.Util
module RT = FStar.Reflection.Typing
let return_post_with_eq (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
let x_tm = RT.var_as_term x in
let eq2_tm = mk_eq2 u a x_tm e in
let p_app_x = pack_ln (Tv_App p (x_tm, Q_Explicit)) in
let star_tm = mk_star p_app_x (mk_pure eq2_tm) in
mk_abs a Q_Explicit (RT.subst_term star_tm [ RT.ND x 0 ])
let return_stt_comp (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
mk_stt_comp u a
(pack_ln (Tv_App p (e, Q_Explicit)))
(return_post_with_eq u a e p x)
val return_stt_typing
(#g:env)
(#u:universe)
(#a:term)
(#e:term)
(#p:term)
(x:var{None? (RT.lookup_bvar g x)})
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(e_typing:RT.tot_typing g e a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_return u a e p)
(return_stt_comp u a e p x))
let return_stt_noeq_comp (u:universe) (a:term) (x:term) (p:term) : term =
mk_stt_comp u a (pack_ln (Tv_App p (x, Q_Explicit))) p
val return_stt_noeq_typing
(#g:env)
(#u:universe)
(#a:term)
(#x:term)
(#p:term)
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(x_typing:RT.tot_typing g x a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_return_noeq u a x p)
(return_stt_noeq_comp u a x p))
let neutral_fv = pack_ln (Tv_FVar (pack_fv neutral_lid))
let return_stt_atomic_comp (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
mk_stt_atomic_comp neutral_fv u a emp_inames_tm
(pack_ln (Tv_App p (e, Q_Explicit)))
(return_post_with_eq u a e p x)
val return_stt_atomic_typing
(#g:env)
(#u:universe)
(#a:term)
(#e:term)
(#p:term)
(x:var{None? (RT.lookup_bvar g x)})
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(e_typing:RT.tot_typing g e a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_atomic_return u a e p)
(return_stt_atomic_comp u a e p x))
let return_stt_atomic_noeq_comp (u:universe) (a:term) (x:term) (p:term) : term =
mk_stt_atomic_comp neutral_fv u a emp_inames_tm (pack_ln (Tv_App p (x, Q_Explicit))) p
val return_stt_atomic_noeq_typing
(#g:env)
(#u:universe)
(#a:term)
(#x:term)
(#p:term)
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(x_typing:RT.tot_typing g x a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_atomic_return_noeq u a x p)
(return_stt_atomic_noeq_comp u a x p))
let return_stt_ghost_comp (u:universe) (a:term) (e:term) (p:term) (x:var) : term =
mk_stt_ghost_comp u a
(pack_ln (Tv_App p (e, Q_Explicit)))
(return_post_with_eq u a e p x)
val return_stt_ghost_typing
(#g:env)
(#u:universe)
(#a:term)
(#e:term)
(#p:term)
(x:var{None? (RT.lookup_bvar g x)})
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(e_typing:RT.ghost_typing g e a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_ghost_return u a e p)
(return_stt_ghost_comp u a e p x))
let return_stt_ghost_noeq_comp (u:universe) (a:term) (x:term) (p:term) : term =
mk_stt_ghost_comp u a (pack_ln (Tv_App p (x, Q_Explicit))) p
val return_stt_ghost_noeq_typing
(#g:env)
(#u:universe)
(#a:term)
(#x:term)
(#p:term)
(a_typing:RT.tot_typing g a (pack_ln (Tv_Type u)))
(x_typing:RT.ghost_typing g x a)
(p_typing:RT.tot_typing g p (mk_arrow (a, Q_Explicit) vprop_tm))
: GTot (RT.tot_typing g
(mk_stt_ghost_return_noeq u a x p)
(return_stt_ghost_noeq_comp u a x p))
(*
g |- inv : bool -> vprop
g |- cond : stt<0> bool (exists_ inv) inv
g |- body : stt<0> unit (inv true) (fun _ -> exists_ inv)
-------------------------------------------------------------------------
g |- while inv cond body : stt<0> unit (exists_ inv) (fun _ -> inv false)
*)
val while_typing
(#g:env)
(#inv:term)
(#cond:term)
(#body:term)
(inv_typing:RT.tot_typing g
inv
(mk_arrow (bool_tm, Q_Explicit) vprop_tm))
(cond_typing:RT.tot_typing g
cond
(mk_stt_comp uzero bool_tm (mk_exists uzero bool_tm inv) inv))
(body_typing:RT.tot_typing g
body
(mk_stt_comp uzero unit_tm
(pack_ln (Tv_App inv (true_tm, Q_Explicit)))
(mk_abs unit_tm Q_Explicit (mk_exists uzero bool_tm inv))))
: RT.tot_typing g
(mk_while inv cond body)
(mk_stt_comp uzero unit_tm (mk_exists uzero bool_tm inv)
(mk_abs unit_tm Q_Explicit (pack_ln (Tv_App inv (false_tm, Q_Explicit)))))
let par_post (u:universe) (aL aR:term) (postL postR:term) (x:var) : term =
let x_tm = RT.var_as_term x in
let postL = pack_ln (Tv_App postL (mk_fst u u aL aR x_tm, Q_Explicit)) in
let postR = pack_ln (Tv_App postR (mk_snd u u aL aR x_tm, Q_Explicit)) in
let post = mk_star postL postR in
RT.subst_term post [ RT.ND x 0 ]
val par_typing
(#g:env)
(#u:universe)
(#aL #aR:term)
(#preL #postL:term)
(#preR #postR:term)
(#eL #eR:term)
(x:var{None? (RT.lookup_bvar g x)})
(aL_typing:RT.tot_typing g aL (pack_ln (Tv_Type u)))
(aR_typing:RT.tot_typing g aR (pack_ln (Tv_Type u)))
(preL_typing:RT.tot_typing g preL vprop_tm)
(postL_typing:RT.tot_typing g postL (mk_arrow (aL, Q_Explicit) vprop_tm))
(preR_typing:RT.tot_typing g preR vprop_tm)
(postR_typing:RT.tot_typing g postR (mk_arrow (aR, Q_Explicit) vprop_tm))
(eL_typing:RT.tot_typing g eL (mk_stt_comp u aL preL postL))
(eR_typing:RT.tot_typing g eR (mk_stt_comp u aR preR postR))
: GTot (RT.tot_typing g
(mk_par u aL aR preL postL preR postR eL eR)
(mk_stt_comp u (mk_tuple2 u u aL aR)
(mk_star preL preR)
(mk_abs (mk_tuple2 u u aL aR) Q_Explicit (par_post u aL aR postL postR x))))
val exists_inversion
(#g:env)
(#u:universe)
(#a:term)
(#p:term)
(e_typing:RT.tot_typing g
(mk_exists u a p)
vprop_tm)
: GTot (RT.tot_typing g
p
(mk_arrow (a, Q_Explicit) vprop_tm))
(*
g |- a : Type u
g |- p : a -> vprop
----------------------------------------------------------------
g |- elim_exists<u> #a p : stt_ghost<u> a empty (exists_<u> p) (fun x -> p (reveal x))
*)
let elim_exists_post_body (u:universe) (a:term) (p:term) (x:var) =
let x_tm = RT.var_as_term x in
let reveal_x = mk_reveal u a x_tm in
let post = pack_ln (Tv_App p (reveal_x, Q_Explicit)) in
RT.subst_term post [ RT.ND x 0 ] | {
"checked_file": "/",
"dependencies": [
"Pulse.Reflection.Util.fst.checked",
"prims.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.Steel.Wrapper.Typing.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse.Reflection.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse.Reflection.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Steel.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Steel.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
u174: FStar.Stubs.Reflection.Types.universe ->
a: FStar.Stubs.Reflection.Types.term ->
p: FStar.Stubs.Reflection.Types.term ->
x: FStar.Stubs.Reflection.V2.Data.var
-> FStar.Stubs.Reflection.Types.term | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.universe",
"FStar.Stubs.Reflection.Types.term",
"FStar.Stubs.Reflection.V2.Data.var",
"Pulse.Reflection.Util.mk_abs",
"FStar.Stubs.Reflection.V2.Data.Q_Explicit",
"Pulse.Steel.Wrapper.Typing.elim_exists_post_body",
"Pulse.Reflection.Util.mk_erased"
] | [] | false | false | false | true | false | let elim_exists_post (u: universe) (a p: term) (x: var) =
| let erased_a = mk_erased u a in
mk_abs erased_a Q_Explicit (elim_exists_post_body u a p x) | false |
|
Vale.Inline.X64.Fswap_inline.fst | Vale.Inline.X64.Fswap_inline.lowstar_cswap_t | val lowstar_cswap_t : Type0 | let lowstar_cswap_t =
assert_norm (List.length cswap_dom + List.length ([]<:list arg) <= 3);
IX64.as_lowstar_sig_t_weak
3
arg_reg
cswap_regs_modified
cswap_xmms_modified
code_cswap
cswap_dom
[]
_
_
// The boolean here doesn't matter
(W.mk_prediction code_cswap cswap_dom [] (cswap_lemma code_cswap IA.win)) | {
"file_name": "vale/code/arch/x64/interop/Vale.Inline.X64.Fswap_inline.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 77,
"end_line": 138,
"start_col": 0,
"start_line": 125
} | module Vale.Inline.X64.Fswap_inline
open FStar.Mul
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module B = LowStar.Buffer
module DV = LowStar.BufferView.Down
open Vale.Def.Types_s
open Vale.Interop.Base
module IX64 = Vale.Interop.X64
module VSig = Vale.AsLowStar.ValeSig
module LSig = Vale.AsLowStar.LowStarSig
module ME = Vale.X64.Memory
module V = Vale.X64.Decls
module IA = Vale.Interop.Assumptions
module W = Vale.AsLowStar.Wrapper
open Vale.X64.MemoryAdapters
module VS = Vale.X64.State
module MS = Vale.X64.Machine_s
module PR = Vale.X64.Print_Inline_s
module FU = Vale.Curve25519.X64.FastUtil
let uint64 = UInt64.t
(* A little utility to trigger normalization in types *)
let as_t (#a:Type) (x:normal a) : a = x
let as_normal_t (#a:Type) (x:a) : normal a = x
[@__reduce__]
let b64 = buf_t TUInt64 TUInt64
[@__reduce__]
let t64_mod = TD_Buffer TUInt64 TUInt64 default_bq
[@__reduce__]
let t64_no_mod = TD_Buffer TUInt64 TUInt64 ({modified=false; strict_disjointness=false; taint=MS.Secret})
[@__reduce__]
let tuint64 = TD_Base TUInt64
[@__reduce__]
let cswap_dom: IX64.arity_ok 3 td =
let y = [tuint64; t64_mod; t64_mod] in
assert_norm (List.length y = 3);
y
(* Need to rearrange the order of arguments *)
[@__reduce__]
let cswap_pre : VSig.vale_pre cswap_dom =
fun (c:V.va_code)
(bit:uint64)
(p0:b64)
(p1:b64)
(va_s0:V.va_state) ->
FU.va_req_Cswap2 c va_s0
(UInt64.v bit) (as_vale_buffer p0) (as_vale_buffer p1)
[@__reduce__]
let cswap_post : VSig.vale_post cswap_dom =
fun (c:V.va_code)
(bit:uint64)
(p0:b64)
(p1:b64)
(va_s0:V.va_state)
(va_s1:V.va_state)
(f:V.va_fuel) ->
FU.va_ens_Cswap2 c va_s0 (UInt64.v bit) (as_vale_buffer p0) (as_vale_buffer p1) va_s1 f
#set-options "--z3rlimit 50"
let cswap_regs_modified: MS.reg_64 -> bool = fun (r:MS.reg_64) ->
let open MS in
if r = rRdi || r = rR8 || r = rR9 || r = rR10 then true
else false
let cswap_xmms_modified = fun _ -> false
[@__reduce__]
let cswap_lemma'
(code:V.va_code)
(_win:bool)
(bit:uint64)
(p0:b64)
(p1:b64)
(va_s0:V.va_state)
: Ghost (V.va_state & V.va_fuel)
(requires
cswap_pre code bit p0 p1 va_s0)
(ensures (fun (va_s1, f) ->
V.eval_code code va_s0 f va_s1 /\
VSig.vale_calling_conventions va_s0 va_s1 cswap_regs_modified cswap_xmms_modified /\
cswap_post code bit p0 p1 va_s0 va_s1 f /\
ME.buffer_readable (VS.vs_get_vale_heap va_s1) (as_vale_buffer p0) /\
ME.buffer_readable (VS.vs_get_vale_heap va_s1) (as_vale_buffer p1) /\
ME.buffer_writeable (as_vale_buffer p0) /\
ME.buffer_writeable (as_vale_buffer p1) /\
ME.modifies (ME.loc_union (ME.loc_buffer (as_vale_buffer p0))
(ME.loc_union (ME.loc_buffer (as_vale_buffer p1))
ME.loc_none)) (VS.vs_get_vale_heap va_s0) (VS.vs_get_vale_heap va_s1)
)) =
let va_s1, f = FU.va_lemma_Cswap2 code va_s0 (UInt64.v bit) (as_vale_buffer p0) (as_vale_buffer p1) in
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt64 ME.TUInt64 p0;
Vale.AsLowStar.MemoryHelpers.buffer_writeable_reveal ME.TUInt64 ME.TUInt64 p1;
(va_s1, f)
(* Prove that cswap_lemma' has the required type *)
let cswap_lemma = as_t #(VSig.vale_sig cswap_regs_modified cswap_xmms_modified cswap_pre cswap_post) cswap_lemma'
let code_cswap = FU.va_code_Cswap2 ()
let of_reg (r:MS.reg_64) : option (IX64.reg_nat 3) = match r with
| 5 -> Some 0 // rdi
| 4 -> Some 1 // rsi
| 3 -> Some 2 // rdx
| _ -> None
let of_arg (i:IX64.reg_nat 3) : MS.reg_64 = match i with
| 0 -> MS.rRdi
| 1 -> MS.rRsi
| 2 -> MS.rRdx
let arg_reg : IX64.arg_reg_relation 3 = IX64.Rel of_reg of_arg
(* Here's the type expected for the cswap wrapper *) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Print_Inline_s.fst.checked",
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Interop.Assumptions.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.X64.FastUtil.fsti.checked",
"Vale.AsLowStar.Wrapper.fsti.checked",
"Vale.AsLowStar.ValeSig.fst.checked",
"Vale.AsLowStar.MemoryHelpers.fsti.checked",
"Vale.AsLowStar.LowStarSig.fst.checked",
"prims.fst.checked",
"LowStar.BufferView.Down.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Inline.X64.Fswap_inline.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.Curve25519.X64.FastUtil",
"short_module": "FU"
},
{
"abbrev": true,
"full_module": "Vale.X64.Print_Inline_s",
"short_module": "PR"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_s",
"short_module": "MS"
},
{
"abbrev": true,
"full_module": "Vale.X64.State",
"short_module": "VS"
},
{
"abbrev": false,
"full_module": "Vale.X64.MemoryAdapters",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.Wrapper",
"short_module": "W"
},
{
"abbrev": true,
"full_module": "Vale.Interop.Assumptions",
"short_module": "IA"
},
{
"abbrev": true,
"full_module": "Vale.X64.Decls",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Vale.X64.Memory",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.LowStarSig",
"short_module": "LSig"
},
{
"abbrev": true,
"full_module": "Vale.AsLowStar.ValeSig",
"short_module": "VSig"
},
{
"abbrev": true,
"full_module": "Vale.Interop.X64",
"short_module": "IX64"
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.BufferView.Down",
"short_module": "DV"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Inline.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.Interop.X64.as_lowstar_sig_t_weak",
"Vale.Inline.X64.Fswap_inline.arg_reg",
"Vale.Inline.X64.Fswap_inline.cswap_regs_modified",
"Vale.Inline.X64.Fswap_inline.cswap_xmms_modified",
"Vale.X64.Machine_s.reg_xmm",
"Vale.Inline.X64.Fswap_inline.code_cswap",
"Vale.Inline.X64.Fswap_inline.cswap_dom",
"Prims.Nil",
"Vale.Interop.Base.arg",
"Vale.AsLowStar.Wrapper.pre_rel_generic",
"Vale.Inline.X64.Fswap_inline.cswap_pre",
"Vale.AsLowStar.Wrapper.post_rel_generic",
"Vale.Inline.X64.Fswap_inline.cswap_post",
"Vale.AsLowStar.Wrapper.mk_prediction",
"Vale.Inline.X64.Fswap_inline.cswap_lemma",
"Vale.Interop.Assumptions.win",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"FStar.List.Tot.Base.length",
"Vale.Interop.Base.td",
"Prims.list"
] | [] | false | false | false | true | true | let lowstar_cswap_t =
| assert_norm (List.length cswap_dom + List.length ([] <: list arg) <= 3);
IX64.as_lowstar_sig_t_weak 3 arg_reg cswap_regs_modified cswap_xmms_modified code_cswap cswap_dom []
_ _ (W.mk_prediction code_cswap cswap_dom [] (cswap_lemma code_cswap IA.win)) | false |
|
Vale.SHA.PPC64LE.SHA_helpers.fsti | Vale.SHA.PPC64LE.SHA_helpers.update_multi_quads | val update_multi_quads (s: seq quad32) (hash_orig: hash256) : Tot (hash256) (decreases (length s)) | val update_multi_quads (s: seq quad32) (hash_orig: hash256) : Tot (hash256) (decreases (length s)) | let rec update_multi_quads (s:seq quad32) (hash_orig:hash256) : Tot (hash256) (decreases (length s))
=
if length s < 4 then
hash_orig
else
let prefix, qs = split s (length s - 4) in
let h_prefix = update_multi_quads prefix hash_orig in
let hash = update_block h_prefix (quads_to_block_be qs) in
hash | {
"file_name": "vale/code/crypto/sha/Vale.SHA.PPC64LE.SHA_helpers.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 8,
"end_line": 267,
"start_col": 0,
"start_line": 259
} | module Vale.SHA.PPC64LE.SHA_helpers
open FStar.Mul
open Vale.Def.Prop_s
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open FStar.Seq
open Vale.Arch.Types
open Vale.Def.Sel
open Vale.SHA2.Wrapper
open Vale.Def.Words.Four_s
unfold let (.[]) = FStar.Seq.index
#reset-options "--max_fuel 0 --max_ifuel 0"
// Specialize these definitions (from Spec.SHA2.fst) for SHA256
unfold let size_k_w_256 = 64
val word:Type0
(* Number of words for a block size *)
let size_block_w_256 = 16
(* Define the size block in bytes *)
let block_length =
4 (*word_length a*) * size_block_w_256
let block_w = m:seq word {length m = size_block_w_256}
let counter = nat
val k : (s:seq word {length s = size_k_w_256})
let hash256 = m:Seq.seq word {Seq.length m = 8}
(* Input data. *)
type byte = UInt8.t
type bytes = Seq.seq byte
(* Input data, multiple of a block length. *)
let bytes_blocks =
l:bytes { Seq.length l % block_length = 0 }
// Hide various SHA2 definitions
val ws_opaque (b:block_w) (t:counter{t < size_k_w_256}):nat32
val shuffle_core_opaque (block:block_w) (hash:hash256) (t:counter{t < size_k_w_256}):hash256
val update_multi_opaque (hash:hash256) (blocks:bytes_blocks):hash256
val update_multi_transparent (hash:hash256) (blocks:bytes_blocks):hash256
// Hide some functions that operate on words & bytes
val word_to_nat32 (x:word) : nat32
val nat32_to_word (x:nat32) : word
//unfold let bytes_blocks256 = bytes_blocks SHA2_256
let repeat_range_vale (max:nat { max < size_k_w_256}) (block:block_w) (hash:hash256) =
Spec.Loops.repeat_range 0 max (shuffle_core_opaque block) hash
let update_multi_opaque_vale (hash:hash256) (blocks:bytes) : hash256 =
if length blocks % size_k_w_256 = 0 then let b:bytes_blocks = blocks in update_multi_opaque hash b else hash
val make_ordered_hash (abcd efgh:quad32): Pure (hash256)
(requires True)
(ensures fun hash ->
length hash == 8 /\
hash.[0] == nat32_to_word abcd.lo0 /\
hash.[1] == nat32_to_word abcd.lo1 /\
hash.[2] == nat32_to_word abcd.hi2 /\
hash.[3] == nat32_to_word abcd.hi3 /\
hash.[4] == nat32_to_word efgh.lo0 /\
hash.[5] == nat32_to_word efgh.lo1 /\
hash.[6] == nat32_to_word efgh.hi2 /\
hash.[7] == nat32_to_word efgh.hi3
)
val update_block (hash:hash256) (block:block_w): hash256
val lemma_update_multi_opaque_vale_is_update_multi (hash:hash256) (blocks:bytes) : Lemma
(requires length blocks % 64 = 0)
(ensures update_multi_opaque_vale hash blocks == update_multi_transparent hash blocks)
val sigma_0_0_partial_def (t:counter) (block:block_w) : nat32
[@"opaque_to_smt"] let sigma_0_0_partial = opaque_make sigma_0_0_partial_def
irreducible let sigma_0_0_partial_reveal = opaque_revealer (`%sigma_0_0_partial) sigma_0_0_partial sigma_0_0_partial_def
val lemma_sha256_sigma0 (src:quad32) (t:counter) (block:block_w) : Lemma
(requires 16 <= t /\ t < size_k_w_256 /\
src.hi3 == ws_opaque block (t-15))
(ensures (sigma256_0_0 src.hi3 == sigma_0_0_partial t block))
val sigma_0_1_partial_def (t:counter) (block:block_w) : nat32
[@"opaque_to_smt"] let sigma_0_1_partial = opaque_make sigma_0_1_partial_def
irreducible let sigma_0_1_partial_reveal = opaque_revealer (`%sigma_0_1_partial) sigma_0_1_partial sigma_0_1_partial_def
val lemma_sha256_sigma1 (src:quad32) (t:counter) (block:block_w) : Lemma
(requires 16 <= t /\ t < size_k_w_256 /\
src.hi3 == ws_opaque block (t-2))
(ensures (sigma256_0_1 src.hi3 == sigma_0_1_partial t block))
val sigma_1_0_partial_def (t:counter) (block:block_w) (hash_orig:hash256) : nat32
[@"opaque_to_smt"] let sigma_1_0_partial = opaque_make sigma_1_0_partial_def
irreducible let sigma_1_0_partial_reveal = opaque_revealer (`%sigma_1_0_partial) sigma_1_0_partial sigma_1_0_partial_def
val lemma_sha256_sigma2 (src:quad32) (t:counter) (block:block_w) (hash_orig:hash256) : Lemma
(requires t < size_k_w_256 /\
src.hi3 == word_to_nat32 ((repeat_range_vale t block hash_orig).[0]))
(ensures (sigma256_1_0 src.hi3 == sigma_1_0_partial t block hash_orig))
val sigma_1_1_partial_def (t:counter) (block:block_w) (hash_orig:hash256) : nat32
[@"opaque_to_smt"] let sigma_1_1_partial = opaque_make sigma_1_1_partial_def
irreducible let sigma_1_1_partial_reveal = opaque_revealer (`%sigma_1_1_partial) sigma_1_1_partial sigma_1_1_partial_def
val lemma_sha256_sigma3 (src:quad32) (t:counter) (block:block_w) (hash_orig:hash256) : Lemma
(requires t < size_k_w_256 /\
src.hi3 == word_to_nat32 ((repeat_range_vale t block hash_orig).[4]))
(ensures (sigma256_1_1 src.hi3 == sigma_1_1_partial t block hash_orig))
val make_seperated_hash (a b c d e f g h:nat32): Pure (hash256)
(requires True)
(ensures fun hash ->
length hash == 8 /\
hash.[0] == nat32_to_word a /\
hash.[1] == nat32_to_word b /\
hash.[2] == nat32_to_word c /\
hash.[3] == nat32_to_word d /\
hash.[4] == nat32_to_word e /\
hash.[5] == nat32_to_word f /\
hash.[6] == nat32_to_word g /\
hash.[7] == nat32_to_word h
)
val make_seperated_hash_quad32 (a b c d e f g h:quad32): Pure (hash256)
(requires True)
(ensures fun hash ->
length hash == 8 /\
hash.[0] == nat32_to_word a.hi3 /\
hash.[1] == nat32_to_word b.hi3 /\
hash.[2] == nat32_to_word c.hi3 /\
hash.[3] == nat32_to_word d.hi3 /\
hash.[4] == nat32_to_word e.hi3 /\
hash.[5] == nat32_to_word f.hi3 /\
hash.[6] == nat32_to_word g.hi3 /\
hash.[7] == nat32_to_word h.hi3
)
val lemma_make_seperated_hash (hash:hash256) (a b c d e f g h:quad32) : Lemma
(requires length hash == 8 /\
a.hi3 == word_to_nat32 hash.[0] /\
b.hi3 == word_to_nat32 hash.[1] /\
c.hi3 == word_to_nat32 hash.[2] /\
d.hi3 == word_to_nat32 hash.[3] /\
e.hi3 == word_to_nat32 hash.[4] /\
f.hi3 == word_to_nat32 hash.[5] /\
g.hi3 == word_to_nat32 hash.[6] /\
h.hi3 == word_to_nat32 hash.[7])
(ensures hash == make_seperated_hash_quad32 a b c d e f g h)
val lemma_vsel32 (a b c:nat32) : Lemma
(ensures (isel32 a b c = (iand32 c a) *^ (iand32 (inot32 c) b)))
val ch_256 (x y z:nat32):Pure(nat32)
(requires True)
(ensures fun a -> a == (iand32 x y) *^ (iand32 (inot32 x) z))
val lemma_eq_maj_xvsel32 (a b c:nat32) : Lemma
(ensures (isel32 c b (a *^ b) = (iand32 a b) *^ ((iand32 a c) *^ (iand32 b c))))
val maj_256 (x y z:nat32):Pure(nat32)
(requires True)
(ensures fun a -> a == (iand32 x y) *^ ((iand32 x z) *^ (iand32 y z)))
val lemma_sigma_0_0_partial (t:counter) (block:block_w) : Lemma
(requires 16 <= t /\ t < size_k_w_256)
(ensures (sigma256_0_0 (ws_opaque block (t-15)) == sigma_0_0_partial t block))
val lemma_sigma_0_1_partial (t:counter) (block:block_w) : Lemma
(requires 16 <= t /\ t < size_k_w_256)
(ensures (sigma256_0_1 (ws_opaque block (t-2)) == sigma_0_1_partial t block))
val lemma_sigma_1_0_partial (t:counter) (block:block_w) (hash_orig:hash256) : Lemma
(requires t < size_k_w_256)
(ensures (sigma256_1_0 (word_to_nat32 ((repeat_range_vale t block hash_orig).[0])) == sigma_1_0_partial t block hash_orig))
val lemma_sigma_1_1_partial (t:counter) (block:block_w) (hash_orig:hash256) : Lemma
(requires t < size_k_w_256)
(ensures (sigma256_1_1 (word_to_nat32 ((repeat_range_vale t block hash_orig).[4])) == sigma_1_1_partial t block hash_orig))
(* Abbreviations and lemmas for the code itself *)
let k_reqs (k_seq:seq quad32) : prop0 =
length k_seq == size_k_w_256 / 4 /\
(forall i . {:pattern (index k_seq i)} 0 <= i /\ i < (size_k_w_256/4) ==>
(k_seq.[i]).lo0 == word_to_nat32 (k.[4 * i]) /\
(k_seq.[i]).lo1 == word_to_nat32 (k.[4 * i + 1]) /\
(k_seq.[i]).hi2 == word_to_nat32 (k.[4 * i + 2]) /\
(k_seq.[i]).hi3 == word_to_nat32 (k.[4 * i + 3]))
let quads_to_block_be (qs:seq quad32) : block_w
=
let nat32_seq = Vale.Def.Words.Seq_s.seq_four_to_seq_BE qs in
let f (n:nat{n < 16}) : word = nat32_to_word (if n < length nat32_seq then nat32_seq.[n] else 0) in
init 16 f
val lemma_quads_to_block_be (qs:seq quad32) : Lemma
(requires length qs == 4)
(ensures
(let block = quads_to_block_be qs in
forall i . {:pattern (index qs i)} 0 <= i /\ i < 4 ==>
(qs.[i]).hi3 == ws_opaque block (4 * i + 0) /\
(qs.[i]).hi2 == ws_opaque block (4 * i + 1) /\
(qs.[i]).lo1 == ws_opaque block (4 * i + 2) /\
(qs.[i]).lo0 == ws_opaque block (4 * i + 3)))
let k_index (ks:seq quad32) (i:nat) : nat32 =
if length ks = size_k_w_256 / 4 && i < size_k_w_256 then four_select ks.[(i/4)] (i % 4)
else 0
val lemma_shuffle_core_properties (t:counter) (block:block_w) (hash_orig:hash256) : Lemma
(requires t < size_k_w_256)
(ensures (let hash = Spec.Loops.repeat_range 0 t (shuffle_core_opaque block) hash_orig in
let h = Spec.Loops.repeat_range 0 (t + 1) (shuffle_core_opaque block) hash_orig in
let a0 = word_to_nat32 hash.[0] in
let b0 = word_to_nat32 hash.[1] in
let c0 = word_to_nat32 hash.[2] in
let d0 = word_to_nat32 hash.[3] in
let e0 = word_to_nat32 hash.[4] in
let f0 = word_to_nat32 hash.[5] in
let g0 = word_to_nat32 hash.[6] in
let h0 = word_to_nat32 hash.[7] in
let t1 = add_wrap (add_wrap (add_wrap (add_wrap h0 (sigma256_1_1 e0)) (ch_256 e0 f0 g0)) (word_to_nat32 k.[t])) (ws_opaque block t) in
let t2 = add_wrap (sigma256_1_0 a0) (maj_256 a0 b0 c0) in
word_to_nat32 h.[0] == add_wrap t1 t2 /\
word_to_nat32 h.[1] == a0 /\
word_to_nat32 h.[2] == b0 /\
word_to_nat32 h.[3] == c0 /\
word_to_nat32 h.[4] == add_wrap d0 t1 /\
word_to_nat32 h.[5] == e0 /\
word_to_nat32 h.[6] == f0 /\
word_to_nat32 h.[7] == g0))
val lemma_ws_opaque (block:block_w) (t:counter) : Lemma
(requires 16 <= t && t < size_k_w_256)
(ensures (let sigma0 = sigma256_0_0 (ws_opaque block (t - 15)) in
let sigma1 = sigma256_0_1 (ws_opaque block (t - 2)) in
ws_opaque block t == add_wrap (add_wrap (add_wrap sigma1 (ws_opaque block (t - 7))) sigma0) (ws_opaque block (t - 16))))
let repeat_range_vale_64 (block:block_w) (hash:hash256) =
Spec.Loops.repeat_range 0 64 (shuffle_core_opaque block) hash
val update_lemma (a b c d e f g h a_old b_old c_old d_old e_old f_old g_old h_old a' b' c' d' e' f' g' h':quad32) (block:block_w) : Lemma
(requires (let hash_orig = make_seperated_hash_quad32 a_old b_old c_old d_old e_old f_old g_old h_old in
make_seperated_hash_quad32 a b c d e f g h ==
repeat_range_vale_64 block hash_orig /\
a' == add_wrap_quad32 a a_old /\
b' == add_wrap_quad32 b b_old /\
c' == add_wrap_quad32 c c_old /\
d' == add_wrap_quad32 d d_old /\
e' == add_wrap_quad32 e e_old /\
f' == add_wrap_quad32 f f_old /\
g' == add_wrap_quad32 g g_old /\
h' == add_wrap_quad32 h h_old))
(ensures (let hash_orig = make_seperated_hash_quad32 a_old b_old c_old d_old e_old f_old g_old h_old in
make_seperated_hash_quad32 a' b' c' d' e' f' g' h' == update_block hash_orig block)) | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.Lib.Seqs_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Sel.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Spec.Loops.fst.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.SHA.PPC64LE.SHA_helpers.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile.Hash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Sel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 -> hash_orig: Vale.SHA.PPC64LE.SHA_helpers.hash256
-> Prims.Tot Vale.SHA.PPC64LE.SHA_helpers.hash256 | Prims.Tot | [
"total",
""
] | [] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Vale.SHA.PPC64LE.SHA_helpers.hash256",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.bool",
"Vale.SHA.PPC64LE.SHA_helpers.update_block",
"Vale.SHA.PPC64LE.SHA_helpers.quads_to_block_be",
"Vale.SHA.PPC64LE.SHA_helpers.update_multi_quads",
"FStar.Pervasives.Native.tuple2",
"FStar.Seq.Properties.split",
"Prims.op_Subtraction"
] | [
"recursion"
] | false | false | false | true | false | let rec update_multi_quads (s: seq quad32) (hash_orig: hash256)
: Tot (hash256) (decreases (length s)) =
| if length s < 4
then hash_orig
else
let prefix, qs = split s (length s - 4) in
let h_prefix = update_multi_quads prefix hash_orig in
let hash = update_block h_prefix (quads_to_block_be qs) in
hash | false |