Datasets:

microsoft

/

FStarDataSet-V2

like 0

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)))

(* 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. **)

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

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)))

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

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}

mt: MerkleTree.Spec.merkle_tree n -> idx: Prims.nat{idx < Prims.pow2 n} -> Prims.GTot MerkleTree.Spec.padded_hash

Prims.GTot

let mt_get #_ #_ mt idx =

S.index mt idx

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)

(* 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.

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

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)

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

(* 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

b: FStar.Tactics.NamedView.binder -> FStar.Tactics.Effect.Tac (FStar.Tactics.PatternMatching.abspat_binder_kind * FStar.Tactics.NamedView.term)

FStar.Tactics.Effect.Tac

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

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"

(* 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

_: FStar.Tactics.PatternMatching.abspat_binder_kind -> Prims.string

Prims.Tot

let string_of_abspat_binder_kind =

function | ABKVar _ -> "varname" | ABKHyp -> "hyp" | ABKGoal -> "goal"

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

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

mt: MerkleTree.Spec.merkle_tree n -> Prims.GTot (MerkleTree.Spec.merkle_tree (n - 1))

Prims.GTot

let mt_next_lv #_ #f #n mt =

hs_next_lv #_ #f #(pow2 (n - 1)) mt

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])

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])

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

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 ])

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 ()

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)

MerkleTree.Spec.hash_fun_t

Prims.Tot

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 ()

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 = () }

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) ); }

GradedMonad.monoid Prims.nat

Prims.Tot

[@@ FStar.Tactics.Typeclasses.tcinstance] let monoid_nat_plus:monoid nat =

{ op = (fun (x: nat) (y: nat) -> x + y); one = 0; properties = () }

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))

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 ->

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

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))

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

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) ->

n: Prims.pos -> mt: MerkleTree.Spec.merkle_tree n -> nmt: MerkleTree.Spec.merkle_tree (n - 1) -> Prims.GTot Type0

Prims.GTot

let mt_next_rel #hsz #f n mt nmt =

hs_next_rel #hsz #f (pow2 (n - 1)) mt nmt

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)

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))

mt: MerkleTree.Spec.merkle_tree n -> MerkleTree.Spec.merkle_tree (n - 1)

Prims.Tot

let mt_right #_ #n mt =

S.slice mt (pow2 (n - 1)) (pow2 n)

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))

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} ->

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

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))

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

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))

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

let mt_next_lv_equiv #hsz #f j n mt1 mt2 =

hs_next_lv_equiv #_ #f j (pow2 (n - 1)) mt1 mt2

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)

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))

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

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)

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)))

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 = ()

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

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)))

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)

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 ->

mt: MerkleTree.Spec.merkle_tree n -> Prims.GTot MerkleTree.Spec.padded_hash

Prims.GTot

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)

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)) }

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

n: Prims.nat -> i: Prims.nat{i <= Prims.pow2 n} -> Type0

Prims.Tot

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))}

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))

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"

mt: MerkleTree.Spec.merkle_tree n -> MerkleTree.Spec.merkle_tree (n - 1)

Prims.Tot

let mt_left #_ #n mt =

S.slice mt 0 (pow2 (n - 1))

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)

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} ->

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

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)

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

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 ->

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

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

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))

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} ->

hs: MerkleTree.Spec.hashes{MerkleTree.Spec.raw_hashes hs} -> Prims.Tot (FStar.Seq.Base.seq MerkleTree.Spec.hash)

Prims.Tot

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))

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

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)

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

let mt_next_rel_next_lv #hsz #f n mt nmt =

hs_next_rel_next_lv #_ #f (pow2 (n - 1)) mt nmt

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))

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 ->

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

let mt_next_lv_mt_left #hsz #f #n mt =

hs_next_lv_slice #_ #f #(pow2 (n - 1)) mt 0 (pow2 (n - 2))

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

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; }

c0: Prims.int -> c1: Prims.int -> c2: Prims.int -> c3: Prims.int -> Prims.int

Prims.Tot

let pow2int_four (c0 c1 c2 c3: int) : int =

c0 + c1 * pow2_64 + c2 * pow2_128 + c3 * pow2_192

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))

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: MerkleTree.Spec.hashes -> Prims.Tot Type0

Prims.Tot

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))

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)

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))

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

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)

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

(* 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

tm: FStar.Tactics.NamedView.term -> FStar.Tactics.Effect.Tac (FStar.Tactics.PatternMatching.matching_problem * FStar.Tactics.PatternMatching.abspat_continuation)

FStar.Tactics.Effect.Tac

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

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)

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: MerkleTree.Spec.path n -> idx: Prims.nat{idx < Prims.pow2 n} -> h: MerkleTree.Spec.padded_hash -> Prims.GTot MerkleTree.Spec.padded_hash

Prims.GTot

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)

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)

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])

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

let rec raw_hashes_index #hsz #f hs i =

if i = 0 then () else raw_hashes_index #_ #f (S.tail hs) (i - 1)

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

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 ->

mt: MerkleTree.Spec.rpmt n i -> FStar.Pervasives.Lemma (ensures i > 0 <==> HRaw? (MerkleTree.Spec.mt_get_root mt))

FStar.Pervasives.Lemma

let rpmt_get_root_raw #hsz #f #n #i mt =

allow_inversion (padded_hash #hsz); rpmt_get_root_pad #_ #f mt

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

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 ->

mt: MerkleTree.Spec.rpmt n i -> FStar.Pervasives.Lemma (ensures i = 0 <==> HPad? (MerkleTree.Spec.mt_get_root mt))

FStar.Pervasives.Lemma

let rpmt_get_root_pad #_ #f #n #i mt =

rpmt_get_root_pad_hashes #_ #f mt; rpmt_pad_hashes_0 #_ #f mt

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)

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)) }

mt: MerkleTree.Spec.rpmt n i -> FStar.Seq.Base.seq MerkleTree.Spec.hash

Prims.Tot

let rpmt_raws #hsz #f #n #i mt =

raw_hashes_raws #_ #f (S.slice mt 0 i)

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])

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))

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

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 ])

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))

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: MerkleTree.Spec.merkle_tree n -> i: Prims.nat{i < Prims.pow2 n} -> Prims.GTot (MerkleTree.Spec.path n)

Prims.GTot

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))

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

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))

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

let rec pad_hashes_slice #hsz #f hs i j =

if i = j then () else pad_hashes_slice #_ #f hs (i + 1) j

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

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 ==

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

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)

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

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 ->

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

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

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

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]

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

let mt_next_lv_get #hsz #f #n mt idx =

hs_next_lv_get #_ #f #(pow2 (n - 1)) mt idx

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

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))

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

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

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

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} ->

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

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)

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))

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)

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

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))

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

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 ->

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

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

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

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 ->

mt: MerkleTree.Spec.merkle_tree n -> FStar.Pervasives.Lemma (ensures HPad? mt.[ 0 ] <==> HPad? (MerkleTree.Spec.mt_get_root mt))

FStar.Pervasives.Lemma

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

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

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 ()

r: Vale.X64.Machine_s.reg_64 -> FStar.Pervasives.Native.option (Vale.Interop.X64.reg_nat 3)

Prims.Tot

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

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})

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

Vale.Interop.Base.td

Prims.Tot

let t64_no_mod =

TD_Buffer TUInt64 TUInt64 ({ modified = false; strict_disjointness = false; taint = MS.Secret })

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)

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]

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

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)

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

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

Vale.Interop.Base.td

Prims.Tot

let t64_mod =

TD_Buffer TUInt64 TUInt64 default_bq

Vale.Inline.X64.Fswap_inline.fst

Vale.Inline.X64.Fswap_inline.uint64

val uint64 : Prims.eqtype

let uint64 = UInt64.t

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

Prims.eqtype

Prims.Tot

let uint64 =

UInt64.t

Vale.Inline.X64.Fswap_inline.fst

Vale.Inline.X64.Fswap_inline.tuint64

val tuint64 : Vale.Interop.Base.td

let tuint64 = TD_Base TUInt64

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})

Vale.Interop.Base.td

Prims.Tot

let tuint64 =

TD_Base TUInt64

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

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

_: _ -> Prims.bool

Prims.Tot

let cswap_xmms_modified =

fun _ -> false

Vale.Inline.X64.Fswap_inline.fst

Vale.Inline.X64.Fswap_inline.b64

val b64 : Type0

let b64 = buf_t TUInt64 TUInt64

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

Type0

Prims.Tot

let b64 =

buf_t TUInt64 TUInt64

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 ()

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'

Vale.X64.Decls.va_code

Prims.Tot

let code_cswap =

FU.va_code_Cswap2 ()

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"]

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 ()

Prims.list Prims.string

Prims.Tot

let cswap_comments:list string =

["Computes p1 <- bit ? p2 : p1 in constant time"]

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" | _ -> ""

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"]

n: Prims.nat -> Prims.string

Prims.Tot

let cswap_names (n: nat) : string =

match n with | 0 -> "bit" | 1 -> "p1" | 2 -> "p2" | _ -> ""

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))

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

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

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))

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

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))

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

let lowstar_cswap_normal_t:normal lowstar_cswap_t =

as_normal_t #lowstar_cswap_t lowstar_cswap

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)

(* 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)

r: Steel.GhostPCMReference.ref a pcm -> v: a -> Steel.Effect.Common.vprop

Prims.Tot

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)

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)

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; }; ()

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

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)

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)

(* 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

a: Type -> p: FStar.PCM.pcm a -> Type0

Prims.Tot

let ref (a: Type) (p: pcm a) =

erased (Steel.Memory.ref a p)

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

(* 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

r: Steel.GhostPCMReference.ref a p -> fact: Steel.Memory.property a -> Type0

Prims.Tot

let witnessed (#a: Type) (#p: pcm a) (r: ref a p) (fact: property a) : Type0 =

Steel.Memory.witnessed r fact

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; }; ()

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))

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

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; }; ()

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

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"

Prims.int

Prims.Tot

let size_k_w_256 =

64

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

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

Prims.int

Prims.Tot

let block_length =

4 * size_block_w_256

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

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

Prims.int

Prims.Tot

let size_block_w_256 =

16

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}

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 =

Type0

Prims.Tot

let block_w =

m: seq word {length m = size_block_w_256}

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; }

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) = ()

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

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; }

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}

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

Type0

Prims.Tot

let hash256 =

m: Seq.seq word {Seq.length m = 8}

Vale.SHA.PPC64LE.SHA_helpers.fsti

Vale.SHA.PPC64LE.SHA_helpers.counter

val counter : Type0

let counter = nat

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

Type0

Prims.Tot

let counter =

nat

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

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)

_: Vale.SHA.PPC64LE.SHA_helpers.counter -> _: Vale.SHA.PPC64LE.SHA_helpers.block_w -> Vale.Def.Words_s.nat32

Prims.Tot

let sigma_0_0_partial =

opaque_make sigma_0_0_partial_def

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; }; ()

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'"

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

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; }; ()

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

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

_: 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

let sigma_1_0_partial_reveal =

opaque_revealer (`%sigma_1_0_partial) sigma_1_0_partial sigma_1_0_partial_def

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

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

_: 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

let sigma_0_1_partial_reveal =

opaque_revealer (`%sigma_0_1_partial) sigma_0_1_partial sigma_0_1_partial_def

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

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

_: 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

let sigma_0_0_partial_reveal =

opaque_revealer (`%sigma_0_0_partial) sigma_0_0_partial sigma_0_0_partial_def

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

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 *)

x: a -> Vale.Interop.Base.normal a

Prims.Tot

let as_normal_t (#a: Type) (x: a) : normal a =

x

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

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))

_: 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

let sigma_1_0_partial =

opaque_make sigma_1_0_partial_def

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

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))

_: 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

let sigma_1_1_partial =

opaque_make sigma_1_1_partial_def

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

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))

_: Vale.SHA.PPC64LE.SHA_helpers.counter -> _: Vale.SHA.PPC64LE.SHA_helpers.block_w -> Vale.Def.Words_s.nat32

Prims.Tot

let sigma_0_1_partial =

opaque_make sigma_0_1_partial_def

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

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

_: 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

let sigma_1_1_partial_reveal =

opaque_revealer (`%sigma_1_1_partial) sigma_1_1_partial sigma_1_1_partial_def

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

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))))

block: Vale.SHA.PPC64LE.SHA_helpers.block_w -> hash: Vale.SHA.PPC64LE.SHA_helpers.hash256 -> Vale.SHA.PPC64LE.SHA_helpers.hash256

Prims.Tot

let repeat_range_vale_64 (block: block_w) (hash: hash256) =

Spec.Loops.repeat_range 0 64 (shuffle_core_opaque block) hash

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))

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 ->

_: MerkleTree.Spec.mt_collide n i -> Prims.GTot MerkleTree.Spec.hash2_raw_collide

Prims.GTot

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))

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; ()

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; }; ()

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

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; ()

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

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

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

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

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 }

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

Type0

Prims.Tot

let bytes_blocks =

l: bytes{Seq.length l % block_length = 0}

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

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

x: Vale.Interop.Base.normal a -> a

Prims.Tot

let as_t (#a: Type) (x: normal a) : a =

x

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 ])

(* 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

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

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])

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)

(* 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 ])

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

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)