Datasets:

microsoft

/

FStarDataSet

like 2

Follow

Microsoft 4,782

Prims.Tot

let bn_mod_inv_prime_precomp_st (t:limb_t) (len:BN.meta_len t) = n:lbignum t len -> mu:limb t -> r2:lbignum t len -> a:lbignum t len -> res:lbignum t len -> Stack unit (requires fun h -> live h n /\ live h r2 /\ live h a /\ live h res /\ disjoint res n /\ disjoint res a /\ disjoint n a /\ disjoint res r2 /\ disjoint a r2 /\ disjoint n r2 /\ S.bn_mod_inv_prime_pre (as_seq h n) (as_seq h a) /\ bn_v h r2 == pow2 (2 * bits t * v len) % bn_v h n /\ (1 + bn_v h n * v mu) % pow2 (bits t) == 0) (ensures fun h0 r h1 -> modifies (loc res) h0 h1 /\ bn_v h1 res * bn_v h0 a % bn_v h0 n = 1)

let bn_mod_inv_prime_precomp_st (t: limb_t) (len: BN.meta_len t) =

n: lbignum t len -> mu: limb t -> r2: lbignum t len -> a: lbignum t len -> res: lbignum t len -> Stack unit (requires fun h -> live h n /\ live h r2 /\ live h a /\ live h res /\ disjoint res n /\ disjoint res a /\ disjoint n a /\ disjoint res r2 /\ disjoint a r2 /\ disjoint n r2 /\ S.bn_mod_inv_prime_pre (as_seq h n) (as_seq h a) /\ bn_v h r2 == pow2 ((2 * bits t) * v len) % bn_v h n /\ (1 + bn_v h n * v mu) % pow2 (bits t) == 0) (ensures fun h0 r h1 -> modifies (loc res) h0 h1 /\ bn_v h1 res * bn_v h0 a % bn_v h0 n = 1)

module Hacl.Bignum.ModInv open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer open Hacl.Bignum.Definitions module ST = FStar.HyperStack.ST module S = Hacl.Spec.Bignum.ModInv module BN = Hacl.Bignum module BE = Hacl.Bignum.Exponentiation module BM = Hacl.Bignum.Montgomery module SD = Hacl.Spec.Bignum.Definitions #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let bn_check_mod_inv_prime_st (t:limb_t) (len:BN.meta_len t) = n:lbignum t len -> a:lbignum t len -> Stack (limb t) (requires fun h -> live h n /\ live h a /\ disjoint n a) (ensures fun h0 r h1 -> modifies0 h0 h1 /\ r == S.bn_check_mod_inv_prime (as_seq h0 n) (as_seq h0 a)) inline_for_extraction noextract val bn_check_mod_inv_prime: #t:limb_t -> len:BN.meta_len t -> bn_check_mod_inv_prime_st t len let bn_check_mod_inv_prime #t len n a = let m0 = BM.bn_check_modulus n in let m1 = BN.bn_is_zero_mask len a in let m2 = BN.bn_lt_mask len a n in m0 &. (lognot m1) &. m2 inline_for_extraction noextract val bn_mod_inv_prime_n2: #t:limb_t -> len:BN.meta_len t -> n:lbignum t len -> res:lbignum t len -> Stack unit (requires fun h -> 1 < bn_v h n /\ live h n /\ live h res /\ disjoint res n) (ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\ as_seq h1 res == S.bn_mod_inv_prime_n2 (as_seq h0 n)) let bn_mod_inv_prime_n2 #t len n res = let c = BN.bn_sub1 len n (uint #t #SEC 2) res in LowStar.Ignore.ignore c; () inline_for_extraction noextract

Hacl.Bignum.ModInv.fst

val bn_mod_inv_prime_precomp_st : t: Hacl.Bignum.Definitions.limb_t -> len: Hacl.Bignum.meta_len t -> Type0

Hacl.Bignum.ModInv.bn_mod_inv_prime_precomp_st

t: Hacl.Bignum.Definitions.limb_t -> len: Hacl.Bignum.meta_len t -> Type0

FStar.HyperStack.ST.Stack

val bn_mod_inv_prime_n2: #t:limb_t -> len:BN.meta_len t -> n:lbignum t len -> res:lbignum t len -> Stack unit (requires fun h -> 1 < bn_v h n /\ live h n /\ live h res /\ disjoint res n) (ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\ as_seq h1 res == S.bn_mod_inv_prime_n2 (as_seq h0 n))

let bn_mod_inv_prime_n2 #t len n res = let c = BN.bn_sub1 len n (uint #t #SEC 2) res in LowStar.Ignore.ignore c; ()

val bn_mod_inv_prime_n2: #t:limb_t -> len:BN.meta_len t -> n:lbignum t len -> res:lbignum t len -> Stack unit (requires fun h -> 1 < bn_v h n /\ live h n /\ live h res /\ disjoint res n) (ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\ as_seq h1 res == S.bn_mod_inv_prime_n2 (as_seq h0 n)) let bn_mod_inv_prime_n2 #t len n res =

let c = BN.bn_sub1 len n (uint #t #SEC 2) res in LowStar.Ignore.ignore c; ()

module Hacl.Bignum.ModInv open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer open Hacl.Bignum.Definitions module ST = FStar.HyperStack.ST module S = Hacl.Spec.Bignum.ModInv module BN = Hacl.Bignum module BE = Hacl.Bignum.Exponentiation module BM = Hacl.Bignum.Montgomery module SD = Hacl.Spec.Bignum.Definitions #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let bn_check_mod_inv_prime_st (t:limb_t) (len:BN.meta_len t) = n:lbignum t len -> a:lbignum t len -> Stack (limb t) (requires fun h -> live h n /\ live h a /\ disjoint n a) (ensures fun h0 r h1 -> modifies0 h0 h1 /\ r == S.bn_check_mod_inv_prime (as_seq h0 n) (as_seq h0 a)) inline_for_extraction noextract val bn_check_mod_inv_prime: #t:limb_t -> len:BN.meta_len t -> bn_check_mod_inv_prime_st t len let bn_check_mod_inv_prime #t len n a = let m0 = BM.bn_check_modulus n in let m1 = BN.bn_is_zero_mask len a in let m2 = BN.bn_lt_mask len a n in m0 &. (lognot m1) &. m2 inline_for_extraction noextract val bn_mod_inv_prime_n2: #t:limb_t -> len:BN.meta_len t -> n:lbignum t len -> res:lbignum t len -> Stack unit (requires fun h -> 1 < bn_v h n /\ live h n /\ live h res /\ disjoint res n) (ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\ as_seq h1 res == S.bn_mod_inv_prime_n2 (as_seq h0 n))

Hacl.Bignum.ModInv.fst

val bn_mod_inv_prime_n2: #t:limb_t -> len:BN.meta_len t -> n:lbignum t len -> res:lbignum t len -> Stack unit (requires fun h -> 1 < bn_v h n /\ live h n /\ live h res /\ disjoint res n) (ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\ as_seq h1 res == S.bn_mod_inv_prime_n2 (as_seq h0 n))

Hacl.Bignum.ModInv.bn_mod_inv_prime_n2

len: Hacl.Bignum.meta_len t -> n: Hacl.Bignum.Definitions.lbignum t len -> res: Hacl.Bignum.Definitions.lbignum t len -> FStar.HyperStack.ST.Stack Prims.unit

Prims.Tot

val mk_bn_mod_inv_prime: #t:limb_t -> len:BN.meta_len t -> bn_mod_exp:BE.bn_mod_exp_st t len -> bn_mod_inv_prime_st t len

let mk_bn_mod_inv_prime #t len bn_mod_exp nBits n a res = let h0 = ST.get () in push_frame (); let n2 = create len (uint #t #SEC 0) in bn_mod_inv_prime_n2 #t len n n2; SD.bn_eval_bound (as_seq h0 n) (v len); bn_mod_exp nBits n a (size (bits t) *! len) n2 res; let h1 = ST.get () in assert (bn_v h1 res == Lib.NatMod.pow_mod #(bn_v h0 n) (bn_v h0 a) (bn_v h1 n2)); S.mod_inv_prime_lemma (bn_v h0 n) (bn_v h0 a); pop_frame ()

val mk_bn_mod_inv_prime: #t:limb_t -> len:BN.meta_len t -> bn_mod_exp:BE.bn_mod_exp_st t len -> bn_mod_inv_prime_st t len let mk_bn_mod_inv_prime #t len bn_mod_exp nBits n a res =

let h0 = ST.get () in push_frame (); let n2 = create len (uint #t #SEC 0) in bn_mod_inv_prime_n2 #t len n n2; SD.bn_eval_bound (as_seq h0 n) (v len); bn_mod_exp nBits n a (size (bits t) *! len) n2 res; let h1 = ST.get () in assert (bn_v h1 res == Lib.NatMod.pow_mod #(bn_v h0 n) (bn_v h0 a) (bn_v h1 n2)); S.mod_inv_prime_lemma (bn_v h0 n) (bn_v h0 a); pop_frame ()

module Hacl.Bignum.ModInv open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer open Hacl.Bignum.Definitions module ST = FStar.HyperStack.ST module S = Hacl.Spec.Bignum.ModInv module BN = Hacl.Bignum module BE = Hacl.Bignum.Exponentiation module BM = Hacl.Bignum.Montgomery module SD = Hacl.Spec.Bignum.Definitions #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let bn_check_mod_inv_prime_st (t:limb_t) (len:BN.meta_len t) = n:lbignum t len -> a:lbignum t len -> Stack (limb t) (requires fun h -> live h n /\ live h a /\ disjoint n a) (ensures fun h0 r h1 -> modifies0 h0 h1 /\ r == S.bn_check_mod_inv_prime (as_seq h0 n) (as_seq h0 a)) inline_for_extraction noextract val bn_check_mod_inv_prime: #t:limb_t -> len:BN.meta_len t -> bn_check_mod_inv_prime_st t len let bn_check_mod_inv_prime #t len n a = let m0 = BM.bn_check_modulus n in let m1 = BN.bn_is_zero_mask len a in let m2 = BN.bn_lt_mask len a n in m0 &. (lognot m1) &. m2 inline_for_extraction noextract val bn_mod_inv_prime_n2: #t:limb_t -> len:BN.meta_len t -> n:lbignum t len -> res:lbignum t len -> Stack unit (requires fun h -> 1 < bn_v h n /\ live h n /\ live h res /\ disjoint res n) (ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\ as_seq h1 res == S.bn_mod_inv_prime_n2 (as_seq h0 n)) let bn_mod_inv_prime_n2 #t len n res = let c = BN.bn_sub1 len n (uint #t #SEC 2) res in LowStar.Ignore.ignore c; () inline_for_extraction noextract let bn_mod_inv_prime_precomp_st (t:limb_t) (len:BN.meta_len t) = n:lbignum t len -> mu:limb t -> r2:lbignum t len -> a:lbignum t len -> res:lbignum t len -> Stack unit (requires fun h -> live h n /\ live h r2 /\ live h a /\ live h res /\ disjoint res n /\ disjoint res a /\ disjoint n a /\ disjoint res r2 /\ disjoint a r2 /\ disjoint n r2 /\ S.bn_mod_inv_prime_pre (as_seq h n) (as_seq h a) /\ bn_v h r2 == pow2 (2 * bits t * v len) % bn_v h n /\ (1 + bn_v h n * v mu) % pow2 (bits t) == 0) (ensures fun h0 r h1 -> modifies (loc res) h0 h1 /\ bn_v h1 res * bn_v h0 a % bn_v h0 n = 1) inline_for_extraction noextract val mk_bn_mod_inv_prime_precomp: #t:limb_t -> len:BN.meta_len t -> bn_mod_exp_precomp:BE.bn_mod_exp_precomp_st t len -> bn_mod_inv_prime_precomp_st t len let mk_bn_mod_inv_prime_precomp #t len bn_mod_exp_precomp n mu r2 a res = let h0 = ST.get () in push_frame (); let n2 = create len (uint #t #SEC 0) in bn_mod_inv_prime_n2 #t len n n2; SD.bn_eval_bound (as_seq h0 n) (v len); bn_mod_exp_precomp n mu r2 a (size (bits t) *! len) n2 res; let h1 = ST.get () in assert (bn_v h1 res == Lib.NatMod.pow_mod #(bn_v h0 n) (bn_v h0 a) (bn_v h1 n2)); S.mod_inv_prime_lemma (bn_v h0 n) (bn_v h0 a); pop_frame () inline_for_extraction noextract let bn_mod_inv_prime_st (t:limb_t) (len:BN.meta_len t) = nBits:size_t -> n:lbignum t len -> a:lbignum t len -> res:lbignum t len -> Stack unit (requires fun h -> live h n /\ live h a /\ live h res /\ disjoint res n /\ disjoint res a /\ disjoint n a /\ v nBits / bits t < v len /\ pow2 (v nBits) < bn_v h n /\ S.bn_mod_inv_prime_pre (as_seq h n) (as_seq h a)) (ensures fun h0 r h1 -> modifies (loc res) h0 h1 /\ bn_v h1 res * bn_v h0 a % bn_v h0 n = 1) inline_for_extraction noextract val mk_bn_mod_inv_prime: #t:limb_t -> len:BN.meta_len t -> bn_mod_exp:BE.bn_mod_exp_st t len -> bn_mod_inv_prime_st t len

Hacl.Bignum.ModInv.fst

val mk_bn_mod_inv_prime: #t:limb_t -> len:BN.meta_len t -> bn_mod_exp:BE.bn_mod_exp_st t len -> bn_mod_inv_prime_st t len

Hacl.Bignum.ModInv.mk_bn_mod_inv_prime

len: Hacl.Bignum.meta_len t -> bn_mod_exp: Hacl.Bignum.Exponentiation.bn_mod_exp_st t len -> Hacl.Bignum.ModInv.bn_mod_inv_prime_st t len

Prims.Tot

val mk_bn_mod_inv_prime_precomp: #t:limb_t -> len:BN.meta_len t -> bn_mod_exp_precomp:BE.bn_mod_exp_precomp_st t len -> bn_mod_inv_prime_precomp_st t len

let mk_bn_mod_inv_prime_precomp #t len bn_mod_exp_precomp n mu r2 a res = let h0 = ST.get () in push_frame (); let n2 = create len (uint #t #SEC 0) in bn_mod_inv_prime_n2 #t len n n2; SD.bn_eval_bound (as_seq h0 n) (v len); bn_mod_exp_precomp n mu r2 a (size (bits t) *! len) n2 res; let h1 = ST.get () in assert (bn_v h1 res == Lib.NatMod.pow_mod #(bn_v h0 n) (bn_v h0 a) (bn_v h1 n2)); S.mod_inv_prime_lemma (bn_v h0 n) (bn_v h0 a); pop_frame ()

val mk_bn_mod_inv_prime_precomp: #t:limb_t -> len:BN.meta_len t -> bn_mod_exp_precomp:BE.bn_mod_exp_precomp_st t len -> bn_mod_inv_prime_precomp_st t len let mk_bn_mod_inv_prime_precomp #t len bn_mod_exp_precomp n mu r2 a res =

let h0 = ST.get () in push_frame (); let n2 = create len (uint #t #SEC 0) in bn_mod_inv_prime_n2 #t len n n2; SD.bn_eval_bound (as_seq h0 n) (v len); bn_mod_exp_precomp n mu r2 a (size (bits t) *! len) n2 res; let h1 = ST.get () in assert (bn_v h1 res == Lib.NatMod.pow_mod #(bn_v h0 n) (bn_v h0 a) (bn_v h1 n2)); S.mod_inv_prime_lemma (bn_v h0 n) (bn_v h0 a); pop_frame ()

module Hacl.Bignum.ModInv open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer open Hacl.Bignum.Definitions module ST = FStar.HyperStack.ST module S = Hacl.Spec.Bignum.ModInv module BN = Hacl.Bignum module BE = Hacl.Bignum.Exponentiation module BM = Hacl.Bignum.Montgomery module SD = Hacl.Spec.Bignum.Definitions #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let bn_check_mod_inv_prime_st (t:limb_t) (len:BN.meta_len t) = n:lbignum t len -> a:lbignum t len -> Stack (limb t) (requires fun h -> live h n /\ live h a /\ disjoint n a) (ensures fun h0 r h1 -> modifies0 h0 h1 /\ r == S.bn_check_mod_inv_prime (as_seq h0 n) (as_seq h0 a)) inline_for_extraction noextract val bn_check_mod_inv_prime: #t:limb_t -> len:BN.meta_len t -> bn_check_mod_inv_prime_st t len let bn_check_mod_inv_prime #t len n a = let m0 = BM.bn_check_modulus n in let m1 = BN.bn_is_zero_mask len a in let m2 = BN.bn_lt_mask len a n in m0 &. (lognot m1) &. m2 inline_for_extraction noextract val bn_mod_inv_prime_n2: #t:limb_t -> len:BN.meta_len t -> n:lbignum t len -> res:lbignum t len -> Stack unit (requires fun h -> 1 < bn_v h n /\ live h n /\ live h res /\ disjoint res n) (ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\ as_seq h1 res == S.bn_mod_inv_prime_n2 (as_seq h0 n)) let bn_mod_inv_prime_n2 #t len n res = let c = BN.bn_sub1 len n (uint #t #SEC 2) res in LowStar.Ignore.ignore c; () inline_for_extraction noextract let bn_mod_inv_prime_precomp_st (t:limb_t) (len:BN.meta_len t) = n:lbignum t len -> mu:limb t -> r2:lbignum t len -> a:lbignum t len -> res:lbignum t len -> Stack unit (requires fun h -> live h n /\ live h r2 /\ live h a /\ live h res /\ disjoint res n /\ disjoint res a /\ disjoint n a /\ disjoint res r2 /\ disjoint a r2 /\ disjoint n r2 /\ S.bn_mod_inv_prime_pre (as_seq h n) (as_seq h a) /\ bn_v h r2 == pow2 (2 * bits t * v len) % bn_v h n /\ (1 + bn_v h n * v mu) % pow2 (bits t) == 0) (ensures fun h0 r h1 -> modifies (loc res) h0 h1 /\ bn_v h1 res * bn_v h0 a % bn_v h0 n = 1) inline_for_extraction noextract val mk_bn_mod_inv_prime_precomp: #t:limb_t -> len:BN.meta_len t -> bn_mod_exp_precomp:BE.bn_mod_exp_precomp_st t len -> bn_mod_inv_prime_precomp_st t len

Hacl.Bignum.ModInv.fst

val mk_bn_mod_inv_prime_precomp: #t:limb_t -> len:BN.meta_len t -> bn_mod_exp_precomp:BE.bn_mod_exp_precomp_st t len -> bn_mod_inv_prime_precomp_st t len

Hacl.Bignum.ModInv.mk_bn_mod_inv_prime_precomp

len: Hacl.Bignum.meta_len t -> bn_mod_exp_precomp: Hacl.Bignum.Exponentiation.bn_mod_exp_precomp_st t len -> Hacl.Bignum.ModInv.bn_mod_inv_prime_precomp_st t len

Prims.Tot

let aff_point = lbuffer uint64 10ul

let aff_point =

lbuffer uint64 10ul

module Hacl.Impl.K256.Point open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module S = Spec.K256 open Hacl.K256.Field #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let as_felem5_lseq (s:LSeq.lseq uint64 5) : felem5 = let open Lib.Sequence in (s.[0],s.[1],s.[2],s.[3],s.[4]) /// Affine coordinates inline_for_extraction noextract let aff_point_seq = LSeq.lseq uint64 10 let aff_point_inv_seq (p:aff_point_seq) = inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 0 5)) /\ inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 5 5)) let aff_point_eval_seq (p:aff_point_seq{aff_point_inv_seq p}) : S.aff_point = as_nat5 (as_felem5_lseq (LSeq.sub p 0 5)), as_nat5 (as_felem5_lseq (LSeq.sub p 5 5))

Hacl.Impl.K256.Point.fsti

val aff_point : Type0

Hacl.Impl.K256.Point.aff_point

Type0

Prims.Tot

let point = lbuffer uint64 15ul

let point =

lbuffer uint64 15ul

module Hacl.Impl.K256.Point open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module S = Spec.K256 open Hacl.K256.Field #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let as_felem5_lseq (s:LSeq.lseq uint64 5) : felem5 = let open Lib.Sequence in (s.[0],s.[1],s.[2],s.[3],s.[4]) /// Affine coordinates inline_for_extraction noextract let aff_point_seq = LSeq.lseq uint64 10 let aff_point_inv_seq (p:aff_point_seq) = inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 0 5)) /\ inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 5 5)) let aff_point_eval_seq (p:aff_point_seq{aff_point_inv_seq p}) : S.aff_point = as_nat5 (as_felem5_lseq (LSeq.sub p 0 5)), as_nat5 (as_felem5_lseq (LSeq.sub p 5 5)) inline_for_extraction noextract let aff_point = lbuffer uint64 10ul noextract let aff_point_inv (h:mem) (p:aff_point) = aff_point_inv_seq (as_seq h p) noextract let aff_point_eval (h:mem) (p:aff_point{aff_point_inv h p}) : GTot S.aff_point = aff_point_eval_seq (as_seq h p) inline_for_extraction noextract let aff_getx (p:aff_point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1) = sub p 0ul 5ul inline_for_extraction noextract let aff_gety (p:aff_point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1) = sub p 5ul 5ul /// Projective coordinates // (_X, _Y, _Z)

Hacl.Impl.K256.Point.fsti

val point : Type0

Hacl.Impl.K256.Point.point

Type0

Prims.Tot

let aff_point_inv (h:mem) (p:aff_point) = aff_point_inv_seq (as_seq h p)

let aff_point_inv (h: mem) (p: aff_point) =

aff_point_inv_seq (as_seq h p)

module Hacl.Impl.K256.Point open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module S = Spec.K256 open Hacl.K256.Field #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let as_felem5_lseq (s:LSeq.lseq uint64 5) : felem5 = let open Lib.Sequence in (s.[0],s.[1],s.[2],s.[3],s.[4]) /// Affine coordinates inline_for_extraction noextract let aff_point_seq = LSeq.lseq uint64 10 let aff_point_inv_seq (p:aff_point_seq) = inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 0 5)) /\ inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 5 5)) let aff_point_eval_seq (p:aff_point_seq{aff_point_inv_seq p}) : S.aff_point = as_nat5 (as_felem5_lseq (LSeq.sub p 0 5)), as_nat5 (as_felem5_lseq (LSeq.sub p 5 5)) inline_for_extraction noextract let aff_point = lbuffer uint64 10ul noextract

Hacl.Impl.K256.Point.fsti

val aff_point_inv : h: FStar.Monotonic.HyperStack.mem -> p: Hacl.Impl.K256.Point.aff_point -> Prims.logical

Hacl.Impl.K256.Point.aff_point_inv

h: FStar.Monotonic.HyperStack.mem -> p: Hacl.Impl.K256.Point.aff_point -> Prims.logical

Prims.GTot

val aff_point_eval (h: mem) (p: aff_point{aff_point_inv h p}) : GTot S.aff_point

let aff_point_eval (h:mem) (p:aff_point{aff_point_inv h p}) : GTot S.aff_point = aff_point_eval_seq (as_seq h p)

val aff_point_eval (h: mem) (p: aff_point{aff_point_inv h p}) : GTot S.aff_point let aff_point_eval (h: mem) (p: aff_point{aff_point_inv h p}) : GTot S.aff_point =

aff_point_eval_seq (as_seq h p)

module Hacl.Impl.K256.Point open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module S = Spec.K256 open Hacl.K256.Field #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let as_felem5_lseq (s:LSeq.lseq uint64 5) : felem5 = let open Lib.Sequence in (s.[0],s.[1],s.[2],s.[3],s.[4]) /// Affine coordinates inline_for_extraction noextract let aff_point_seq = LSeq.lseq uint64 10 let aff_point_inv_seq (p:aff_point_seq) = inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 0 5)) /\ inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 5 5)) let aff_point_eval_seq (p:aff_point_seq{aff_point_inv_seq p}) : S.aff_point = as_nat5 (as_felem5_lseq (LSeq.sub p 0 5)), as_nat5 (as_felem5_lseq (LSeq.sub p 5 5)) inline_for_extraction noextract let aff_point = lbuffer uint64 10ul noextract let aff_point_inv (h:mem) (p:aff_point) = aff_point_inv_seq (as_seq h p) noextract

Hacl.Impl.K256.Point.fsti

val aff_point_eval (h: mem) (p: aff_point{aff_point_inv h p}) : GTot S.aff_point

Hacl.Impl.K256.Point.aff_point_eval

h: FStar.Monotonic.HyperStack.mem -> p: Hacl.Impl.K256.Point.aff_point{Hacl.Impl.K256.Point.aff_point_inv h p} -> Prims.GTot Spec.K256.PointOps.aff_point

Prims.Tot

let aff_point_seq = LSeq.lseq uint64 10

let aff_point_seq =

LSeq.lseq uint64 10

module Hacl.Impl.K256.Point open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module S = Spec.K256 open Hacl.K256.Field #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let as_felem5_lseq (s:LSeq.lseq uint64 5) : felem5 = let open Lib.Sequence in (s.[0],s.[1],s.[2],s.[3],s.[4]) /// Affine coordinates

Hacl.Impl.K256.Point.fsti

val aff_point_seq : Type0

Hacl.Impl.K256.Point.aff_point_seq

Type0

Prims.Tot

let aff_point_inv_seq (p:aff_point_seq) = inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 0 5)) /\ inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 5 5))

let aff_point_inv_seq (p: aff_point_seq) =

inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 0 5)) /\ inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 5 5))

module Hacl.Impl.K256.Point open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module S = Spec.K256 open Hacl.K256.Field #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let as_felem5_lseq (s:LSeq.lseq uint64 5) : felem5 = let open Lib.Sequence in (s.[0],s.[1],s.[2],s.[3],s.[4]) /// Affine coordinates inline_for_extraction noextract let aff_point_seq = LSeq.lseq uint64 10

Hacl.Impl.K256.Point.fsti

val aff_point_inv_seq : p: Hacl.Impl.K256.Point.aff_point_seq -> Prims.logical

Hacl.Impl.K256.Point.aff_point_inv_seq

p: Hacl.Impl.K256.Point.aff_point_seq -> Prims.logical

Prims.Tot

val aff_point_eval_seq (p: aff_point_seq{aff_point_inv_seq p}) : S.aff_point

let aff_point_eval_seq (p:aff_point_seq{aff_point_inv_seq p}) : S.aff_point = as_nat5 (as_felem5_lseq (LSeq.sub p 0 5)), as_nat5 (as_felem5_lseq (LSeq.sub p 5 5))

val aff_point_eval_seq (p: aff_point_seq{aff_point_inv_seq p}) : S.aff_point let aff_point_eval_seq (p: aff_point_seq{aff_point_inv_seq p}) : S.aff_point =

as_nat5 (as_felem5_lseq (LSeq.sub p 0 5)), as_nat5 (as_felem5_lseq (LSeq.sub p 5 5))

module Hacl.Impl.K256.Point open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module S = Spec.K256 open Hacl.K256.Field #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let as_felem5_lseq (s:LSeq.lseq uint64 5) : felem5 = let open Lib.Sequence in (s.[0],s.[1],s.[2],s.[3],s.[4]) /// Affine coordinates inline_for_extraction noextract let aff_point_seq = LSeq.lseq uint64 10 let aff_point_inv_seq (p:aff_point_seq) = inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 0 5)) /\ inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 5 5))

Hacl.Impl.K256.Point.fsti

val aff_point_eval_seq (p: aff_point_seq{aff_point_inv_seq p}) : S.aff_point

Hacl.Impl.K256.Point.aff_point_eval_seq

p: Hacl.Impl.K256.Point.aff_point_seq{Hacl.Impl.K256.Point.aff_point_inv_seq p} -> Spec.K256.PointOps.aff_point

Prims.GTot

val point_eval (h: mem) (p: point) : GTot S.proj_point

let point_eval (h:mem) (p:point) : GTot S.proj_point = feval h (gsub p 0ul 5ul), feval h (gsub p 5ul 5ul), feval h (gsub p 10ul 5ul)

val point_eval (h: mem) (p: point) : GTot S.proj_point let point_eval (h: mem) (p: point) : GTot S.proj_point =

feval h (gsub p 0ul 5ul), feval h (gsub p 5ul 5ul), feval h (gsub p 10ul 5ul)

module Hacl.Impl.K256.Point open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module S = Spec.K256 open Hacl.K256.Field #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let as_felem5_lseq (s:LSeq.lseq uint64 5) : felem5 = let open Lib.Sequence in (s.[0],s.[1],s.[2],s.[3],s.[4]) /// Affine coordinates inline_for_extraction noextract let aff_point_seq = LSeq.lseq uint64 10 let aff_point_inv_seq (p:aff_point_seq) = inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 0 5)) /\ inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 5 5)) let aff_point_eval_seq (p:aff_point_seq{aff_point_inv_seq p}) : S.aff_point = as_nat5 (as_felem5_lseq (LSeq.sub p 0 5)), as_nat5 (as_felem5_lseq (LSeq.sub p 5 5)) inline_for_extraction noextract let aff_point = lbuffer uint64 10ul noextract let aff_point_inv (h:mem) (p:aff_point) = aff_point_inv_seq (as_seq h p) noextract let aff_point_eval (h:mem) (p:aff_point{aff_point_inv h p}) : GTot S.aff_point = aff_point_eval_seq (as_seq h p) inline_for_extraction noextract let aff_getx (p:aff_point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1) = sub p 0ul 5ul inline_for_extraction noextract let aff_gety (p:aff_point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1) = sub p 5ul 5ul /// Projective coordinates // (_X, _Y, _Z) inline_for_extraction noextract let point = lbuffer uint64 15ul inline_for_extraction noextract let getx (p:point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1) = sub p 0ul 5ul inline_for_extraction noextract let gety (p:point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1) = sub p 5ul 5ul inline_for_extraction noextract let getz (p:point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 10ul 5ul /\ h0 == h1) = sub p 10ul 5ul inline_for_extraction noextract let point_inv_lseq (p:LSeq.lseq uint64 15) = inv_lazy_reduced2_5 (as_felem5_lseq (LSeq.sub p 0 5)) /\ inv_lazy_reduced2_5 (as_felem5_lseq (LSeq.sub p 5 5)) /\ inv_lazy_reduced2_5 (as_felem5_lseq (LSeq.sub p 10 5)) inline_for_extraction noextract let point_inv (h:mem) (p:point) = inv_lazy_reduced2 h (gsub p 0ul 5ul) /\ inv_lazy_reduced2 h (gsub p 5ul 5ul) /\ inv_lazy_reduced2 h (gsub p 10ul 5ul) inline_for_extraction noextract let point_eval_lseq (p:LSeq.lseq uint64 15) : GTot S.proj_point = feval5 (as_felem5_lseq (LSeq.sub p 0 5)), feval5 (as_felem5_lseq (LSeq.sub p 5 5)), feval5 (as_felem5_lseq (LSeq.sub p 10 5)) inline_for_extraction noextract

Hacl.Impl.K256.Point.fsti

val point_eval (h: mem) (p: point) : GTot S.proj_point

Hacl.Impl.K256.Point.point_eval

h: FStar.Monotonic.HyperStack.mem -> p: Hacl.Impl.K256.Point.point -> Prims.GTot Spec.K256.PointOps.proj_point

Prims.Tot

let point_inv (h:mem) (p:point) = inv_lazy_reduced2 h (gsub p 0ul 5ul) /\ inv_lazy_reduced2 h (gsub p 5ul 5ul) /\ inv_lazy_reduced2 h (gsub p 10ul 5ul)

let point_inv (h: mem) (p: point) =

inv_lazy_reduced2 h (gsub p 0ul 5ul) /\ inv_lazy_reduced2 h (gsub p 5ul 5ul) /\ inv_lazy_reduced2 h (gsub p 10ul 5ul)

module Hacl.Impl.K256.Point open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module S = Spec.K256 open Hacl.K256.Field #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let as_felem5_lseq (s:LSeq.lseq uint64 5) : felem5 = let open Lib.Sequence in (s.[0],s.[1],s.[2],s.[3],s.[4]) /// Affine coordinates inline_for_extraction noextract let aff_point_seq = LSeq.lseq uint64 10 let aff_point_inv_seq (p:aff_point_seq) = inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 0 5)) /\ inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 5 5)) let aff_point_eval_seq (p:aff_point_seq{aff_point_inv_seq p}) : S.aff_point = as_nat5 (as_felem5_lseq (LSeq.sub p 0 5)), as_nat5 (as_felem5_lseq (LSeq.sub p 5 5)) inline_for_extraction noextract let aff_point = lbuffer uint64 10ul noextract let aff_point_inv (h:mem) (p:aff_point) = aff_point_inv_seq (as_seq h p) noextract let aff_point_eval (h:mem) (p:aff_point{aff_point_inv h p}) : GTot S.aff_point = aff_point_eval_seq (as_seq h p) inline_for_extraction noextract let aff_getx (p:aff_point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1) = sub p 0ul 5ul inline_for_extraction noextract let aff_gety (p:aff_point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1) = sub p 5ul 5ul /// Projective coordinates // (_X, _Y, _Z) inline_for_extraction noextract let point = lbuffer uint64 15ul inline_for_extraction noextract let getx (p:point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1) = sub p 0ul 5ul inline_for_extraction noextract let gety (p:point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1) = sub p 5ul 5ul inline_for_extraction noextract let getz (p:point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 10ul 5ul /\ h0 == h1) = sub p 10ul 5ul inline_for_extraction noextract let point_inv_lseq (p:LSeq.lseq uint64 15) = inv_lazy_reduced2_5 (as_felem5_lseq (LSeq.sub p 0 5)) /\ inv_lazy_reduced2_5 (as_felem5_lseq (LSeq.sub p 5 5)) /\ inv_lazy_reduced2_5 (as_felem5_lseq (LSeq.sub p 10 5)) inline_for_extraction noextract

Hacl.Impl.K256.Point.fsti

val point_inv : h: FStar.Monotonic.HyperStack.mem -> p: Hacl.Impl.K256.Point.point -> Prims.logical

Hacl.Impl.K256.Point.point_inv

h: FStar.Monotonic.HyperStack.mem -> p: Hacl.Impl.K256.Point.point -> Prims.logical

Prims.Tot

let point_inv_lseq (p:LSeq.lseq uint64 15) = inv_lazy_reduced2_5 (as_felem5_lseq (LSeq.sub p 0 5)) /\ inv_lazy_reduced2_5 (as_felem5_lseq (LSeq.sub p 5 5)) /\ inv_lazy_reduced2_5 (as_felem5_lseq (LSeq.sub p 10 5))

let point_inv_lseq (p: LSeq.lseq uint64 15) =

inv_lazy_reduced2_5 (as_felem5_lseq (LSeq.sub p 0 5)) /\ inv_lazy_reduced2_5 (as_felem5_lseq (LSeq.sub p 5 5)) /\ inv_lazy_reduced2_5 (as_felem5_lseq (LSeq.sub p 10 5))

module Hacl.Impl.K256.Point open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module S = Spec.K256 open Hacl.K256.Field #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let as_felem5_lseq (s:LSeq.lseq uint64 5) : felem5 = let open Lib.Sequence in (s.[0],s.[1],s.[2],s.[3],s.[4]) /// Affine coordinates inline_for_extraction noextract let aff_point_seq = LSeq.lseq uint64 10 let aff_point_inv_seq (p:aff_point_seq) = inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 0 5)) /\ inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 5 5)) let aff_point_eval_seq (p:aff_point_seq{aff_point_inv_seq p}) : S.aff_point = as_nat5 (as_felem5_lseq (LSeq.sub p 0 5)), as_nat5 (as_felem5_lseq (LSeq.sub p 5 5)) inline_for_extraction noextract let aff_point = lbuffer uint64 10ul noextract let aff_point_inv (h:mem) (p:aff_point) = aff_point_inv_seq (as_seq h p) noextract let aff_point_eval (h:mem) (p:aff_point{aff_point_inv h p}) : GTot S.aff_point = aff_point_eval_seq (as_seq h p) inline_for_extraction noextract let aff_getx (p:aff_point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1) = sub p 0ul 5ul inline_for_extraction noextract let aff_gety (p:aff_point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1) = sub p 5ul 5ul /// Projective coordinates // (_X, _Y, _Z) inline_for_extraction noextract let point = lbuffer uint64 15ul inline_for_extraction noextract let getx (p:point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1) = sub p 0ul 5ul inline_for_extraction noextract let gety (p:point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1) = sub p 5ul 5ul inline_for_extraction noextract let getz (p:point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 10ul 5ul /\ h0 == h1) = sub p 10ul 5ul inline_for_extraction noextract

Hacl.Impl.K256.Point.fsti

val point_inv_lseq : p: Lib.Sequence.lseq Lib.IntTypes.uint64 15 -> Prims.logical

Hacl.Impl.K256.Point.point_inv_lseq

p: Lib.Sequence.lseq Lib.IntTypes.uint64 15 -> Prims.logical

FStar.HyperStack.ST.Stack

val aff_gety (p: aff_point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1)

let aff_gety (p:aff_point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1) = sub p 5ul 5ul

val aff_gety (p: aff_point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1) let aff_gety (p: aff_point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1) =

sub p 5ul 5ul

module Hacl.Impl.K256.Point open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module S = Spec.K256 open Hacl.K256.Field #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let as_felem5_lseq (s:LSeq.lseq uint64 5) : felem5 = let open Lib.Sequence in (s.[0],s.[1],s.[2],s.[3],s.[4]) /// Affine coordinates inline_for_extraction noextract let aff_point_seq = LSeq.lseq uint64 10 let aff_point_inv_seq (p:aff_point_seq) = inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 0 5)) /\ inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 5 5)) let aff_point_eval_seq (p:aff_point_seq{aff_point_inv_seq p}) : S.aff_point = as_nat5 (as_felem5_lseq (LSeq.sub p 0 5)), as_nat5 (as_felem5_lseq (LSeq.sub p 5 5)) inline_for_extraction noextract let aff_point = lbuffer uint64 10ul noextract let aff_point_inv (h:mem) (p:aff_point) = aff_point_inv_seq (as_seq h p) noextract let aff_point_eval (h:mem) (p:aff_point{aff_point_inv h p}) : GTot S.aff_point = aff_point_eval_seq (as_seq h p) inline_for_extraction noextract let aff_getx (p:aff_point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1) = sub p 0ul 5ul inline_for_extraction noextract let aff_gety (p:aff_point) : Stack felem (requires fun h -> live h p)

Hacl.Impl.K256.Point.fsti

val aff_gety (p: aff_point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1)

Hacl.Impl.K256.Point.aff_gety

p: Hacl.Impl.K256.Point.aff_point -> FStar.HyperStack.ST.Stack Hacl.K256.Field.felem

FStar.HyperStack.ST.Stack

val aff_getx (p: aff_point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1)

let aff_getx (p:aff_point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1) = sub p 0ul 5ul

val aff_getx (p: aff_point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1) let aff_getx (p: aff_point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1) =

sub p 0ul 5ul

module Hacl.Impl.K256.Point open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module S = Spec.K256 open Hacl.K256.Field #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let as_felem5_lseq (s:LSeq.lseq uint64 5) : felem5 = let open Lib.Sequence in (s.[0],s.[1],s.[2],s.[3],s.[4]) /// Affine coordinates inline_for_extraction noextract let aff_point_seq = LSeq.lseq uint64 10 let aff_point_inv_seq (p:aff_point_seq) = inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 0 5)) /\ inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 5 5)) let aff_point_eval_seq (p:aff_point_seq{aff_point_inv_seq p}) : S.aff_point = as_nat5 (as_felem5_lseq (LSeq.sub p 0 5)), as_nat5 (as_felem5_lseq (LSeq.sub p 5 5)) inline_for_extraction noextract let aff_point = lbuffer uint64 10ul noextract let aff_point_inv (h:mem) (p:aff_point) = aff_point_inv_seq (as_seq h p) noextract let aff_point_eval (h:mem) (p:aff_point{aff_point_inv h p}) : GTot S.aff_point = aff_point_eval_seq (as_seq h p) inline_for_extraction noextract let aff_getx (p:aff_point) : Stack felem (requires fun h -> live h p)

Hacl.Impl.K256.Point.fsti

val aff_getx (p: aff_point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1)

Hacl.Impl.K256.Point.aff_getx

p: Hacl.Impl.K256.Point.aff_point -> FStar.HyperStack.ST.Stack Hacl.K256.Field.felem

Prims.Tot

val as_felem5_lseq (s: LSeq.lseq uint64 5) : felem5

let as_felem5_lseq (s:LSeq.lseq uint64 5) : felem5 = let open Lib.Sequence in (s.[0],s.[1],s.[2],s.[3],s.[4])

val as_felem5_lseq (s: LSeq.lseq uint64 5) : felem5 let as_felem5_lseq (s: LSeq.lseq uint64 5) : felem5 =

let open Lib.Sequence in (s.[ 0 ], s.[ 1 ], s.[ 2 ], s.[ 3 ], s.[ 4 ])

module Hacl.Impl.K256.Point open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module S = Spec.K256 open Hacl.K256.Field #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract

Hacl.Impl.K256.Point.fsti

val as_felem5_lseq (s: LSeq.lseq uint64 5) : felem5

Hacl.Impl.K256.Point.as_felem5_lseq

s: Lib.Sequence.lseq Lib.IntTypes.uint64 5 -> Hacl.Spec.K256.Field52.Definitions.felem5

FStar.HyperStack.ST.Stack

val gety (p: point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1)

let gety (p:point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1) = sub p 5ul 5ul

val gety (p: point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1) let gety (p: point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1) =

sub p 5ul 5ul

module Hacl.Impl.K256.Point open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module S = Spec.K256 open Hacl.K256.Field #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let as_felem5_lseq (s:LSeq.lseq uint64 5) : felem5 = let open Lib.Sequence in (s.[0],s.[1],s.[2],s.[3],s.[4]) /// Affine coordinates inline_for_extraction noextract let aff_point_seq = LSeq.lseq uint64 10 let aff_point_inv_seq (p:aff_point_seq) = inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 0 5)) /\ inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 5 5)) let aff_point_eval_seq (p:aff_point_seq{aff_point_inv_seq p}) : S.aff_point = as_nat5 (as_felem5_lseq (LSeq.sub p 0 5)), as_nat5 (as_felem5_lseq (LSeq.sub p 5 5)) inline_for_extraction noextract let aff_point = lbuffer uint64 10ul noextract let aff_point_inv (h:mem) (p:aff_point) = aff_point_inv_seq (as_seq h p) noextract let aff_point_eval (h:mem) (p:aff_point{aff_point_inv h p}) : GTot S.aff_point = aff_point_eval_seq (as_seq h p) inline_for_extraction noextract let aff_getx (p:aff_point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1) = sub p 0ul 5ul inline_for_extraction noextract let aff_gety (p:aff_point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1) = sub p 5ul 5ul /// Projective coordinates // (_X, _Y, _Z) inline_for_extraction noextract let point = lbuffer uint64 15ul inline_for_extraction noextract let getx (p:point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1) = sub p 0ul 5ul inline_for_extraction noextract let gety (p:point) : Stack felem (requires fun h -> live h p)

Hacl.Impl.K256.Point.fsti

val gety (p: point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1)

Hacl.Impl.K256.Point.gety

p: Hacl.Impl.K256.Point.point -> FStar.HyperStack.ST.Stack Hacl.K256.Field.felem

FStar.HyperStack.ST.Stack

val getx (p: point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1)

let getx (p:point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1) = sub p 0ul 5ul

val getx (p: point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1) let getx (p: point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1) =

sub p 0ul 5ul

module Hacl.Impl.K256.Point open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module S = Spec.K256 open Hacl.K256.Field #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let as_felem5_lseq (s:LSeq.lseq uint64 5) : felem5 = let open Lib.Sequence in (s.[0],s.[1],s.[2],s.[3],s.[4]) /// Affine coordinates inline_for_extraction noextract let aff_point_seq = LSeq.lseq uint64 10 let aff_point_inv_seq (p:aff_point_seq) = inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 0 5)) /\ inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 5 5)) let aff_point_eval_seq (p:aff_point_seq{aff_point_inv_seq p}) : S.aff_point = as_nat5 (as_felem5_lseq (LSeq.sub p 0 5)), as_nat5 (as_felem5_lseq (LSeq.sub p 5 5)) inline_for_extraction noextract let aff_point = lbuffer uint64 10ul noextract let aff_point_inv (h:mem) (p:aff_point) = aff_point_inv_seq (as_seq h p) noextract let aff_point_eval (h:mem) (p:aff_point{aff_point_inv h p}) : GTot S.aff_point = aff_point_eval_seq (as_seq h p) inline_for_extraction noextract let aff_getx (p:aff_point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1) = sub p 0ul 5ul inline_for_extraction noextract let aff_gety (p:aff_point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1) = sub p 5ul 5ul /// Projective coordinates // (_X, _Y, _Z) inline_for_extraction noextract let point = lbuffer uint64 15ul inline_for_extraction noextract let getx (p:point) : Stack felem (requires fun h -> live h p)

Hacl.Impl.K256.Point.fsti

val getx (p: point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1)

Hacl.Impl.K256.Point.getx

p: Hacl.Impl.K256.Point.point -> FStar.HyperStack.ST.Stack Hacl.K256.Field.felem

FStar.HyperStack.ST.Stack

val getz (p: point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 10ul 5ul /\ h0 == h1)

let getz (p:point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 10ul 5ul /\ h0 == h1) = sub p 10ul 5ul

val getz (p: point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 10ul 5ul /\ h0 == h1) let getz (p: point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 10ul 5ul /\ h0 == h1) =

sub p 10ul 5ul

module Hacl.Impl.K256.Point open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module S = Spec.K256 open Hacl.K256.Field #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let as_felem5_lseq (s:LSeq.lseq uint64 5) : felem5 = let open Lib.Sequence in (s.[0],s.[1],s.[2],s.[3],s.[4]) /// Affine coordinates inline_for_extraction noextract let aff_point_seq = LSeq.lseq uint64 10 let aff_point_inv_seq (p:aff_point_seq) = inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 0 5)) /\ inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 5 5)) let aff_point_eval_seq (p:aff_point_seq{aff_point_inv_seq p}) : S.aff_point = as_nat5 (as_felem5_lseq (LSeq.sub p 0 5)), as_nat5 (as_felem5_lseq (LSeq.sub p 5 5)) inline_for_extraction noextract let aff_point = lbuffer uint64 10ul noextract let aff_point_inv (h:mem) (p:aff_point) = aff_point_inv_seq (as_seq h p) noextract let aff_point_eval (h:mem) (p:aff_point{aff_point_inv h p}) : GTot S.aff_point = aff_point_eval_seq (as_seq h p) inline_for_extraction noextract let aff_getx (p:aff_point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1) = sub p 0ul 5ul inline_for_extraction noextract let aff_gety (p:aff_point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1) = sub p 5ul 5ul /// Projective coordinates // (_X, _Y, _Z) inline_for_extraction noextract let point = lbuffer uint64 15ul inline_for_extraction noextract let getx (p:point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1) = sub p 0ul 5ul inline_for_extraction noextract let gety (p:point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1) = sub p 5ul 5ul inline_for_extraction noextract let getz (p:point) : Stack felem (requires fun h -> live h p)

Hacl.Impl.K256.Point.fsti

val getz (p: point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 10ul 5ul /\ h0 == h1)

Hacl.Impl.K256.Point.getz

p: Hacl.Impl.K256.Point.point -> FStar.HyperStack.ST.Stack Hacl.K256.Field.felem

Prims.GTot

val point_eval_lseq (p: LSeq.lseq uint64 15) : GTot S.proj_point

let point_eval_lseq (p:LSeq.lseq uint64 15) : GTot S.proj_point = feval5 (as_felem5_lseq (LSeq.sub p 0 5)), feval5 (as_felem5_lseq (LSeq.sub p 5 5)), feval5 (as_felem5_lseq (LSeq.sub p 10 5))

val point_eval_lseq (p: LSeq.lseq uint64 15) : GTot S.proj_point let point_eval_lseq (p: LSeq.lseq uint64 15) : GTot S.proj_point =

feval5 (as_felem5_lseq (LSeq.sub p 0 5)), feval5 (as_felem5_lseq (LSeq.sub p 5 5)), feval5 (as_felem5_lseq (LSeq.sub p 10 5))

module Hacl.Impl.K256.Point open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module S = Spec.K256 open Hacl.K256.Field #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let as_felem5_lseq (s:LSeq.lseq uint64 5) : felem5 = let open Lib.Sequence in (s.[0],s.[1],s.[2],s.[3],s.[4]) /// Affine coordinates inline_for_extraction noextract let aff_point_seq = LSeq.lseq uint64 10 let aff_point_inv_seq (p:aff_point_seq) = inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 0 5)) /\ inv_fully_reduced5 (as_felem5_lseq (LSeq.sub p 5 5)) let aff_point_eval_seq (p:aff_point_seq{aff_point_inv_seq p}) : S.aff_point = as_nat5 (as_felem5_lseq (LSeq.sub p 0 5)), as_nat5 (as_felem5_lseq (LSeq.sub p 5 5)) inline_for_extraction noextract let aff_point = lbuffer uint64 10ul noextract let aff_point_inv (h:mem) (p:aff_point) = aff_point_inv_seq (as_seq h p) noextract let aff_point_eval (h:mem) (p:aff_point{aff_point_inv h p}) : GTot S.aff_point = aff_point_eval_seq (as_seq h p) inline_for_extraction noextract let aff_getx (p:aff_point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1) = sub p 0ul 5ul inline_for_extraction noextract let aff_gety (p:aff_point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1) = sub p 5ul 5ul /// Projective coordinates // (_X, _Y, _Z) inline_for_extraction noextract let point = lbuffer uint64 15ul inline_for_extraction noextract let getx (p:point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 0ul 5ul /\ h0 == h1) = sub p 0ul 5ul inline_for_extraction noextract let gety (p:point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 5ul 5ul /\ h0 == h1) = sub p 5ul 5ul inline_for_extraction noextract let getz (p:point) : Stack felem (requires fun h -> live h p) (ensures fun h0 f h1 -> f == gsub p 10ul 5ul /\ h0 == h1) = sub p 10ul 5ul inline_for_extraction noextract let point_inv_lseq (p:LSeq.lseq uint64 15) = inv_lazy_reduced2_5 (as_felem5_lseq (LSeq.sub p 0 5)) /\ inv_lazy_reduced2_5 (as_felem5_lseq (LSeq.sub p 5 5)) /\ inv_lazy_reduced2_5 (as_felem5_lseq (LSeq.sub p 10 5)) inline_for_extraction noextract let point_inv (h:mem) (p:point) = inv_lazy_reduced2 h (gsub p 0ul 5ul) /\ inv_lazy_reduced2 h (gsub p 5ul 5ul) /\ inv_lazy_reduced2 h (gsub p 10ul 5ul) inline_for_extraction noextract

Hacl.Impl.K256.Point.fsti

val point_eval_lseq (p: LSeq.lseq uint64 15) : GTot S.proj_point

Hacl.Impl.K256.Point.point_eval_lseq

p: Lib.Sequence.lseq Lib.IntTypes.uint64 15 -> Prims.GTot Spec.K256.PointOps.proj_point

Prims.Tot

val crypto_kem_dec: a:FP.frodo_alg -> gen_a:FP.frodo_gen_a{is_supported gen_a} -> crypto_kem_dec_st a gen_a

let crypto_kem_dec a gen_a ss ct sk = Hacl.Impl.Frodo.KEM.Decaps.crypto_kem_dec a gen_a ss ct sk

val crypto_kem_dec: a:FP.frodo_alg -> gen_a:FP.frodo_gen_a{is_supported gen_a} -> crypto_kem_dec_st a gen_a let crypto_kem_dec a gen_a ss ct sk =

Hacl.Impl.Frodo.KEM.Decaps.crypto_kem_dec a gen_a ss ct sk

module Hacl.Frodo.KEM open FStar.HyperStack open FStar.HyperStack.ST open Lib.IntTypes open Lib.Buffer open Hacl.Impl.Matrix open Hacl.Impl.Frodo.Params open Hacl.Impl.Frodo.KEM open Hacl.Frodo.Random module S = Spec.Frodo.KEM module FP = Spec.Frodo.Params #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let crypto_kem_keypair_st (a:FP.frodo_alg) (gen_a:FP.frodo_gen_a{is_supported gen_a}) = pk:lbytes (crypto_publickeybytes a) -> sk:lbytes (crypto_secretkeybytes a) -> Stack uint32 (requires fun h -> live h pk /\ live h sk /\ disjoint pk sk /\ disjoint state pk /\ disjoint state sk) (ensures fun h0 r h1 -> modifies (loc state |+| (loc pk |+| loc sk)) h0 h1 /\ (as_seq h1 pk, as_seq h1 sk) == S.crypto_kem_keypair a gen_a (as_seq h0 state)) inline_for_extraction noextract val crypto_kem_keypair: a:FP.frodo_alg -> gen_a:FP.frodo_gen_a{is_supported gen_a} -> crypto_kem_keypair_st a gen_a let crypto_kem_keypair a gen_a pk sk = Hacl.Impl.Frodo.KEM.KeyGen.crypto_kem_keypair a gen_a pk sk inline_for_extraction noextract let crypto_kem_enc_st (a:FP.frodo_alg) (gen_a:FP.frodo_gen_a{is_supported gen_a}) = ct:lbytes (crypto_ciphertextbytes a) -> ss:lbytes (crypto_bytes a) -> pk:lbytes (crypto_publickeybytes a) -> Stack uint32 (requires fun h -> live h ct /\ live h ss /\ live h pk /\ disjoint ct ss /\ disjoint ct pk /\ disjoint ss pk /\ disjoint state ct /\ disjoint state ss /\ disjoint state pk) (ensures fun h0 _ h1 -> modifies (loc state |+| (loc ct |+| loc ss)) h0 h1 /\ (as_seq h1 ct, as_seq h1 ss) == S.crypto_kem_enc a gen_a (as_seq h0 state) (as_seq h0 pk)) inline_for_extraction noextract val crypto_kem_enc: a:FP.frodo_alg -> gen_a:FP.frodo_gen_a{is_supported gen_a} -> crypto_kem_enc_st a gen_a let crypto_kem_enc a gen_a ct ss pk = Hacl.Impl.Frodo.KEM.Encaps.crypto_kem_enc a gen_a ct ss pk inline_for_extraction noextract let crypto_kem_dec_st (a:FP.frodo_alg) (gen_a:FP.frodo_gen_a{is_supported gen_a}) = ss:lbytes (crypto_bytes a) -> ct:lbytes (crypto_ciphertextbytes a) -> sk:lbytes (crypto_secretkeybytes a) -> Stack uint32 (requires fun h -> live h ss /\ live h ct /\ live h sk /\ disjoint ss ct /\ disjoint ss sk /\ disjoint ct sk) (ensures fun h0 r h1 -> modifies (loc ss) h0 h1 /\ as_seq h1 ss == S.crypto_kem_dec a gen_a (as_seq h0 ct) (as_seq h0 sk)) inline_for_extraction noextract val crypto_kem_dec: a:FP.frodo_alg -> gen_a:FP.frodo_gen_a{is_supported gen_a} -> crypto_kem_dec_st a gen_a

Hacl.Frodo.KEM.fst

val crypto_kem_dec: a:FP.frodo_alg -> gen_a:FP.frodo_gen_a{is_supported gen_a} -> crypto_kem_dec_st a gen_a

Hacl.Frodo.KEM.crypto_kem_dec

a: Spec.Frodo.Params.frodo_alg -> gen_a: Spec.Frodo.Params.frodo_gen_a{Hacl.Impl.Frodo.Params.is_supported gen_a} -> Hacl.Frodo.KEM.crypto_kem_dec_st a gen_a

Prims.Tot

val crypto_kem_keypair: a:FP.frodo_alg -> gen_a:FP.frodo_gen_a{is_supported gen_a} -> crypto_kem_keypair_st a gen_a

let crypto_kem_keypair a gen_a pk sk = Hacl.Impl.Frodo.KEM.KeyGen.crypto_kem_keypair a gen_a pk sk

val crypto_kem_keypair: a:FP.frodo_alg -> gen_a:FP.frodo_gen_a{is_supported gen_a} -> crypto_kem_keypair_st a gen_a let crypto_kem_keypair a gen_a pk sk =

Hacl.Impl.Frodo.KEM.KeyGen.crypto_kem_keypair a gen_a pk sk

module Hacl.Frodo.KEM open FStar.HyperStack open FStar.HyperStack.ST open Lib.IntTypes open Lib.Buffer open Hacl.Impl.Matrix open Hacl.Impl.Frodo.Params open Hacl.Impl.Frodo.KEM open Hacl.Frodo.Random module S = Spec.Frodo.KEM module FP = Spec.Frodo.Params #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let crypto_kem_keypair_st (a:FP.frodo_alg) (gen_a:FP.frodo_gen_a{is_supported gen_a}) = pk:lbytes (crypto_publickeybytes a) -> sk:lbytes (crypto_secretkeybytes a) -> Stack uint32 (requires fun h -> live h pk /\ live h sk /\ disjoint pk sk /\ disjoint state pk /\ disjoint state sk) (ensures fun h0 r h1 -> modifies (loc state |+| (loc pk |+| loc sk)) h0 h1 /\ (as_seq h1 pk, as_seq h1 sk) == S.crypto_kem_keypair a gen_a (as_seq h0 state)) inline_for_extraction noextract val crypto_kem_keypair: a:FP.frodo_alg -> gen_a:FP.frodo_gen_a{is_supported gen_a} -> crypto_kem_keypair_st a gen_a

Hacl.Frodo.KEM.fst

val crypto_kem_keypair: a:FP.frodo_alg -> gen_a:FP.frodo_gen_a{is_supported gen_a} -> crypto_kem_keypair_st a gen_a

Hacl.Frodo.KEM.crypto_kem_keypair

a: Spec.Frodo.Params.frodo_alg -> gen_a: Spec.Frodo.Params.frodo_gen_a{Hacl.Impl.Frodo.Params.is_supported gen_a} -> Hacl.Frodo.KEM.crypto_kem_keypair_st a gen_a

Prims.Tot

val crypto_kem_enc: a:FP.frodo_alg -> gen_a:FP.frodo_gen_a{is_supported gen_a} -> crypto_kem_enc_st a gen_a

let crypto_kem_enc a gen_a ct ss pk = Hacl.Impl.Frodo.KEM.Encaps.crypto_kem_enc a gen_a ct ss pk

val crypto_kem_enc: a:FP.frodo_alg -> gen_a:FP.frodo_gen_a{is_supported gen_a} -> crypto_kem_enc_st a gen_a let crypto_kem_enc a gen_a ct ss pk =

Hacl.Impl.Frodo.KEM.Encaps.crypto_kem_enc a gen_a ct ss pk

module Hacl.Frodo.KEM open FStar.HyperStack open FStar.HyperStack.ST open Lib.IntTypes open Lib.Buffer open Hacl.Impl.Matrix open Hacl.Impl.Frodo.Params open Hacl.Impl.Frodo.KEM open Hacl.Frodo.Random module S = Spec.Frodo.KEM module FP = Spec.Frodo.Params #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let crypto_kem_keypair_st (a:FP.frodo_alg) (gen_a:FP.frodo_gen_a{is_supported gen_a}) = pk:lbytes (crypto_publickeybytes a) -> sk:lbytes (crypto_secretkeybytes a) -> Stack uint32 (requires fun h -> live h pk /\ live h sk /\ disjoint pk sk /\ disjoint state pk /\ disjoint state sk) (ensures fun h0 r h1 -> modifies (loc state |+| (loc pk |+| loc sk)) h0 h1 /\ (as_seq h1 pk, as_seq h1 sk) == S.crypto_kem_keypair a gen_a (as_seq h0 state)) inline_for_extraction noextract val crypto_kem_keypair: a:FP.frodo_alg -> gen_a:FP.frodo_gen_a{is_supported gen_a} -> crypto_kem_keypair_st a gen_a let crypto_kem_keypair a gen_a pk sk = Hacl.Impl.Frodo.KEM.KeyGen.crypto_kem_keypair a gen_a pk sk inline_for_extraction noextract let crypto_kem_enc_st (a:FP.frodo_alg) (gen_a:FP.frodo_gen_a{is_supported gen_a}) = ct:lbytes (crypto_ciphertextbytes a) -> ss:lbytes (crypto_bytes a) -> pk:lbytes (crypto_publickeybytes a) -> Stack uint32 (requires fun h -> live h ct /\ live h ss /\ live h pk /\ disjoint ct ss /\ disjoint ct pk /\ disjoint ss pk /\ disjoint state ct /\ disjoint state ss /\ disjoint state pk) (ensures fun h0 _ h1 -> modifies (loc state |+| (loc ct |+| loc ss)) h0 h1 /\ (as_seq h1 ct, as_seq h1 ss) == S.crypto_kem_enc a gen_a (as_seq h0 state) (as_seq h0 pk)) inline_for_extraction noextract val crypto_kem_enc: a:FP.frodo_alg -> gen_a:FP.frodo_gen_a{is_supported gen_a} -> crypto_kem_enc_st a gen_a

Hacl.Frodo.KEM.fst

val crypto_kem_enc: a:FP.frodo_alg -> gen_a:FP.frodo_gen_a{is_supported gen_a} -> crypto_kem_enc_st a gen_a

Hacl.Frodo.KEM.crypto_kem_enc

a: Spec.Frodo.Params.frodo_alg -> gen_a: Spec.Frodo.Params.frodo_gen_a{Hacl.Impl.Frodo.Params.is_supported gen_a} -> Hacl.Frodo.KEM.crypto_kem_enc_st a gen_a

Prims.Tot

let crypto_kem_keypair_st (a:FP.frodo_alg) (gen_a:FP.frodo_gen_a{is_supported gen_a}) = pk:lbytes (crypto_publickeybytes a) -> sk:lbytes (crypto_secretkeybytes a) -> Stack uint32 (requires fun h -> live h pk /\ live h sk /\ disjoint pk sk /\ disjoint state pk /\ disjoint state sk) (ensures fun h0 r h1 -> modifies (loc state |+| (loc pk |+| loc sk)) h0 h1 /\ (as_seq h1 pk, as_seq h1 sk) == S.crypto_kem_keypair a gen_a (as_seq h0 state))

let crypto_kem_keypair_st (a: FP.frodo_alg) (gen_a: FP.frodo_gen_a{is_supported gen_a}) =

pk: lbytes (crypto_publickeybytes a) -> sk: lbytes (crypto_secretkeybytes a) -> Stack uint32 (requires fun h -> live h pk /\ live h sk /\ disjoint pk sk /\ disjoint state pk /\ disjoint state sk) (ensures fun h0 r h1 -> modifies (loc state |+| (loc pk |+| loc sk)) h0 h1 /\ (as_seq h1 pk, as_seq h1 sk) == S.crypto_kem_keypair a gen_a (as_seq h0 state))

module Hacl.Frodo.KEM open FStar.HyperStack open FStar.HyperStack.ST open Lib.IntTypes open Lib.Buffer open Hacl.Impl.Matrix open Hacl.Impl.Frodo.Params open Hacl.Impl.Frodo.KEM open Hacl.Frodo.Random module S = Spec.Frodo.KEM module FP = Spec.Frodo.Params #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract

Hacl.Frodo.KEM.fst

val crypto_kem_keypair_st : a: Spec.Frodo.Params.frodo_alg -> gen_a: Spec.Frodo.Params.frodo_gen_a{Hacl.Impl.Frodo.Params.is_supported gen_a} -> Type0

Hacl.Frodo.KEM.crypto_kem_keypair_st

a: Spec.Frodo.Params.frodo_alg -> gen_a: Spec.Frodo.Params.frodo_gen_a{Hacl.Impl.Frodo.Params.is_supported gen_a} -> Type0

Prims.Tot

let crypto_kem_enc_st (a:FP.frodo_alg) (gen_a:FP.frodo_gen_a{is_supported gen_a}) = ct:lbytes (crypto_ciphertextbytes a) -> ss:lbytes (crypto_bytes a) -> pk:lbytes (crypto_publickeybytes a) -> Stack uint32 (requires fun h -> live h ct /\ live h ss /\ live h pk /\ disjoint ct ss /\ disjoint ct pk /\ disjoint ss pk /\ disjoint state ct /\ disjoint state ss /\ disjoint state pk) (ensures fun h0 _ h1 -> modifies (loc state |+| (loc ct |+| loc ss)) h0 h1 /\ (as_seq h1 ct, as_seq h1 ss) == S.crypto_kem_enc a gen_a (as_seq h0 state) (as_seq h0 pk))

let crypto_kem_enc_st (a: FP.frodo_alg) (gen_a: FP.frodo_gen_a{is_supported gen_a}) =

ct: lbytes (crypto_ciphertextbytes a) -> ss: lbytes (crypto_bytes a) -> pk: lbytes (crypto_publickeybytes a) -> Stack uint32 (requires fun h -> live h ct /\ live h ss /\ live h pk /\ disjoint ct ss /\ disjoint ct pk /\ disjoint ss pk /\ disjoint state ct /\ disjoint state ss /\ disjoint state pk) (ensures fun h0 _ h1 -> modifies (loc state |+| (loc ct |+| loc ss)) h0 h1 /\ (as_seq h1 ct, as_seq h1 ss) == S.crypto_kem_enc a gen_a (as_seq h0 state) (as_seq h0 pk))

module Hacl.Frodo.KEM open FStar.HyperStack open FStar.HyperStack.ST open Lib.IntTypes open Lib.Buffer open Hacl.Impl.Matrix open Hacl.Impl.Frodo.Params open Hacl.Impl.Frodo.KEM open Hacl.Frodo.Random module S = Spec.Frodo.KEM module FP = Spec.Frodo.Params #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let crypto_kem_keypair_st (a:FP.frodo_alg) (gen_a:FP.frodo_gen_a{is_supported gen_a}) = pk:lbytes (crypto_publickeybytes a) -> sk:lbytes (crypto_secretkeybytes a) -> Stack uint32 (requires fun h -> live h pk /\ live h sk /\ disjoint pk sk /\ disjoint state pk /\ disjoint state sk) (ensures fun h0 r h1 -> modifies (loc state |+| (loc pk |+| loc sk)) h0 h1 /\ (as_seq h1 pk, as_seq h1 sk) == S.crypto_kem_keypair a gen_a (as_seq h0 state)) inline_for_extraction noextract val crypto_kem_keypair: a:FP.frodo_alg -> gen_a:FP.frodo_gen_a{is_supported gen_a} -> crypto_kem_keypair_st a gen_a let crypto_kem_keypair a gen_a pk sk = Hacl.Impl.Frodo.KEM.KeyGen.crypto_kem_keypair a gen_a pk sk inline_for_extraction noextract

Hacl.Frodo.KEM.fst

val crypto_kem_enc_st : a: Spec.Frodo.Params.frodo_alg -> gen_a: Spec.Frodo.Params.frodo_gen_a{Hacl.Impl.Frodo.Params.is_supported gen_a} -> Type0

Hacl.Frodo.KEM.crypto_kem_enc_st

a: Spec.Frodo.Params.frodo_alg -> gen_a: Spec.Frodo.Params.frodo_gen_a{Hacl.Impl.Frodo.Params.is_supported gen_a} -> Type0

Prims.Tot

let crypto_kem_dec_st (a:FP.frodo_alg) (gen_a:FP.frodo_gen_a{is_supported gen_a}) = ss:lbytes (crypto_bytes a) -> ct:lbytes (crypto_ciphertextbytes a) -> sk:lbytes (crypto_secretkeybytes a) -> Stack uint32 (requires fun h -> live h ss /\ live h ct /\ live h sk /\ disjoint ss ct /\ disjoint ss sk /\ disjoint ct sk) (ensures fun h0 r h1 -> modifies (loc ss) h0 h1 /\ as_seq h1 ss == S.crypto_kem_dec a gen_a (as_seq h0 ct) (as_seq h0 sk))

let crypto_kem_dec_st (a: FP.frodo_alg) (gen_a: FP.frodo_gen_a{is_supported gen_a}) =

ss: lbytes (crypto_bytes a) -> ct: lbytes (crypto_ciphertextbytes a) -> sk: lbytes (crypto_secretkeybytes a) -> Stack uint32 (requires fun h -> live h ss /\ live h ct /\ live h sk /\ disjoint ss ct /\ disjoint ss sk /\ disjoint ct sk) (ensures fun h0 r h1 -> modifies (loc ss) h0 h1 /\ as_seq h1 ss == S.crypto_kem_dec a gen_a (as_seq h0 ct) (as_seq h0 sk))

module Hacl.Frodo.KEM open FStar.HyperStack open FStar.HyperStack.ST open Lib.IntTypes open Lib.Buffer open Hacl.Impl.Matrix open Hacl.Impl.Frodo.Params open Hacl.Impl.Frodo.KEM open Hacl.Frodo.Random module S = Spec.Frodo.KEM module FP = Spec.Frodo.Params #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let crypto_kem_keypair_st (a:FP.frodo_alg) (gen_a:FP.frodo_gen_a{is_supported gen_a}) = pk:lbytes (crypto_publickeybytes a) -> sk:lbytes (crypto_secretkeybytes a) -> Stack uint32 (requires fun h -> live h pk /\ live h sk /\ disjoint pk sk /\ disjoint state pk /\ disjoint state sk) (ensures fun h0 r h1 -> modifies (loc state |+| (loc pk |+| loc sk)) h0 h1 /\ (as_seq h1 pk, as_seq h1 sk) == S.crypto_kem_keypair a gen_a (as_seq h0 state)) inline_for_extraction noextract val crypto_kem_keypair: a:FP.frodo_alg -> gen_a:FP.frodo_gen_a{is_supported gen_a} -> crypto_kem_keypair_st a gen_a let crypto_kem_keypair a gen_a pk sk = Hacl.Impl.Frodo.KEM.KeyGen.crypto_kem_keypair a gen_a pk sk inline_for_extraction noextract let crypto_kem_enc_st (a:FP.frodo_alg) (gen_a:FP.frodo_gen_a{is_supported gen_a}) = ct:lbytes (crypto_ciphertextbytes a) -> ss:lbytes (crypto_bytes a) -> pk:lbytes (crypto_publickeybytes a) -> Stack uint32 (requires fun h -> live h ct /\ live h ss /\ live h pk /\ disjoint ct ss /\ disjoint ct pk /\ disjoint ss pk /\ disjoint state ct /\ disjoint state ss /\ disjoint state pk) (ensures fun h0 _ h1 -> modifies (loc state |+| (loc ct |+| loc ss)) h0 h1 /\ (as_seq h1 ct, as_seq h1 ss) == S.crypto_kem_enc a gen_a (as_seq h0 state) (as_seq h0 pk)) inline_for_extraction noextract val crypto_kem_enc: a:FP.frodo_alg -> gen_a:FP.frodo_gen_a{is_supported gen_a} -> crypto_kem_enc_st a gen_a let crypto_kem_enc a gen_a ct ss pk = Hacl.Impl.Frodo.KEM.Encaps.crypto_kem_enc a gen_a ct ss pk inline_for_extraction noextract

Hacl.Frodo.KEM.fst

val crypto_kem_dec_st : a: Spec.Frodo.Params.frodo_alg -> gen_a: Spec.Frodo.Params.frodo_gen_a{Hacl.Impl.Frodo.Params.is_supported gen_a} -> Type0

Hacl.Frodo.KEM.crypto_kem_dec_st

a: Spec.Frodo.Params.frodo_alg -> gen_a: Spec.Frodo.Params.frodo_gen_a{Hacl.Impl.Frodo.Params.is_supported gen_a} -> Type0

Prims.Tot

let pow2_16 = 0x10000

let pow2_16 =

0x10000

module Vale.Def.Words_s open FStar.Mul (* Various representations of words with 2^n bits. For example, a byte might be represented as a record of 8 bools, a sequence of 8 bools, or a natural number 0 <= n < 256. Sequences might be little endian or big endian. A 32-bit word could be four bytes, 32 bools, or a natural number 0 <= n < 0x100000000. This library defines various representations and conversions between them. *) // Records with up to eight fields, listed in order from least significant to most significant. // (More than eight fields can be built hierarchically, as in four (four nat8)) type two (a:Type) : Type = { lo:a; hi:a; } type four (a:Type) : Type = { lo0:a; lo1:a; hi2:a; hi3:a; } type eight (a:Type) : Type = { lo_0:a; lo_1:a; lo_2:a; lo_3:a; hi_4:a; hi_5:a; hi_6:a; hi_7:a } unfold let pow2_norm (n:nat) = normalize_term (pow2 n) unfold let pow2_1 = 0x2 unfold let pow2_2 = 0x4 unfold let pow2_4 = 0x10

Vale.Def.Words_s.fsti

val pow2_16 : Prims.int

Vale.Def.Words_s.pow2_16

Prims.int

Prims.Tot

let nat1 = natN pow2_1

let nat1 =

natN pow2_1

module Vale.Def.Words_s open FStar.Mul (* Various representations of words with 2^n bits. For example, a byte might be represented as a record of 8 bools, a sequence of 8 bools, or a natural number 0 <= n < 256. Sequences might be little endian or big endian. A 32-bit word could be four bytes, 32 bools, or a natural number 0 <= n < 0x100000000. This library defines various representations and conversions between them. *) // Records with up to eight fields, listed in order from least significant to most significant. // (More than eight fields can be built hierarchically, as in four (four nat8)) type two (a:Type) : Type = { lo:a; hi:a; } type four (a:Type) : Type = { lo0:a; lo1:a; hi2:a; hi3:a; } type eight (a:Type) : Type = { lo_0:a; lo_1:a; lo_2:a; lo_3:a; hi_4:a; hi_5:a; hi_6:a; hi_7:a } unfold let pow2_norm (n:nat) = normalize_term (pow2 n) unfold let pow2_1 = 0x2 unfold let pow2_2 = 0x4 unfold let pow2_4 = 0x10 unfold let pow2_8 = 0x100 unfold let pow2_16 = 0x10000 unfold let pow2_32 = 0x100000000 unfold let pow2_64 = 0x10000000000000000 unfold let pow2_128 = 0x100000000000000000000000000000000

Vale.Def.Words_s.fsti

val nat1 : Type0

Vale.Def.Words_s.nat1

Type0

Prims.Tot

let pow2_64 = 0x10000000000000000

let pow2_64 =

0x10000000000000000

module Vale.Def.Words_s open FStar.Mul (* Various representations of words with 2^n bits. For example, a byte might be represented as a record of 8 bools, a sequence of 8 bools, or a natural number 0 <= n < 256. Sequences might be little endian or big endian. A 32-bit word could be four bytes, 32 bools, or a natural number 0 <= n < 0x100000000. This library defines various representations and conversions between them. *) // Records with up to eight fields, listed in order from least significant to most significant. // (More than eight fields can be built hierarchically, as in four (four nat8)) type two (a:Type) : Type = { lo:a; hi:a; } type four (a:Type) : Type = { lo0:a; lo1:a; hi2:a; hi3:a; } type eight (a:Type) : Type = { lo_0:a; lo_1:a; lo_2:a; lo_3:a; hi_4:a; hi_5:a; hi_6:a; hi_7:a } unfold let pow2_norm (n:nat) = normalize_term (pow2 n) unfold let pow2_1 = 0x2 unfold let pow2_2 = 0x4 unfold let pow2_4 = 0x10 unfold let pow2_8 = 0x100 unfold let pow2_16 = 0x10000

Vale.Def.Words_s.fsti

val pow2_64 : Prims.int

Vale.Def.Words_s.pow2_64

Prims.int

Prims.Tot

let pow2_4 = 0x10

let pow2_4 =

0x10

module Vale.Def.Words_s open FStar.Mul (* Various representations of words with 2^n bits. For example, a byte might be represented as a record of 8 bools, a sequence of 8 bools, or a natural number 0 <= n < 256. Sequences might be little endian or big endian. A 32-bit word could be four bytes, 32 bools, or a natural number 0 <= n < 0x100000000. This library defines various representations and conversions between them. *) // Records with up to eight fields, listed in order from least significant to most significant. // (More than eight fields can be built hierarchically, as in four (four nat8)) type two (a:Type) : Type = { lo:a; hi:a; } type four (a:Type) : Type = { lo0:a; lo1:a; hi2:a; hi3:a; } type eight (a:Type) : Type = { lo_0:a; lo_1:a; lo_2:a; lo_3:a; hi_4:a; hi_5:a; hi_6:a; hi_7:a } unfold let pow2_norm (n:nat) = normalize_term (pow2 n) unfold let pow2_1 = 0x2

Vale.Def.Words_s.fsti

val pow2_4 : Prims.int

Vale.Def.Words_s.pow2_4

Prims.int

Prims.Tot

let nat16 = natN pow2_16

let nat16 =

natN pow2_16

module Vale.Def.Words_s open FStar.Mul (* Various representations of words with 2^n bits. For example, a byte might be represented as a record of 8 bools, a sequence of 8 bools, or a natural number 0 <= n < 256. Sequences might be little endian or big endian. A 32-bit word could be four bytes, 32 bools, or a natural number 0 <= n < 0x100000000. This library defines various representations and conversions between them. *) // Records with up to eight fields, listed in order from least significant to most significant. // (More than eight fields can be built hierarchically, as in four (four nat8)) type two (a:Type) : Type = { lo:a; hi:a; } type four (a:Type) : Type = { lo0:a; lo1:a; hi2:a; hi3:a; } type eight (a:Type) : Type = { lo_0:a; lo_1:a; lo_2:a; lo_3:a; hi_4:a; hi_5:a; hi_6:a; hi_7:a } unfold let pow2_norm (n:nat) = normalize_term (pow2 n) unfold let pow2_1 = 0x2 unfold let pow2_2 = 0x4 unfold let pow2_4 = 0x10 unfold let pow2_8 = 0x100 unfold let pow2_16 = 0x10000 unfold let pow2_32 = 0x100000000 unfold let pow2_64 = 0x10000000000000000 unfold let pow2_128 = 0x100000000000000000000000000000000 let natN (n:nat) = x:nat{x < n} let nat1 = natN pow2_1 let nat2 = natN pow2_2 let nat4 = natN pow2_4

Vale.Def.Words_s.fsti

val nat16 : Type0

Vale.Def.Words_s.nat16

Type0

Prims.Tot

let pow2_1 = 0x2

let pow2_1 =

0x2

module Vale.Def.Words_s open FStar.Mul (* Various representations of words with 2^n bits. For example, a byte might be represented as a record of 8 bools, a sequence of 8 bools, or a natural number 0 <= n < 256. Sequences might be little endian or big endian. A 32-bit word could be four bytes, 32 bools, or a natural number 0 <= n < 0x100000000. This library defines various representations and conversions between them. *) // Records with up to eight fields, listed in order from least significant to most significant. // (More than eight fields can be built hierarchically, as in four (four nat8)) type two (a:Type) : Type = { lo:a; hi:a; } type four (a:Type) : Type = { lo0:a; lo1:a; hi2:a; hi3:a; } type eight (a:Type) : Type = { lo_0:a; lo_1:a; lo_2:a; lo_3:a; hi_4:a; hi_5:a; hi_6:a; hi_7:a } unfold let pow2_norm (n:nat) = normalize_term (pow2 n)

Vale.Def.Words_s.fsti

val pow2_1 : Prims.int

Vale.Def.Words_s.pow2_1

Prims.int

Prims.Tot

let pow2_128 = 0x100000000000000000000000000000000

let pow2_128 =

0x100000000000000000000000000000000

module Vale.Def.Words_s open FStar.Mul (* Various representations of words with 2^n bits. For example, a byte might be represented as a record of 8 bools, a sequence of 8 bools, or a natural number 0 <= n < 256. Sequences might be little endian or big endian. A 32-bit word could be four bytes, 32 bools, or a natural number 0 <= n < 0x100000000. This library defines various representations and conversions between them. *) // Records with up to eight fields, listed in order from least significant to most significant. // (More than eight fields can be built hierarchically, as in four (four nat8)) type two (a:Type) : Type = { lo:a; hi:a; } type four (a:Type) : Type = { lo0:a; lo1:a; hi2:a; hi3:a; } type eight (a:Type) : Type = { lo_0:a; lo_1:a; lo_2:a; lo_3:a; hi_4:a; hi_5:a; hi_6:a; hi_7:a } unfold let pow2_norm (n:nat) = normalize_term (pow2 n) unfold let pow2_1 = 0x2 unfold let pow2_2 = 0x4 unfold let pow2_4 = 0x10 unfold let pow2_8 = 0x100 unfold let pow2_16 = 0x10000 unfold let pow2_32 = 0x100000000

Vale.Def.Words_s.fsti

val pow2_128 : Prims.int

Vale.Def.Words_s.pow2_128

Prims.int

Prims.Tot

let nat8 = natN pow2_8

let nat8 =

natN pow2_8

module Vale.Def.Words_s open FStar.Mul (* Various representations of words with 2^n bits. For example, a byte might be represented as a record of 8 bools, a sequence of 8 bools, or a natural number 0 <= n < 256. Sequences might be little endian or big endian. A 32-bit word could be four bytes, 32 bools, or a natural number 0 <= n < 0x100000000. This library defines various representations and conversions between them. *) // Records with up to eight fields, listed in order from least significant to most significant. // (More than eight fields can be built hierarchically, as in four (four nat8)) type two (a:Type) : Type = { lo:a; hi:a; } type four (a:Type) : Type = { lo0:a; lo1:a; hi2:a; hi3:a; } type eight (a:Type) : Type = { lo_0:a; lo_1:a; lo_2:a; lo_3:a; hi_4:a; hi_5:a; hi_6:a; hi_7:a } unfold let pow2_norm (n:nat) = normalize_term (pow2 n) unfold let pow2_1 = 0x2 unfold let pow2_2 = 0x4 unfold let pow2_4 = 0x10 unfold let pow2_8 = 0x100 unfold let pow2_16 = 0x10000 unfold let pow2_32 = 0x100000000 unfold let pow2_64 = 0x10000000000000000 unfold let pow2_128 = 0x100000000000000000000000000000000 let natN (n:nat) = x:nat{x < n} let nat1 = natN pow2_1 let nat2 = natN pow2_2

Vale.Def.Words_s.fsti

val nat8 : Type0

Vale.Def.Words_s.nat8

Type0

Prims.Tot

let pow2_norm (n:nat) = normalize_term (pow2 n)

let pow2_norm (n: nat) =

normalize_term (pow2 n)

module Vale.Def.Words_s open FStar.Mul (* Various representations of words with 2^n bits. For example, a byte might be represented as a record of 8 bools, a sequence of 8 bools, or a natural number 0 <= n < 256. Sequences might be little endian or big endian. A 32-bit word could be four bytes, 32 bools, or a natural number 0 <= n < 0x100000000. This library defines various representations and conversions between them. *) // Records with up to eight fields, listed in order from least significant to most significant. // (More than eight fields can be built hierarchically, as in four (four nat8)) type two (a:Type) : Type = { lo:a; hi:a; } type four (a:Type) : Type = { lo0:a; lo1:a; hi2:a; hi3:a; } type eight (a:Type) : Type = { lo_0:a; lo_1:a; lo_2:a; lo_3:a; hi_4:a; hi_5:a; hi_6:a; hi_7:a }

Vale.Def.Words_s.fsti

val pow2_norm : n: Prims.nat -> Prims.pos

Vale.Def.Words_s.pow2_norm

n: Prims.nat -> Prims.pos

Prims.Tot

let pow2_2 = 0x4

let pow2_2 =

0x4

module Vale.Def.Words_s open FStar.Mul (* Various representations of words with 2^n bits. For example, a byte might be represented as a record of 8 bools, a sequence of 8 bools, or a natural number 0 <= n < 256. Sequences might be little endian or big endian. A 32-bit word could be four bytes, 32 bools, or a natural number 0 <= n < 0x100000000. This library defines various representations and conversions between them. *) // Records with up to eight fields, listed in order from least significant to most significant. // (More than eight fields can be built hierarchically, as in four (four nat8)) type two (a:Type) : Type = { lo:a; hi:a; } type four (a:Type) : Type = { lo0:a; lo1:a; hi2:a; hi3:a; } type eight (a:Type) : Type = { lo_0:a; lo_1:a; lo_2:a; lo_3:a; hi_4:a; hi_5:a; hi_6:a; hi_7:a } unfold let pow2_norm (n:nat) = normalize_term (pow2 n)

Vale.Def.Words_s.fsti

val pow2_2 : Prims.int

Vale.Def.Words_s.pow2_2

Prims.int

Prims.Tot

let nat4 = natN pow2_4

let nat4 =

natN pow2_4

module Vale.Def.Words_s open FStar.Mul (* Various representations of words with 2^n bits. For example, a byte might be represented as a record of 8 bools, a sequence of 8 bools, or a natural number 0 <= n < 256. Sequences might be little endian or big endian. A 32-bit word could be four bytes, 32 bools, or a natural number 0 <= n < 0x100000000. This library defines various representations and conversions between them. *) // Records with up to eight fields, listed in order from least significant to most significant. // (More than eight fields can be built hierarchically, as in four (four nat8)) type two (a:Type) : Type = { lo:a; hi:a; } type four (a:Type) : Type = { lo0:a; lo1:a; hi2:a; hi3:a; } type eight (a:Type) : Type = { lo_0:a; lo_1:a; lo_2:a; lo_3:a; hi_4:a; hi_5:a; hi_6:a; hi_7:a } unfold let pow2_norm (n:nat) = normalize_term (pow2 n) unfold let pow2_1 = 0x2 unfold let pow2_2 = 0x4 unfold let pow2_4 = 0x10 unfold let pow2_8 = 0x100 unfold let pow2_16 = 0x10000 unfold let pow2_32 = 0x100000000 unfold let pow2_64 = 0x10000000000000000 unfold let pow2_128 = 0x100000000000000000000000000000000 let natN (n:nat) = x:nat{x < n} let nat1 = natN pow2_1

Vale.Def.Words_s.fsti

val nat4 : Type0

Vale.Def.Words_s.nat4

Type0

Prims.Tot

let pow2_32 = 0x100000000

let pow2_32 =

0x100000000

module Vale.Def.Words_s open FStar.Mul (* Various representations of words with 2^n bits. For example, a byte might be represented as a record of 8 bools, a sequence of 8 bools, or a natural number 0 <= n < 256. Sequences might be little endian or big endian. A 32-bit word could be four bytes, 32 bools, or a natural number 0 <= n < 0x100000000. This library defines various representations and conversions between them. *) // Records with up to eight fields, listed in order from least significant to most significant. // (More than eight fields can be built hierarchically, as in four (four nat8)) type two (a:Type) : Type = { lo:a; hi:a; } type four (a:Type) : Type = { lo0:a; lo1:a; hi2:a; hi3:a; } type eight (a:Type) : Type = { lo_0:a; lo_1:a; lo_2:a; lo_3:a; hi_4:a; hi_5:a; hi_6:a; hi_7:a } unfold let pow2_norm (n:nat) = normalize_term (pow2 n) unfold let pow2_1 = 0x2 unfold let pow2_2 = 0x4 unfold let pow2_4 = 0x10 unfold let pow2_8 = 0x100

Vale.Def.Words_s.fsti

val pow2_32 : Prims.int

Vale.Def.Words_s.pow2_32

Prims.int

Prims.Tot

let nat32 = natN pow2_32

let nat32 =

natN pow2_32

module Vale.Def.Words_s open FStar.Mul (* Various representations of words with 2^n bits. For example, a byte might be represented as a record of 8 bools, a sequence of 8 bools, or a natural number 0 <= n < 256. Sequences might be little endian or big endian. A 32-bit word could be four bytes, 32 bools, or a natural number 0 <= n < 0x100000000. This library defines various representations and conversions between them. *) // Records with up to eight fields, listed in order from least significant to most significant. // (More than eight fields can be built hierarchically, as in four (four nat8)) type two (a:Type) : Type = { lo:a; hi:a; } type four (a:Type) : Type = { lo0:a; lo1:a; hi2:a; hi3:a; } type eight (a:Type) : Type = { lo_0:a; lo_1:a; lo_2:a; lo_3:a; hi_4:a; hi_5:a; hi_6:a; hi_7:a } unfold let pow2_norm (n:nat) = normalize_term (pow2 n) unfold let pow2_1 = 0x2 unfold let pow2_2 = 0x4 unfold let pow2_4 = 0x10 unfold let pow2_8 = 0x100 unfold let pow2_16 = 0x10000 unfold let pow2_32 = 0x100000000 unfold let pow2_64 = 0x10000000000000000 unfold let pow2_128 = 0x100000000000000000000000000000000 let natN (n:nat) = x:nat{x < n} let nat1 = natN pow2_1 let nat2 = natN pow2_2 let nat4 = natN pow2_4 let nat8 = natN pow2_8

Vale.Def.Words_s.fsti

val nat32 : Type0

Vale.Def.Words_s.nat32

Type0

Prims.Tot

let nat2 = natN pow2_2

let nat2 =

natN pow2_2

module Vale.Def.Words_s open FStar.Mul (* Various representations of words with 2^n bits. For example, a byte might be represented as a record of 8 bools, a sequence of 8 bools, or a natural number 0 <= n < 256. Sequences might be little endian or big endian. A 32-bit word could be four bytes, 32 bools, or a natural number 0 <= n < 0x100000000. This library defines various representations and conversions between them. *) // Records with up to eight fields, listed in order from least significant to most significant. // (More than eight fields can be built hierarchically, as in four (four nat8)) type two (a:Type) : Type = { lo:a; hi:a; } type four (a:Type) : Type = { lo0:a; lo1:a; hi2:a; hi3:a; } type eight (a:Type) : Type = { lo_0:a; lo_1:a; lo_2:a; lo_3:a; hi_4:a; hi_5:a; hi_6:a; hi_7:a } unfold let pow2_norm (n:nat) = normalize_term (pow2 n) unfold let pow2_1 = 0x2 unfold let pow2_2 = 0x4 unfold let pow2_4 = 0x10 unfold let pow2_8 = 0x100 unfold let pow2_16 = 0x10000 unfold let pow2_32 = 0x100000000 unfold let pow2_64 = 0x10000000000000000 unfold let pow2_128 = 0x100000000000000000000000000000000 let natN (n:nat) = x:nat{x < n}

Vale.Def.Words_s.fsti

val nat2 : Type0

Vale.Def.Words_s.nat2

Type0

Prims.Tot

let nat128 = natN pow2_128

let nat128 =

natN pow2_128

module Vale.Def.Words_s open FStar.Mul (* Various representations of words with 2^n bits. For example, a byte might be represented as a record of 8 bools, a sequence of 8 bools, or a natural number 0 <= n < 256. Sequences might be little endian or big endian. A 32-bit word could be four bytes, 32 bools, or a natural number 0 <= n < 0x100000000. This library defines various representations and conversions between them. *) // Records with up to eight fields, listed in order from least significant to most significant. // (More than eight fields can be built hierarchically, as in four (four nat8)) type two (a:Type) : Type = { lo:a; hi:a; } type four (a:Type) : Type = { lo0:a; lo1:a; hi2:a; hi3:a; } type eight (a:Type) : Type = { lo_0:a; lo_1:a; lo_2:a; lo_3:a; hi_4:a; hi_5:a; hi_6:a; hi_7:a } unfold let pow2_norm (n:nat) = normalize_term (pow2 n) unfold let pow2_1 = 0x2 unfold let pow2_2 = 0x4 unfold let pow2_4 = 0x10 unfold let pow2_8 = 0x100 unfold let pow2_16 = 0x10000 unfold let pow2_32 = 0x100000000 unfold let pow2_64 = 0x10000000000000000 unfold let pow2_128 = 0x100000000000000000000000000000000 let natN (n:nat) = x:nat{x < n} let nat1 = natN pow2_1 let nat2 = natN pow2_2 let nat4 = natN pow2_4 let nat8 = natN pow2_8 let nat16 = natN pow2_16 let nat32 = natN pow2_32

Vale.Def.Words_s.fsti

val nat128 : Type0

Vale.Def.Words_s.nat128

Type0

Prims.Tot

let pow2_8 = 0x100

let pow2_8 =

0x100

module Vale.Def.Words_s open FStar.Mul (* Various representations of words with 2^n bits. For example, a byte might be represented as a record of 8 bools, a sequence of 8 bools, or a natural number 0 <= n < 256. Sequences might be little endian or big endian. A 32-bit word could be four bytes, 32 bools, or a natural number 0 <= n < 0x100000000. This library defines various representations and conversions between them. *) // Records with up to eight fields, listed in order from least significant to most significant. // (More than eight fields can be built hierarchically, as in four (four nat8)) type two (a:Type) : Type = { lo:a; hi:a; } type four (a:Type) : Type = { lo0:a; lo1:a; hi2:a; hi3:a; } type eight (a:Type) : Type = { lo_0:a; lo_1:a; lo_2:a; lo_3:a; hi_4:a; hi_5:a; hi_6:a; hi_7:a } unfold let pow2_norm (n:nat) = normalize_term (pow2 n) unfold let pow2_1 = 0x2 unfold let pow2_2 = 0x4

Vale.Def.Words_s.fsti

val pow2_8 : Prims.int

Vale.Def.Words_s.pow2_8

Prims.int

Prims.Tot

let natN (n:nat) = x:nat{x < n}

let natN (n: nat) =

x: nat{x < n}

module Vale.Def.Words_s open FStar.Mul (* Various representations of words with 2^n bits. For example, a byte might be represented as a record of 8 bools, a sequence of 8 bools, or a natural number 0 <= n < 256. Sequences might be little endian or big endian. A 32-bit word could be four bytes, 32 bools, or a natural number 0 <= n < 0x100000000. This library defines various representations and conversions between them. *) // Records with up to eight fields, listed in order from least significant to most significant. // (More than eight fields can be built hierarchically, as in four (four nat8)) type two (a:Type) : Type = { lo:a; hi:a; } type four (a:Type) : Type = { lo0:a; lo1:a; hi2:a; hi3:a; } type eight (a:Type) : Type = { lo_0:a; lo_1:a; lo_2:a; lo_3:a; hi_4:a; hi_5:a; hi_6:a; hi_7:a } unfold let pow2_norm (n:nat) = normalize_term (pow2 n) unfold let pow2_1 = 0x2 unfold let pow2_2 = 0x4 unfold let pow2_4 = 0x10 unfold let pow2_8 = 0x100 unfold let pow2_16 = 0x10000 unfold let pow2_32 = 0x100000000 unfold let pow2_64 = 0x10000000000000000 unfold let pow2_128 = 0x100000000000000000000000000000000

Vale.Def.Words_s.fsti

val natN : n: Prims.nat -> Type0

Vale.Def.Words_s.natN

n: Prims.nat -> Type0

Prims.Tot

let nat64 = natN pow2_64

let nat64 =

natN pow2_64

module Vale.Def.Words_s open FStar.Mul (* Various representations of words with 2^n bits. For example, a byte might be represented as a record of 8 bools, a sequence of 8 bools, or a natural number 0 <= n < 256. Sequences might be little endian or big endian. A 32-bit word could be four bytes, 32 bools, or a natural number 0 <= n < 0x100000000. This library defines various representations and conversions between them. *) // Records with up to eight fields, listed in order from least significant to most significant. // (More than eight fields can be built hierarchically, as in four (four nat8)) type two (a:Type) : Type = { lo:a; hi:a; } type four (a:Type) : Type = { lo0:a; lo1:a; hi2:a; hi3:a; } type eight (a:Type) : Type = { lo_0:a; lo_1:a; lo_2:a; lo_3:a; hi_4:a; hi_5:a; hi_6:a; hi_7:a } unfold let pow2_norm (n:nat) = normalize_term (pow2 n) unfold let pow2_1 = 0x2 unfold let pow2_2 = 0x4 unfold let pow2_4 = 0x10 unfold let pow2_8 = 0x100 unfold let pow2_16 = 0x10000 unfold let pow2_32 = 0x100000000 unfold let pow2_64 = 0x10000000000000000 unfold let pow2_128 = 0x100000000000000000000000000000000 let natN (n:nat) = x:nat{x < n} let nat1 = natN pow2_1 let nat2 = natN pow2_2 let nat4 = natN pow2_4 let nat8 = natN pow2_8 let nat16 = natN pow2_16

Vale.Def.Words_s.fsti

val nat64 : Type0

Vale.Def.Words_s.nat64

Type0

FStar.HyperStack.ST.Stack

val point_add_4 (x3 y3 z3 t1 t2:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t1 /\ live h t2 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t1; loc t2 ] /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h y3 < S.prime) (ensures fun h0 _ h1 -> modifies (loc x3 |+| loc y3 |+| loc z3) h0 h1 /\ as_nat h1 x3 < S.prime /\ as_nat h1 y3 < S.prime /\ as_nat h1 z3 < S.prime /\ (let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let y3_s = fmont_as_nat h0 y3 in let z3_s = S.fmul S.b_coeff t2_s in let x3_s = S.fsub y3_s z3_s in let z3_s = S.fadd x3_s x3_s in let x3_s = S.fadd x3_s z3_s in let z3_s = S.fsub t1_s x3_s in let x3_s = S.fadd t1_s x3_s in let y3_s = S.fmul S.b_coeff y3_s in fmont_as_nat h1 x3 == x3_s /\ fmont_as_nat h1 y3 == y3_s /\ fmont_as_nat h1 z3 == z3_s))

let point_add_4 x3 y3 z3 t1 t2 = fmul_by_b_coeff z3 t2; fsub x3 y3 z3; fdouble z3 x3; fadd x3 x3 z3; fsub z3 t1 x3; fadd x3 t1 x3; fmul_by_b_coeff y3 y3

val point_add_4 (x3 y3 z3 t1 t2:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t1 /\ live h t2 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t1; loc t2 ] /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h y3 < S.prime) (ensures fun h0 _ h1 -> modifies (loc x3 |+| loc y3 |+| loc z3) h0 h1 /\ as_nat h1 x3 < S.prime /\ as_nat h1 y3 < S.prime /\ as_nat h1 z3 < S.prime /\ (let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let y3_s = fmont_as_nat h0 y3 in let z3_s = S.fmul S.b_coeff t2_s in let x3_s = S.fsub y3_s z3_s in let z3_s = S.fadd x3_s x3_s in let x3_s = S.fadd x3_s z3_s in let z3_s = S.fsub t1_s x3_s in let x3_s = S.fadd t1_s x3_s in let y3_s = S.fmul S.b_coeff y3_s in fmont_as_nat h1 x3 == x3_s /\ fmont_as_nat h1 y3 == y3_s /\ fmont_as_nat h1 z3 == z3_s)) let point_add_4 x3 y3 z3 t1 t2 =

fmul_by_b_coeff z3 t2; fsub x3 y3 z3; fdouble z3 x3; fadd x3 x3 z3; fsub z3 t1 x3; fadd x3 t1 x3; fmul_by_b_coeff y3 y3

module Hacl.Impl.P256.PointAdd open FStar.Mul open FStar.HyperStack.All open FStar.HyperStack module ST = FStar.HyperStack.ST open Lib.IntTypes open Lib.Buffer open Hacl.Impl.P256.Bignum open Hacl.Impl.P256.Field module S = Spec.P256 #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract val point_add_1 (t0 t1 t2 t3 t4:felem) (p q:point) : Stack unit (requires fun h -> live h t0 /\ live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [loc t0; loc t1; loc t2; loc t3; loc t4 ] /\ eq_or_disjoint p q /\ disjoint p t0 /\ disjoint p t1 /\ disjoint p t2 /\ disjoint p t3 /\ disjoint p t4 /\ disjoint q t0 /\ disjoint q t1 /\ disjoint q t2 /\ disjoint q t3 /\ disjoint q t4 /\ point_inv h p /\ point_inv h q) (ensures fun h0 _ h1 -> modifies (loc t0 |+| loc t1 |+| loc t2 |+| loc t3 |+| loc t4) h0 h1 /\ as_nat h1 t0 < S.prime /\ as_nat h1 t1 < S.prime /\ as_nat h1 t2 < S.prime /\ as_nat h1 t3 < S.prime /\ as_nat h1 t4 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t0_s = S.fmul x1 x2 in let t1_s = S.fmul y1 y2 in let t2_s = S.fmul z1 z2 in let t3_s = S.fadd x1 y1 in let t4_s = S.fadd x2 y2 in let t3_s = S.fmul t3_s t4_s in let t4_s = S.fadd t0_s t1_s in fmont_as_nat h1 t0 == t0_s /\ fmont_as_nat h1 t1 == t1_s /\ fmont_as_nat h1 t2 == t2_s /\ fmont_as_nat h1 t3 == t3_s /\ fmont_as_nat h1 t4 == t4_s)) let point_add_1 t0 t1 t2 t3 t4 p q = let x1, y1, z1 = getx p, gety p, getz p in let x2, y2, z2 = getx q, gety q, getz q in fmul t0 x1 x2; fmul t1 y1 y2; fmul t2 z1 z2; fadd t3 x1 y1; fadd t4 x2 y2; fmul t3 t3 t4; fadd t4 t0 t1 inline_for_extraction noextract val point_add_2 (t1 t2 t3 t4 t5:felem) (p q:point) : Stack unit (requires fun h -> live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ live h t5 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [ loc t1; loc t2; loc t3; loc t4; loc t5 ] /\ eq_or_disjoint p q /\ disjoint p t1 /\ disjoint p t2 /\ disjoint p t3 /\ disjoint p t4 /\ disjoint p t5 /\ disjoint q t1 /\ disjoint q t2 /\ disjoint q t3 /\ disjoint q t4 /\ disjoint q t5 /\ point_inv h p /\ point_inv h q /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h t3 < S.prime /\ as_nat h t4 < S.prime) (ensures fun h0 _ h1 -> modifies (loc t3 |+| loc t4 |+| loc t5) h0 h1 /\ as_nat h1 t3 < S.prime /\ as_nat h1 t4 < S.prime /\ as_nat h1 t5 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let t3_s = fmont_as_nat h0 t3 in let t4_s = fmont_as_nat h0 t4 in let t3_s = S.fsub t3_s t4_s in let t4_s = S.fadd y1 z1 in let t5_s = S.fadd y2 z2 in let t4_s = S.fmul t4_s t5_s in let t5_s = S.fadd t1_s t2_s in let t4_s = S.fsub t4_s t5_s in fmont_as_nat h1 t3 == t3_s /\ fmont_as_nat h1 t4 == t4_s /\ fmont_as_nat h1 t5 == t5_s)) let point_add_2 t1 t2 t3 t4 t5 p q = let y1, z1 = gety p, getz p in let y2, z2 = gety q, getz q in fsub t3 t3 t4; fadd t4 y1 z1; fadd t5 y2 z2; fmul t4 t4 t5; fadd t5 t1 t2; fsub t4 t4 t5 inline_for_extraction noextract val point_add_3 (x3 y3 t0 t2:felem) (p q:point) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h t0 /\ live h t2 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc t0; loc t2 ] /\ eq_or_disjoint p q /\ disjoint p x3 /\ disjoint p y3 /\ disjoint p t0 /\ disjoint p t2 /\ disjoint q x3 /\ disjoint q y3 /\ disjoint q t0 /\ disjoint q t2 /\ point_inv h p /\ point_inv h q /\ as_nat h t0 < S.prime /\ as_nat h t2 < S.prime) (ensures fun h0 _ h1 -> modifies (loc x3 |+| loc y3) h0 h1 /\ as_nat h1 x3 < S.prime /\ as_nat h1 y3 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t0_s = fmont_as_nat h0 t0 in let t2_s = fmont_as_nat h0 t2 in let x3_s = S.fadd x1 z1 in let y3_s = S.fadd x2 z2 in let x3_s = S.fmul x3_s y3_s in let y3_s = S.fadd t0_s t2_s in let y3_s = S.fsub x3_s y3_s in fmont_as_nat h1 x3 == x3_s /\ fmont_as_nat h1 y3 == y3_s)) let point_add_3 x3 y3 t0 t2 p q = let x1, z1 = getx p, getz p in let x2, z2 = getx q, getz q in fadd x3 x1 z1; fadd y3 x2 z2; fmul x3 x3 y3; fadd y3 t0 t2; fsub y3 x3 y3 inline_for_extraction noextract val point_add_4 (x3 y3 z3 t1 t2:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t1 /\ live h t2 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t1; loc t2 ] /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h y3 < S.prime) (ensures fun h0 _ h1 -> modifies (loc x3 |+| loc y3 |+| loc z3) h0 h1 /\ as_nat h1 x3 < S.prime /\ as_nat h1 y3 < S.prime /\ as_nat h1 z3 < S.prime /\ (let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let y3_s = fmont_as_nat h0 y3 in let z3_s = S.fmul S.b_coeff t2_s in let x3_s = S.fsub y3_s z3_s in let z3_s = S.fadd x3_s x3_s in let x3_s = S.fadd x3_s z3_s in let z3_s = S.fsub t1_s x3_s in let x3_s = S.fadd t1_s x3_s in let y3_s = S.fmul S.b_coeff y3_s in fmont_as_nat h1 x3 == x3_s /\ fmont_as_nat h1 y3 == y3_s /\ fmont_as_nat h1 z3 == z3_s))

Hacl.Impl.P256.PointAdd.fst

val point_add_4 (x3 y3 z3 t1 t2:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t1 /\ live h t2 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t1; loc t2 ] /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h y3 < S.prime) (ensures fun h0 _ h1 -> modifies (loc x3 |+| loc y3 |+| loc z3) h0 h1 /\ as_nat h1 x3 < S.prime /\ as_nat h1 y3 < S.prime /\ as_nat h1 z3 < S.prime /\ (let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let y3_s = fmont_as_nat h0 y3 in let z3_s = S.fmul S.b_coeff t2_s in let x3_s = S.fsub y3_s z3_s in let z3_s = S.fadd x3_s x3_s in let x3_s = S.fadd x3_s z3_s in let z3_s = S.fsub t1_s x3_s in let x3_s = S.fadd t1_s x3_s in let y3_s = S.fmul S.b_coeff y3_s in fmont_as_nat h1 x3 == x3_s /\ fmont_as_nat h1 y3 == y3_s /\ fmont_as_nat h1 z3 == z3_s))

Hacl.Impl.P256.PointAdd.point_add_4

x3: Hacl.Impl.P256.Bignum.felem -> y3: Hacl.Impl.P256.Bignum.felem -> z3: Hacl.Impl.P256.Bignum.felem -> t1: Hacl.Impl.P256.Bignum.felem -> t2: Hacl.Impl.P256.Bignum.felem -> FStar.HyperStack.ST.Stack Prims.unit

FStar.HyperStack.ST.Stack

val point_add_3 (x3 y3 t0 t2:felem) (p q:point) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h t0 /\ live h t2 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc t0; loc t2 ] /\ eq_or_disjoint p q /\ disjoint p x3 /\ disjoint p y3 /\ disjoint p t0 /\ disjoint p t2 /\ disjoint q x3 /\ disjoint q y3 /\ disjoint q t0 /\ disjoint q t2 /\ point_inv h p /\ point_inv h q /\ as_nat h t0 < S.prime /\ as_nat h t2 < S.prime) (ensures fun h0 _ h1 -> modifies (loc x3 |+| loc y3) h0 h1 /\ as_nat h1 x3 < S.prime /\ as_nat h1 y3 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t0_s = fmont_as_nat h0 t0 in let t2_s = fmont_as_nat h0 t2 in let x3_s = S.fadd x1 z1 in let y3_s = S.fadd x2 z2 in let x3_s = S.fmul x3_s y3_s in let y3_s = S.fadd t0_s t2_s in let y3_s = S.fsub x3_s y3_s in fmont_as_nat h1 x3 == x3_s /\ fmont_as_nat h1 y3 == y3_s))

let point_add_3 x3 y3 t0 t2 p q = let x1, z1 = getx p, getz p in let x2, z2 = getx q, getz q in fadd x3 x1 z1; fadd y3 x2 z2; fmul x3 x3 y3; fadd y3 t0 t2; fsub y3 x3 y3

val point_add_3 (x3 y3 t0 t2:felem) (p q:point) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h t0 /\ live h t2 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc t0; loc t2 ] /\ eq_or_disjoint p q /\ disjoint p x3 /\ disjoint p y3 /\ disjoint p t0 /\ disjoint p t2 /\ disjoint q x3 /\ disjoint q y3 /\ disjoint q t0 /\ disjoint q t2 /\ point_inv h p /\ point_inv h q /\ as_nat h t0 < S.prime /\ as_nat h t2 < S.prime) (ensures fun h0 _ h1 -> modifies (loc x3 |+| loc y3) h0 h1 /\ as_nat h1 x3 < S.prime /\ as_nat h1 y3 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t0_s = fmont_as_nat h0 t0 in let t2_s = fmont_as_nat h0 t2 in let x3_s = S.fadd x1 z1 in let y3_s = S.fadd x2 z2 in let x3_s = S.fmul x3_s y3_s in let y3_s = S.fadd t0_s t2_s in let y3_s = S.fsub x3_s y3_s in fmont_as_nat h1 x3 == x3_s /\ fmont_as_nat h1 y3 == y3_s)) let point_add_3 x3 y3 t0 t2 p q =

let x1, z1 = getx p, getz p in let x2, z2 = getx q, getz q in fadd x3 x1 z1; fadd y3 x2 z2; fmul x3 x3 y3; fadd y3 t0 t2; fsub y3 x3 y3

module Hacl.Impl.P256.PointAdd open FStar.Mul open FStar.HyperStack.All open FStar.HyperStack module ST = FStar.HyperStack.ST open Lib.IntTypes open Lib.Buffer open Hacl.Impl.P256.Bignum open Hacl.Impl.P256.Field module S = Spec.P256 #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract val point_add_1 (t0 t1 t2 t3 t4:felem) (p q:point) : Stack unit (requires fun h -> live h t0 /\ live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [loc t0; loc t1; loc t2; loc t3; loc t4 ] /\ eq_or_disjoint p q /\ disjoint p t0 /\ disjoint p t1 /\ disjoint p t2 /\ disjoint p t3 /\ disjoint p t4 /\ disjoint q t0 /\ disjoint q t1 /\ disjoint q t2 /\ disjoint q t3 /\ disjoint q t4 /\ point_inv h p /\ point_inv h q) (ensures fun h0 _ h1 -> modifies (loc t0 |+| loc t1 |+| loc t2 |+| loc t3 |+| loc t4) h0 h1 /\ as_nat h1 t0 < S.prime /\ as_nat h1 t1 < S.prime /\ as_nat h1 t2 < S.prime /\ as_nat h1 t3 < S.prime /\ as_nat h1 t4 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t0_s = S.fmul x1 x2 in let t1_s = S.fmul y1 y2 in let t2_s = S.fmul z1 z2 in let t3_s = S.fadd x1 y1 in let t4_s = S.fadd x2 y2 in let t3_s = S.fmul t3_s t4_s in let t4_s = S.fadd t0_s t1_s in fmont_as_nat h1 t0 == t0_s /\ fmont_as_nat h1 t1 == t1_s /\ fmont_as_nat h1 t2 == t2_s /\ fmont_as_nat h1 t3 == t3_s /\ fmont_as_nat h1 t4 == t4_s)) let point_add_1 t0 t1 t2 t3 t4 p q = let x1, y1, z1 = getx p, gety p, getz p in let x2, y2, z2 = getx q, gety q, getz q in fmul t0 x1 x2; fmul t1 y1 y2; fmul t2 z1 z2; fadd t3 x1 y1; fadd t4 x2 y2; fmul t3 t3 t4; fadd t4 t0 t1 inline_for_extraction noextract val point_add_2 (t1 t2 t3 t4 t5:felem) (p q:point) : Stack unit (requires fun h -> live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ live h t5 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [ loc t1; loc t2; loc t3; loc t4; loc t5 ] /\ eq_or_disjoint p q /\ disjoint p t1 /\ disjoint p t2 /\ disjoint p t3 /\ disjoint p t4 /\ disjoint p t5 /\ disjoint q t1 /\ disjoint q t2 /\ disjoint q t3 /\ disjoint q t4 /\ disjoint q t5 /\ point_inv h p /\ point_inv h q /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h t3 < S.prime /\ as_nat h t4 < S.prime) (ensures fun h0 _ h1 -> modifies (loc t3 |+| loc t4 |+| loc t5) h0 h1 /\ as_nat h1 t3 < S.prime /\ as_nat h1 t4 < S.prime /\ as_nat h1 t5 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let t3_s = fmont_as_nat h0 t3 in let t4_s = fmont_as_nat h0 t4 in let t3_s = S.fsub t3_s t4_s in let t4_s = S.fadd y1 z1 in let t5_s = S.fadd y2 z2 in let t4_s = S.fmul t4_s t5_s in let t5_s = S.fadd t1_s t2_s in let t4_s = S.fsub t4_s t5_s in fmont_as_nat h1 t3 == t3_s /\ fmont_as_nat h1 t4 == t4_s /\ fmont_as_nat h1 t5 == t5_s)) let point_add_2 t1 t2 t3 t4 t5 p q = let y1, z1 = gety p, getz p in let y2, z2 = gety q, getz q in fsub t3 t3 t4; fadd t4 y1 z1; fadd t5 y2 z2; fmul t4 t4 t5; fadd t5 t1 t2; fsub t4 t4 t5 inline_for_extraction noextract val point_add_3 (x3 y3 t0 t2:felem) (p q:point) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h t0 /\ live h t2 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc t0; loc t2 ] /\ eq_or_disjoint p q /\ disjoint p x3 /\ disjoint p y3 /\ disjoint p t0 /\ disjoint p t2 /\ disjoint q x3 /\ disjoint q y3 /\ disjoint q t0 /\ disjoint q t2 /\ point_inv h p /\ point_inv h q /\ as_nat h t0 < S.prime /\ as_nat h t2 < S.prime) (ensures fun h0 _ h1 -> modifies (loc x3 |+| loc y3) h0 h1 /\ as_nat h1 x3 < S.prime /\ as_nat h1 y3 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t0_s = fmont_as_nat h0 t0 in let t2_s = fmont_as_nat h0 t2 in let x3_s = S.fadd x1 z1 in let y3_s = S.fadd x2 z2 in let x3_s = S.fmul x3_s y3_s in let y3_s = S.fadd t0_s t2_s in let y3_s = S.fsub x3_s y3_s in fmont_as_nat h1 x3 == x3_s /\ fmont_as_nat h1 y3 == y3_s))

Hacl.Impl.P256.PointAdd.fst

val point_add_3 (x3 y3 t0 t2:felem) (p q:point) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h t0 /\ live h t2 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc t0; loc t2 ] /\ eq_or_disjoint p q /\ disjoint p x3 /\ disjoint p y3 /\ disjoint p t0 /\ disjoint p t2 /\ disjoint q x3 /\ disjoint q y3 /\ disjoint q t0 /\ disjoint q t2 /\ point_inv h p /\ point_inv h q /\ as_nat h t0 < S.prime /\ as_nat h t2 < S.prime) (ensures fun h0 _ h1 -> modifies (loc x3 |+| loc y3) h0 h1 /\ as_nat h1 x3 < S.prime /\ as_nat h1 y3 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t0_s = fmont_as_nat h0 t0 in let t2_s = fmont_as_nat h0 t2 in let x3_s = S.fadd x1 z1 in let y3_s = S.fadd x2 z2 in let x3_s = S.fmul x3_s y3_s in let y3_s = S.fadd t0_s t2_s in let y3_s = S.fsub x3_s y3_s in fmont_as_nat h1 x3 == x3_s /\ fmont_as_nat h1 y3 == y3_s))

Hacl.Impl.P256.PointAdd.point_add_3

x3: Hacl.Impl.P256.Bignum.felem -> y3: Hacl.Impl.P256.Bignum.felem -> t0: Hacl.Impl.P256.Bignum.felem -> t2: Hacl.Impl.P256.Bignum.felem -> p: Hacl.Impl.P256.Point.point -> q: Hacl.Impl.P256.Point.point -> FStar.HyperStack.ST.Stack Prims.unit

FStar.HyperStack.ST.Stack

val point_add_7 (x3 y3 z3 t0 t1 t2 t3 t4:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t0 /\ live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t0; loc t1; loc t2; loc t3; loc t4 ] /\ as_nat h x3 < S.prime /\ as_nat h z3 < S.prime /\ as_nat h t0 < S.prime /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h t3 < S.prime /\ as_nat h t4 < S.prime) (ensures fun h0 _ h1 -> modifies (loc x3 |+| loc y3 |+| loc z3 |+| loc t1) h0 h1 /\ as_nat h1 x3 < S.prime /\ as_nat h1 y3 < S.prime /\ as_nat h1 z3 < S.prime /\ as_nat h1 t1 < S.prime /\ (let x3_s = fmont_as_nat h0 x3 in let z3_s = fmont_as_nat h0 z3 in let t0_s = fmont_as_nat h0 t0 in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let t3_s = fmont_as_nat h0 t3 in let t4_s = fmont_as_nat h0 t4 in let y3_s = S.fmul x3_s z3_s in let y3_s = S.fadd y3_s t2_s in let x3_s = S.fmul t3_s x3_s in let x3_s = S.fsub x3_s t1_s in let z3_s = S.fmul t4_s z3_s in let t1_s = S.fmul t3_s t0_s in let z3_s = S.fadd z3_s t1_s in fmont_as_nat h1 x3 == x3_s /\ fmont_as_nat h1 y3 == y3_s /\ fmont_as_nat h1 z3 == z3_s /\ fmont_as_nat h1 t1 == t1_s))

let point_add_7 x3 y3 z3 t0 t1 t2 t3 t4 = fmul y3 x3 z3; fadd y3 y3 t2; fmul x3 t3 x3; fsub x3 x3 t1; fmul z3 t4 z3; fmul t1 t3 t0; fadd z3 z3 t1

val point_add_7 (x3 y3 z3 t0 t1 t2 t3 t4:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t0 /\ live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t0; loc t1; loc t2; loc t3; loc t4 ] /\ as_nat h x3 < S.prime /\ as_nat h z3 < S.prime /\ as_nat h t0 < S.prime /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h t3 < S.prime /\ as_nat h t4 < S.prime) (ensures fun h0 _ h1 -> modifies (loc x3 |+| loc y3 |+| loc z3 |+| loc t1) h0 h1 /\ as_nat h1 x3 < S.prime /\ as_nat h1 y3 < S.prime /\ as_nat h1 z3 < S.prime /\ as_nat h1 t1 < S.prime /\ (let x3_s = fmont_as_nat h0 x3 in let z3_s = fmont_as_nat h0 z3 in let t0_s = fmont_as_nat h0 t0 in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let t3_s = fmont_as_nat h0 t3 in let t4_s = fmont_as_nat h0 t4 in let y3_s = S.fmul x3_s z3_s in let y3_s = S.fadd y3_s t2_s in let x3_s = S.fmul t3_s x3_s in let x3_s = S.fsub x3_s t1_s in let z3_s = S.fmul t4_s z3_s in let t1_s = S.fmul t3_s t0_s in let z3_s = S.fadd z3_s t1_s in fmont_as_nat h1 x3 == x3_s /\ fmont_as_nat h1 y3 == y3_s /\ fmont_as_nat h1 z3 == z3_s /\ fmont_as_nat h1 t1 == t1_s)) let point_add_7 x3 y3 z3 t0 t1 t2 t3 t4 =

fmul y3 x3 z3; fadd y3 y3 t2; fmul x3 t3 x3; fsub x3 x3 t1; fmul z3 t4 z3; fmul t1 t3 t0; fadd z3 z3 t1

module Hacl.Impl.P256.PointAdd open FStar.Mul open FStar.HyperStack.All open FStar.HyperStack module ST = FStar.HyperStack.ST open Lib.IntTypes open Lib.Buffer open Hacl.Impl.P256.Bignum open Hacl.Impl.P256.Field module S = Spec.P256 #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract val point_add_1 (t0 t1 t2 t3 t4:felem) (p q:point) : Stack unit (requires fun h -> live h t0 /\ live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [loc t0; loc t1; loc t2; loc t3; loc t4 ] /\ eq_or_disjoint p q /\ disjoint p t0 /\ disjoint p t1 /\ disjoint p t2 /\ disjoint p t3 /\ disjoint p t4 /\ disjoint q t0 /\ disjoint q t1 /\ disjoint q t2 /\ disjoint q t3 /\ disjoint q t4 /\ point_inv h p /\ point_inv h q) (ensures fun h0 _ h1 -> modifies (loc t0 |+| loc t1 |+| loc t2 |+| loc t3 |+| loc t4) h0 h1 /\ as_nat h1 t0 < S.prime /\ as_nat h1 t1 < S.prime /\ as_nat h1 t2 < S.prime /\ as_nat h1 t3 < S.prime /\ as_nat h1 t4 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t0_s = S.fmul x1 x2 in let t1_s = S.fmul y1 y2 in let t2_s = S.fmul z1 z2 in let t3_s = S.fadd x1 y1 in let t4_s = S.fadd x2 y2 in let t3_s = S.fmul t3_s t4_s in let t4_s = S.fadd t0_s t1_s in fmont_as_nat h1 t0 == t0_s /\ fmont_as_nat h1 t1 == t1_s /\ fmont_as_nat h1 t2 == t2_s /\ fmont_as_nat h1 t3 == t3_s /\ fmont_as_nat h1 t4 == t4_s)) let point_add_1 t0 t1 t2 t3 t4 p q = let x1, y1, z1 = getx p, gety p, getz p in let x2, y2, z2 = getx q, gety q, getz q in fmul t0 x1 x2; fmul t1 y1 y2; fmul t2 z1 z2; fadd t3 x1 y1; fadd t4 x2 y2; fmul t3 t3 t4; fadd t4 t0 t1 inline_for_extraction noextract val point_add_2 (t1 t2 t3 t4 t5:felem) (p q:point) : Stack unit (requires fun h -> live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ live h t5 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [ loc t1; loc t2; loc t3; loc t4; loc t5 ] /\ eq_or_disjoint p q /\ disjoint p t1 /\ disjoint p t2 /\ disjoint p t3 /\ disjoint p t4 /\ disjoint p t5 /\ disjoint q t1 /\ disjoint q t2 /\ disjoint q t3 /\ disjoint q t4 /\ disjoint q t5 /\ point_inv h p /\ point_inv h q /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h t3 < S.prime /\ as_nat h t4 < S.prime) (ensures fun h0 _ h1 -> modifies (loc t3 |+| loc t4 |+| loc t5) h0 h1 /\ as_nat h1 t3 < S.prime /\ as_nat h1 t4 < S.prime /\ as_nat h1 t5 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let t3_s = fmont_as_nat h0 t3 in let t4_s = fmont_as_nat h0 t4 in let t3_s = S.fsub t3_s t4_s in let t4_s = S.fadd y1 z1 in let t5_s = S.fadd y2 z2 in let t4_s = S.fmul t4_s t5_s in let t5_s = S.fadd t1_s t2_s in let t4_s = S.fsub t4_s t5_s in fmont_as_nat h1 t3 == t3_s /\ fmont_as_nat h1 t4 == t4_s /\ fmont_as_nat h1 t5 == t5_s)) let point_add_2 t1 t2 t3 t4 t5 p q = let y1, z1 = gety p, getz p in let y2, z2 = gety q, getz q in fsub t3 t3 t4; fadd t4 y1 z1; fadd t5 y2 z2; fmul t4 t4 t5; fadd t5 t1 t2; fsub t4 t4 t5 inline_for_extraction noextract val point_add_3 (x3 y3 t0 t2:felem) (p q:point) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h t0 /\ live h t2 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc t0; loc t2 ] /\ eq_or_disjoint p q /\ disjoint p x3 /\ disjoint p y3 /\ disjoint p t0 /\ disjoint p t2 /\ disjoint q x3 /\ disjoint q y3 /\ disjoint q t0 /\ disjoint q t2 /\ point_inv h p /\ point_inv h q /\ as_nat h t0 < S.prime /\ as_nat h t2 < S.prime) (ensures fun h0 _ h1 -> modifies (loc x3 |+| loc y3) h0 h1 /\ as_nat h1 x3 < S.prime /\ as_nat h1 y3 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t0_s = fmont_as_nat h0 t0 in let t2_s = fmont_as_nat h0 t2 in let x3_s = S.fadd x1 z1 in let y3_s = S.fadd x2 z2 in let x3_s = S.fmul x3_s y3_s in let y3_s = S.fadd t0_s t2_s in let y3_s = S.fsub x3_s y3_s in fmont_as_nat h1 x3 == x3_s /\ fmont_as_nat h1 y3 == y3_s)) let point_add_3 x3 y3 t0 t2 p q = let x1, z1 = getx p, getz p in let x2, z2 = getx q, getz q in fadd x3 x1 z1; fadd y3 x2 z2; fmul x3 x3 y3; fadd y3 t0 t2; fsub y3 x3 y3 inline_for_extraction noextract val point_add_4 (x3 y3 z3 t1 t2:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t1 /\ live h t2 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t1; loc t2 ] /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h y3 < S.prime) (ensures fun h0 _ h1 -> modifies (loc x3 |+| loc y3 |+| loc z3) h0 h1 /\ as_nat h1 x3 < S.prime /\ as_nat h1 y3 < S.prime /\ as_nat h1 z3 < S.prime /\ (let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let y3_s = fmont_as_nat h0 y3 in let z3_s = S.fmul S.b_coeff t2_s in let x3_s = S.fsub y3_s z3_s in let z3_s = S.fadd x3_s x3_s in let x3_s = S.fadd x3_s z3_s in let z3_s = S.fsub t1_s x3_s in let x3_s = S.fadd t1_s x3_s in let y3_s = S.fmul S.b_coeff y3_s in fmont_as_nat h1 x3 == x3_s /\ fmont_as_nat h1 y3 == y3_s /\ fmont_as_nat h1 z3 == z3_s)) let point_add_4 x3 y3 z3 t1 t2 = fmul_by_b_coeff z3 t2; fsub x3 y3 z3; fdouble z3 x3; fadd x3 x3 z3; fsub z3 t1 x3; fadd x3 t1 x3; fmul_by_b_coeff y3 y3 inline_for_extraction noextract val point_add_5 (x3 y3 z3 t0 t1 t2:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t0 /\ live h t1 /\ live h t2 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t0; loc t1; loc t2 ] /\ as_nat h y3 < S.prime /\ as_nat h t0 < S.prime /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime) (ensures fun h0 _ h1 -> modifies (loc y3 |+| loc t1 |+| loc t2) h0 h1 /\ as_nat h1 t1 < S.prime /\ as_nat h1 t2 < S.prime /\ as_nat h1 y3 < S.prime /\ (let t0_s = fmont_as_nat h0 t0 in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let y3_s = fmont_as_nat h0 y3 in let t1_s = S.fadd t2_s t2_s in let t2_s = S.fadd t1_s t2_s in let y3_s = S.fsub y3_s t2_s in let y3_s = S.fsub y3_s t0_s in let t1_s = S.fadd y3_s y3_s in fmont_as_nat h1 t1 == t1_s /\ fmont_as_nat h1 t2 == t2_s /\ fmont_as_nat h1 y3 == y3_s)) let point_add_5 x3 y3 z3 t0 t1 t2 = fdouble t1 t2; fadd t2 t1 t2; fsub y3 y3 t2; fsub y3 y3 t0; fdouble t1 y3 inline_for_extraction noextract val point_add_6 (x3 y3 z3 t0 t1 t2 t4:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t0 /\ live h t1 /\ live h t2 /\ live h t4 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t0; loc t1; loc t2; loc t4 ] /\ as_nat h y3 < S.prime /\ as_nat h t0 < S.prime /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h t4 < S.prime) (ensures fun h0 _ h1 -> modifies (loc y3 |+| loc t0 |+| loc t1 |+| loc t2) h0 h1 /\ as_nat h1 t0 < S.prime /\ as_nat h1 t1 < S.prime /\ as_nat h1 t2 < S.prime /\ as_nat h1 y3 < S.prime /\ (let t0_s = fmont_as_nat h0 t0 in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let t4_s = fmont_as_nat h0 t4 in let y3_s = fmont_as_nat h0 y3 in let y3_s = S.fadd t1_s y3_s in let t1_s = S.fadd t0_s t0_s in let t0_s = S.fadd t1_s t0_s in let t0_s = S.fsub t0_s t2_s in let t1_s = S.fmul t4_s y3_s in let t2_s = S.fmul t0_s y3_s in fmont_as_nat h1 t0 == t0_s /\ fmont_as_nat h1 t1 == t1_s /\ fmont_as_nat h1 t2 == t2_s /\ fmont_as_nat h1 y3 == y3_s)) let point_add_6 x3 y3 z3 t0 t1 t2 t4 = fadd y3 t1 y3; fdouble t1 t0; fadd t0 t1 t0; fsub t0 t0 t2; fmul t1 t4 y3; fmul t2 t0 y3 inline_for_extraction noextract val point_add_7 (x3 y3 z3 t0 t1 t2 t3 t4:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t0 /\ live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t0; loc t1; loc t2; loc t3; loc t4 ] /\ as_nat h x3 < S.prime /\ as_nat h z3 < S.prime /\ as_nat h t0 < S.prime /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h t3 < S.prime /\ as_nat h t4 < S.prime) (ensures fun h0 _ h1 -> modifies (loc x3 |+| loc y3 |+| loc z3 |+| loc t1) h0 h1 /\ as_nat h1 x3 < S.prime /\ as_nat h1 y3 < S.prime /\ as_nat h1 z3 < S.prime /\ as_nat h1 t1 < S.prime /\ (let x3_s = fmont_as_nat h0 x3 in let z3_s = fmont_as_nat h0 z3 in let t0_s = fmont_as_nat h0 t0 in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let t3_s = fmont_as_nat h0 t3 in let t4_s = fmont_as_nat h0 t4 in let y3_s = S.fmul x3_s z3_s in let y3_s = S.fadd y3_s t2_s in let x3_s = S.fmul t3_s x3_s in let x3_s = S.fsub x3_s t1_s in let z3_s = S.fmul t4_s z3_s in let t1_s = S.fmul t3_s t0_s in let z3_s = S.fadd z3_s t1_s in fmont_as_nat h1 x3 == x3_s /\ fmont_as_nat h1 y3 == y3_s /\ fmont_as_nat h1 z3 == z3_s /\ fmont_as_nat h1 t1 == t1_s))

Hacl.Impl.P256.PointAdd.fst

val point_add_7 (x3 y3 z3 t0 t1 t2 t3 t4:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t0 /\ live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t0; loc t1; loc t2; loc t3; loc t4 ] /\ as_nat h x3 < S.prime /\ as_nat h z3 < S.prime /\ as_nat h t0 < S.prime /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h t3 < S.prime /\ as_nat h t4 < S.prime) (ensures fun h0 _ h1 -> modifies (loc x3 |+| loc y3 |+| loc z3 |+| loc t1) h0 h1 /\ as_nat h1 x3 < S.prime /\ as_nat h1 y3 < S.prime /\ as_nat h1 z3 < S.prime /\ as_nat h1 t1 < S.prime /\ (let x3_s = fmont_as_nat h0 x3 in let z3_s = fmont_as_nat h0 z3 in let t0_s = fmont_as_nat h0 t0 in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let t3_s = fmont_as_nat h0 t3 in let t4_s = fmont_as_nat h0 t4 in let y3_s = S.fmul x3_s z3_s in let y3_s = S.fadd y3_s t2_s in let x3_s = S.fmul t3_s x3_s in let x3_s = S.fsub x3_s t1_s in let z3_s = S.fmul t4_s z3_s in let t1_s = S.fmul t3_s t0_s in let z3_s = S.fadd z3_s t1_s in fmont_as_nat h1 x3 == x3_s /\ fmont_as_nat h1 y3 == y3_s /\ fmont_as_nat h1 z3 == z3_s /\ fmont_as_nat h1 t1 == t1_s))

Hacl.Impl.P256.PointAdd.point_add_7

x3: Hacl.Impl.P256.Bignum.felem -> y3: Hacl.Impl.P256.Bignum.felem -> z3: Hacl.Impl.P256.Bignum.felem -> t0: Hacl.Impl.P256.Bignum.felem -> t1: Hacl.Impl.P256.Bignum.felem -> t2: Hacl.Impl.P256.Bignum.felem -> t3: Hacl.Impl.P256.Bignum.felem -> t4: Hacl.Impl.P256.Bignum.felem -> FStar.HyperStack.ST.Stack Prims.unit

FStar.HyperStack.ST.Stack

val point_add_2 (t1 t2 t3 t4 t5:felem) (p q:point) : Stack unit (requires fun h -> live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ live h t5 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [ loc t1; loc t2; loc t3; loc t4; loc t5 ] /\ eq_or_disjoint p q /\ disjoint p t1 /\ disjoint p t2 /\ disjoint p t3 /\ disjoint p t4 /\ disjoint p t5 /\ disjoint q t1 /\ disjoint q t2 /\ disjoint q t3 /\ disjoint q t4 /\ disjoint q t5 /\ point_inv h p /\ point_inv h q /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h t3 < S.prime /\ as_nat h t4 < S.prime) (ensures fun h0 _ h1 -> modifies (loc t3 |+| loc t4 |+| loc t5) h0 h1 /\ as_nat h1 t3 < S.prime /\ as_nat h1 t4 < S.prime /\ as_nat h1 t5 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let t3_s = fmont_as_nat h0 t3 in let t4_s = fmont_as_nat h0 t4 in let t3_s = S.fsub t3_s t4_s in let t4_s = S.fadd y1 z1 in let t5_s = S.fadd y2 z2 in let t4_s = S.fmul t4_s t5_s in let t5_s = S.fadd t1_s t2_s in let t4_s = S.fsub t4_s t5_s in fmont_as_nat h1 t3 == t3_s /\ fmont_as_nat h1 t4 == t4_s /\ fmont_as_nat h1 t5 == t5_s))

let point_add_2 t1 t2 t3 t4 t5 p q = let y1, z1 = gety p, getz p in let y2, z2 = gety q, getz q in fsub t3 t3 t4; fadd t4 y1 z1; fadd t5 y2 z2; fmul t4 t4 t5; fadd t5 t1 t2; fsub t4 t4 t5

val point_add_2 (t1 t2 t3 t4 t5:felem) (p q:point) : Stack unit (requires fun h -> live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ live h t5 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [ loc t1; loc t2; loc t3; loc t4; loc t5 ] /\ eq_or_disjoint p q /\ disjoint p t1 /\ disjoint p t2 /\ disjoint p t3 /\ disjoint p t4 /\ disjoint p t5 /\ disjoint q t1 /\ disjoint q t2 /\ disjoint q t3 /\ disjoint q t4 /\ disjoint q t5 /\ point_inv h p /\ point_inv h q /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h t3 < S.prime /\ as_nat h t4 < S.prime) (ensures fun h0 _ h1 -> modifies (loc t3 |+| loc t4 |+| loc t5) h0 h1 /\ as_nat h1 t3 < S.prime /\ as_nat h1 t4 < S.prime /\ as_nat h1 t5 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let t3_s = fmont_as_nat h0 t3 in let t4_s = fmont_as_nat h0 t4 in let t3_s = S.fsub t3_s t4_s in let t4_s = S.fadd y1 z1 in let t5_s = S.fadd y2 z2 in let t4_s = S.fmul t4_s t5_s in let t5_s = S.fadd t1_s t2_s in let t4_s = S.fsub t4_s t5_s in fmont_as_nat h1 t3 == t3_s /\ fmont_as_nat h1 t4 == t4_s /\ fmont_as_nat h1 t5 == t5_s)) let point_add_2 t1 t2 t3 t4 t5 p q =

let y1, z1 = gety p, getz p in let y2, z2 = gety q, getz q in fsub t3 t3 t4; fadd t4 y1 z1; fadd t5 y2 z2; fmul t4 t4 t5; fadd t5 t1 t2; fsub t4 t4 t5

module Hacl.Impl.P256.PointAdd open FStar.Mul open FStar.HyperStack.All open FStar.HyperStack module ST = FStar.HyperStack.ST open Lib.IntTypes open Lib.Buffer open Hacl.Impl.P256.Bignum open Hacl.Impl.P256.Field module S = Spec.P256 #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract val point_add_1 (t0 t1 t2 t3 t4:felem) (p q:point) : Stack unit (requires fun h -> live h t0 /\ live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [loc t0; loc t1; loc t2; loc t3; loc t4 ] /\ eq_or_disjoint p q /\ disjoint p t0 /\ disjoint p t1 /\ disjoint p t2 /\ disjoint p t3 /\ disjoint p t4 /\ disjoint q t0 /\ disjoint q t1 /\ disjoint q t2 /\ disjoint q t3 /\ disjoint q t4 /\ point_inv h p /\ point_inv h q) (ensures fun h0 _ h1 -> modifies (loc t0 |+| loc t1 |+| loc t2 |+| loc t3 |+| loc t4) h0 h1 /\ as_nat h1 t0 < S.prime /\ as_nat h1 t1 < S.prime /\ as_nat h1 t2 < S.prime /\ as_nat h1 t3 < S.prime /\ as_nat h1 t4 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t0_s = S.fmul x1 x2 in let t1_s = S.fmul y1 y2 in let t2_s = S.fmul z1 z2 in let t3_s = S.fadd x1 y1 in let t4_s = S.fadd x2 y2 in let t3_s = S.fmul t3_s t4_s in let t4_s = S.fadd t0_s t1_s in fmont_as_nat h1 t0 == t0_s /\ fmont_as_nat h1 t1 == t1_s /\ fmont_as_nat h1 t2 == t2_s /\ fmont_as_nat h1 t3 == t3_s /\ fmont_as_nat h1 t4 == t4_s)) let point_add_1 t0 t1 t2 t3 t4 p q = let x1, y1, z1 = getx p, gety p, getz p in let x2, y2, z2 = getx q, gety q, getz q in fmul t0 x1 x2; fmul t1 y1 y2; fmul t2 z1 z2; fadd t3 x1 y1; fadd t4 x2 y2; fmul t3 t3 t4; fadd t4 t0 t1 inline_for_extraction noextract val point_add_2 (t1 t2 t3 t4 t5:felem) (p q:point) : Stack unit (requires fun h -> live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ live h t5 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [ loc t1; loc t2; loc t3; loc t4; loc t5 ] /\ eq_or_disjoint p q /\ disjoint p t1 /\ disjoint p t2 /\ disjoint p t3 /\ disjoint p t4 /\ disjoint p t5 /\ disjoint q t1 /\ disjoint q t2 /\ disjoint q t3 /\ disjoint q t4 /\ disjoint q t5 /\ point_inv h p /\ point_inv h q /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h t3 < S.prime /\ as_nat h t4 < S.prime) (ensures fun h0 _ h1 -> modifies (loc t3 |+| loc t4 |+| loc t5) h0 h1 /\ as_nat h1 t3 < S.prime /\ as_nat h1 t4 < S.prime /\ as_nat h1 t5 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let t3_s = fmont_as_nat h0 t3 in let t4_s = fmont_as_nat h0 t4 in let t3_s = S.fsub t3_s t4_s in let t4_s = S.fadd y1 z1 in let t5_s = S.fadd y2 z2 in let t4_s = S.fmul t4_s t5_s in let t5_s = S.fadd t1_s t2_s in let t4_s = S.fsub t4_s t5_s in fmont_as_nat h1 t3 == t3_s /\ fmont_as_nat h1 t4 == t4_s /\ fmont_as_nat h1 t5 == t5_s))

Hacl.Impl.P256.PointAdd.fst

val point_add_2 (t1 t2 t3 t4 t5:felem) (p q:point) : Stack unit (requires fun h -> live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ live h t5 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [ loc t1; loc t2; loc t3; loc t4; loc t5 ] /\ eq_or_disjoint p q /\ disjoint p t1 /\ disjoint p t2 /\ disjoint p t3 /\ disjoint p t4 /\ disjoint p t5 /\ disjoint q t1 /\ disjoint q t2 /\ disjoint q t3 /\ disjoint q t4 /\ disjoint q t5 /\ point_inv h p /\ point_inv h q /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h t3 < S.prime /\ as_nat h t4 < S.prime) (ensures fun h0 _ h1 -> modifies (loc t3 |+| loc t4 |+| loc t5) h0 h1 /\ as_nat h1 t3 < S.prime /\ as_nat h1 t4 < S.prime /\ as_nat h1 t5 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let t3_s = fmont_as_nat h0 t3 in let t4_s = fmont_as_nat h0 t4 in let t3_s = S.fsub t3_s t4_s in let t4_s = S.fadd y1 z1 in let t5_s = S.fadd y2 z2 in let t4_s = S.fmul t4_s t5_s in let t5_s = S.fadd t1_s t2_s in let t4_s = S.fsub t4_s t5_s in fmont_as_nat h1 t3 == t3_s /\ fmont_as_nat h1 t4 == t4_s /\ fmont_as_nat h1 t5 == t5_s))

Hacl.Impl.P256.PointAdd.point_add_2

t1: Hacl.Impl.P256.Bignum.felem -> t2: Hacl.Impl.P256.Bignum.felem -> t3: Hacl.Impl.P256.Bignum.felem -> t4: Hacl.Impl.P256.Bignum.felem -> t5: Hacl.Impl.P256.Bignum.felem -> p: Hacl.Impl.P256.Point.point -> q: Hacl.Impl.P256.Point.point -> FStar.HyperStack.ST.Stack Prims.unit

FStar.HyperStack.ST.Stack

val point_add_6 (x3 y3 z3 t0 t1 t2 t4:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t0 /\ live h t1 /\ live h t2 /\ live h t4 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t0; loc t1; loc t2; loc t4 ] /\ as_nat h y3 < S.prime /\ as_nat h t0 < S.prime /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h t4 < S.prime) (ensures fun h0 _ h1 -> modifies (loc y3 |+| loc t0 |+| loc t1 |+| loc t2) h0 h1 /\ as_nat h1 t0 < S.prime /\ as_nat h1 t1 < S.prime /\ as_nat h1 t2 < S.prime /\ as_nat h1 y3 < S.prime /\ (let t0_s = fmont_as_nat h0 t0 in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let t4_s = fmont_as_nat h0 t4 in let y3_s = fmont_as_nat h0 y3 in let y3_s = S.fadd t1_s y3_s in let t1_s = S.fadd t0_s t0_s in let t0_s = S.fadd t1_s t0_s in let t0_s = S.fsub t0_s t2_s in let t1_s = S.fmul t4_s y3_s in let t2_s = S.fmul t0_s y3_s in fmont_as_nat h1 t0 == t0_s /\ fmont_as_nat h1 t1 == t1_s /\ fmont_as_nat h1 t2 == t2_s /\ fmont_as_nat h1 y3 == y3_s))

let point_add_6 x3 y3 z3 t0 t1 t2 t4 = fadd y3 t1 y3; fdouble t1 t0; fadd t0 t1 t0; fsub t0 t0 t2; fmul t1 t4 y3; fmul t2 t0 y3

val point_add_6 (x3 y3 z3 t0 t1 t2 t4:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t0 /\ live h t1 /\ live h t2 /\ live h t4 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t0; loc t1; loc t2; loc t4 ] /\ as_nat h y3 < S.prime /\ as_nat h t0 < S.prime /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h t4 < S.prime) (ensures fun h0 _ h1 -> modifies (loc y3 |+| loc t0 |+| loc t1 |+| loc t2) h0 h1 /\ as_nat h1 t0 < S.prime /\ as_nat h1 t1 < S.prime /\ as_nat h1 t2 < S.prime /\ as_nat h1 y3 < S.prime /\ (let t0_s = fmont_as_nat h0 t0 in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let t4_s = fmont_as_nat h0 t4 in let y3_s = fmont_as_nat h0 y3 in let y3_s = S.fadd t1_s y3_s in let t1_s = S.fadd t0_s t0_s in let t0_s = S.fadd t1_s t0_s in let t0_s = S.fsub t0_s t2_s in let t1_s = S.fmul t4_s y3_s in let t2_s = S.fmul t0_s y3_s in fmont_as_nat h1 t0 == t0_s /\ fmont_as_nat h1 t1 == t1_s /\ fmont_as_nat h1 t2 == t2_s /\ fmont_as_nat h1 y3 == y3_s)) let point_add_6 x3 y3 z3 t0 t1 t2 t4 =

fadd y3 t1 y3; fdouble t1 t0; fadd t0 t1 t0; fsub t0 t0 t2; fmul t1 t4 y3; fmul t2 t0 y3

module Hacl.Impl.P256.PointAdd open FStar.Mul open FStar.HyperStack.All open FStar.HyperStack module ST = FStar.HyperStack.ST open Lib.IntTypes open Lib.Buffer open Hacl.Impl.P256.Bignum open Hacl.Impl.P256.Field module S = Spec.P256 #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract val point_add_1 (t0 t1 t2 t3 t4:felem) (p q:point) : Stack unit (requires fun h -> live h t0 /\ live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [loc t0; loc t1; loc t2; loc t3; loc t4 ] /\ eq_or_disjoint p q /\ disjoint p t0 /\ disjoint p t1 /\ disjoint p t2 /\ disjoint p t3 /\ disjoint p t4 /\ disjoint q t0 /\ disjoint q t1 /\ disjoint q t2 /\ disjoint q t3 /\ disjoint q t4 /\ point_inv h p /\ point_inv h q) (ensures fun h0 _ h1 -> modifies (loc t0 |+| loc t1 |+| loc t2 |+| loc t3 |+| loc t4) h0 h1 /\ as_nat h1 t0 < S.prime /\ as_nat h1 t1 < S.prime /\ as_nat h1 t2 < S.prime /\ as_nat h1 t3 < S.prime /\ as_nat h1 t4 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t0_s = S.fmul x1 x2 in let t1_s = S.fmul y1 y2 in let t2_s = S.fmul z1 z2 in let t3_s = S.fadd x1 y1 in let t4_s = S.fadd x2 y2 in let t3_s = S.fmul t3_s t4_s in let t4_s = S.fadd t0_s t1_s in fmont_as_nat h1 t0 == t0_s /\ fmont_as_nat h1 t1 == t1_s /\ fmont_as_nat h1 t2 == t2_s /\ fmont_as_nat h1 t3 == t3_s /\ fmont_as_nat h1 t4 == t4_s)) let point_add_1 t0 t1 t2 t3 t4 p q = let x1, y1, z1 = getx p, gety p, getz p in let x2, y2, z2 = getx q, gety q, getz q in fmul t0 x1 x2; fmul t1 y1 y2; fmul t2 z1 z2; fadd t3 x1 y1; fadd t4 x2 y2; fmul t3 t3 t4; fadd t4 t0 t1 inline_for_extraction noextract val point_add_2 (t1 t2 t3 t4 t5:felem) (p q:point) : Stack unit (requires fun h -> live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ live h t5 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [ loc t1; loc t2; loc t3; loc t4; loc t5 ] /\ eq_or_disjoint p q /\ disjoint p t1 /\ disjoint p t2 /\ disjoint p t3 /\ disjoint p t4 /\ disjoint p t5 /\ disjoint q t1 /\ disjoint q t2 /\ disjoint q t3 /\ disjoint q t4 /\ disjoint q t5 /\ point_inv h p /\ point_inv h q /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h t3 < S.prime /\ as_nat h t4 < S.prime) (ensures fun h0 _ h1 -> modifies (loc t3 |+| loc t4 |+| loc t5) h0 h1 /\ as_nat h1 t3 < S.prime /\ as_nat h1 t4 < S.prime /\ as_nat h1 t5 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let t3_s = fmont_as_nat h0 t3 in let t4_s = fmont_as_nat h0 t4 in let t3_s = S.fsub t3_s t4_s in let t4_s = S.fadd y1 z1 in let t5_s = S.fadd y2 z2 in let t4_s = S.fmul t4_s t5_s in let t5_s = S.fadd t1_s t2_s in let t4_s = S.fsub t4_s t5_s in fmont_as_nat h1 t3 == t3_s /\ fmont_as_nat h1 t4 == t4_s /\ fmont_as_nat h1 t5 == t5_s)) let point_add_2 t1 t2 t3 t4 t5 p q = let y1, z1 = gety p, getz p in let y2, z2 = gety q, getz q in fsub t3 t3 t4; fadd t4 y1 z1; fadd t5 y2 z2; fmul t4 t4 t5; fadd t5 t1 t2; fsub t4 t4 t5 inline_for_extraction noextract val point_add_3 (x3 y3 t0 t2:felem) (p q:point) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h t0 /\ live h t2 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc t0; loc t2 ] /\ eq_or_disjoint p q /\ disjoint p x3 /\ disjoint p y3 /\ disjoint p t0 /\ disjoint p t2 /\ disjoint q x3 /\ disjoint q y3 /\ disjoint q t0 /\ disjoint q t2 /\ point_inv h p /\ point_inv h q /\ as_nat h t0 < S.prime /\ as_nat h t2 < S.prime) (ensures fun h0 _ h1 -> modifies (loc x3 |+| loc y3) h0 h1 /\ as_nat h1 x3 < S.prime /\ as_nat h1 y3 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t0_s = fmont_as_nat h0 t0 in let t2_s = fmont_as_nat h0 t2 in let x3_s = S.fadd x1 z1 in let y3_s = S.fadd x2 z2 in let x3_s = S.fmul x3_s y3_s in let y3_s = S.fadd t0_s t2_s in let y3_s = S.fsub x3_s y3_s in fmont_as_nat h1 x3 == x3_s /\ fmont_as_nat h1 y3 == y3_s)) let point_add_3 x3 y3 t0 t2 p q = let x1, z1 = getx p, getz p in let x2, z2 = getx q, getz q in fadd x3 x1 z1; fadd y3 x2 z2; fmul x3 x3 y3; fadd y3 t0 t2; fsub y3 x3 y3 inline_for_extraction noextract val point_add_4 (x3 y3 z3 t1 t2:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t1 /\ live h t2 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t1; loc t2 ] /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h y3 < S.prime) (ensures fun h0 _ h1 -> modifies (loc x3 |+| loc y3 |+| loc z3) h0 h1 /\ as_nat h1 x3 < S.prime /\ as_nat h1 y3 < S.prime /\ as_nat h1 z3 < S.prime /\ (let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let y3_s = fmont_as_nat h0 y3 in let z3_s = S.fmul S.b_coeff t2_s in let x3_s = S.fsub y3_s z3_s in let z3_s = S.fadd x3_s x3_s in let x3_s = S.fadd x3_s z3_s in let z3_s = S.fsub t1_s x3_s in let x3_s = S.fadd t1_s x3_s in let y3_s = S.fmul S.b_coeff y3_s in fmont_as_nat h1 x3 == x3_s /\ fmont_as_nat h1 y3 == y3_s /\ fmont_as_nat h1 z3 == z3_s)) let point_add_4 x3 y3 z3 t1 t2 = fmul_by_b_coeff z3 t2; fsub x3 y3 z3; fdouble z3 x3; fadd x3 x3 z3; fsub z3 t1 x3; fadd x3 t1 x3; fmul_by_b_coeff y3 y3 inline_for_extraction noextract val point_add_5 (x3 y3 z3 t0 t1 t2:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t0 /\ live h t1 /\ live h t2 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t0; loc t1; loc t2 ] /\ as_nat h y3 < S.prime /\ as_nat h t0 < S.prime /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime) (ensures fun h0 _ h1 -> modifies (loc y3 |+| loc t1 |+| loc t2) h0 h1 /\ as_nat h1 t1 < S.prime /\ as_nat h1 t2 < S.prime /\ as_nat h1 y3 < S.prime /\ (let t0_s = fmont_as_nat h0 t0 in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let y3_s = fmont_as_nat h0 y3 in let t1_s = S.fadd t2_s t2_s in let t2_s = S.fadd t1_s t2_s in let y3_s = S.fsub y3_s t2_s in let y3_s = S.fsub y3_s t0_s in let t1_s = S.fadd y3_s y3_s in fmont_as_nat h1 t1 == t1_s /\ fmont_as_nat h1 t2 == t2_s /\ fmont_as_nat h1 y3 == y3_s)) let point_add_5 x3 y3 z3 t0 t1 t2 = fdouble t1 t2; fadd t2 t1 t2; fsub y3 y3 t2; fsub y3 y3 t0; fdouble t1 y3 inline_for_extraction noextract val point_add_6 (x3 y3 z3 t0 t1 t2 t4:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t0 /\ live h t1 /\ live h t2 /\ live h t4 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t0; loc t1; loc t2; loc t4 ] /\ as_nat h y3 < S.prime /\ as_nat h t0 < S.prime /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h t4 < S.prime) (ensures fun h0 _ h1 -> modifies (loc y3 |+| loc t0 |+| loc t1 |+| loc t2) h0 h1 /\ as_nat h1 t0 < S.prime /\ as_nat h1 t1 < S.prime /\ as_nat h1 t2 < S.prime /\ as_nat h1 y3 < S.prime /\ (let t0_s = fmont_as_nat h0 t0 in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let t4_s = fmont_as_nat h0 t4 in let y3_s = fmont_as_nat h0 y3 in let y3_s = S.fadd t1_s y3_s in let t1_s = S.fadd t0_s t0_s in let t0_s = S.fadd t1_s t0_s in let t0_s = S.fsub t0_s t2_s in let t1_s = S.fmul t4_s y3_s in let t2_s = S.fmul t0_s y3_s in fmont_as_nat h1 t0 == t0_s /\ fmont_as_nat h1 t1 == t1_s /\ fmont_as_nat h1 t2 == t2_s /\ fmont_as_nat h1 y3 == y3_s))

Hacl.Impl.P256.PointAdd.fst

val point_add_6 (x3 y3 z3 t0 t1 t2 t4:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t0 /\ live h t1 /\ live h t2 /\ live h t4 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t0; loc t1; loc t2; loc t4 ] /\ as_nat h y3 < S.prime /\ as_nat h t0 < S.prime /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h t4 < S.prime) (ensures fun h0 _ h1 -> modifies (loc y3 |+| loc t0 |+| loc t1 |+| loc t2) h0 h1 /\ as_nat h1 t0 < S.prime /\ as_nat h1 t1 < S.prime /\ as_nat h1 t2 < S.prime /\ as_nat h1 y3 < S.prime /\ (let t0_s = fmont_as_nat h0 t0 in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let t4_s = fmont_as_nat h0 t4 in let y3_s = fmont_as_nat h0 y3 in let y3_s = S.fadd t1_s y3_s in let t1_s = S.fadd t0_s t0_s in let t0_s = S.fadd t1_s t0_s in let t0_s = S.fsub t0_s t2_s in let t1_s = S.fmul t4_s y3_s in let t2_s = S.fmul t0_s y3_s in fmont_as_nat h1 t0 == t0_s /\ fmont_as_nat h1 t1 == t1_s /\ fmont_as_nat h1 t2 == t2_s /\ fmont_as_nat h1 y3 == y3_s))

Hacl.Impl.P256.PointAdd.point_add_6

x3: Hacl.Impl.P256.Bignum.felem -> y3: Hacl.Impl.P256.Bignum.felem -> z3: Hacl.Impl.P256.Bignum.felem -> t0: Hacl.Impl.P256.Bignum.felem -> t1: Hacl.Impl.P256.Bignum.felem -> t2: Hacl.Impl.P256.Bignum.felem -> t4: Hacl.Impl.P256.Bignum.felem -> FStar.HyperStack.ST.Stack Prims.unit

FStar.HyperStack.ST.Stack

val point_add_1 (t0 t1 t2 t3 t4:felem) (p q:point) : Stack unit (requires fun h -> live h t0 /\ live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [loc t0; loc t1; loc t2; loc t3; loc t4 ] /\ eq_or_disjoint p q /\ disjoint p t0 /\ disjoint p t1 /\ disjoint p t2 /\ disjoint p t3 /\ disjoint p t4 /\ disjoint q t0 /\ disjoint q t1 /\ disjoint q t2 /\ disjoint q t3 /\ disjoint q t4 /\ point_inv h p /\ point_inv h q) (ensures fun h0 _ h1 -> modifies (loc t0 |+| loc t1 |+| loc t2 |+| loc t3 |+| loc t4) h0 h1 /\ as_nat h1 t0 < S.prime /\ as_nat h1 t1 < S.prime /\ as_nat h1 t2 < S.prime /\ as_nat h1 t3 < S.prime /\ as_nat h1 t4 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t0_s = S.fmul x1 x2 in let t1_s = S.fmul y1 y2 in let t2_s = S.fmul z1 z2 in let t3_s = S.fadd x1 y1 in let t4_s = S.fadd x2 y2 in let t3_s = S.fmul t3_s t4_s in let t4_s = S.fadd t0_s t1_s in fmont_as_nat h1 t0 == t0_s /\ fmont_as_nat h1 t1 == t1_s /\ fmont_as_nat h1 t2 == t2_s /\ fmont_as_nat h1 t3 == t3_s /\ fmont_as_nat h1 t4 == t4_s))

let point_add_1 t0 t1 t2 t3 t4 p q = let x1, y1, z1 = getx p, gety p, getz p in let x2, y2, z2 = getx q, gety q, getz q in fmul t0 x1 x2; fmul t1 y1 y2; fmul t2 z1 z2; fadd t3 x1 y1; fadd t4 x2 y2; fmul t3 t3 t4; fadd t4 t0 t1

val point_add_1 (t0 t1 t2 t3 t4:felem) (p q:point) : Stack unit (requires fun h -> live h t0 /\ live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [loc t0; loc t1; loc t2; loc t3; loc t4 ] /\ eq_or_disjoint p q /\ disjoint p t0 /\ disjoint p t1 /\ disjoint p t2 /\ disjoint p t3 /\ disjoint p t4 /\ disjoint q t0 /\ disjoint q t1 /\ disjoint q t2 /\ disjoint q t3 /\ disjoint q t4 /\ point_inv h p /\ point_inv h q) (ensures fun h0 _ h1 -> modifies (loc t0 |+| loc t1 |+| loc t2 |+| loc t3 |+| loc t4) h0 h1 /\ as_nat h1 t0 < S.prime /\ as_nat h1 t1 < S.prime /\ as_nat h1 t2 < S.prime /\ as_nat h1 t3 < S.prime /\ as_nat h1 t4 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t0_s = S.fmul x1 x2 in let t1_s = S.fmul y1 y2 in let t2_s = S.fmul z1 z2 in let t3_s = S.fadd x1 y1 in let t4_s = S.fadd x2 y2 in let t3_s = S.fmul t3_s t4_s in let t4_s = S.fadd t0_s t1_s in fmont_as_nat h1 t0 == t0_s /\ fmont_as_nat h1 t1 == t1_s /\ fmont_as_nat h1 t2 == t2_s /\ fmont_as_nat h1 t3 == t3_s /\ fmont_as_nat h1 t4 == t4_s)) let point_add_1 t0 t1 t2 t3 t4 p q =

let x1, y1, z1 = getx p, gety p, getz p in let x2, y2, z2 = getx q, gety q, getz q in fmul t0 x1 x2; fmul t1 y1 y2; fmul t2 z1 z2; fadd t3 x1 y1; fadd t4 x2 y2; fmul t3 t3 t4; fadd t4 t0 t1

module Hacl.Impl.P256.PointAdd open FStar.Mul open FStar.HyperStack.All open FStar.HyperStack module ST = FStar.HyperStack.ST open Lib.IntTypes open Lib.Buffer open Hacl.Impl.P256.Bignum open Hacl.Impl.P256.Field module S = Spec.P256 #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract val point_add_1 (t0 t1 t2 t3 t4:felem) (p q:point) : Stack unit (requires fun h -> live h t0 /\ live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [loc t0; loc t1; loc t2; loc t3; loc t4 ] /\ eq_or_disjoint p q /\ disjoint p t0 /\ disjoint p t1 /\ disjoint p t2 /\ disjoint p t3 /\ disjoint p t4 /\ disjoint q t0 /\ disjoint q t1 /\ disjoint q t2 /\ disjoint q t3 /\ disjoint q t4 /\ point_inv h p /\ point_inv h q) (ensures fun h0 _ h1 -> modifies (loc t0 |+| loc t1 |+| loc t2 |+| loc t3 |+| loc t4) h0 h1 /\ as_nat h1 t0 < S.prime /\ as_nat h1 t1 < S.prime /\ as_nat h1 t2 < S.prime /\ as_nat h1 t3 < S.prime /\ as_nat h1 t4 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t0_s = S.fmul x1 x2 in let t1_s = S.fmul y1 y2 in let t2_s = S.fmul z1 z2 in let t3_s = S.fadd x1 y1 in let t4_s = S.fadd x2 y2 in let t3_s = S.fmul t3_s t4_s in let t4_s = S.fadd t0_s t1_s in fmont_as_nat h1 t0 == t0_s /\ fmont_as_nat h1 t1 == t1_s /\ fmont_as_nat h1 t2 == t2_s /\ fmont_as_nat h1 t3 == t3_s /\ fmont_as_nat h1 t4 == t4_s))

Hacl.Impl.P256.PointAdd.fst

val point_add_1 (t0 t1 t2 t3 t4:felem) (p q:point) : Stack unit (requires fun h -> live h t0 /\ live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [loc t0; loc t1; loc t2; loc t3; loc t4 ] /\ eq_or_disjoint p q /\ disjoint p t0 /\ disjoint p t1 /\ disjoint p t2 /\ disjoint p t3 /\ disjoint p t4 /\ disjoint q t0 /\ disjoint q t1 /\ disjoint q t2 /\ disjoint q t3 /\ disjoint q t4 /\ point_inv h p /\ point_inv h q) (ensures fun h0 _ h1 -> modifies (loc t0 |+| loc t1 |+| loc t2 |+| loc t3 |+| loc t4) h0 h1 /\ as_nat h1 t0 < S.prime /\ as_nat h1 t1 < S.prime /\ as_nat h1 t2 < S.prime /\ as_nat h1 t3 < S.prime /\ as_nat h1 t4 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t0_s = S.fmul x1 x2 in let t1_s = S.fmul y1 y2 in let t2_s = S.fmul z1 z2 in let t3_s = S.fadd x1 y1 in let t4_s = S.fadd x2 y2 in let t3_s = S.fmul t3_s t4_s in let t4_s = S.fadd t0_s t1_s in fmont_as_nat h1 t0 == t0_s /\ fmont_as_nat h1 t1 == t1_s /\ fmont_as_nat h1 t2 == t2_s /\ fmont_as_nat h1 t3 == t3_s /\ fmont_as_nat h1 t4 == t4_s))

Hacl.Impl.P256.PointAdd.point_add_1

t0: Hacl.Impl.P256.Bignum.felem -> t1: Hacl.Impl.P256.Bignum.felem -> t2: Hacl.Impl.P256.Bignum.felem -> t3: Hacl.Impl.P256.Bignum.felem -> t4: Hacl.Impl.P256.Bignum.felem -> p: Hacl.Impl.P256.Point.point -> q: Hacl.Impl.P256.Point.point -> FStar.HyperStack.ST.Stack Prims.unit

FStar.HyperStack.ST.Stack

val point_add_5 (x3 y3 z3 t0 t1 t2:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t0 /\ live h t1 /\ live h t2 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t0; loc t1; loc t2 ] /\ as_nat h y3 < S.prime /\ as_nat h t0 < S.prime /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime) (ensures fun h0 _ h1 -> modifies (loc y3 |+| loc t1 |+| loc t2) h0 h1 /\ as_nat h1 t1 < S.prime /\ as_nat h1 t2 < S.prime /\ as_nat h1 y3 < S.prime /\ (let t0_s = fmont_as_nat h0 t0 in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let y3_s = fmont_as_nat h0 y3 in let t1_s = S.fadd t2_s t2_s in let t2_s = S.fadd t1_s t2_s in let y3_s = S.fsub y3_s t2_s in let y3_s = S.fsub y3_s t0_s in let t1_s = S.fadd y3_s y3_s in fmont_as_nat h1 t1 == t1_s /\ fmont_as_nat h1 t2 == t2_s /\ fmont_as_nat h1 y3 == y3_s))

let point_add_5 x3 y3 z3 t0 t1 t2 = fdouble t1 t2; fadd t2 t1 t2; fsub y3 y3 t2; fsub y3 y3 t0; fdouble t1 y3

val point_add_5 (x3 y3 z3 t0 t1 t2:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t0 /\ live h t1 /\ live h t2 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t0; loc t1; loc t2 ] /\ as_nat h y3 < S.prime /\ as_nat h t0 < S.prime /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime) (ensures fun h0 _ h1 -> modifies (loc y3 |+| loc t1 |+| loc t2) h0 h1 /\ as_nat h1 t1 < S.prime /\ as_nat h1 t2 < S.prime /\ as_nat h1 y3 < S.prime /\ (let t0_s = fmont_as_nat h0 t0 in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let y3_s = fmont_as_nat h0 y3 in let t1_s = S.fadd t2_s t2_s in let t2_s = S.fadd t1_s t2_s in let y3_s = S.fsub y3_s t2_s in let y3_s = S.fsub y3_s t0_s in let t1_s = S.fadd y3_s y3_s in fmont_as_nat h1 t1 == t1_s /\ fmont_as_nat h1 t2 == t2_s /\ fmont_as_nat h1 y3 == y3_s)) let point_add_5 x3 y3 z3 t0 t1 t2 =

fdouble t1 t2; fadd t2 t1 t2; fsub y3 y3 t2; fsub y3 y3 t0; fdouble t1 y3

module Hacl.Impl.P256.PointAdd open FStar.Mul open FStar.HyperStack.All open FStar.HyperStack module ST = FStar.HyperStack.ST open Lib.IntTypes open Lib.Buffer open Hacl.Impl.P256.Bignum open Hacl.Impl.P256.Field module S = Spec.P256 #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract val point_add_1 (t0 t1 t2 t3 t4:felem) (p q:point) : Stack unit (requires fun h -> live h t0 /\ live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [loc t0; loc t1; loc t2; loc t3; loc t4 ] /\ eq_or_disjoint p q /\ disjoint p t0 /\ disjoint p t1 /\ disjoint p t2 /\ disjoint p t3 /\ disjoint p t4 /\ disjoint q t0 /\ disjoint q t1 /\ disjoint q t2 /\ disjoint q t3 /\ disjoint q t4 /\ point_inv h p /\ point_inv h q) (ensures fun h0 _ h1 -> modifies (loc t0 |+| loc t1 |+| loc t2 |+| loc t3 |+| loc t4) h0 h1 /\ as_nat h1 t0 < S.prime /\ as_nat h1 t1 < S.prime /\ as_nat h1 t2 < S.prime /\ as_nat h1 t3 < S.prime /\ as_nat h1 t4 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t0_s = S.fmul x1 x2 in let t1_s = S.fmul y1 y2 in let t2_s = S.fmul z1 z2 in let t3_s = S.fadd x1 y1 in let t4_s = S.fadd x2 y2 in let t3_s = S.fmul t3_s t4_s in let t4_s = S.fadd t0_s t1_s in fmont_as_nat h1 t0 == t0_s /\ fmont_as_nat h1 t1 == t1_s /\ fmont_as_nat h1 t2 == t2_s /\ fmont_as_nat h1 t3 == t3_s /\ fmont_as_nat h1 t4 == t4_s)) let point_add_1 t0 t1 t2 t3 t4 p q = let x1, y1, z1 = getx p, gety p, getz p in let x2, y2, z2 = getx q, gety q, getz q in fmul t0 x1 x2; fmul t1 y1 y2; fmul t2 z1 z2; fadd t3 x1 y1; fadd t4 x2 y2; fmul t3 t3 t4; fadd t4 t0 t1 inline_for_extraction noextract val point_add_2 (t1 t2 t3 t4 t5:felem) (p q:point) : Stack unit (requires fun h -> live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ live h t5 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [ loc t1; loc t2; loc t3; loc t4; loc t5 ] /\ eq_or_disjoint p q /\ disjoint p t1 /\ disjoint p t2 /\ disjoint p t3 /\ disjoint p t4 /\ disjoint p t5 /\ disjoint q t1 /\ disjoint q t2 /\ disjoint q t3 /\ disjoint q t4 /\ disjoint q t5 /\ point_inv h p /\ point_inv h q /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h t3 < S.prime /\ as_nat h t4 < S.prime) (ensures fun h0 _ h1 -> modifies (loc t3 |+| loc t4 |+| loc t5) h0 h1 /\ as_nat h1 t3 < S.prime /\ as_nat h1 t4 < S.prime /\ as_nat h1 t5 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let t3_s = fmont_as_nat h0 t3 in let t4_s = fmont_as_nat h0 t4 in let t3_s = S.fsub t3_s t4_s in let t4_s = S.fadd y1 z1 in let t5_s = S.fadd y2 z2 in let t4_s = S.fmul t4_s t5_s in let t5_s = S.fadd t1_s t2_s in let t4_s = S.fsub t4_s t5_s in fmont_as_nat h1 t3 == t3_s /\ fmont_as_nat h1 t4 == t4_s /\ fmont_as_nat h1 t5 == t5_s)) let point_add_2 t1 t2 t3 t4 t5 p q = let y1, z1 = gety p, getz p in let y2, z2 = gety q, getz q in fsub t3 t3 t4; fadd t4 y1 z1; fadd t5 y2 z2; fmul t4 t4 t5; fadd t5 t1 t2; fsub t4 t4 t5 inline_for_extraction noextract val point_add_3 (x3 y3 t0 t2:felem) (p q:point) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h t0 /\ live h t2 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc t0; loc t2 ] /\ eq_or_disjoint p q /\ disjoint p x3 /\ disjoint p y3 /\ disjoint p t0 /\ disjoint p t2 /\ disjoint q x3 /\ disjoint q y3 /\ disjoint q t0 /\ disjoint q t2 /\ point_inv h p /\ point_inv h q /\ as_nat h t0 < S.prime /\ as_nat h t2 < S.prime) (ensures fun h0 _ h1 -> modifies (loc x3 |+| loc y3) h0 h1 /\ as_nat h1 x3 < S.prime /\ as_nat h1 y3 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t0_s = fmont_as_nat h0 t0 in let t2_s = fmont_as_nat h0 t2 in let x3_s = S.fadd x1 z1 in let y3_s = S.fadd x2 z2 in let x3_s = S.fmul x3_s y3_s in let y3_s = S.fadd t0_s t2_s in let y3_s = S.fsub x3_s y3_s in fmont_as_nat h1 x3 == x3_s /\ fmont_as_nat h1 y3 == y3_s)) let point_add_3 x3 y3 t0 t2 p q = let x1, z1 = getx p, getz p in let x2, z2 = getx q, getz q in fadd x3 x1 z1; fadd y3 x2 z2; fmul x3 x3 y3; fadd y3 t0 t2; fsub y3 x3 y3 inline_for_extraction noextract val point_add_4 (x3 y3 z3 t1 t2:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t1 /\ live h t2 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t1; loc t2 ] /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h y3 < S.prime) (ensures fun h0 _ h1 -> modifies (loc x3 |+| loc y3 |+| loc z3) h0 h1 /\ as_nat h1 x3 < S.prime /\ as_nat h1 y3 < S.prime /\ as_nat h1 z3 < S.prime /\ (let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let y3_s = fmont_as_nat h0 y3 in let z3_s = S.fmul S.b_coeff t2_s in let x3_s = S.fsub y3_s z3_s in let z3_s = S.fadd x3_s x3_s in let x3_s = S.fadd x3_s z3_s in let z3_s = S.fsub t1_s x3_s in let x3_s = S.fadd t1_s x3_s in let y3_s = S.fmul S.b_coeff y3_s in fmont_as_nat h1 x3 == x3_s /\ fmont_as_nat h1 y3 == y3_s /\ fmont_as_nat h1 z3 == z3_s)) let point_add_4 x3 y3 z3 t1 t2 = fmul_by_b_coeff z3 t2; fsub x3 y3 z3; fdouble z3 x3; fadd x3 x3 z3; fsub z3 t1 x3; fadd x3 t1 x3; fmul_by_b_coeff y3 y3 inline_for_extraction noextract val point_add_5 (x3 y3 z3 t0 t1 t2:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t0 /\ live h t1 /\ live h t2 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t0; loc t1; loc t2 ] /\ as_nat h y3 < S.prime /\ as_nat h t0 < S.prime /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime) (ensures fun h0 _ h1 -> modifies (loc y3 |+| loc t1 |+| loc t2) h0 h1 /\ as_nat h1 t1 < S.prime /\ as_nat h1 t2 < S.prime /\ as_nat h1 y3 < S.prime /\ (let t0_s = fmont_as_nat h0 t0 in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let y3_s = fmont_as_nat h0 y3 in let t1_s = S.fadd t2_s t2_s in let t2_s = S.fadd t1_s t2_s in let y3_s = S.fsub y3_s t2_s in let y3_s = S.fsub y3_s t0_s in let t1_s = S.fadd y3_s y3_s in fmont_as_nat h1 t1 == t1_s /\ fmont_as_nat h1 t2 == t2_s /\ fmont_as_nat h1 y3 == y3_s))

Hacl.Impl.P256.PointAdd.fst

val point_add_5 (x3 y3 z3 t0 t1 t2:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t0 /\ live h t1 /\ live h t2 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t0; loc t1; loc t2 ] /\ as_nat h y3 < S.prime /\ as_nat h t0 < S.prime /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime) (ensures fun h0 _ h1 -> modifies (loc y3 |+| loc t1 |+| loc t2) h0 h1 /\ as_nat h1 t1 < S.prime /\ as_nat h1 t2 < S.prime /\ as_nat h1 y3 < S.prime /\ (let t0_s = fmont_as_nat h0 t0 in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let y3_s = fmont_as_nat h0 y3 in let t1_s = S.fadd t2_s t2_s in let t2_s = S.fadd t1_s t2_s in let y3_s = S.fsub y3_s t2_s in let y3_s = S.fsub y3_s t0_s in let t1_s = S.fadd y3_s y3_s in fmont_as_nat h1 t1 == t1_s /\ fmont_as_nat h1 t2 == t2_s /\ fmont_as_nat h1 y3 == y3_s))

Hacl.Impl.P256.PointAdd.point_add_5

x3: Hacl.Impl.P256.Bignum.felem -> y3: Hacl.Impl.P256.Bignum.felem -> z3: Hacl.Impl.P256.Bignum.felem -> t0: Hacl.Impl.P256.Bignum.felem -> t1: Hacl.Impl.P256.Bignum.felem -> t2: Hacl.Impl.P256.Bignum.felem -> FStar.HyperStack.ST.Stack Prims.unit

FStar.HyperStack.ST.Stack

val point_add_noalloc: tmp:lbuffer uint64 24ul -> res:point -> p:point -> q:point -> Stack unit (requires fun h -> live h p /\ live h q /\ live h res /\ live h tmp /\ eq_or_disjoint p q /\ disjoint q res /\ disjoint p res /\ disjoint tmp p /\ disjoint tmp q /\ disjoint tmp res /\ point_inv h p /\ point_inv h q) (ensures fun h0 _ h1 -> modifies (loc res |+| loc tmp) h0 h1 /\ point_inv h1 res /\ from_mont_point (as_point_nat h1 res) == S.point_add (from_mont_point (as_point_nat h0 p)) (from_mont_point (as_point_nat h0 q)))

let point_add_noalloc tmp res p q = let x3, y3, z3 = getx res, gety res, getz res in let t0 = sub tmp 0ul 4ul in let t1 = sub tmp 4ul 4ul in let t2 = sub tmp 8ul 4ul in let t3 = sub tmp 12ul 4ul in let t4 = sub tmp 16ul 4ul in let t5 = sub tmp 20ul 4ul in point_add_1 t0 t1 t2 t3 t4 p q; point_add_2 t1 t2 t3 t4 t5 p q; point_add_3 x3 y3 t0 t2 p q; point_add_4 x3 y3 z3 t1 t2; point_add_5 x3 y3 z3 t0 t1 t2; point_add_6 x3 y3 z3 t0 t1 t2 t4; point_add_7 x3 y3 z3 t0 t1 t2 t3 t4

val point_add_noalloc: tmp:lbuffer uint64 24ul -> res:point -> p:point -> q:point -> Stack unit (requires fun h -> live h p /\ live h q /\ live h res /\ live h tmp /\ eq_or_disjoint p q /\ disjoint q res /\ disjoint p res /\ disjoint tmp p /\ disjoint tmp q /\ disjoint tmp res /\ point_inv h p /\ point_inv h q) (ensures fun h0 _ h1 -> modifies (loc res |+| loc tmp) h0 h1 /\ point_inv h1 res /\ from_mont_point (as_point_nat h1 res) == S.point_add (from_mont_point (as_point_nat h0 p)) (from_mont_point (as_point_nat h0 q))) let point_add_noalloc tmp res p q =

let x3, y3, z3 = getx res, gety res, getz res in let t0 = sub tmp 0ul 4ul in let t1 = sub tmp 4ul 4ul in let t2 = sub tmp 8ul 4ul in let t3 = sub tmp 12ul 4ul in let t4 = sub tmp 16ul 4ul in let t5 = sub tmp 20ul 4ul in point_add_1 t0 t1 t2 t3 t4 p q; point_add_2 t1 t2 t3 t4 t5 p q; point_add_3 x3 y3 t0 t2 p q; point_add_4 x3 y3 z3 t1 t2; point_add_5 x3 y3 z3 t0 t1 t2; point_add_6 x3 y3 z3 t0 t1 t2 t4; point_add_7 x3 y3 z3 t0 t1 t2 t3 t4

module Hacl.Impl.P256.PointAdd open FStar.Mul open FStar.HyperStack.All open FStar.HyperStack module ST = FStar.HyperStack.ST open Lib.IntTypes open Lib.Buffer open Hacl.Impl.P256.Bignum open Hacl.Impl.P256.Field module S = Spec.P256 #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract val point_add_1 (t0 t1 t2 t3 t4:felem) (p q:point) : Stack unit (requires fun h -> live h t0 /\ live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [loc t0; loc t1; loc t2; loc t3; loc t4 ] /\ eq_or_disjoint p q /\ disjoint p t0 /\ disjoint p t1 /\ disjoint p t2 /\ disjoint p t3 /\ disjoint p t4 /\ disjoint q t0 /\ disjoint q t1 /\ disjoint q t2 /\ disjoint q t3 /\ disjoint q t4 /\ point_inv h p /\ point_inv h q) (ensures fun h0 _ h1 -> modifies (loc t0 |+| loc t1 |+| loc t2 |+| loc t3 |+| loc t4) h0 h1 /\ as_nat h1 t0 < S.prime /\ as_nat h1 t1 < S.prime /\ as_nat h1 t2 < S.prime /\ as_nat h1 t3 < S.prime /\ as_nat h1 t4 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t0_s = S.fmul x1 x2 in let t1_s = S.fmul y1 y2 in let t2_s = S.fmul z1 z2 in let t3_s = S.fadd x1 y1 in let t4_s = S.fadd x2 y2 in let t3_s = S.fmul t3_s t4_s in let t4_s = S.fadd t0_s t1_s in fmont_as_nat h1 t0 == t0_s /\ fmont_as_nat h1 t1 == t1_s /\ fmont_as_nat h1 t2 == t2_s /\ fmont_as_nat h1 t3 == t3_s /\ fmont_as_nat h1 t4 == t4_s)) let point_add_1 t0 t1 t2 t3 t4 p q = let x1, y1, z1 = getx p, gety p, getz p in let x2, y2, z2 = getx q, gety q, getz q in fmul t0 x1 x2; fmul t1 y1 y2; fmul t2 z1 z2; fadd t3 x1 y1; fadd t4 x2 y2; fmul t3 t3 t4; fadd t4 t0 t1 inline_for_extraction noextract val point_add_2 (t1 t2 t3 t4 t5:felem) (p q:point) : Stack unit (requires fun h -> live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ live h t5 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [ loc t1; loc t2; loc t3; loc t4; loc t5 ] /\ eq_or_disjoint p q /\ disjoint p t1 /\ disjoint p t2 /\ disjoint p t3 /\ disjoint p t4 /\ disjoint p t5 /\ disjoint q t1 /\ disjoint q t2 /\ disjoint q t3 /\ disjoint q t4 /\ disjoint q t5 /\ point_inv h p /\ point_inv h q /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h t3 < S.prime /\ as_nat h t4 < S.prime) (ensures fun h0 _ h1 -> modifies (loc t3 |+| loc t4 |+| loc t5) h0 h1 /\ as_nat h1 t3 < S.prime /\ as_nat h1 t4 < S.prime /\ as_nat h1 t5 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let t3_s = fmont_as_nat h0 t3 in let t4_s = fmont_as_nat h0 t4 in let t3_s = S.fsub t3_s t4_s in let t4_s = S.fadd y1 z1 in let t5_s = S.fadd y2 z2 in let t4_s = S.fmul t4_s t5_s in let t5_s = S.fadd t1_s t2_s in let t4_s = S.fsub t4_s t5_s in fmont_as_nat h1 t3 == t3_s /\ fmont_as_nat h1 t4 == t4_s /\ fmont_as_nat h1 t5 == t5_s)) let point_add_2 t1 t2 t3 t4 t5 p q = let y1, z1 = gety p, getz p in let y2, z2 = gety q, getz q in fsub t3 t3 t4; fadd t4 y1 z1; fadd t5 y2 z2; fmul t4 t4 t5; fadd t5 t1 t2; fsub t4 t4 t5 inline_for_extraction noextract val point_add_3 (x3 y3 t0 t2:felem) (p q:point) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h t0 /\ live h t2 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc t0; loc t2 ] /\ eq_or_disjoint p q /\ disjoint p x3 /\ disjoint p y3 /\ disjoint p t0 /\ disjoint p t2 /\ disjoint q x3 /\ disjoint q y3 /\ disjoint q t0 /\ disjoint q t2 /\ point_inv h p /\ point_inv h q /\ as_nat h t0 < S.prime /\ as_nat h t2 < S.prime) (ensures fun h0 _ h1 -> modifies (loc x3 |+| loc y3) h0 h1 /\ as_nat h1 x3 < S.prime /\ as_nat h1 y3 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t0_s = fmont_as_nat h0 t0 in let t2_s = fmont_as_nat h0 t2 in let x3_s = S.fadd x1 z1 in let y3_s = S.fadd x2 z2 in let x3_s = S.fmul x3_s y3_s in let y3_s = S.fadd t0_s t2_s in let y3_s = S.fsub x3_s y3_s in fmont_as_nat h1 x3 == x3_s /\ fmont_as_nat h1 y3 == y3_s)) let point_add_3 x3 y3 t0 t2 p q = let x1, z1 = getx p, getz p in let x2, z2 = getx q, getz q in fadd x3 x1 z1; fadd y3 x2 z2; fmul x3 x3 y3; fadd y3 t0 t2; fsub y3 x3 y3 inline_for_extraction noextract val point_add_4 (x3 y3 z3 t1 t2:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t1 /\ live h t2 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t1; loc t2 ] /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h y3 < S.prime) (ensures fun h0 _ h1 -> modifies (loc x3 |+| loc y3 |+| loc z3) h0 h1 /\ as_nat h1 x3 < S.prime /\ as_nat h1 y3 < S.prime /\ as_nat h1 z3 < S.prime /\ (let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let y3_s = fmont_as_nat h0 y3 in let z3_s = S.fmul S.b_coeff t2_s in let x3_s = S.fsub y3_s z3_s in let z3_s = S.fadd x3_s x3_s in let x3_s = S.fadd x3_s z3_s in let z3_s = S.fsub t1_s x3_s in let x3_s = S.fadd t1_s x3_s in let y3_s = S.fmul S.b_coeff y3_s in fmont_as_nat h1 x3 == x3_s /\ fmont_as_nat h1 y3 == y3_s /\ fmont_as_nat h1 z3 == z3_s)) let point_add_4 x3 y3 z3 t1 t2 = fmul_by_b_coeff z3 t2; fsub x3 y3 z3; fdouble z3 x3; fadd x3 x3 z3; fsub z3 t1 x3; fadd x3 t1 x3; fmul_by_b_coeff y3 y3 inline_for_extraction noextract val point_add_5 (x3 y3 z3 t0 t1 t2:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t0 /\ live h t1 /\ live h t2 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t0; loc t1; loc t2 ] /\ as_nat h y3 < S.prime /\ as_nat h t0 < S.prime /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime) (ensures fun h0 _ h1 -> modifies (loc y3 |+| loc t1 |+| loc t2) h0 h1 /\ as_nat h1 t1 < S.prime /\ as_nat h1 t2 < S.prime /\ as_nat h1 y3 < S.prime /\ (let t0_s = fmont_as_nat h0 t0 in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let y3_s = fmont_as_nat h0 y3 in let t1_s = S.fadd t2_s t2_s in let t2_s = S.fadd t1_s t2_s in let y3_s = S.fsub y3_s t2_s in let y3_s = S.fsub y3_s t0_s in let t1_s = S.fadd y3_s y3_s in fmont_as_nat h1 t1 == t1_s /\ fmont_as_nat h1 t2 == t2_s /\ fmont_as_nat h1 y3 == y3_s)) let point_add_5 x3 y3 z3 t0 t1 t2 = fdouble t1 t2; fadd t2 t1 t2; fsub y3 y3 t2; fsub y3 y3 t0; fdouble t1 y3 inline_for_extraction noextract val point_add_6 (x3 y3 z3 t0 t1 t2 t4:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t0 /\ live h t1 /\ live h t2 /\ live h t4 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t0; loc t1; loc t2; loc t4 ] /\ as_nat h y3 < S.prime /\ as_nat h t0 < S.prime /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h t4 < S.prime) (ensures fun h0 _ h1 -> modifies (loc y3 |+| loc t0 |+| loc t1 |+| loc t2) h0 h1 /\ as_nat h1 t0 < S.prime /\ as_nat h1 t1 < S.prime /\ as_nat h1 t2 < S.prime /\ as_nat h1 y3 < S.prime /\ (let t0_s = fmont_as_nat h0 t0 in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let t4_s = fmont_as_nat h0 t4 in let y3_s = fmont_as_nat h0 y3 in let y3_s = S.fadd t1_s y3_s in let t1_s = S.fadd t0_s t0_s in let t0_s = S.fadd t1_s t0_s in let t0_s = S.fsub t0_s t2_s in let t1_s = S.fmul t4_s y3_s in let t2_s = S.fmul t0_s y3_s in fmont_as_nat h1 t0 == t0_s /\ fmont_as_nat h1 t1 == t1_s /\ fmont_as_nat h1 t2 == t2_s /\ fmont_as_nat h1 y3 == y3_s)) let point_add_6 x3 y3 z3 t0 t1 t2 t4 = fadd y3 t1 y3; fdouble t1 t0; fadd t0 t1 t0; fsub t0 t0 t2; fmul t1 t4 y3; fmul t2 t0 y3 inline_for_extraction noextract val point_add_7 (x3 y3 z3 t0 t1 t2 t3 t4:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t0 /\ live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t0; loc t1; loc t2; loc t3; loc t4 ] /\ as_nat h x3 < S.prime /\ as_nat h z3 < S.prime /\ as_nat h t0 < S.prime /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h t3 < S.prime /\ as_nat h t4 < S.prime) (ensures fun h0 _ h1 -> modifies (loc x3 |+| loc y3 |+| loc z3 |+| loc t1) h0 h1 /\ as_nat h1 x3 < S.prime /\ as_nat h1 y3 < S.prime /\ as_nat h1 z3 < S.prime /\ as_nat h1 t1 < S.prime /\ (let x3_s = fmont_as_nat h0 x3 in let z3_s = fmont_as_nat h0 z3 in let t0_s = fmont_as_nat h0 t0 in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let t3_s = fmont_as_nat h0 t3 in let t4_s = fmont_as_nat h0 t4 in let y3_s = S.fmul x3_s z3_s in let y3_s = S.fadd y3_s t2_s in let x3_s = S.fmul t3_s x3_s in let x3_s = S.fsub x3_s t1_s in let z3_s = S.fmul t4_s z3_s in let t1_s = S.fmul t3_s t0_s in let z3_s = S.fadd z3_s t1_s in fmont_as_nat h1 x3 == x3_s /\ fmont_as_nat h1 y3 == y3_s /\ fmont_as_nat h1 z3 == z3_s /\ fmont_as_nat h1 t1 == t1_s)) let point_add_7 x3 y3 z3 t0 t1 t2 t3 t4 = fmul y3 x3 z3; fadd y3 y3 t2; fmul x3 t3 x3; fsub x3 x3 t1; fmul z3 t4 z3; fmul t1 t3 t0; fadd z3 z3 t1 inline_for_extraction noextract val point_add_noalloc: tmp:lbuffer uint64 24ul -> res:point -> p:point -> q:point -> Stack unit (requires fun h -> live h p /\ live h q /\ live h res /\ live h tmp /\ eq_or_disjoint p q /\ disjoint q res /\ disjoint p res /\ disjoint tmp p /\ disjoint tmp q /\ disjoint tmp res /\ point_inv h p /\ point_inv h q) (ensures fun h0 _ h1 -> modifies (loc res |+| loc tmp) h0 h1 /\ point_inv h1 res /\ from_mont_point (as_point_nat h1 res) == S.point_add (from_mont_point (as_point_nat h0 p)) (from_mont_point (as_point_nat h0 q)))

Hacl.Impl.P256.PointAdd.fst

val point_add_noalloc: tmp:lbuffer uint64 24ul -> res:point -> p:point -> q:point -> Stack unit (requires fun h -> live h p /\ live h q /\ live h res /\ live h tmp /\ eq_or_disjoint p q /\ disjoint q res /\ disjoint p res /\ disjoint tmp p /\ disjoint tmp q /\ disjoint tmp res /\ point_inv h p /\ point_inv h q) (ensures fun h0 _ h1 -> modifies (loc res |+| loc tmp) h0 h1 /\ point_inv h1 res /\ from_mont_point (as_point_nat h1 res) == S.point_add (from_mont_point (as_point_nat h0 p)) (from_mont_point (as_point_nat h0 q)))

Hacl.Impl.P256.PointAdd.point_add_noalloc

tmp: Lib.Buffer.lbuffer Lib.IntTypes.uint64 24ul -> res: Hacl.Impl.P256.Point.point -> p: Hacl.Impl.P256.Point.point -> q: Hacl.Impl.P256.Point.point -> FStar.HyperStack.ST.Stack Prims.unit

FStar.HyperStack.ST.Stack

val point_add: res:point -> p:point -> q:point -> Stack unit (requires fun h -> live h p /\ live h q /\ live h res /\ eq_or_disjoint p q /\ eq_or_disjoint q res /\ eq_or_disjoint p res /\ point_inv h p /\ point_inv h q) (ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\ point_inv h1 res /\ from_mont_point (as_point_nat h1 res) == S.point_add (from_mont_point (as_point_nat h0 p)) (from_mont_point (as_point_nat h0 q)))

let point_add res p q = push_frame (); let tmp = create 36ul (u64 0) in let t0 = sub tmp 0ul 24ul in let t1 = sub tmp 24ul 12ul in point_add_noalloc t0 t1 p q; copy res t1; pop_frame ()

val point_add: res:point -> p:point -> q:point -> Stack unit (requires fun h -> live h p /\ live h q /\ live h res /\ eq_or_disjoint p q /\ eq_or_disjoint q res /\ eq_or_disjoint p res /\ point_inv h p /\ point_inv h q) (ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\ point_inv h1 res /\ from_mont_point (as_point_nat h1 res) == S.point_add (from_mont_point (as_point_nat h0 p)) (from_mont_point (as_point_nat h0 q))) let point_add res p q =

push_frame (); let tmp = create 36ul (u64 0) in let t0 = sub tmp 0ul 24ul in let t1 = sub tmp 24ul 12ul in point_add_noalloc t0 t1 p q; copy res t1; pop_frame ()

module Hacl.Impl.P256.PointAdd open FStar.Mul open FStar.HyperStack.All open FStar.HyperStack module ST = FStar.HyperStack.ST open Lib.IntTypes open Lib.Buffer open Hacl.Impl.P256.Bignum open Hacl.Impl.P256.Field module S = Spec.P256 #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract val point_add_1 (t0 t1 t2 t3 t4:felem) (p q:point) : Stack unit (requires fun h -> live h t0 /\ live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [loc t0; loc t1; loc t2; loc t3; loc t4 ] /\ eq_or_disjoint p q /\ disjoint p t0 /\ disjoint p t1 /\ disjoint p t2 /\ disjoint p t3 /\ disjoint p t4 /\ disjoint q t0 /\ disjoint q t1 /\ disjoint q t2 /\ disjoint q t3 /\ disjoint q t4 /\ point_inv h p /\ point_inv h q) (ensures fun h0 _ h1 -> modifies (loc t0 |+| loc t1 |+| loc t2 |+| loc t3 |+| loc t4) h0 h1 /\ as_nat h1 t0 < S.prime /\ as_nat h1 t1 < S.prime /\ as_nat h1 t2 < S.prime /\ as_nat h1 t3 < S.prime /\ as_nat h1 t4 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t0_s = S.fmul x1 x2 in let t1_s = S.fmul y1 y2 in let t2_s = S.fmul z1 z2 in let t3_s = S.fadd x1 y1 in let t4_s = S.fadd x2 y2 in let t3_s = S.fmul t3_s t4_s in let t4_s = S.fadd t0_s t1_s in fmont_as_nat h1 t0 == t0_s /\ fmont_as_nat h1 t1 == t1_s /\ fmont_as_nat h1 t2 == t2_s /\ fmont_as_nat h1 t3 == t3_s /\ fmont_as_nat h1 t4 == t4_s)) let point_add_1 t0 t1 t2 t3 t4 p q = let x1, y1, z1 = getx p, gety p, getz p in let x2, y2, z2 = getx q, gety q, getz q in fmul t0 x1 x2; fmul t1 y1 y2; fmul t2 z1 z2; fadd t3 x1 y1; fadd t4 x2 y2; fmul t3 t3 t4; fadd t4 t0 t1 inline_for_extraction noextract val point_add_2 (t1 t2 t3 t4 t5:felem) (p q:point) : Stack unit (requires fun h -> live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ live h t5 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [ loc t1; loc t2; loc t3; loc t4; loc t5 ] /\ eq_or_disjoint p q /\ disjoint p t1 /\ disjoint p t2 /\ disjoint p t3 /\ disjoint p t4 /\ disjoint p t5 /\ disjoint q t1 /\ disjoint q t2 /\ disjoint q t3 /\ disjoint q t4 /\ disjoint q t5 /\ point_inv h p /\ point_inv h q /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h t3 < S.prime /\ as_nat h t4 < S.prime) (ensures fun h0 _ h1 -> modifies (loc t3 |+| loc t4 |+| loc t5) h0 h1 /\ as_nat h1 t3 < S.prime /\ as_nat h1 t4 < S.prime /\ as_nat h1 t5 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let t3_s = fmont_as_nat h0 t3 in let t4_s = fmont_as_nat h0 t4 in let t3_s = S.fsub t3_s t4_s in let t4_s = S.fadd y1 z1 in let t5_s = S.fadd y2 z2 in let t4_s = S.fmul t4_s t5_s in let t5_s = S.fadd t1_s t2_s in let t4_s = S.fsub t4_s t5_s in fmont_as_nat h1 t3 == t3_s /\ fmont_as_nat h1 t4 == t4_s /\ fmont_as_nat h1 t5 == t5_s)) let point_add_2 t1 t2 t3 t4 t5 p q = let y1, z1 = gety p, getz p in let y2, z2 = gety q, getz q in fsub t3 t3 t4; fadd t4 y1 z1; fadd t5 y2 z2; fmul t4 t4 t5; fadd t5 t1 t2; fsub t4 t4 t5 inline_for_extraction noextract val point_add_3 (x3 y3 t0 t2:felem) (p q:point) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h t0 /\ live h t2 /\ live h p /\ live h q /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc t0; loc t2 ] /\ eq_or_disjoint p q /\ disjoint p x3 /\ disjoint p y3 /\ disjoint p t0 /\ disjoint p t2 /\ disjoint q x3 /\ disjoint q y3 /\ disjoint q t0 /\ disjoint q t2 /\ point_inv h p /\ point_inv h q /\ as_nat h t0 < S.prime /\ as_nat h t2 < S.prime) (ensures fun h0 _ h1 -> modifies (loc x3 |+| loc y3) h0 h1 /\ as_nat h1 x3 < S.prime /\ as_nat h1 y3 < S.prime /\ (let x1, y1, z1 = from_mont_point (as_point_nat h0 p) in let x2, y2, z2 = from_mont_point (as_point_nat h0 q) in let t0_s = fmont_as_nat h0 t0 in let t2_s = fmont_as_nat h0 t2 in let x3_s = S.fadd x1 z1 in let y3_s = S.fadd x2 z2 in let x3_s = S.fmul x3_s y3_s in let y3_s = S.fadd t0_s t2_s in let y3_s = S.fsub x3_s y3_s in fmont_as_nat h1 x3 == x3_s /\ fmont_as_nat h1 y3 == y3_s)) let point_add_3 x3 y3 t0 t2 p q = let x1, z1 = getx p, getz p in let x2, z2 = getx q, getz q in fadd x3 x1 z1; fadd y3 x2 z2; fmul x3 x3 y3; fadd y3 t0 t2; fsub y3 x3 y3 inline_for_extraction noextract val point_add_4 (x3 y3 z3 t1 t2:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t1 /\ live h t2 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t1; loc t2 ] /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h y3 < S.prime) (ensures fun h0 _ h1 -> modifies (loc x3 |+| loc y3 |+| loc z3) h0 h1 /\ as_nat h1 x3 < S.prime /\ as_nat h1 y3 < S.prime /\ as_nat h1 z3 < S.prime /\ (let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let y3_s = fmont_as_nat h0 y3 in let z3_s = S.fmul S.b_coeff t2_s in let x3_s = S.fsub y3_s z3_s in let z3_s = S.fadd x3_s x3_s in let x3_s = S.fadd x3_s z3_s in let z3_s = S.fsub t1_s x3_s in let x3_s = S.fadd t1_s x3_s in let y3_s = S.fmul S.b_coeff y3_s in fmont_as_nat h1 x3 == x3_s /\ fmont_as_nat h1 y3 == y3_s /\ fmont_as_nat h1 z3 == z3_s)) let point_add_4 x3 y3 z3 t1 t2 = fmul_by_b_coeff z3 t2; fsub x3 y3 z3; fdouble z3 x3; fadd x3 x3 z3; fsub z3 t1 x3; fadd x3 t1 x3; fmul_by_b_coeff y3 y3 inline_for_extraction noextract val point_add_5 (x3 y3 z3 t0 t1 t2:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t0 /\ live h t1 /\ live h t2 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t0; loc t1; loc t2 ] /\ as_nat h y3 < S.prime /\ as_nat h t0 < S.prime /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime) (ensures fun h0 _ h1 -> modifies (loc y3 |+| loc t1 |+| loc t2) h0 h1 /\ as_nat h1 t1 < S.prime /\ as_nat h1 t2 < S.prime /\ as_nat h1 y3 < S.prime /\ (let t0_s = fmont_as_nat h0 t0 in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let y3_s = fmont_as_nat h0 y3 in let t1_s = S.fadd t2_s t2_s in let t2_s = S.fadd t1_s t2_s in let y3_s = S.fsub y3_s t2_s in let y3_s = S.fsub y3_s t0_s in let t1_s = S.fadd y3_s y3_s in fmont_as_nat h1 t1 == t1_s /\ fmont_as_nat h1 t2 == t2_s /\ fmont_as_nat h1 y3 == y3_s)) let point_add_5 x3 y3 z3 t0 t1 t2 = fdouble t1 t2; fadd t2 t1 t2; fsub y3 y3 t2; fsub y3 y3 t0; fdouble t1 y3 inline_for_extraction noextract val point_add_6 (x3 y3 z3 t0 t1 t2 t4:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t0 /\ live h t1 /\ live h t2 /\ live h t4 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t0; loc t1; loc t2; loc t4 ] /\ as_nat h y3 < S.prime /\ as_nat h t0 < S.prime /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h t4 < S.prime) (ensures fun h0 _ h1 -> modifies (loc y3 |+| loc t0 |+| loc t1 |+| loc t2) h0 h1 /\ as_nat h1 t0 < S.prime /\ as_nat h1 t1 < S.prime /\ as_nat h1 t2 < S.prime /\ as_nat h1 y3 < S.prime /\ (let t0_s = fmont_as_nat h0 t0 in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let t4_s = fmont_as_nat h0 t4 in let y3_s = fmont_as_nat h0 y3 in let y3_s = S.fadd t1_s y3_s in let t1_s = S.fadd t0_s t0_s in let t0_s = S.fadd t1_s t0_s in let t0_s = S.fsub t0_s t2_s in let t1_s = S.fmul t4_s y3_s in let t2_s = S.fmul t0_s y3_s in fmont_as_nat h1 t0 == t0_s /\ fmont_as_nat h1 t1 == t1_s /\ fmont_as_nat h1 t2 == t2_s /\ fmont_as_nat h1 y3 == y3_s)) let point_add_6 x3 y3 z3 t0 t1 t2 t4 = fadd y3 t1 y3; fdouble t1 t0; fadd t0 t1 t0; fsub t0 t0 t2; fmul t1 t4 y3; fmul t2 t0 y3 inline_for_extraction noextract val point_add_7 (x3 y3 z3 t0 t1 t2 t3 t4:felem) : Stack unit (requires fun h -> live h x3 /\ live h y3 /\ live h z3 /\ live h t0 /\ live h t1 /\ live h t2 /\ live h t3 /\ live h t4 /\ LowStar.Monotonic.Buffer.all_disjoint [ loc x3; loc y3; loc z3; loc t0; loc t1; loc t2; loc t3; loc t4 ] /\ as_nat h x3 < S.prime /\ as_nat h z3 < S.prime /\ as_nat h t0 < S.prime /\ as_nat h t1 < S.prime /\ as_nat h t2 < S.prime /\ as_nat h t3 < S.prime /\ as_nat h t4 < S.prime) (ensures fun h0 _ h1 -> modifies (loc x3 |+| loc y3 |+| loc z3 |+| loc t1) h0 h1 /\ as_nat h1 x3 < S.prime /\ as_nat h1 y3 < S.prime /\ as_nat h1 z3 < S.prime /\ as_nat h1 t1 < S.prime /\ (let x3_s = fmont_as_nat h0 x3 in let z3_s = fmont_as_nat h0 z3 in let t0_s = fmont_as_nat h0 t0 in let t1_s = fmont_as_nat h0 t1 in let t2_s = fmont_as_nat h0 t2 in let t3_s = fmont_as_nat h0 t3 in let t4_s = fmont_as_nat h0 t4 in let y3_s = S.fmul x3_s z3_s in let y3_s = S.fadd y3_s t2_s in let x3_s = S.fmul t3_s x3_s in let x3_s = S.fsub x3_s t1_s in let z3_s = S.fmul t4_s z3_s in let t1_s = S.fmul t3_s t0_s in let z3_s = S.fadd z3_s t1_s in fmont_as_nat h1 x3 == x3_s /\ fmont_as_nat h1 y3 == y3_s /\ fmont_as_nat h1 z3 == z3_s /\ fmont_as_nat h1 t1 == t1_s)) let point_add_7 x3 y3 z3 t0 t1 t2 t3 t4 = fmul y3 x3 z3; fadd y3 y3 t2; fmul x3 t3 x3; fsub x3 x3 t1; fmul z3 t4 z3; fmul t1 t3 t0; fadd z3 z3 t1 inline_for_extraction noextract val point_add_noalloc: tmp:lbuffer uint64 24ul -> res:point -> p:point -> q:point -> Stack unit (requires fun h -> live h p /\ live h q /\ live h res /\ live h tmp /\ eq_or_disjoint p q /\ disjoint q res /\ disjoint p res /\ disjoint tmp p /\ disjoint tmp q /\ disjoint tmp res /\ point_inv h p /\ point_inv h q) (ensures fun h0 _ h1 -> modifies (loc res |+| loc tmp) h0 h1 /\ point_inv h1 res /\ from_mont_point (as_point_nat h1 res) == S.point_add (from_mont_point (as_point_nat h0 p)) (from_mont_point (as_point_nat h0 q))) let point_add_noalloc tmp res p q = let x3, y3, z3 = getx res, gety res, getz res in let t0 = sub tmp 0ul 4ul in let t1 = sub tmp 4ul 4ul in let t2 = sub tmp 8ul 4ul in let t3 = sub tmp 12ul 4ul in let t4 = sub tmp 16ul 4ul in let t5 = sub tmp 20ul 4ul in point_add_1 t0 t1 t2 t3 t4 p q; point_add_2 t1 t2 t3 t4 t5 p q; point_add_3 x3 y3 t0 t2 p q; point_add_4 x3 y3 z3 t1 t2; point_add_5 x3 y3 z3 t0 t1 t2; point_add_6 x3 y3 z3 t0 t1 t2 t4; point_add_7 x3 y3 z3 t0 t1 t2 t3 t4 [@CInline]

Hacl.Impl.P256.PointAdd.fst

val point_add: res:point -> p:point -> q:point -> Stack unit (requires fun h -> live h p /\ live h q /\ live h res /\ eq_or_disjoint p q /\ eq_or_disjoint q res /\ eq_or_disjoint p res /\ point_inv h p /\ point_inv h q) (ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\ point_inv h1 res /\ from_mont_point (as_point_nat h1 res) == S.point_add (from_mont_point (as_point_nat h0 p)) (from_mont_point (as_point_nat h0 q)))

Hacl.Impl.P256.PointAdd.point_add

res: Hacl.Impl.P256.Point.point -> p: Hacl.Impl.P256.Point.point -> q: Hacl.Impl.P256.Point.point -> FStar.HyperStack.ST.Stack Prims.unit

Prims.Tot

let msg_len_t (a:Hash.fixed_len_alg) = msgLen:size_t{v msgLen `less_than_max_input_length` a}

let msg_len_t (a: Hash.fixed_len_alg) =

msgLen: size_t{(v msgLen) `less_than_max_input_length` a}

module Hacl.Impl.RSAPSS.Padding open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer open Hacl.Impl.RSAPSS.MGF module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module Hash = Spec.Agile.Hash module S = Spec.RSAPSS module BD = Hacl.Bignum.Definitions #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length inline_for_extraction noextract let salt_len_t (a:Hash.fixed_len_alg) = saltLen:size_t{8 + Hash.hash_length a + v saltLen <= max_size_t /\ (8 + Hash.hash_length a + v saltLen) `less_than_max_input_length` a} inline_for_extraction noextract

Hacl.Impl.RSAPSS.Padding.fst

val msg_len_t : a: Spec.Hash.Definitions.fixed_len_alg -> Type0

Hacl.Impl.RSAPSS.Padding.msg_len_t

a: Spec.Hash.Definitions.fixed_len_alg -> Type0

Prims.Tot

let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length

let less_than_max_input_length =

Spec.Hash.Definitions.less_than_max_input_length

module Hacl.Impl.RSAPSS.Padding open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer open Hacl.Impl.RSAPSS.MGF module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module Hash = Spec.Agile.Hash module S = Spec.RSAPSS module BD = Hacl.Bignum.Definitions #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"

Hacl.Impl.RSAPSS.Padding.fst

val less_than_max_input_length : l: Prims.int -> a: Spec.Hash.Definitions.hash_alg -> Prims.bool

Hacl.Impl.RSAPSS.Padding.less_than_max_input_length

l: Prims.int -> a: Spec.Hash.Definitions.hash_alg -> Prims.bool

Prims.Tot

let salt_len_t (a:Hash.fixed_len_alg) = saltLen:size_t{8 + Hash.hash_length a + v saltLen <= max_size_t /\ (8 + Hash.hash_length a + v saltLen) `less_than_max_input_length` a}

let salt_len_t (a: Hash.fixed_len_alg) =

saltLen: size_t { 8 + Hash.hash_length a + v saltLen <= max_size_t /\ (8 + Hash.hash_length a + v saltLen) `less_than_max_input_length` a }

module Hacl.Impl.RSAPSS.Padding open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer open Hacl.Impl.RSAPSS.MGF module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module Hash = Spec.Agile.Hash module S = Spec.RSAPSS module BD = Hacl.Bignum.Definitions #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length inline_for_extraction noextract

Hacl.Impl.RSAPSS.Padding.fst

val salt_len_t : a: Spec.Hash.Definitions.fixed_len_alg -> Type0

Hacl.Impl.RSAPSS.Padding.salt_len_t

a: Spec.Hash.Definitions.fixed_len_alg -> Type0

Prims.Tot

let em_len_t (a:Hash.fixed_len_alg) (saltLen:salt_len_t a) = emBits:size_t{0 < v emBits /\ Hash.hash_length a + v saltLen + 2 <= S.blocks (v emBits) 8}

let em_len_t (a: Hash.fixed_len_alg) (saltLen: salt_len_t a) =

emBits: size_t{0 < v emBits /\ Hash.hash_length a + v saltLen + 2 <= S.blocks (v emBits) 8}

module Hacl.Impl.RSAPSS.Padding open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer open Hacl.Impl.RSAPSS.MGF module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module Hash = Spec.Agile.Hash module S = Spec.RSAPSS module BD = Hacl.Bignum.Definitions #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length inline_for_extraction noextract let salt_len_t (a:Hash.fixed_len_alg) = saltLen:size_t{8 + Hash.hash_length a + v saltLen <= max_size_t /\ (8 + Hash.hash_length a + v saltLen) `less_than_max_input_length` a} inline_for_extraction noextract let msg_len_t (a:Hash.fixed_len_alg) = msgLen:size_t{v msgLen `less_than_max_input_length` a} inline_for_extraction noextract

Hacl.Impl.RSAPSS.Padding.fst

val em_len_t : a: Spec.Hash.Definitions.fixed_len_alg -> saltLen: Hacl.Impl.RSAPSS.Padding.salt_len_t a -> Type0

Hacl.Impl.RSAPSS.Padding.em_len_t

a: Spec.Hash.Definitions.fixed_len_alg -> saltLen: Hacl.Impl.RSAPSS.Padding.salt_len_t a -> Type0

FStar.HyperStack.ST.Stack

val xor_bytes: len:size_t{v len > 0} -> b1:lbuffer uint8 len -> b2:lbuffer uint8 len -> Stack unit (requires fun h -> live h b1 /\ live h b2 /\ disjoint b1 b2) (ensures fun h0 _ h1 -> modifies (loc b1) h0 h1 /\ as_seq h1 b1 == S.xor_bytes (as_seq h0 b1) (as_seq h0 b2))

let xor_bytes len b1 b2 = map2T len b1 (fun x y -> x ^. y) b1 b2

val xor_bytes: len:size_t{v len > 0} -> b1:lbuffer uint8 len -> b2:lbuffer uint8 len -> Stack unit (requires fun h -> live h b1 /\ live h b2 /\ disjoint b1 b2) (ensures fun h0 _ h1 -> modifies (loc b1) h0 h1 /\ as_seq h1 b1 == S.xor_bytes (as_seq h0 b1) (as_seq h0 b2)) let xor_bytes len b1 b2 =

map2T len b1 (fun x y -> x ^. y) b1 b2

module Hacl.Impl.RSAPSS.Padding open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer open Hacl.Impl.RSAPSS.MGF module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module Hash = Spec.Agile.Hash module S = Spec.RSAPSS module BD = Hacl.Bignum.Definitions #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length inline_for_extraction noextract let salt_len_t (a:Hash.fixed_len_alg) = saltLen:size_t{8 + Hash.hash_length a + v saltLen <= max_size_t /\ (8 + Hash.hash_length a + v saltLen) `less_than_max_input_length` a} inline_for_extraction noextract let msg_len_t (a:Hash.fixed_len_alg) = msgLen:size_t{v msgLen `less_than_max_input_length` a} inline_for_extraction noextract let em_len_t (a:Hash.fixed_len_alg) (saltLen:salt_len_t a) = emBits:size_t{0 < v emBits /\ Hash.hash_length a + v saltLen + 2 <= S.blocks (v emBits) 8} inline_for_extraction noextract val xor_bytes: len:size_t{v len > 0} -> b1:lbuffer uint8 len -> b2:lbuffer uint8 len -> Stack unit (requires fun h -> live h b1 /\ live h b2 /\ disjoint b1 b2) (ensures fun h0 _ h1 -> modifies (loc b1) h0 h1 /\ as_seq h1 b1 == S.xor_bytes (as_seq h0 b1) (as_seq h0 b2))

Hacl.Impl.RSAPSS.Padding.fst

val xor_bytes: len:size_t{v len > 0} -> b1:lbuffer uint8 len -> b2:lbuffer uint8 len -> Stack unit (requires fun h -> live h b1 /\ live h b2 /\ disjoint b1 b2) (ensures fun h0 _ h1 -> modifies (loc b1) h0 h1 /\ as_seq h1 b1 == S.xor_bytes (as_seq h0 b1) (as_seq h0 b2))

Hacl.Impl.RSAPSS.Padding.xor_bytes

len: Lib.IntTypes.size_t{Lib.IntTypes.v len > 0} -> b1: Lib.Buffer.lbuffer Lib.IntTypes.uint8 len -> b2: Lib.Buffer.lbuffer Lib.IntTypes.uint8 len -> FStar.HyperStack.ST.Stack Prims.unit

FStar.HyperStack.ST.Stack

val db_zero: len:size_t{v len > 0} -> db:lbuffer uint8 len -> emBits:size_t -> Stack unit (requires fun h -> live h db) (ensures fun h0 _ h1 -> modifies (loc db) h0 h1 /\ as_seq h1 db == S.db_zero #(v len) (as_seq h0 db) (v emBits))

let db_zero len db emBits = let msBits = emBits %. 8ul in if msBits >. 0ul then db.(0ul) <- db.(0ul) &. (u8 0xff >>. (8ul -. msBits))

val db_zero: len:size_t{v len > 0} -> db:lbuffer uint8 len -> emBits:size_t -> Stack unit (requires fun h -> live h db) (ensures fun h0 _ h1 -> modifies (loc db) h0 h1 /\ as_seq h1 db == S.db_zero #(v len) (as_seq h0 db) (v emBits)) let db_zero len db emBits =

let msBits = emBits %. 8ul in if msBits >. 0ul then db.(0ul) <- db.(0ul) &. (u8 0xff >>. (8ul -. msBits))

module Hacl.Impl.RSAPSS.Padding open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer open Hacl.Impl.RSAPSS.MGF module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module Hash = Spec.Agile.Hash module S = Spec.RSAPSS module BD = Hacl.Bignum.Definitions #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length inline_for_extraction noextract let salt_len_t (a:Hash.fixed_len_alg) = saltLen:size_t{8 + Hash.hash_length a + v saltLen <= max_size_t /\ (8 + Hash.hash_length a + v saltLen) `less_than_max_input_length` a} inline_for_extraction noextract let msg_len_t (a:Hash.fixed_len_alg) = msgLen:size_t{v msgLen `less_than_max_input_length` a} inline_for_extraction noextract let em_len_t (a:Hash.fixed_len_alg) (saltLen:salt_len_t a) = emBits:size_t{0 < v emBits /\ Hash.hash_length a + v saltLen + 2 <= S.blocks (v emBits) 8} inline_for_extraction noextract val xor_bytes: len:size_t{v len > 0} -> b1:lbuffer uint8 len -> b2:lbuffer uint8 len -> Stack unit (requires fun h -> live h b1 /\ live h b2 /\ disjoint b1 b2) (ensures fun h0 _ h1 -> modifies (loc b1) h0 h1 /\ as_seq h1 b1 == S.xor_bytes (as_seq h0 b1) (as_seq h0 b2)) let xor_bytes len b1 b2 = map2T len b1 (fun x y -> x ^. y) b1 b2 inline_for_extraction noextract val db_zero: len:size_t{v len > 0} -> db:lbuffer uint8 len -> emBits:size_t -> Stack unit (requires fun h -> live h db) (ensures fun h0 _ h1 -> modifies (loc db) h0 h1 /\ as_seq h1 db == S.db_zero #(v len) (as_seq h0 db) (v emBits))

Hacl.Impl.RSAPSS.Padding.fst

val db_zero: len:size_t{v len > 0} -> db:lbuffer uint8 len -> emBits:size_t -> Stack unit (requires fun h -> live h db) (ensures fun h0 _ h1 -> modifies (loc db) h0 h1 /\ as_seq h1 db == S.db_zero #(v len) (as_seq h0 db) (v emBits))

Hacl.Impl.RSAPSS.Padding.db_zero

len: Lib.IntTypes.size_t{Lib.IntTypes.v len > 0} -> db: Lib.Buffer.lbuffer Lib.IntTypes.uint8 len -> emBits: Lib.IntTypes.size_t -> FStar.HyperStack.ST.Stack Prims.unit

FStar.HyperStack.ST.Stack

val get_m1Hash: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> salt:lbuffer uint8 saltLen -> msgLen:msg_len_t a -> msg:lbuffer uint8 msgLen -> hLen:size_t{v hLen == Hash.hash_length a} -> m1Hash:lbuffer uint8 hLen -> Stack unit (requires fun h -> live h salt /\ live h msg /\ live h m1Hash /\ disjoint msg salt /\ disjoint m1Hash msg /\ disjoint m1Hash salt) (ensures fun h0 _ h1 -> modifies (loc m1Hash) h0 h1 /\ (let mHash = Hash.hash a (as_seq h0 msg) in let m1Len = 8 + Hash.hash_length a + v saltLen in let m1 = LSeq.create m1Len (u8 0) in let m1 = LSeq.update_sub m1 8 (Hash.hash_length a) mHash in let m1 = LSeq.update_sub m1 (8 + Hash.hash_length a) (v saltLen) (as_seq h0 salt) in as_seq h1 m1Hash == Hash.hash a m1))

let get_m1Hash a saltLen salt msgLen msg hLen m1Hash = push_frame (); //m1 = [8 * 0x00; mHash; salt] let m1Len = 8ul +! hLen +! saltLen in let m1 = create m1Len (u8 0) in let h0 = ST.get () in update_sub_f h0 m1 8ul hLen (fun h -> Hash.hash a (as_seq h0 msg)) (fun _ -> hash a (sub m1 8ul hLen) msgLen msg); update_sub m1 (8ul +! hLen) saltLen salt; hash a m1Hash m1Len m1; pop_frame()

val get_m1Hash: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> salt:lbuffer uint8 saltLen -> msgLen:msg_len_t a -> msg:lbuffer uint8 msgLen -> hLen:size_t{v hLen == Hash.hash_length a} -> m1Hash:lbuffer uint8 hLen -> Stack unit (requires fun h -> live h salt /\ live h msg /\ live h m1Hash /\ disjoint msg salt /\ disjoint m1Hash msg /\ disjoint m1Hash salt) (ensures fun h0 _ h1 -> modifies (loc m1Hash) h0 h1 /\ (let mHash = Hash.hash a (as_seq h0 msg) in let m1Len = 8 + Hash.hash_length a + v saltLen in let m1 = LSeq.create m1Len (u8 0) in let m1 = LSeq.update_sub m1 8 (Hash.hash_length a) mHash in let m1 = LSeq.update_sub m1 (8 + Hash.hash_length a) (v saltLen) (as_seq h0 salt) in as_seq h1 m1Hash == Hash.hash a m1)) let get_m1Hash a saltLen salt msgLen msg hLen m1Hash =

push_frame (); let m1Len = 8ul +! hLen +! saltLen in let m1 = create m1Len (u8 0) in let h0 = ST.get () in update_sub_f h0 m1 8ul hLen (fun h -> Hash.hash a (as_seq h0 msg)) (fun _ -> hash a (sub m1 8ul hLen) msgLen msg); update_sub m1 (8ul +! hLen) saltLen salt; hash a m1Hash m1Len m1; pop_frame ()

module Hacl.Impl.RSAPSS.Padding open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer open Hacl.Impl.RSAPSS.MGF module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module Hash = Spec.Agile.Hash module S = Spec.RSAPSS module BD = Hacl.Bignum.Definitions #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length inline_for_extraction noextract let salt_len_t (a:Hash.fixed_len_alg) = saltLen:size_t{8 + Hash.hash_length a + v saltLen <= max_size_t /\ (8 + Hash.hash_length a + v saltLen) `less_than_max_input_length` a} inline_for_extraction noextract let msg_len_t (a:Hash.fixed_len_alg) = msgLen:size_t{v msgLen `less_than_max_input_length` a} inline_for_extraction noextract let em_len_t (a:Hash.fixed_len_alg) (saltLen:salt_len_t a) = emBits:size_t{0 < v emBits /\ Hash.hash_length a + v saltLen + 2 <= S.blocks (v emBits) 8} inline_for_extraction noextract val xor_bytes: len:size_t{v len > 0} -> b1:lbuffer uint8 len -> b2:lbuffer uint8 len -> Stack unit (requires fun h -> live h b1 /\ live h b2 /\ disjoint b1 b2) (ensures fun h0 _ h1 -> modifies (loc b1) h0 h1 /\ as_seq h1 b1 == S.xor_bytes (as_seq h0 b1) (as_seq h0 b2)) let xor_bytes len b1 b2 = map2T len b1 (fun x y -> x ^. y) b1 b2 inline_for_extraction noextract val db_zero: len:size_t{v len > 0} -> db:lbuffer uint8 len -> emBits:size_t -> Stack unit (requires fun h -> live h db) (ensures fun h0 _ h1 -> modifies (loc db) h0 h1 /\ as_seq h1 db == S.db_zero #(v len) (as_seq h0 db) (v emBits)) let db_zero len db emBits = let msBits = emBits %. 8ul in if msBits >. 0ul then db.(0ul) <- db.(0ul) &. (u8 0xff >>. (8ul -. msBits)) inline_for_extraction noextract val get_m1Hash: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> salt:lbuffer uint8 saltLen -> msgLen:msg_len_t a -> msg:lbuffer uint8 msgLen -> hLen:size_t{v hLen == Hash.hash_length a} -> m1Hash:lbuffer uint8 hLen -> Stack unit (requires fun h -> live h salt /\ live h msg /\ live h m1Hash /\ disjoint msg salt /\ disjoint m1Hash msg /\ disjoint m1Hash salt) (ensures fun h0 _ h1 -> modifies (loc m1Hash) h0 h1 /\ (let mHash = Hash.hash a (as_seq h0 msg) in let m1Len = 8 + Hash.hash_length a + v saltLen in let m1 = LSeq.create m1Len (u8 0) in let m1 = LSeq.update_sub m1 8 (Hash.hash_length a) mHash in let m1 = LSeq.update_sub m1 (8 + Hash.hash_length a) (v saltLen) (as_seq h0 salt) in as_seq h1 m1Hash == Hash.hash a m1))

Hacl.Impl.RSAPSS.Padding.fst

val get_m1Hash: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> salt:lbuffer uint8 saltLen -> msgLen:msg_len_t a -> msg:lbuffer uint8 msgLen -> hLen:size_t{v hLen == Hash.hash_length a} -> m1Hash:lbuffer uint8 hLen -> Stack unit (requires fun h -> live h salt /\ live h msg /\ live h m1Hash /\ disjoint msg salt /\ disjoint m1Hash msg /\ disjoint m1Hash salt) (ensures fun h0 _ h1 -> modifies (loc m1Hash) h0 h1 /\ (let mHash = Hash.hash a (as_seq h0 msg) in let m1Len = 8 + Hash.hash_length a + v saltLen in let m1 = LSeq.create m1Len (u8 0) in let m1 = LSeq.update_sub m1 8 (Hash.hash_length a) mHash in let m1 = LSeq.update_sub m1 (8 + Hash.hash_length a) (v saltLen) (as_seq h0 salt) in as_seq h1 m1Hash == Hash.hash a m1))

Hacl.Impl.RSAPSS.Padding.get_m1Hash

a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} -> saltLen: Hacl.Impl.RSAPSS.Padding.salt_len_t a -> salt: Lib.Buffer.lbuffer Lib.IntTypes.uint8 saltLen -> msgLen: Hacl.Impl.RSAPSS.Padding.msg_len_t a -> msg: Lib.Buffer.lbuffer Lib.IntTypes.uint8 msgLen -> hLen: Lib.IntTypes.size_t{Lib.IntTypes.v hLen == Spec.Hash.Definitions.hash_length a} -> m1Hash: Lib.Buffer.lbuffer Lib.IntTypes.uint8 hLen -> FStar.HyperStack.ST.Stack Prims.unit

FStar.HyperStack.ST.Stack

val pss_verify: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> msgLen:msg_len_t a -> msg:lbuffer uint8 msgLen -> emBits:size_t{0 < v emBits} -> em:lbuffer uint8 (BD.blocks emBits 8ul) -> Stack bool (requires fun h -> live h msg /\ live h em /\ disjoint em msg) (ensures fun h0 r h1 -> modifies0 h0 h1 /\ r == S.pss_verify a (v saltLen) (v msgLen) (as_seq h0 msg) (v emBits) (as_seq h0 em))

let pss_verify a saltLen msgLen msg emBits em = let emLen = BD.blocks emBits 8ul in let msBits = emBits %. 8ul in let em_0 = if msBits >. 0ul then em.(0ul) &. (u8 0xff <<. msBits) else u8 0 in let em_last = em.(emLen -! 1ul) in if (emLen <. saltLen +! hash_len a +! 2ul) then false else begin if not (FStar.UInt8.(Lib.RawIntTypes.u8_to_UInt8 em_last =^ 0xbcuy) && FStar.UInt8.(Lib.RawIntTypes.u8_to_UInt8 em_0 =^ 0uy)) then false else pss_verify_ a saltLen msgLen msg emBits em end

val pss_verify: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> msgLen:msg_len_t a -> msg:lbuffer uint8 msgLen -> emBits:size_t{0 < v emBits} -> em:lbuffer uint8 (BD.blocks emBits 8ul) -> Stack bool (requires fun h -> live h msg /\ live h em /\ disjoint em msg) (ensures fun h0 r h1 -> modifies0 h0 h1 /\ r == S.pss_verify a (v saltLen) (v msgLen) (as_seq h0 msg) (v emBits) (as_seq h0 em)) let pss_verify a saltLen msgLen msg emBits em =

let emLen = BD.blocks emBits 8ul in let msBits = emBits %. 8ul in let em_0 = if msBits >. 0ul then em.(0ul) &. (u8 0xff <<. msBits) else u8 0 in let em_last = em.(emLen -! 1ul) in if (emLen <. saltLen +! hash_len a +! 2ul) then false else if not (FStar.UInt8.(Lib.RawIntTypes.u8_to_UInt8 em_last =^ 0xbcuy) && FStar.UInt8.(Lib.RawIntTypes.u8_to_UInt8 em_0 =^ 0uy)) then false else pss_verify_ a saltLen msgLen msg emBits em

module Hacl.Impl.RSAPSS.Padding open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer open Hacl.Impl.RSAPSS.MGF module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module Hash = Spec.Agile.Hash module S = Spec.RSAPSS module BD = Hacl.Bignum.Definitions #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length inline_for_extraction noextract let salt_len_t (a:Hash.fixed_len_alg) = saltLen:size_t{8 + Hash.hash_length a + v saltLen <= max_size_t /\ (8 + Hash.hash_length a + v saltLen) `less_than_max_input_length` a} inline_for_extraction noextract let msg_len_t (a:Hash.fixed_len_alg) = msgLen:size_t{v msgLen `less_than_max_input_length` a} inline_for_extraction noextract let em_len_t (a:Hash.fixed_len_alg) (saltLen:salt_len_t a) = emBits:size_t{0 < v emBits /\ Hash.hash_length a + v saltLen + 2 <= S.blocks (v emBits) 8} inline_for_extraction noextract val xor_bytes: len:size_t{v len > 0} -> b1:lbuffer uint8 len -> b2:lbuffer uint8 len -> Stack unit (requires fun h -> live h b1 /\ live h b2 /\ disjoint b1 b2) (ensures fun h0 _ h1 -> modifies (loc b1) h0 h1 /\ as_seq h1 b1 == S.xor_bytes (as_seq h0 b1) (as_seq h0 b2)) let xor_bytes len b1 b2 = map2T len b1 (fun x y -> x ^. y) b1 b2 inline_for_extraction noextract val db_zero: len:size_t{v len > 0} -> db:lbuffer uint8 len -> emBits:size_t -> Stack unit (requires fun h -> live h db) (ensures fun h0 _ h1 -> modifies (loc db) h0 h1 /\ as_seq h1 db == S.db_zero #(v len) (as_seq h0 db) (v emBits)) let db_zero len db emBits = let msBits = emBits %. 8ul in if msBits >. 0ul then db.(0ul) <- db.(0ul) &. (u8 0xff >>. (8ul -. msBits)) inline_for_extraction noextract val get_m1Hash: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> salt:lbuffer uint8 saltLen -> msgLen:msg_len_t a -> msg:lbuffer uint8 msgLen -> hLen:size_t{v hLen == Hash.hash_length a} -> m1Hash:lbuffer uint8 hLen -> Stack unit (requires fun h -> live h salt /\ live h msg /\ live h m1Hash /\ disjoint msg salt /\ disjoint m1Hash msg /\ disjoint m1Hash salt) (ensures fun h0 _ h1 -> modifies (loc m1Hash) h0 h1 /\ (let mHash = Hash.hash a (as_seq h0 msg) in let m1Len = 8 + Hash.hash_length a + v saltLen in let m1 = LSeq.create m1Len (u8 0) in let m1 = LSeq.update_sub m1 8 (Hash.hash_length a) mHash in let m1 = LSeq.update_sub m1 (8 + Hash.hash_length a) (v saltLen) (as_seq h0 salt) in as_seq h1 m1Hash == Hash.hash a m1)) let get_m1Hash a saltLen salt msgLen msg hLen m1Hash = push_frame (); //m1 = [8 * 0x00; mHash; salt] let m1Len = 8ul +! hLen +! saltLen in let m1 = create m1Len (u8 0) in let h0 = ST.get () in update_sub_f h0 m1 8ul hLen (fun h -> Hash.hash a (as_seq h0 msg)) (fun _ -> hash a (sub m1 8ul hLen) msgLen msg); update_sub m1 (8ul +! hLen) saltLen salt; hash a m1Hash m1Len m1; pop_frame() inline_for_extraction noextract val get_maskedDB: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> salt:lbuffer uint8 saltLen -> hLen:size_t{v hLen == Hash.hash_length a} -> m1Hash:lbuffer uint8 hLen -> emBits:em_len_t a saltLen -> dbLen:size_t{v dbLen == S.blocks (v emBits) 8 - Hash.hash_length a - 1} -> db_mask:lbuffer uint8 dbLen -> Stack unit (requires fun h -> live h salt /\ live h m1Hash /\ live h db_mask /\ disjoint m1Hash salt /\ disjoint m1Hash db_mask /\ disjoint db_mask salt /\ as_seq h db_mask == LSeq.create (v dbLen) (u8 0)) (ensures fun h0 _ h1 -> modifies (loc db_mask) h0 h1 /\ (let emLen = S.blocks (v emBits) 8 in let dbLen = emLen - Hash.hash_length a - 1 in let db = LSeq.create dbLen (u8 0) in let last_before_salt = dbLen - v saltLen - 1 in let db = LSeq.upd db last_before_salt (u8 1) in let db = LSeq.update_sub db (last_before_salt + 1) (v saltLen) (as_seq h0 salt) in let dbMask = S.mgf_hash a (v hLen) (as_seq h0 m1Hash) dbLen in let maskedDB = S.xor_bytes db dbMask in let maskedDB = S.db_zero maskedDB (v emBits) in as_seq h1 db_mask == maskedDB)) let get_maskedDB a saltLen salt hLen m1Hash emBits dbLen db = push_frame (); //db = [0x00;..; 0x00; 0x01; salt] let last_before_salt = dbLen -! saltLen -! 1ul in db.(last_before_salt) <- u8 1; update_sub db (last_before_salt +! 1ul) saltLen salt; let dbMask = create dbLen (u8 0) in assert_norm (Hash.hash_length a + 4 <= max_size_t /\ (Hash.hash_length a + 4) `less_than_max_input_length` a); mgf_hash a hLen m1Hash dbLen dbMask; xor_bytes dbLen db dbMask; db_zero dbLen db emBits; pop_frame() val pss_encode: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> salt:lbuffer uint8 saltLen -> msgLen:msg_len_t a -> msg:lbuffer uint8 msgLen -> emBits:em_len_t a saltLen -> em:lbuffer uint8 (BD.blocks emBits 8ul) -> Stack unit (requires fun h -> live h salt /\ live h msg /\ live h em /\ disjoint msg salt /\ disjoint em msg /\ disjoint em salt /\ as_seq h em == LSeq.create (S.blocks (v emBits) 8) (u8 0)) (ensures fun h0 _ h1 -> modifies (loc em) h0 h1 /\ as_seq h1 em == S.pss_encode a (v saltLen) (as_seq h0 salt) (v msgLen) (as_seq h0 msg) (v emBits)) [@CInline] let pss_encode a saltLen salt msgLen msg emBits em = push_frame (); let hLen = hash_len a in let m1Hash = create hLen (u8 0) in get_m1Hash a saltLen salt msgLen msg hLen m1Hash; let emLen = BD.blocks emBits 8ul in let dbLen = emLen -! hLen -! 1ul in let db = create dbLen (u8 0) in get_maskedDB a saltLen salt hLen m1Hash emBits dbLen db; update_sub em 0ul dbLen db; update_sub em dbLen hLen m1Hash; em.(emLen -! 1ul) <- u8 0xbc; pop_frame() inline_for_extraction noextract val pss_verify_: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> msgLen:msg_len_t a -> msg:lbuffer uint8 msgLen -> emBits:em_len_t a saltLen -> em:lbuffer uint8 (BD.blocks emBits 8ul) -> Stack bool (requires fun h -> live h msg /\ live h em /\ disjoint em msg) (ensures fun h0 r h1 -> modifies0 h0 h1 /\ r == S.pss_verify_ a (v saltLen) (v msgLen) (as_seq h0 msg) (v emBits) (as_seq h0 em)) let pss_verify_ a saltLen msgLen msg emBits em = push_frame (); let emLen = BD.blocks emBits 8ul in let hLen = hash_len a in let m1Hash0 = create hLen (u8 0) in let dbLen = emLen -! hLen -! 1ul in let maskedDB = sub em 0ul dbLen in let m1Hash = sub em dbLen hLen in let dbMask = create dbLen (u8 0) in mgf_hash a hLen m1Hash dbLen dbMask; xor_bytes dbLen dbMask maskedDB; db_zero dbLen dbMask emBits; let padLen = emLen -! saltLen -! hLen -! 1ul in let pad2 = create padLen (u8 0) in pad2.(padLen -! 1ul) <- u8 0x01; let pad = sub dbMask 0ul padLen in let salt = sub dbMask padLen saltLen in let res = if not (Lib.ByteBuffer.lbytes_eq #padLen pad pad2) then false else begin get_m1Hash a saltLen salt msgLen msg hLen m1Hash0; Lib.ByteBuffer.lbytes_eq #hLen m1Hash0 m1Hash end in pop_frame (); res #set-options "--z3rlimit 300" val pss_verify: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> msgLen:msg_len_t a -> msg:lbuffer uint8 msgLen -> emBits:size_t{0 < v emBits} -> em:lbuffer uint8 (BD.blocks emBits 8ul) -> Stack bool (requires fun h -> live h msg /\ live h em /\ disjoint em msg) (ensures fun h0 r h1 -> modifies0 h0 h1 /\ r == S.pss_verify a (v saltLen) (v msgLen) (as_seq h0 msg) (v emBits) (as_seq h0 em))

Hacl.Impl.RSAPSS.Padding.fst

val pss_verify: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> msgLen:msg_len_t a -> msg:lbuffer uint8 msgLen -> emBits:size_t{0 < v emBits} -> em:lbuffer uint8 (BD.blocks emBits 8ul) -> Stack bool (requires fun h -> live h msg /\ live h em /\ disjoint em msg) (ensures fun h0 r h1 -> modifies0 h0 h1 /\ r == S.pss_verify a (v saltLen) (v msgLen) (as_seq h0 msg) (v emBits) (as_seq h0 em))

Hacl.Impl.RSAPSS.Padding.pss_verify

a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} -> saltLen: Hacl.Impl.RSAPSS.Padding.salt_len_t a -> msgLen: Hacl.Impl.RSAPSS.Padding.msg_len_t a -> msg: Lib.Buffer.lbuffer Lib.IntTypes.uint8 msgLen -> emBits: Lib.IntTypes.size_t{0 < Lib.IntTypes.v emBits} -> em: Lib.Buffer.lbuffer Lib.IntTypes.uint8 (Hacl.Bignum.Definitions.blocks emBits 8ul) -> FStar.HyperStack.ST.Stack Prims.bool

FStar.HyperStack.ST.Stack

val get_maskedDB: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> salt:lbuffer uint8 saltLen -> hLen:size_t{v hLen == Hash.hash_length a} -> m1Hash:lbuffer uint8 hLen -> emBits:em_len_t a saltLen -> dbLen:size_t{v dbLen == S.blocks (v emBits) 8 - Hash.hash_length a - 1} -> db_mask:lbuffer uint8 dbLen -> Stack unit (requires fun h -> live h salt /\ live h m1Hash /\ live h db_mask /\ disjoint m1Hash salt /\ disjoint m1Hash db_mask /\ disjoint db_mask salt /\ as_seq h db_mask == LSeq.create (v dbLen) (u8 0)) (ensures fun h0 _ h1 -> modifies (loc db_mask) h0 h1 /\ (let emLen = S.blocks (v emBits) 8 in let dbLen = emLen - Hash.hash_length a - 1 in let db = LSeq.create dbLen (u8 0) in let last_before_salt = dbLen - v saltLen - 1 in let db = LSeq.upd db last_before_salt (u8 1) in let db = LSeq.update_sub db (last_before_salt + 1) (v saltLen) (as_seq h0 salt) in let dbMask = S.mgf_hash a (v hLen) (as_seq h0 m1Hash) dbLen in let maskedDB = S.xor_bytes db dbMask in let maskedDB = S.db_zero maskedDB (v emBits) in as_seq h1 db_mask == maskedDB))

let get_maskedDB a saltLen salt hLen m1Hash emBits dbLen db = push_frame (); //db = [0x00;..; 0x00; 0x01; salt] let last_before_salt = dbLen -! saltLen -! 1ul in db.(last_before_salt) <- u8 1; update_sub db (last_before_salt +! 1ul) saltLen salt; let dbMask = create dbLen (u8 0) in assert_norm (Hash.hash_length a + 4 <= max_size_t /\ (Hash.hash_length a + 4) `less_than_max_input_length` a); mgf_hash a hLen m1Hash dbLen dbMask; xor_bytes dbLen db dbMask; db_zero dbLen db emBits; pop_frame()

val get_maskedDB: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> salt:lbuffer uint8 saltLen -> hLen:size_t{v hLen == Hash.hash_length a} -> m1Hash:lbuffer uint8 hLen -> emBits:em_len_t a saltLen -> dbLen:size_t{v dbLen == S.blocks (v emBits) 8 - Hash.hash_length a - 1} -> db_mask:lbuffer uint8 dbLen -> Stack unit (requires fun h -> live h salt /\ live h m1Hash /\ live h db_mask /\ disjoint m1Hash salt /\ disjoint m1Hash db_mask /\ disjoint db_mask salt /\ as_seq h db_mask == LSeq.create (v dbLen) (u8 0)) (ensures fun h0 _ h1 -> modifies (loc db_mask) h0 h1 /\ (let emLen = S.blocks (v emBits) 8 in let dbLen = emLen - Hash.hash_length a - 1 in let db = LSeq.create dbLen (u8 0) in let last_before_salt = dbLen - v saltLen - 1 in let db = LSeq.upd db last_before_salt (u8 1) in let db = LSeq.update_sub db (last_before_salt + 1) (v saltLen) (as_seq h0 salt) in let dbMask = S.mgf_hash a (v hLen) (as_seq h0 m1Hash) dbLen in let maskedDB = S.xor_bytes db dbMask in let maskedDB = S.db_zero maskedDB (v emBits) in as_seq h1 db_mask == maskedDB)) let get_maskedDB a saltLen salt hLen m1Hash emBits dbLen db =

push_frame (); let last_before_salt = dbLen -! saltLen -! 1ul in db.(last_before_salt) <- u8 1; update_sub db (last_before_salt +! 1ul) saltLen salt; let dbMask = create dbLen (u8 0) in assert_norm (Hash.hash_length a + 4 <= max_size_t /\ (Hash.hash_length a + 4) `less_than_max_input_length` a); mgf_hash a hLen m1Hash dbLen dbMask; xor_bytes dbLen db dbMask; db_zero dbLen db emBits; pop_frame ()

module Hacl.Impl.RSAPSS.Padding open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer open Hacl.Impl.RSAPSS.MGF module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module Hash = Spec.Agile.Hash module S = Spec.RSAPSS module BD = Hacl.Bignum.Definitions #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length inline_for_extraction noextract let salt_len_t (a:Hash.fixed_len_alg) = saltLen:size_t{8 + Hash.hash_length a + v saltLen <= max_size_t /\ (8 + Hash.hash_length a + v saltLen) `less_than_max_input_length` a} inline_for_extraction noextract let msg_len_t (a:Hash.fixed_len_alg) = msgLen:size_t{v msgLen `less_than_max_input_length` a} inline_for_extraction noextract let em_len_t (a:Hash.fixed_len_alg) (saltLen:salt_len_t a) = emBits:size_t{0 < v emBits /\ Hash.hash_length a + v saltLen + 2 <= S.blocks (v emBits) 8} inline_for_extraction noextract val xor_bytes: len:size_t{v len > 0} -> b1:lbuffer uint8 len -> b2:lbuffer uint8 len -> Stack unit (requires fun h -> live h b1 /\ live h b2 /\ disjoint b1 b2) (ensures fun h0 _ h1 -> modifies (loc b1) h0 h1 /\ as_seq h1 b1 == S.xor_bytes (as_seq h0 b1) (as_seq h0 b2)) let xor_bytes len b1 b2 = map2T len b1 (fun x y -> x ^. y) b1 b2 inline_for_extraction noextract val db_zero: len:size_t{v len > 0} -> db:lbuffer uint8 len -> emBits:size_t -> Stack unit (requires fun h -> live h db) (ensures fun h0 _ h1 -> modifies (loc db) h0 h1 /\ as_seq h1 db == S.db_zero #(v len) (as_seq h0 db) (v emBits)) let db_zero len db emBits = let msBits = emBits %. 8ul in if msBits >. 0ul then db.(0ul) <- db.(0ul) &. (u8 0xff >>. (8ul -. msBits)) inline_for_extraction noextract val get_m1Hash: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> salt:lbuffer uint8 saltLen -> msgLen:msg_len_t a -> msg:lbuffer uint8 msgLen -> hLen:size_t{v hLen == Hash.hash_length a} -> m1Hash:lbuffer uint8 hLen -> Stack unit (requires fun h -> live h salt /\ live h msg /\ live h m1Hash /\ disjoint msg salt /\ disjoint m1Hash msg /\ disjoint m1Hash salt) (ensures fun h0 _ h1 -> modifies (loc m1Hash) h0 h1 /\ (let mHash = Hash.hash a (as_seq h0 msg) in let m1Len = 8 + Hash.hash_length a + v saltLen in let m1 = LSeq.create m1Len (u8 0) in let m1 = LSeq.update_sub m1 8 (Hash.hash_length a) mHash in let m1 = LSeq.update_sub m1 (8 + Hash.hash_length a) (v saltLen) (as_seq h0 salt) in as_seq h1 m1Hash == Hash.hash a m1)) let get_m1Hash a saltLen salt msgLen msg hLen m1Hash = push_frame (); //m1 = [8 * 0x00; mHash; salt] let m1Len = 8ul +! hLen +! saltLen in let m1 = create m1Len (u8 0) in let h0 = ST.get () in update_sub_f h0 m1 8ul hLen (fun h -> Hash.hash a (as_seq h0 msg)) (fun _ -> hash a (sub m1 8ul hLen) msgLen msg); update_sub m1 (8ul +! hLen) saltLen salt; hash a m1Hash m1Len m1; pop_frame() inline_for_extraction noextract val get_maskedDB: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> salt:lbuffer uint8 saltLen -> hLen:size_t{v hLen == Hash.hash_length a} -> m1Hash:lbuffer uint8 hLen -> emBits:em_len_t a saltLen -> dbLen:size_t{v dbLen == S.blocks (v emBits) 8 - Hash.hash_length a - 1} -> db_mask:lbuffer uint8 dbLen -> Stack unit (requires fun h -> live h salt /\ live h m1Hash /\ live h db_mask /\ disjoint m1Hash salt /\ disjoint m1Hash db_mask /\ disjoint db_mask salt /\ as_seq h db_mask == LSeq.create (v dbLen) (u8 0)) (ensures fun h0 _ h1 -> modifies (loc db_mask) h0 h1 /\ (let emLen = S.blocks (v emBits) 8 in let dbLen = emLen - Hash.hash_length a - 1 in let db = LSeq.create dbLen (u8 0) in let last_before_salt = dbLen - v saltLen - 1 in let db = LSeq.upd db last_before_salt (u8 1) in let db = LSeq.update_sub db (last_before_salt + 1) (v saltLen) (as_seq h0 salt) in let dbMask = S.mgf_hash a (v hLen) (as_seq h0 m1Hash) dbLen in let maskedDB = S.xor_bytes db dbMask in let maskedDB = S.db_zero maskedDB (v emBits) in as_seq h1 db_mask == maskedDB))

Hacl.Impl.RSAPSS.Padding.fst

val get_maskedDB: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> salt:lbuffer uint8 saltLen -> hLen:size_t{v hLen == Hash.hash_length a} -> m1Hash:lbuffer uint8 hLen -> emBits:em_len_t a saltLen -> dbLen:size_t{v dbLen == S.blocks (v emBits) 8 - Hash.hash_length a - 1} -> db_mask:lbuffer uint8 dbLen -> Stack unit (requires fun h -> live h salt /\ live h m1Hash /\ live h db_mask /\ disjoint m1Hash salt /\ disjoint m1Hash db_mask /\ disjoint db_mask salt /\ as_seq h db_mask == LSeq.create (v dbLen) (u8 0)) (ensures fun h0 _ h1 -> modifies (loc db_mask) h0 h1 /\ (let emLen = S.blocks (v emBits) 8 in let dbLen = emLen - Hash.hash_length a - 1 in let db = LSeq.create dbLen (u8 0) in let last_before_salt = dbLen - v saltLen - 1 in let db = LSeq.upd db last_before_salt (u8 1) in let db = LSeq.update_sub db (last_before_salt + 1) (v saltLen) (as_seq h0 salt) in let dbMask = S.mgf_hash a (v hLen) (as_seq h0 m1Hash) dbLen in let maskedDB = S.xor_bytes db dbMask in let maskedDB = S.db_zero maskedDB (v emBits) in as_seq h1 db_mask == maskedDB))

Hacl.Impl.RSAPSS.Padding.get_maskedDB

a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} -> saltLen: Hacl.Impl.RSAPSS.Padding.salt_len_t a -> salt: Lib.Buffer.lbuffer Lib.IntTypes.uint8 saltLen -> hLen: Lib.IntTypes.size_t{Lib.IntTypes.v hLen == Spec.Hash.Definitions.hash_length a} -> m1Hash: Lib.Buffer.lbuffer Lib.IntTypes.uint8 hLen -> emBits: Hacl.Impl.RSAPSS.Padding.em_len_t a saltLen -> dbLen: Lib.IntTypes.size_t { Lib.IntTypes.v dbLen == Spec.RSAPSS.blocks (Lib.IntTypes.v emBits) 8 - Spec.Hash.Definitions.hash_length a - 1 } -> db_mask: Lib.Buffer.lbuffer Lib.IntTypes.uint8 dbLen -> FStar.HyperStack.ST.Stack Prims.unit

FStar.HyperStack.ST.Stack

val pss_encode: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> salt:lbuffer uint8 saltLen -> msgLen:msg_len_t a -> msg:lbuffer uint8 msgLen -> emBits:em_len_t a saltLen -> em:lbuffer uint8 (BD.blocks emBits 8ul) -> Stack unit (requires fun h -> live h salt /\ live h msg /\ live h em /\ disjoint msg salt /\ disjoint em msg /\ disjoint em salt /\ as_seq h em == LSeq.create (S.blocks (v emBits) 8) (u8 0)) (ensures fun h0 _ h1 -> modifies (loc em) h0 h1 /\ as_seq h1 em == S.pss_encode a (v saltLen) (as_seq h0 salt) (v msgLen) (as_seq h0 msg) (v emBits))

let pss_encode a saltLen salt msgLen msg emBits em = push_frame (); let hLen = hash_len a in let m1Hash = create hLen (u8 0) in get_m1Hash a saltLen salt msgLen msg hLen m1Hash; let emLen = BD.blocks emBits 8ul in let dbLen = emLen -! hLen -! 1ul in let db = create dbLen (u8 0) in get_maskedDB a saltLen salt hLen m1Hash emBits dbLen db; update_sub em 0ul dbLen db; update_sub em dbLen hLen m1Hash; em.(emLen -! 1ul) <- u8 0xbc; pop_frame()

val pss_encode: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> salt:lbuffer uint8 saltLen -> msgLen:msg_len_t a -> msg:lbuffer uint8 msgLen -> emBits:em_len_t a saltLen -> em:lbuffer uint8 (BD.blocks emBits 8ul) -> Stack unit (requires fun h -> live h salt /\ live h msg /\ live h em /\ disjoint msg salt /\ disjoint em msg /\ disjoint em salt /\ as_seq h em == LSeq.create (S.blocks (v emBits) 8) (u8 0)) (ensures fun h0 _ h1 -> modifies (loc em) h0 h1 /\ as_seq h1 em == S.pss_encode a (v saltLen) (as_seq h0 salt) (v msgLen) (as_seq h0 msg) (v emBits)) let pss_encode a saltLen salt msgLen msg emBits em =

push_frame (); let hLen = hash_len a in let m1Hash = create hLen (u8 0) in get_m1Hash a saltLen salt msgLen msg hLen m1Hash; let emLen = BD.blocks emBits 8ul in let dbLen = emLen -! hLen -! 1ul in let db = create dbLen (u8 0) in get_maskedDB a saltLen salt hLen m1Hash emBits dbLen db; update_sub em 0ul dbLen db; update_sub em dbLen hLen m1Hash; em.(emLen -! 1ul) <- u8 0xbc; pop_frame ()

module Hacl.Impl.RSAPSS.Padding open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer open Hacl.Impl.RSAPSS.MGF module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module Hash = Spec.Agile.Hash module S = Spec.RSAPSS module BD = Hacl.Bignum.Definitions #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length inline_for_extraction noextract let salt_len_t (a:Hash.fixed_len_alg) = saltLen:size_t{8 + Hash.hash_length a + v saltLen <= max_size_t /\ (8 + Hash.hash_length a + v saltLen) `less_than_max_input_length` a} inline_for_extraction noextract let msg_len_t (a:Hash.fixed_len_alg) = msgLen:size_t{v msgLen `less_than_max_input_length` a} inline_for_extraction noextract let em_len_t (a:Hash.fixed_len_alg) (saltLen:salt_len_t a) = emBits:size_t{0 < v emBits /\ Hash.hash_length a + v saltLen + 2 <= S.blocks (v emBits) 8} inline_for_extraction noextract val xor_bytes: len:size_t{v len > 0} -> b1:lbuffer uint8 len -> b2:lbuffer uint8 len -> Stack unit (requires fun h -> live h b1 /\ live h b2 /\ disjoint b1 b2) (ensures fun h0 _ h1 -> modifies (loc b1) h0 h1 /\ as_seq h1 b1 == S.xor_bytes (as_seq h0 b1) (as_seq h0 b2)) let xor_bytes len b1 b2 = map2T len b1 (fun x y -> x ^. y) b1 b2 inline_for_extraction noextract val db_zero: len:size_t{v len > 0} -> db:lbuffer uint8 len -> emBits:size_t -> Stack unit (requires fun h -> live h db) (ensures fun h0 _ h1 -> modifies (loc db) h0 h1 /\ as_seq h1 db == S.db_zero #(v len) (as_seq h0 db) (v emBits)) let db_zero len db emBits = let msBits = emBits %. 8ul in if msBits >. 0ul then db.(0ul) <- db.(0ul) &. (u8 0xff >>. (8ul -. msBits)) inline_for_extraction noextract val get_m1Hash: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> salt:lbuffer uint8 saltLen -> msgLen:msg_len_t a -> msg:lbuffer uint8 msgLen -> hLen:size_t{v hLen == Hash.hash_length a} -> m1Hash:lbuffer uint8 hLen -> Stack unit (requires fun h -> live h salt /\ live h msg /\ live h m1Hash /\ disjoint msg salt /\ disjoint m1Hash msg /\ disjoint m1Hash salt) (ensures fun h0 _ h1 -> modifies (loc m1Hash) h0 h1 /\ (let mHash = Hash.hash a (as_seq h0 msg) in let m1Len = 8 + Hash.hash_length a + v saltLen in let m1 = LSeq.create m1Len (u8 0) in let m1 = LSeq.update_sub m1 8 (Hash.hash_length a) mHash in let m1 = LSeq.update_sub m1 (8 + Hash.hash_length a) (v saltLen) (as_seq h0 salt) in as_seq h1 m1Hash == Hash.hash a m1)) let get_m1Hash a saltLen salt msgLen msg hLen m1Hash = push_frame (); //m1 = [8 * 0x00; mHash; salt] let m1Len = 8ul +! hLen +! saltLen in let m1 = create m1Len (u8 0) in let h0 = ST.get () in update_sub_f h0 m1 8ul hLen (fun h -> Hash.hash a (as_seq h0 msg)) (fun _ -> hash a (sub m1 8ul hLen) msgLen msg); update_sub m1 (8ul +! hLen) saltLen salt; hash a m1Hash m1Len m1; pop_frame() inline_for_extraction noextract val get_maskedDB: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> salt:lbuffer uint8 saltLen -> hLen:size_t{v hLen == Hash.hash_length a} -> m1Hash:lbuffer uint8 hLen -> emBits:em_len_t a saltLen -> dbLen:size_t{v dbLen == S.blocks (v emBits) 8 - Hash.hash_length a - 1} -> db_mask:lbuffer uint8 dbLen -> Stack unit (requires fun h -> live h salt /\ live h m1Hash /\ live h db_mask /\ disjoint m1Hash salt /\ disjoint m1Hash db_mask /\ disjoint db_mask salt /\ as_seq h db_mask == LSeq.create (v dbLen) (u8 0)) (ensures fun h0 _ h1 -> modifies (loc db_mask) h0 h1 /\ (let emLen = S.blocks (v emBits) 8 in let dbLen = emLen - Hash.hash_length a - 1 in let db = LSeq.create dbLen (u8 0) in let last_before_salt = dbLen - v saltLen - 1 in let db = LSeq.upd db last_before_salt (u8 1) in let db = LSeq.update_sub db (last_before_salt + 1) (v saltLen) (as_seq h0 salt) in let dbMask = S.mgf_hash a (v hLen) (as_seq h0 m1Hash) dbLen in let maskedDB = S.xor_bytes db dbMask in let maskedDB = S.db_zero maskedDB (v emBits) in as_seq h1 db_mask == maskedDB)) let get_maskedDB a saltLen salt hLen m1Hash emBits dbLen db = push_frame (); //db = [0x00;..; 0x00; 0x01; salt] let last_before_salt = dbLen -! saltLen -! 1ul in db.(last_before_salt) <- u8 1; update_sub db (last_before_salt +! 1ul) saltLen salt; let dbMask = create dbLen (u8 0) in assert_norm (Hash.hash_length a + 4 <= max_size_t /\ (Hash.hash_length a + 4) `less_than_max_input_length` a); mgf_hash a hLen m1Hash dbLen dbMask; xor_bytes dbLen db dbMask; db_zero dbLen db emBits; pop_frame() val pss_encode: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> salt:lbuffer uint8 saltLen -> msgLen:msg_len_t a -> msg:lbuffer uint8 msgLen -> emBits:em_len_t a saltLen -> em:lbuffer uint8 (BD.blocks emBits 8ul) -> Stack unit (requires fun h -> live h salt /\ live h msg /\ live h em /\ disjoint msg salt /\ disjoint em msg /\ disjoint em salt /\ as_seq h em == LSeq.create (S.blocks (v emBits) 8) (u8 0)) (ensures fun h0 _ h1 -> modifies (loc em) h0 h1 /\ as_seq h1 em == S.pss_encode a (v saltLen) (as_seq h0 salt) (v msgLen) (as_seq h0 msg) (v emBits)) [@CInline]

Hacl.Impl.RSAPSS.Padding.fst

val pss_encode: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> salt:lbuffer uint8 saltLen -> msgLen:msg_len_t a -> msg:lbuffer uint8 msgLen -> emBits:em_len_t a saltLen -> em:lbuffer uint8 (BD.blocks emBits 8ul) -> Stack unit (requires fun h -> live h salt /\ live h msg /\ live h em /\ disjoint msg salt /\ disjoint em msg /\ disjoint em salt /\ as_seq h em == LSeq.create (S.blocks (v emBits) 8) (u8 0)) (ensures fun h0 _ h1 -> modifies (loc em) h0 h1 /\ as_seq h1 em == S.pss_encode a (v saltLen) (as_seq h0 salt) (v msgLen) (as_seq h0 msg) (v emBits))

Hacl.Impl.RSAPSS.Padding.pss_encode

a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} -> saltLen: Hacl.Impl.RSAPSS.Padding.salt_len_t a -> salt: Lib.Buffer.lbuffer Lib.IntTypes.uint8 saltLen -> msgLen: Hacl.Impl.RSAPSS.Padding.msg_len_t a -> msg: Lib.Buffer.lbuffer Lib.IntTypes.uint8 msgLen -> emBits: Hacl.Impl.RSAPSS.Padding.em_len_t a saltLen -> em: Lib.Buffer.lbuffer Lib.IntTypes.uint8 (Hacl.Bignum.Definitions.blocks emBits 8ul) -> FStar.HyperStack.ST.Stack Prims.unit

FStar.HyperStack.ST.Stack

val pss_verify_: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> msgLen:msg_len_t a -> msg:lbuffer uint8 msgLen -> emBits:em_len_t a saltLen -> em:lbuffer uint8 (BD.blocks emBits 8ul) -> Stack bool (requires fun h -> live h msg /\ live h em /\ disjoint em msg) (ensures fun h0 r h1 -> modifies0 h0 h1 /\ r == S.pss_verify_ a (v saltLen) (v msgLen) (as_seq h0 msg) (v emBits) (as_seq h0 em))

let pss_verify_ a saltLen msgLen msg emBits em = push_frame (); let emLen = BD.blocks emBits 8ul in let hLen = hash_len a in let m1Hash0 = create hLen (u8 0) in let dbLen = emLen -! hLen -! 1ul in let maskedDB = sub em 0ul dbLen in let m1Hash = sub em dbLen hLen in let dbMask = create dbLen (u8 0) in mgf_hash a hLen m1Hash dbLen dbMask; xor_bytes dbLen dbMask maskedDB; db_zero dbLen dbMask emBits; let padLen = emLen -! saltLen -! hLen -! 1ul in let pad2 = create padLen (u8 0) in pad2.(padLen -! 1ul) <- u8 0x01; let pad = sub dbMask 0ul padLen in let salt = sub dbMask padLen saltLen in let res = if not (Lib.ByteBuffer.lbytes_eq #padLen pad pad2) then false else begin get_m1Hash a saltLen salt msgLen msg hLen m1Hash0; Lib.ByteBuffer.lbytes_eq #hLen m1Hash0 m1Hash end in pop_frame (); res

val pss_verify_: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> msgLen:msg_len_t a -> msg:lbuffer uint8 msgLen -> emBits:em_len_t a saltLen -> em:lbuffer uint8 (BD.blocks emBits 8ul) -> Stack bool (requires fun h -> live h msg /\ live h em /\ disjoint em msg) (ensures fun h0 r h1 -> modifies0 h0 h1 /\ r == S.pss_verify_ a (v saltLen) (v msgLen) (as_seq h0 msg) (v emBits) (as_seq h0 em)) let pss_verify_ a saltLen msgLen msg emBits em =

push_frame (); let emLen = BD.blocks emBits 8ul in let hLen = hash_len a in let m1Hash0 = create hLen (u8 0) in let dbLen = emLen -! hLen -! 1ul in let maskedDB = sub em 0ul dbLen in let m1Hash = sub em dbLen hLen in let dbMask = create dbLen (u8 0) in mgf_hash a hLen m1Hash dbLen dbMask; xor_bytes dbLen dbMask maskedDB; db_zero dbLen dbMask emBits; let padLen = emLen -! saltLen -! hLen -! 1ul in let pad2 = create padLen (u8 0) in pad2.(padLen -! 1ul) <- u8 0x01; let pad = sub dbMask 0ul padLen in let salt = sub dbMask padLen saltLen in let res = if not (Lib.ByteBuffer.lbytes_eq #padLen pad pad2) then false else (get_m1Hash a saltLen salt msgLen msg hLen m1Hash0; Lib.ByteBuffer.lbytes_eq #hLen m1Hash0 m1Hash) in pop_frame (); res

module Hacl.Impl.RSAPSS.Padding open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Lib.IntTypes open Lib.Buffer open Hacl.Impl.RSAPSS.MGF module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module Hash = Spec.Agile.Hash module S = Spec.RSAPSS module BD = Hacl.Bignum.Definitions #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let less_than_max_input_length = Spec.Hash.Definitions.less_than_max_input_length inline_for_extraction noextract let salt_len_t (a:Hash.fixed_len_alg) = saltLen:size_t{8 + Hash.hash_length a + v saltLen <= max_size_t /\ (8 + Hash.hash_length a + v saltLen) `less_than_max_input_length` a} inline_for_extraction noextract let msg_len_t (a:Hash.fixed_len_alg) = msgLen:size_t{v msgLen `less_than_max_input_length` a} inline_for_extraction noextract let em_len_t (a:Hash.fixed_len_alg) (saltLen:salt_len_t a) = emBits:size_t{0 < v emBits /\ Hash.hash_length a + v saltLen + 2 <= S.blocks (v emBits) 8} inline_for_extraction noextract val xor_bytes: len:size_t{v len > 0} -> b1:lbuffer uint8 len -> b2:lbuffer uint8 len -> Stack unit (requires fun h -> live h b1 /\ live h b2 /\ disjoint b1 b2) (ensures fun h0 _ h1 -> modifies (loc b1) h0 h1 /\ as_seq h1 b1 == S.xor_bytes (as_seq h0 b1) (as_seq h0 b2)) let xor_bytes len b1 b2 = map2T len b1 (fun x y -> x ^. y) b1 b2 inline_for_extraction noextract val db_zero: len:size_t{v len > 0} -> db:lbuffer uint8 len -> emBits:size_t -> Stack unit (requires fun h -> live h db) (ensures fun h0 _ h1 -> modifies (loc db) h0 h1 /\ as_seq h1 db == S.db_zero #(v len) (as_seq h0 db) (v emBits)) let db_zero len db emBits = let msBits = emBits %. 8ul in if msBits >. 0ul then db.(0ul) <- db.(0ul) &. (u8 0xff >>. (8ul -. msBits)) inline_for_extraction noextract val get_m1Hash: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> salt:lbuffer uint8 saltLen -> msgLen:msg_len_t a -> msg:lbuffer uint8 msgLen -> hLen:size_t{v hLen == Hash.hash_length a} -> m1Hash:lbuffer uint8 hLen -> Stack unit (requires fun h -> live h salt /\ live h msg /\ live h m1Hash /\ disjoint msg salt /\ disjoint m1Hash msg /\ disjoint m1Hash salt) (ensures fun h0 _ h1 -> modifies (loc m1Hash) h0 h1 /\ (let mHash = Hash.hash a (as_seq h0 msg) in let m1Len = 8 + Hash.hash_length a + v saltLen in let m1 = LSeq.create m1Len (u8 0) in let m1 = LSeq.update_sub m1 8 (Hash.hash_length a) mHash in let m1 = LSeq.update_sub m1 (8 + Hash.hash_length a) (v saltLen) (as_seq h0 salt) in as_seq h1 m1Hash == Hash.hash a m1)) let get_m1Hash a saltLen salt msgLen msg hLen m1Hash = push_frame (); //m1 = [8 * 0x00; mHash; salt] let m1Len = 8ul +! hLen +! saltLen in let m1 = create m1Len (u8 0) in let h0 = ST.get () in update_sub_f h0 m1 8ul hLen (fun h -> Hash.hash a (as_seq h0 msg)) (fun _ -> hash a (sub m1 8ul hLen) msgLen msg); update_sub m1 (8ul +! hLen) saltLen salt; hash a m1Hash m1Len m1; pop_frame() inline_for_extraction noextract val get_maskedDB: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> salt:lbuffer uint8 saltLen -> hLen:size_t{v hLen == Hash.hash_length a} -> m1Hash:lbuffer uint8 hLen -> emBits:em_len_t a saltLen -> dbLen:size_t{v dbLen == S.blocks (v emBits) 8 - Hash.hash_length a - 1} -> db_mask:lbuffer uint8 dbLen -> Stack unit (requires fun h -> live h salt /\ live h m1Hash /\ live h db_mask /\ disjoint m1Hash salt /\ disjoint m1Hash db_mask /\ disjoint db_mask salt /\ as_seq h db_mask == LSeq.create (v dbLen) (u8 0)) (ensures fun h0 _ h1 -> modifies (loc db_mask) h0 h1 /\ (let emLen = S.blocks (v emBits) 8 in let dbLen = emLen - Hash.hash_length a - 1 in let db = LSeq.create dbLen (u8 0) in let last_before_salt = dbLen - v saltLen - 1 in let db = LSeq.upd db last_before_salt (u8 1) in let db = LSeq.update_sub db (last_before_salt + 1) (v saltLen) (as_seq h0 salt) in let dbMask = S.mgf_hash a (v hLen) (as_seq h0 m1Hash) dbLen in let maskedDB = S.xor_bytes db dbMask in let maskedDB = S.db_zero maskedDB (v emBits) in as_seq h1 db_mask == maskedDB)) let get_maskedDB a saltLen salt hLen m1Hash emBits dbLen db = push_frame (); //db = [0x00;..; 0x00; 0x01; salt] let last_before_salt = dbLen -! saltLen -! 1ul in db.(last_before_salt) <- u8 1; update_sub db (last_before_salt +! 1ul) saltLen salt; let dbMask = create dbLen (u8 0) in assert_norm (Hash.hash_length a + 4 <= max_size_t /\ (Hash.hash_length a + 4) `less_than_max_input_length` a); mgf_hash a hLen m1Hash dbLen dbMask; xor_bytes dbLen db dbMask; db_zero dbLen db emBits; pop_frame() val pss_encode: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> salt:lbuffer uint8 saltLen -> msgLen:msg_len_t a -> msg:lbuffer uint8 msgLen -> emBits:em_len_t a saltLen -> em:lbuffer uint8 (BD.blocks emBits 8ul) -> Stack unit (requires fun h -> live h salt /\ live h msg /\ live h em /\ disjoint msg salt /\ disjoint em msg /\ disjoint em salt /\ as_seq h em == LSeq.create (S.blocks (v emBits) 8) (u8 0)) (ensures fun h0 _ h1 -> modifies (loc em) h0 h1 /\ as_seq h1 em == S.pss_encode a (v saltLen) (as_seq h0 salt) (v msgLen) (as_seq h0 msg) (v emBits)) [@CInline] let pss_encode a saltLen salt msgLen msg emBits em = push_frame (); let hLen = hash_len a in let m1Hash = create hLen (u8 0) in get_m1Hash a saltLen salt msgLen msg hLen m1Hash; let emLen = BD.blocks emBits 8ul in let dbLen = emLen -! hLen -! 1ul in let db = create dbLen (u8 0) in get_maskedDB a saltLen salt hLen m1Hash emBits dbLen db; update_sub em 0ul dbLen db; update_sub em dbLen hLen m1Hash; em.(emLen -! 1ul) <- u8 0xbc; pop_frame() inline_for_extraction noextract val pss_verify_: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> msgLen:msg_len_t a -> msg:lbuffer uint8 msgLen -> emBits:em_len_t a saltLen -> em:lbuffer uint8 (BD.blocks emBits 8ul) -> Stack bool (requires fun h -> live h msg /\ live h em /\ disjoint em msg) (ensures fun h0 r h1 -> modifies0 h0 h1 /\ r == S.pss_verify_ a (v saltLen) (v msgLen) (as_seq h0 msg) (v emBits) (as_seq h0 em))

Hacl.Impl.RSAPSS.Padding.fst

val pss_verify_: a:Hash.hash_alg{S.hash_is_supported a} -> saltLen:salt_len_t a -> msgLen:msg_len_t a -> msg:lbuffer uint8 msgLen -> emBits:em_len_t a saltLen -> em:lbuffer uint8 (BD.blocks emBits 8ul) -> Stack bool (requires fun h -> live h msg /\ live h em /\ disjoint em msg) (ensures fun h0 r h1 -> modifies0 h0 h1 /\ r == S.pss_verify_ a (v saltLen) (v msgLen) (as_seq h0 msg) (v emBits) (as_seq h0 em))

Hacl.Impl.RSAPSS.Padding.pss_verify_

a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} -> saltLen: Hacl.Impl.RSAPSS.Padding.salt_len_t a -> msgLen: Hacl.Impl.RSAPSS.Padding.msg_len_t a -> msg: Lib.Buffer.lbuffer Lib.IntTypes.uint8 msgLen -> emBits: Hacl.Impl.RSAPSS.Padding.em_len_t a saltLen -> em: Lib.Buffer.lbuffer Lib.IntTypes.uint8 (Hacl.Bignum.Definitions.blocks emBits 8ul) -> FStar.HyperStack.ST.Stack Prims.bool

Prims.Tot

val pts_to (#n:US.t) (bv:bv_t n) (p:perm) (s:repr) : vprop

let pts_to bv p s = A.pts_to bv p s

val pts_to (#n:US.t) (bv:bv_t n) (p:perm) (s:repr) : vprop let pts_to bv p s =

A.pts_to bv p s

(* Copyright 2021 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Authors: Aseem Rastogi *) module Steel.ST.BitVector open Steel.ST.Effect.Ghost open Steel.ST.Effect open Steel.ST.Util module US = FStar.SizeT module G = FStar.Ghost module A = Steel.ST.Array /// Implementation of bv_t using an array of bool type bv_t n = a:A.array bool{A.length a == US.v n /\ A.is_full_array a}

Steel.ST.BitVector.fst

val pts_to (#n:US.t) (bv:bv_t n) (p:perm) (s:repr) : vprop

Steel.ST.BitVector.pts_to

bv: Steel.ST.BitVector.bv_t n -> p: Steel.FractionalPermission.perm -> s: Steel.ST.BitVector.repr -> Steel.Effect.Common.vprop

Steel.ST.Effect.Ghost.STGhost

val pts_to_length (#opened:_) (#n:US.t) (#p:perm) (bv:bv_t n) (s:repr) : STGhost unit opened (pts_to bv p s) (fun _ -> pts_to bv p s) (requires True) (ensures fun _ -> Seq.length s == US.v n)

let pts_to_length bv s = A.pts_to_length bv s

val pts_to_length (#opened:_) (#n:US.t) (#p:perm) (bv:bv_t n) (s:repr) : STGhost unit opened (pts_to bv p s) (fun _ -> pts_to bv p s) (requires True) (ensures fun _ -> Seq.length s == US.v n) let pts_to_length bv s =

A.pts_to_length bv s

(* Copyright 2021 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Authors: Aseem Rastogi *) module Steel.ST.BitVector open Steel.ST.Effect.Ghost open Steel.ST.Effect open Steel.ST.Util module US = FStar.SizeT module G = FStar.Ghost module A = Steel.ST.Array /// Implementation of bv_t using an array of bool type bv_t n = a:A.array bool{A.length a == US.v n /\ A.is_full_array a} let pts_to bv p s = A.pts_to bv p s

Steel.ST.BitVector.fst

val pts_to_length (#opened:_) (#n:US.t) (#p:perm) (bv:bv_t n) (s:repr) : STGhost unit opened (pts_to bv p s) (fun _ -> pts_to bv p s) (requires True) (ensures fun _ -> Seq.length s == US.v n)

Steel.ST.BitVector.pts_to_length

bv: Steel.ST.BitVector.bv_t n -> s: Steel.ST.BitVector.repr -> Steel.ST.Effect.Ghost.STGhost Prims.unit

Steel.ST.Effect.STT

val alloc (n:US.t{US.v n > 0}) : STT (bv_t n) emp (fun r -> pts_to r full_perm (Seq.create (US.v n) false))

let alloc n = A.alloc false n

val alloc (n:US.t{US.v n > 0}) : STT (bv_t n) emp (fun r -> pts_to r full_perm (Seq.create (US.v n) false)) let alloc n =

A.alloc false n

(* Copyright 2021 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Authors: Aseem Rastogi *) module Steel.ST.BitVector open Steel.ST.Effect.Ghost open Steel.ST.Effect open Steel.ST.Util module US = FStar.SizeT module G = FStar.Ghost module A = Steel.ST.Array /// Implementation of bv_t using an array of bool type bv_t n = a:A.array bool{A.length a == US.v n /\ A.is_full_array a} let pts_to bv p s = A.pts_to bv p s let pts_to_length bv s = A.pts_to_length bv s

Steel.ST.BitVector.fst

val alloc (n:US.t{US.v n > 0}) : STT (bv_t n) emp (fun r -> pts_to r full_perm (Seq.create (US.v n) false))

Steel.ST.BitVector.alloc

n: FStar.SizeT.t{FStar.SizeT.v n > 0} -> Steel.ST.Effect.STT (Steel.ST.BitVector.bv_t n)

Steel.ST.Effect.ST

val bv_is_set (#n:US.t) (#p:perm) (#s:G.erased repr) (bv:bv_t n) (i:US.t{US.v i < Seq.length s}) : ST bool (pts_to bv p s) (fun _ -> pts_to bv p s) (requires True) (ensures fun b -> b == Seq.index s (US.v i))

let bv_is_set bv i = A.read bv i

val bv_is_set (#n:US.t) (#p:perm) (#s:G.erased repr) (bv:bv_t n) (i:US.t{US.v i < Seq.length s}) : ST bool (pts_to bv p s) (fun _ -> pts_to bv p s) (requires True) (ensures fun b -> b == Seq.index s (US.v i)) let bv_is_set bv i =

A.read bv i

(* Copyright 2021 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Authors: Aseem Rastogi *) module Steel.ST.BitVector open Steel.ST.Effect.Ghost open Steel.ST.Effect open Steel.ST.Util module US = FStar.SizeT module G = FStar.Ghost module A = Steel.ST.Array /// Implementation of bv_t using an array of bool type bv_t n = a:A.array bool{A.length a == US.v n /\ A.is_full_array a} let pts_to bv p s = A.pts_to bv p s let pts_to_length bv s = A.pts_to_length bv s let alloc n = A.alloc false n

Steel.ST.BitVector.fst

val bv_is_set (#n:US.t) (#p:perm) (#s:G.erased repr) (bv:bv_t n) (i:US.t{US.v i < Seq.length s}) : ST bool (pts_to bv p s) (fun _ -> pts_to bv p s) (requires True) (ensures fun b -> b == Seq.index s (US.v i))

Steel.ST.BitVector.bv_is_set

bv: Steel.ST.BitVector.bv_t n -> i: FStar.SizeT.t{FStar.SizeT.v i < FStar.Seq.Base.length (FStar.Ghost.reveal s)} -> Steel.ST.Effect.ST Prims.bool

Steel.ST.Effect.STT

val bv_set (#n:US.t) (#s:G.erased repr) (bv:bv_t n) (i:US.t{US.v i < Seq.length s}) : STT unit (pts_to bv full_perm s) (fun _ -> pts_to bv full_perm (Seq.upd s (US.v i) true))

let bv_set #_ #s bv i = A.write #_ bv #s i true

val bv_set (#n:US.t) (#s:G.erased repr) (bv:bv_t n) (i:US.t{US.v i < Seq.length s}) : STT unit (pts_to bv full_perm s) (fun _ -> pts_to bv full_perm (Seq.upd s (US.v i) true)) let bv_set #_ #s bv i =

A.write #_ bv #s i true

(* Copyright 2021 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Authors: Aseem Rastogi *) module Steel.ST.BitVector open Steel.ST.Effect.Ghost open Steel.ST.Effect open Steel.ST.Util module US = FStar.SizeT module G = FStar.Ghost module A = Steel.ST.Array /// Implementation of bv_t using an array of bool type bv_t n = a:A.array bool{A.length a == US.v n /\ A.is_full_array a} let pts_to bv p s = A.pts_to bv p s let pts_to_length bv s = A.pts_to_length bv s let alloc n = A.alloc false n let bv_is_set bv i = A.read bv i

Steel.ST.BitVector.fst

val bv_set (#n:US.t) (#s:G.erased repr) (bv:bv_t n) (i:US.t{US.v i < Seq.length s}) : STT unit (pts_to bv full_perm s) (fun _ -> pts_to bv full_perm (Seq.upd s (US.v i) true))

Steel.ST.BitVector.bv_set

bv: Steel.ST.BitVector.bv_t n -> i: FStar.SizeT.t{FStar.SizeT.v i < FStar.Seq.Base.length (FStar.Ghost.reveal s)} -> Steel.ST.Effect.STT Prims.unit

Steel.ST.Effect.STT

val bv_unset (#n:US.t) (#s:G.erased repr) (bv:bv_t n) (i:US.t{US.v i < Seq.length s}) : STT unit (pts_to bv full_perm s) (fun _ -> pts_to bv full_perm (Seq.upd s (US.v i) false))

let bv_unset #_ #s bv i = A.write #_ bv #s i false

val bv_unset (#n:US.t) (#s:G.erased repr) (bv:bv_t n) (i:US.t{US.v i < Seq.length s}) : STT unit (pts_to bv full_perm s) (fun _ -> pts_to bv full_perm (Seq.upd s (US.v i) false)) let bv_unset #_ #s bv i =

A.write #_ bv #s i false

(* Copyright 2021 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Authors: Aseem Rastogi *) module Steel.ST.BitVector open Steel.ST.Effect.Ghost open Steel.ST.Effect open Steel.ST.Util module US = FStar.SizeT module G = FStar.Ghost module A = Steel.ST.Array /// Implementation of bv_t using an array of bool type bv_t n = a:A.array bool{A.length a == US.v n /\ A.is_full_array a} let pts_to bv p s = A.pts_to bv p s let pts_to_length bv s = A.pts_to_length bv s let alloc n = A.alloc false n let bv_is_set bv i = A.read bv i let bv_set #_ #s bv i = A.write #_ bv #s i true

Steel.ST.BitVector.fst

val bv_unset (#n:US.t) (#s:G.erased repr) (bv:bv_t n) (i:US.t{US.v i < Seq.length s}) : STT unit (pts_to bv full_perm s) (fun _ -> pts_to bv full_perm (Seq.upd s (US.v i) false))

Steel.ST.BitVector.bv_unset

bv: Steel.ST.BitVector.bv_t n -> i: FStar.SizeT.t{FStar.SizeT.v i < FStar.Seq.Base.length (FStar.Ghost.reveal s)} -> Steel.ST.Effect.STT Prims.unit

Prims.Tot

val adx_pre:VSig.vale_pre dom

let adx_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_adx_bmi2_stdcall c va_s0 IA.win

val adx_pre:VSig.vale_pre dom let adx_pre:VSig.vale_pre dom =

fun (c: V.va_code) (va_s0: V.va_state) -> VC.va_req_Check_adx_bmi2_stdcall c va_s0 IA.win

module Vale.Stdcalls.X64.Cpuid open FStar.Mul open Vale.Interop.Base module IX64 = Vale.Interop.X64 module VSig = Vale.AsLowStar.ValeSig module LSig = Vale.AsLowStar.LowStarSig module V = Vale.X64.Decls module IA = Vale.Interop.Assumptions module W = Vale.AsLowStar.Wrapper open Vale.X64.MemoryAdapters module VC = Vale.Lib.X64.Cpuidstdcall (* A little utility to trigger normalization in types *) noextract let as_t (#a:Type) (x:normal a) : a = x noextract let as_normal_t (#a:Type) (x:a) : normal a = x [@__reduce__] noextract let dom: IX64.arity_ok_stdcall td = [] (* Need to rearrange the order of arguments *) [@__reduce__] noextract let aesni_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_aesni_stdcall c va_s0 IA.win [@__reduce__] noextract let aesni_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_aesni_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let aesni_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires aesni_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ aesni_post code va_s0 va_s1 f)) = VC.va_lemma_Check_aesni_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let aesni_lemma = as_t #(VSig.vale_sig_stdcall aesni_pre aesni_post) aesni_lemma' noextract let code_aesni = VC.va_code_Check_aesni_stdcall IA.win (* Here's the type expected for the check_aesni wrapper *) [@__reduce__] noextract let lowstar_aesni_t = IX64.as_lowstar_sig_t_weak_stdcall code_aesni dom [] _ _ (W.mk_prediction code_aesni dom [] (aesni_lemma code_aesni IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let sha_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_sha_stdcall c va_s0 IA.win [@__reduce__] noextract let sha_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_sha_stdcall c va_s0 IA.win va_s1 f open Vale.X64.Machine_s open Vale.X64.State #set-options "--z3rlimit 20" (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let sha_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires sha_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ sha_post code va_s0 va_s1 f)) = VC.va_lemma_Check_sha_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let sha_lemma = as_t #(VSig.vale_sig_stdcall sha_pre sha_post) sha_lemma' noextract let code_sha = VC.va_code_Check_sha_stdcall IA.win (* Here's the type expected for the check_aesni wrapper *) [@__reduce__] noextract let lowstar_sha_t = IX64.as_lowstar_sig_t_weak_stdcall code_sha dom [] _ _ (W.mk_prediction code_sha dom [] (sha_lemma code_sha IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract

Vale.Stdcalls.X64.Cpuid.fsti

val adx_pre:VSig.vale_pre dom

Vale.Stdcalls.X64.Cpuid.adx_pre

Vale.AsLowStar.ValeSig.vale_pre Vale.Stdcalls.X64.Cpuid.dom

Prims.Tot

val aesni_pre:VSig.vale_pre dom

let aesni_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_aesni_stdcall c va_s0 IA.win

val aesni_pre:VSig.vale_pre dom let aesni_pre:VSig.vale_pre dom =

fun (c: V.va_code) (va_s0: V.va_state) -> VC.va_req_Check_aesni_stdcall c va_s0 IA.win

module Vale.Stdcalls.X64.Cpuid open FStar.Mul open Vale.Interop.Base module IX64 = Vale.Interop.X64 module VSig = Vale.AsLowStar.ValeSig module LSig = Vale.AsLowStar.LowStarSig module V = Vale.X64.Decls module IA = Vale.Interop.Assumptions module W = Vale.AsLowStar.Wrapper open Vale.X64.MemoryAdapters module VC = Vale.Lib.X64.Cpuidstdcall (* A little utility to trigger normalization in types *) noextract let as_t (#a:Type) (x:normal a) : a = x noextract let as_normal_t (#a:Type) (x:a) : normal a = x [@__reduce__] noextract let dom: IX64.arity_ok_stdcall td = [] (* Need to rearrange the order of arguments *) [@__reduce__] noextract

Vale.Stdcalls.X64.Cpuid.fsti

val aesni_pre:VSig.vale_pre dom

Vale.Stdcalls.X64.Cpuid.aesni_pre

Vale.AsLowStar.ValeSig.vale_pre Vale.Stdcalls.X64.Cpuid.dom

Prims.Tot

val aesni_post:VSig.vale_post dom

let aesni_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_aesni_stdcall c va_s0 IA.win va_s1 f

val aesni_post:VSig.vale_post dom let aesni_post:VSig.vale_post dom =

fun (c: V.va_code) (va_s0: V.va_state) (va_s1: V.va_state) (f: V.va_fuel) -> VC.va_ens_Check_aesni_stdcall c va_s0 IA.win va_s1 f

module Vale.Stdcalls.X64.Cpuid open FStar.Mul open Vale.Interop.Base module IX64 = Vale.Interop.X64 module VSig = Vale.AsLowStar.ValeSig module LSig = Vale.AsLowStar.LowStarSig module V = Vale.X64.Decls module IA = Vale.Interop.Assumptions module W = Vale.AsLowStar.Wrapper open Vale.X64.MemoryAdapters module VC = Vale.Lib.X64.Cpuidstdcall (* A little utility to trigger normalization in types *) noextract let as_t (#a:Type) (x:normal a) : a = x noextract let as_normal_t (#a:Type) (x:a) : normal a = x [@__reduce__] noextract let dom: IX64.arity_ok_stdcall td = [] (* Need to rearrange the order of arguments *) [@__reduce__] noextract let aesni_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_aesni_stdcall c va_s0 IA.win [@__reduce__] noextract

Vale.Stdcalls.X64.Cpuid.fsti

val aesni_post:VSig.vale_post dom

Vale.Stdcalls.X64.Cpuid.aesni_post

Vale.AsLowStar.ValeSig.vale_post Vale.Stdcalls.X64.Cpuid.dom

Prims.Tot

let code_movbe = VC.va_code_Check_movbe_stdcall IA.win

let code_movbe =

VC.va_code_Check_movbe_stdcall IA.win

module Vale.Stdcalls.X64.Cpuid open FStar.Mul open Vale.Interop.Base module IX64 = Vale.Interop.X64 module VSig = Vale.AsLowStar.ValeSig module LSig = Vale.AsLowStar.LowStarSig module V = Vale.X64.Decls module IA = Vale.Interop.Assumptions module W = Vale.AsLowStar.Wrapper open Vale.X64.MemoryAdapters module VC = Vale.Lib.X64.Cpuidstdcall (* A little utility to trigger normalization in types *) noextract let as_t (#a:Type) (x:normal a) : a = x noextract let as_normal_t (#a:Type) (x:a) : normal a = x [@__reduce__] noextract let dom: IX64.arity_ok_stdcall td = [] (* Need to rearrange the order of arguments *) [@__reduce__] noextract let aesni_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_aesni_stdcall c va_s0 IA.win [@__reduce__] noextract let aesni_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_aesni_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let aesni_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires aesni_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ aesni_post code va_s0 va_s1 f)) = VC.va_lemma_Check_aesni_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let aesni_lemma = as_t #(VSig.vale_sig_stdcall aesni_pre aesni_post) aesni_lemma' noextract let code_aesni = VC.va_code_Check_aesni_stdcall IA.win (* Here's the type expected for the check_aesni wrapper *) [@__reduce__] noextract let lowstar_aesni_t = IX64.as_lowstar_sig_t_weak_stdcall code_aesni dom [] _ _ (W.mk_prediction code_aesni dom [] (aesni_lemma code_aesni IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let sha_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_sha_stdcall c va_s0 IA.win [@__reduce__] noextract let sha_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_sha_stdcall c va_s0 IA.win va_s1 f open Vale.X64.Machine_s open Vale.X64.State #set-options "--z3rlimit 20" (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let sha_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires sha_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ sha_post code va_s0 va_s1 f)) = VC.va_lemma_Check_sha_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let sha_lemma = as_t #(VSig.vale_sig_stdcall sha_pre sha_post) sha_lemma' noextract let code_sha = VC.va_code_Check_sha_stdcall IA.win (* Here's the type expected for the check_aesni wrapper *) [@__reduce__] noextract let lowstar_sha_t = IX64.as_lowstar_sig_t_weak_stdcall code_sha dom [] _ _ (W.mk_prediction code_sha dom [] (sha_lemma code_sha IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let adx_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_adx_bmi2_stdcall c va_s0 IA.win [@__reduce__] noextract let adx_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_adx_bmi2_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let adx_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires adx_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ adx_post code va_s0 va_s1 f)) = VC.va_lemma_Check_adx_bmi2_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let adx_lemma = as_t #(VSig.vale_sig_stdcall adx_pre adx_post) adx_lemma' noextract let code_adx = VC.va_code_Check_adx_bmi2_stdcall IA.win (* Here's the type expected for the check_adx wrapper *) [@__reduce__] noextract let lowstar_adx_t = IX64.as_lowstar_sig_t_weak_stdcall code_adx dom [] _ _ (W.mk_prediction code_adx dom [] (adx_lemma code_adx IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let avx_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_avx_stdcall c va_s0 IA.win [@__reduce__] noextract let avx_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_avx_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let avx_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires avx_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ avx_post code va_s0 va_s1 f)) = VC.va_lemma_Check_avx_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let avx_lemma = as_t #(VSig.vale_sig_stdcall avx_pre avx_post) avx_lemma' noextract let code_avx = VC.va_code_Check_avx_stdcall IA.win (* Here's the type expected for the check_avx wrapper *) [@__reduce__] noextract let lowstar_avx_t = IX64.as_lowstar_sig_t_weak_stdcall code_avx dom [] _ _ (W.mk_prediction code_avx dom [] (avx_lemma code_avx IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let avx2_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_avx2_stdcall c va_s0 IA.win [@__reduce__] noextract let avx2_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_avx2_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let avx2_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires avx2_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ avx2_post code va_s0 va_s1 f)) = VC.va_lemma_Check_avx2_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let avx2_lemma = as_t #(VSig.vale_sig_stdcall avx2_pre avx2_post) avx2_lemma' noextract let code_avx2 = VC.va_code_Check_avx2_stdcall IA.win (* Here's the type expected for the check_avx wrapper *) [@__reduce__] noextract let lowstar_avx2_t = IX64.as_lowstar_sig_t_weak_stdcall code_avx2 dom [] _ _ (W.mk_prediction code_avx2 dom [] (avx2_lemma code_avx2 IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let movbe_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_movbe_stdcall c va_s0 IA.win [@__reduce__] noextract let movbe_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_movbe_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let movbe_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires movbe_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ movbe_post code va_s0 va_s1 f)) = VC.va_lemma_Check_movbe_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let movbe_lemma = as_t #(VSig.vale_sig_stdcall movbe_pre movbe_post) movbe_lemma'

Vale.Stdcalls.X64.Cpuid.fsti

val code_movbe : Vale.X64.Decls.va_code

Vale.Stdcalls.X64.Cpuid.code_movbe

Vale.X64.Decls.va_code

Prims.Tot

val avx2_post:VSig.vale_post dom

let avx2_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_avx2_stdcall c va_s0 IA.win va_s1 f

val avx2_post:VSig.vale_post dom let avx2_post:VSig.vale_post dom =

fun (c: V.va_code) (va_s0: V.va_state) (va_s1: V.va_state) (f: V.va_fuel) -> VC.va_ens_Check_avx2_stdcall c va_s0 IA.win va_s1 f

module Vale.Stdcalls.X64.Cpuid open FStar.Mul open Vale.Interop.Base module IX64 = Vale.Interop.X64 module VSig = Vale.AsLowStar.ValeSig module LSig = Vale.AsLowStar.LowStarSig module V = Vale.X64.Decls module IA = Vale.Interop.Assumptions module W = Vale.AsLowStar.Wrapper open Vale.X64.MemoryAdapters module VC = Vale.Lib.X64.Cpuidstdcall (* A little utility to trigger normalization in types *) noextract let as_t (#a:Type) (x:normal a) : a = x noextract let as_normal_t (#a:Type) (x:a) : normal a = x [@__reduce__] noextract let dom: IX64.arity_ok_stdcall td = [] (* Need to rearrange the order of arguments *) [@__reduce__] noextract let aesni_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_aesni_stdcall c va_s0 IA.win [@__reduce__] noextract let aesni_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_aesni_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let aesni_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires aesni_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ aesni_post code va_s0 va_s1 f)) = VC.va_lemma_Check_aesni_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let aesni_lemma = as_t #(VSig.vale_sig_stdcall aesni_pre aesni_post) aesni_lemma' noextract let code_aesni = VC.va_code_Check_aesni_stdcall IA.win (* Here's the type expected for the check_aesni wrapper *) [@__reduce__] noextract let lowstar_aesni_t = IX64.as_lowstar_sig_t_weak_stdcall code_aesni dom [] _ _ (W.mk_prediction code_aesni dom [] (aesni_lemma code_aesni IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let sha_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_sha_stdcall c va_s0 IA.win [@__reduce__] noextract let sha_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_sha_stdcall c va_s0 IA.win va_s1 f open Vale.X64.Machine_s open Vale.X64.State #set-options "--z3rlimit 20" (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let sha_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires sha_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ sha_post code va_s0 va_s1 f)) = VC.va_lemma_Check_sha_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let sha_lemma = as_t #(VSig.vale_sig_stdcall sha_pre sha_post) sha_lemma' noextract let code_sha = VC.va_code_Check_sha_stdcall IA.win (* Here's the type expected for the check_aesni wrapper *) [@__reduce__] noextract let lowstar_sha_t = IX64.as_lowstar_sig_t_weak_stdcall code_sha dom [] _ _ (W.mk_prediction code_sha dom [] (sha_lemma code_sha IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let adx_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_adx_bmi2_stdcall c va_s0 IA.win [@__reduce__] noextract let adx_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_adx_bmi2_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let adx_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires adx_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ adx_post code va_s0 va_s1 f)) = VC.va_lemma_Check_adx_bmi2_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let adx_lemma = as_t #(VSig.vale_sig_stdcall adx_pre adx_post) adx_lemma' noextract let code_adx = VC.va_code_Check_adx_bmi2_stdcall IA.win (* Here's the type expected for the check_adx wrapper *) [@__reduce__] noextract let lowstar_adx_t = IX64.as_lowstar_sig_t_weak_stdcall code_adx dom [] _ _ (W.mk_prediction code_adx dom [] (adx_lemma code_adx IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let avx_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_avx_stdcall c va_s0 IA.win [@__reduce__] noextract let avx_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_avx_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let avx_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires avx_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ avx_post code va_s0 va_s1 f)) = VC.va_lemma_Check_avx_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let avx_lemma = as_t #(VSig.vale_sig_stdcall avx_pre avx_post) avx_lemma' noextract let code_avx = VC.va_code_Check_avx_stdcall IA.win (* Here's the type expected for the check_avx wrapper *) [@__reduce__] noextract let lowstar_avx_t = IX64.as_lowstar_sig_t_weak_stdcall code_avx dom [] _ _ (W.mk_prediction code_avx dom [] (avx_lemma code_avx IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let avx2_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_avx2_stdcall c va_s0 IA.win [@__reduce__] noextract

Vale.Stdcalls.X64.Cpuid.fsti

val avx2_post:VSig.vale_post dom

Vale.Stdcalls.X64.Cpuid.avx2_post

Vale.AsLowStar.ValeSig.vale_post Vale.Stdcalls.X64.Cpuid.dom

Prims.Tot

let code_aesni = VC.va_code_Check_aesni_stdcall IA.win

let code_aesni =

VC.va_code_Check_aesni_stdcall IA.win

module Vale.Stdcalls.X64.Cpuid open FStar.Mul open Vale.Interop.Base module IX64 = Vale.Interop.X64 module VSig = Vale.AsLowStar.ValeSig module LSig = Vale.AsLowStar.LowStarSig module V = Vale.X64.Decls module IA = Vale.Interop.Assumptions module W = Vale.AsLowStar.Wrapper open Vale.X64.MemoryAdapters module VC = Vale.Lib.X64.Cpuidstdcall (* A little utility to trigger normalization in types *) noextract let as_t (#a:Type) (x:normal a) : a = x noextract let as_normal_t (#a:Type) (x:a) : normal a = x [@__reduce__] noextract let dom: IX64.arity_ok_stdcall td = [] (* Need to rearrange the order of arguments *) [@__reduce__] noextract let aesni_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_aesni_stdcall c va_s0 IA.win [@__reduce__] noextract let aesni_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_aesni_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let aesni_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires aesni_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ aesni_post code va_s0 va_s1 f)) = VC.va_lemma_Check_aesni_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let aesni_lemma = as_t #(VSig.vale_sig_stdcall aesni_pre aesni_post) aesni_lemma'

Vale.Stdcalls.X64.Cpuid.fsti

val code_aesni : Vale.X64.Decls.va_code

Vale.Stdcalls.X64.Cpuid.code_aesni

Vale.X64.Decls.va_code

Prims.Tot

val rdrand_pre:VSig.vale_pre dom

let rdrand_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_rdrand_stdcall c va_s0 IA.win

val rdrand_pre:VSig.vale_pre dom let rdrand_pre:VSig.vale_pre dom =

fun (c: V.va_code) (va_s0: V.va_state) -> VC.va_req_Check_rdrand_stdcall c va_s0 IA.win

module Vale.Stdcalls.X64.Cpuid open FStar.Mul open Vale.Interop.Base module IX64 = Vale.Interop.X64 module VSig = Vale.AsLowStar.ValeSig module LSig = Vale.AsLowStar.LowStarSig module V = Vale.X64.Decls module IA = Vale.Interop.Assumptions module W = Vale.AsLowStar.Wrapper open Vale.X64.MemoryAdapters module VC = Vale.Lib.X64.Cpuidstdcall (* A little utility to trigger normalization in types *) noextract let as_t (#a:Type) (x:normal a) : a = x noextract let as_normal_t (#a:Type) (x:a) : normal a = x [@__reduce__] noextract let dom: IX64.arity_ok_stdcall td = [] (* Need to rearrange the order of arguments *) [@__reduce__] noextract let aesni_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_aesni_stdcall c va_s0 IA.win [@__reduce__] noextract let aesni_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_aesni_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let aesni_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires aesni_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ aesni_post code va_s0 va_s1 f)) = VC.va_lemma_Check_aesni_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let aesni_lemma = as_t #(VSig.vale_sig_stdcall aesni_pre aesni_post) aesni_lemma' noextract let code_aesni = VC.va_code_Check_aesni_stdcall IA.win (* Here's the type expected for the check_aesni wrapper *) [@__reduce__] noextract let lowstar_aesni_t = IX64.as_lowstar_sig_t_weak_stdcall code_aesni dom [] _ _ (W.mk_prediction code_aesni dom [] (aesni_lemma code_aesni IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let sha_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_sha_stdcall c va_s0 IA.win [@__reduce__] noextract let sha_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_sha_stdcall c va_s0 IA.win va_s1 f open Vale.X64.Machine_s open Vale.X64.State #set-options "--z3rlimit 20" (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let sha_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires sha_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ sha_post code va_s0 va_s1 f)) = VC.va_lemma_Check_sha_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let sha_lemma = as_t #(VSig.vale_sig_stdcall sha_pre sha_post) sha_lemma' noextract let code_sha = VC.va_code_Check_sha_stdcall IA.win (* Here's the type expected for the check_aesni wrapper *) [@__reduce__] noextract let lowstar_sha_t = IX64.as_lowstar_sig_t_weak_stdcall code_sha dom [] _ _ (W.mk_prediction code_sha dom [] (sha_lemma code_sha IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let adx_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_adx_bmi2_stdcall c va_s0 IA.win [@__reduce__] noextract let adx_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_adx_bmi2_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let adx_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires adx_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ adx_post code va_s0 va_s1 f)) = VC.va_lemma_Check_adx_bmi2_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let adx_lemma = as_t #(VSig.vale_sig_stdcall adx_pre adx_post) adx_lemma' noextract let code_adx = VC.va_code_Check_adx_bmi2_stdcall IA.win (* Here's the type expected for the check_adx wrapper *) [@__reduce__] noextract let lowstar_adx_t = IX64.as_lowstar_sig_t_weak_stdcall code_adx dom [] _ _ (W.mk_prediction code_adx dom [] (adx_lemma code_adx IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let avx_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_avx_stdcall c va_s0 IA.win [@__reduce__] noextract let avx_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_avx_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let avx_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires avx_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ avx_post code va_s0 va_s1 f)) = VC.va_lemma_Check_avx_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let avx_lemma = as_t #(VSig.vale_sig_stdcall avx_pre avx_post) avx_lemma' noextract let code_avx = VC.va_code_Check_avx_stdcall IA.win (* Here's the type expected for the check_avx wrapper *) [@__reduce__] noextract let lowstar_avx_t = IX64.as_lowstar_sig_t_weak_stdcall code_avx dom [] _ _ (W.mk_prediction code_avx dom [] (avx_lemma code_avx IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let avx2_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_avx2_stdcall c va_s0 IA.win [@__reduce__] noextract let avx2_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_avx2_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let avx2_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires avx2_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ avx2_post code va_s0 va_s1 f)) = VC.va_lemma_Check_avx2_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let avx2_lemma = as_t #(VSig.vale_sig_stdcall avx2_pre avx2_post) avx2_lemma' noextract let code_avx2 = VC.va_code_Check_avx2_stdcall IA.win (* Here's the type expected for the check_avx wrapper *) [@__reduce__] noextract let lowstar_avx2_t = IX64.as_lowstar_sig_t_weak_stdcall code_avx2 dom [] _ _ (W.mk_prediction code_avx2 dom [] (avx2_lemma code_avx2 IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let movbe_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_movbe_stdcall c va_s0 IA.win [@__reduce__] noextract let movbe_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_movbe_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let movbe_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires movbe_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ movbe_post code va_s0 va_s1 f)) = VC.va_lemma_Check_movbe_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let movbe_lemma = as_t #(VSig.vale_sig_stdcall movbe_pre movbe_post) movbe_lemma' noextract let code_movbe = VC.va_code_Check_movbe_stdcall IA.win (* Here's the type expected for the check_movbe wrapper *) [@__reduce__] noextract let lowstar_movbe_t = IX64.as_lowstar_sig_t_weak_stdcall code_movbe dom [] _ _ (W.mk_prediction code_movbe dom [] (movbe_lemma code_movbe IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let sse_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_sse_stdcall c va_s0 IA.win [@__reduce__] noextract let sse_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_sse_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let sse_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires sse_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ sse_post code va_s0 va_s1 f)) = VC.va_lemma_Check_sse_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let sse_lemma = as_t #(VSig.vale_sig_stdcall sse_pre sse_post) sse_lemma' noextract let code_sse = VC.va_code_Check_sse_stdcall IA.win (* Here's the type expected for the check_sse wrapper *) [@__reduce__] noextract let lowstar_sse_t = IX64.as_lowstar_sig_t_weak_stdcall code_sse dom [] _ _ (W.mk_prediction code_sse dom [] (sse_lemma code_sse IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract

Vale.Stdcalls.X64.Cpuid.fsti

val rdrand_pre:VSig.vale_pre dom

Vale.Stdcalls.X64.Cpuid.rdrand_pre

Vale.AsLowStar.ValeSig.vale_pre Vale.Stdcalls.X64.Cpuid.dom

Prims.Tot

val sha_post:VSig.vale_post dom

let sha_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_sha_stdcall c va_s0 IA.win va_s1 f

val sha_post:VSig.vale_post dom let sha_post:VSig.vale_post dom =

fun (c: V.va_code) (va_s0: V.va_state) (va_s1: V.va_state) (f: V.va_fuel) -> VC.va_ens_Check_sha_stdcall c va_s0 IA.win va_s1 f

module Vale.Stdcalls.X64.Cpuid open FStar.Mul open Vale.Interop.Base module IX64 = Vale.Interop.X64 module VSig = Vale.AsLowStar.ValeSig module LSig = Vale.AsLowStar.LowStarSig module V = Vale.X64.Decls module IA = Vale.Interop.Assumptions module W = Vale.AsLowStar.Wrapper open Vale.X64.MemoryAdapters module VC = Vale.Lib.X64.Cpuidstdcall (* A little utility to trigger normalization in types *) noextract let as_t (#a:Type) (x:normal a) : a = x noextract let as_normal_t (#a:Type) (x:a) : normal a = x [@__reduce__] noextract let dom: IX64.arity_ok_stdcall td = [] (* Need to rearrange the order of arguments *) [@__reduce__] noextract let aesni_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_aesni_stdcall c va_s0 IA.win [@__reduce__] noextract let aesni_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_aesni_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let aesni_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires aesni_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ aesni_post code va_s0 va_s1 f)) = VC.va_lemma_Check_aesni_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let aesni_lemma = as_t #(VSig.vale_sig_stdcall aesni_pre aesni_post) aesni_lemma' noextract let code_aesni = VC.va_code_Check_aesni_stdcall IA.win (* Here's the type expected for the check_aesni wrapper *) [@__reduce__] noextract let lowstar_aesni_t = IX64.as_lowstar_sig_t_weak_stdcall code_aesni dom [] _ _ (W.mk_prediction code_aesni dom [] (aesni_lemma code_aesni IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let sha_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_sha_stdcall c va_s0 IA.win [@__reduce__] noextract

Vale.Stdcalls.X64.Cpuid.fsti

val sha_post:VSig.vale_post dom

Vale.Stdcalls.X64.Cpuid.sha_post

Vale.AsLowStar.ValeSig.vale_post Vale.Stdcalls.X64.Cpuid.dom

Prims.Tot

val avx_post:VSig.vale_post dom

let avx_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_avx_stdcall c va_s0 IA.win va_s1 f

val avx_post:VSig.vale_post dom let avx_post:VSig.vale_post dom =

fun (c: V.va_code) (va_s0: V.va_state) (va_s1: V.va_state) (f: V.va_fuel) -> VC.va_ens_Check_avx_stdcall c va_s0 IA.win va_s1 f

module Vale.Stdcalls.X64.Cpuid open FStar.Mul open Vale.Interop.Base module IX64 = Vale.Interop.X64 module VSig = Vale.AsLowStar.ValeSig module LSig = Vale.AsLowStar.LowStarSig module V = Vale.X64.Decls module IA = Vale.Interop.Assumptions module W = Vale.AsLowStar.Wrapper open Vale.X64.MemoryAdapters module VC = Vale.Lib.X64.Cpuidstdcall (* A little utility to trigger normalization in types *) noextract let as_t (#a:Type) (x:normal a) : a = x noextract let as_normal_t (#a:Type) (x:a) : normal a = x [@__reduce__] noextract let dom: IX64.arity_ok_stdcall td = [] (* Need to rearrange the order of arguments *) [@__reduce__] noextract let aesni_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_aesni_stdcall c va_s0 IA.win [@__reduce__] noextract let aesni_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_aesni_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let aesni_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires aesni_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ aesni_post code va_s0 va_s1 f)) = VC.va_lemma_Check_aesni_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let aesni_lemma = as_t #(VSig.vale_sig_stdcall aesni_pre aesni_post) aesni_lemma' noextract let code_aesni = VC.va_code_Check_aesni_stdcall IA.win (* Here's the type expected for the check_aesni wrapper *) [@__reduce__] noextract let lowstar_aesni_t = IX64.as_lowstar_sig_t_weak_stdcall code_aesni dom [] _ _ (W.mk_prediction code_aesni dom [] (aesni_lemma code_aesni IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let sha_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_sha_stdcall c va_s0 IA.win [@__reduce__] noextract let sha_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_sha_stdcall c va_s0 IA.win va_s1 f open Vale.X64.Machine_s open Vale.X64.State #set-options "--z3rlimit 20" (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let sha_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires sha_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ sha_post code va_s0 va_s1 f)) = VC.va_lemma_Check_sha_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let sha_lemma = as_t #(VSig.vale_sig_stdcall sha_pre sha_post) sha_lemma' noextract let code_sha = VC.va_code_Check_sha_stdcall IA.win (* Here's the type expected for the check_aesni wrapper *) [@__reduce__] noextract let lowstar_sha_t = IX64.as_lowstar_sig_t_weak_stdcall code_sha dom [] _ _ (W.mk_prediction code_sha dom [] (sha_lemma code_sha IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let adx_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_adx_bmi2_stdcall c va_s0 IA.win [@__reduce__] noextract let adx_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_adx_bmi2_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let adx_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires adx_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ adx_post code va_s0 va_s1 f)) = VC.va_lemma_Check_adx_bmi2_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let adx_lemma = as_t #(VSig.vale_sig_stdcall adx_pre adx_post) adx_lemma' noextract let code_adx = VC.va_code_Check_adx_bmi2_stdcall IA.win (* Here's the type expected for the check_adx wrapper *) [@__reduce__] noextract let lowstar_adx_t = IX64.as_lowstar_sig_t_weak_stdcall code_adx dom [] _ _ (W.mk_prediction code_adx dom [] (adx_lemma code_adx IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let avx_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_avx_stdcall c va_s0 IA.win [@__reduce__] noextract

Vale.Stdcalls.X64.Cpuid.fsti

val avx_post:VSig.vale_post dom

Vale.Stdcalls.X64.Cpuid.avx_post

Vale.AsLowStar.ValeSig.vale_post Vale.Stdcalls.X64.Cpuid.dom

Prims.Tot

val osxsave_pre:VSig.vale_pre dom

let osxsave_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_osxsave_stdcall c va_s0 IA.win

val osxsave_pre:VSig.vale_pre dom let osxsave_pre:VSig.vale_pre dom =

fun (c: V.va_code) (va_s0: V.va_state) -> VC.va_req_Check_osxsave_stdcall c va_s0 IA.win

module Vale.Stdcalls.X64.Cpuid open FStar.Mul open Vale.Interop.Base module IX64 = Vale.Interop.X64 module VSig = Vale.AsLowStar.ValeSig module LSig = Vale.AsLowStar.LowStarSig module V = Vale.X64.Decls module IA = Vale.Interop.Assumptions module W = Vale.AsLowStar.Wrapper open Vale.X64.MemoryAdapters module VC = Vale.Lib.X64.Cpuidstdcall (* A little utility to trigger normalization in types *) noextract let as_t (#a:Type) (x:normal a) : a = x noextract let as_normal_t (#a:Type) (x:a) : normal a = x [@__reduce__] noextract let dom: IX64.arity_ok_stdcall td = [] (* Need to rearrange the order of arguments *) [@__reduce__] noextract let aesni_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_aesni_stdcall c va_s0 IA.win [@__reduce__] noextract let aesni_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_aesni_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let aesni_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires aesni_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ aesni_post code va_s0 va_s1 f)) = VC.va_lemma_Check_aesni_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let aesni_lemma = as_t #(VSig.vale_sig_stdcall aesni_pre aesni_post) aesni_lemma' noextract let code_aesni = VC.va_code_Check_aesni_stdcall IA.win (* Here's the type expected for the check_aesni wrapper *) [@__reduce__] noextract let lowstar_aesni_t = IX64.as_lowstar_sig_t_weak_stdcall code_aesni dom [] _ _ (W.mk_prediction code_aesni dom [] (aesni_lemma code_aesni IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let sha_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_sha_stdcall c va_s0 IA.win [@__reduce__] noextract let sha_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_sha_stdcall c va_s0 IA.win va_s1 f open Vale.X64.Machine_s open Vale.X64.State #set-options "--z3rlimit 20" (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let sha_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires sha_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ sha_post code va_s0 va_s1 f)) = VC.va_lemma_Check_sha_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let sha_lemma = as_t #(VSig.vale_sig_stdcall sha_pre sha_post) sha_lemma' noextract let code_sha = VC.va_code_Check_sha_stdcall IA.win (* Here's the type expected for the check_aesni wrapper *) [@__reduce__] noextract let lowstar_sha_t = IX64.as_lowstar_sig_t_weak_stdcall code_sha dom [] _ _ (W.mk_prediction code_sha dom [] (sha_lemma code_sha IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let adx_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_adx_bmi2_stdcall c va_s0 IA.win [@__reduce__] noextract let adx_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_adx_bmi2_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let adx_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires adx_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ adx_post code va_s0 va_s1 f)) = VC.va_lemma_Check_adx_bmi2_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let adx_lemma = as_t #(VSig.vale_sig_stdcall adx_pre adx_post) adx_lemma' noextract let code_adx = VC.va_code_Check_adx_bmi2_stdcall IA.win (* Here's the type expected for the check_adx wrapper *) [@__reduce__] noextract let lowstar_adx_t = IX64.as_lowstar_sig_t_weak_stdcall code_adx dom [] _ _ (W.mk_prediction code_adx dom [] (adx_lemma code_adx IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let avx_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_avx_stdcall c va_s0 IA.win [@__reduce__] noextract let avx_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_avx_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let avx_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires avx_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ avx_post code va_s0 va_s1 f)) = VC.va_lemma_Check_avx_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let avx_lemma = as_t #(VSig.vale_sig_stdcall avx_pre avx_post) avx_lemma' noextract let code_avx = VC.va_code_Check_avx_stdcall IA.win (* Here's the type expected for the check_avx wrapper *) [@__reduce__] noextract let lowstar_avx_t = IX64.as_lowstar_sig_t_weak_stdcall code_avx dom [] _ _ (W.mk_prediction code_avx dom [] (avx_lemma code_avx IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let avx2_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_avx2_stdcall c va_s0 IA.win [@__reduce__] noextract let avx2_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_avx2_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let avx2_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires avx2_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ avx2_post code va_s0 va_s1 f)) = VC.va_lemma_Check_avx2_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let avx2_lemma = as_t #(VSig.vale_sig_stdcall avx2_pre avx2_post) avx2_lemma' noextract let code_avx2 = VC.va_code_Check_avx2_stdcall IA.win (* Here's the type expected for the check_avx wrapper *) [@__reduce__] noextract let lowstar_avx2_t = IX64.as_lowstar_sig_t_weak_stdcall code_avx2 dom [] _ _ (W.mk_prediction code_avx2 dom [] (avx2_lemma code_avx2 IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let movbe_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_movbe_stdcall c va_s0 IA.win [@__reduce__] noextract let movbe_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_movbe_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let movbe_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires movbe_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ movbe_post code va_s0 va_s1 f)) = VC.va_lemma_Check_movbe_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let movbe_lemma = as_t #(VSig.vale_sig_stdcall movbe_pre movbe_post) movbe_lemma' noextract let code_movbe = VC.va_code_Check_movbe_stdcall IA.win (* Here's the type expected for the check_movbe wrapper *) [@__reduce__] noextract let lowstar_movbe_t = IX64.as_lowstar_sig_t_weak_stdcall code_movbe dom [] _ _ (W.mk_prediction code_movbe dom [] (movbe_lemma code_movbe IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let sse_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_sse_stdcall c va_s0 IA.win [@__reduce__] noextract let sse_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_sse_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let sse_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires sse_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ sse_post code va_s0 va_s1 f)) = VC.va_lemma_Check_sse_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let sse_lemma = as_t #(VSig.vale_sig_stdcall sse_pre sse_post) sse_lemma' noextract let code_sse = VC.va_code_Check_sse_stdcall IA.win (* Here's the type expected for the check_sse wrapper *) [@__reduce__] noextract let lowstar_sse_t = IX64.as_lowstar_sig_t_weak_stdcall code_sse dom [] _ _ (W.mk_prediction code_sse dom [] (sse_lemma code_sse IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let rdrand_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_rdrand_stdcall c va_s0 IA.win [@__reduce__] noextract let rdrand_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_rdrand_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let rdrand_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires rdrand_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ rdrand_post code va_s0 va_s1 f)) = VC.va_lemma_Check_rdrand_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let rdrand_lemma = as_t #(VSig.vale_sig_stdcall rdrand_pre rdrand_post) rdrand_lemma' noextract let code_rdrand = VC.va_code_Check_rdrand_stdcall IA.win (* Here's the type expected for the check_rdrand wrapper *) [@__reduce__] noextract let lowstar_rdrand_t = IX64.as_lowstar_sig_t_weak_stdcall code_rdrand dom [] _ _ (W.mk_prediction code_rdrand dom [] (rdrand_lemma code_rdrand IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let avx512_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_avx512_stdcall c va_s0 IA.win [@__reduce__] noextract let avx512_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_avx512_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let avx512_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires avx512_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ avx512_post code va_s0 va_s1 f)) = VC.va_lemma_Check_avx512_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let avx512_lemma = as_t #(VSig.vale_sig_stdcall avx512_pre avx512_post) avx512_lemma' noextract let code_avx512 = VC.va_code_Check_avx512_stdcall IA.win (* Here's the type expected for the check_avx wrapper *) [@__reduce__] noextract let lowstar_avx512_t = IX64.as_lowstar_sig_t_weak_stdcall code_avx512 dom [] _ _ (W.mk_prediction code_avx512 dom [] (avx512_lemma code_avx512 IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract

Vale.Stdcalls.X64.Cpuid.fsti

val osxsave_pre:VSig.vale_pre dom

Vale.Stdcalls.X64.Cpuid.osxsave_pre

Vale.AsLowStar.ValeSig.vale_pre Vale.Stdcalls.X64.Cpuid.dom

Prims.Tot

val avx_xcr0_pre:VSig.vale_pre dom

let avx_xcr0_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_avx_xcr0_stdcall c va_s0 IA.win

val avx_xcr0_pre:VSig.vale_pre dom let avx_xcr0_pre:VSig.vale_pre dom =

fun (c: V.va_code) (va_s0: V.va_state) -> VC.va_req_Check_avx_xcr0_stdcall c va_s0 IA.win

module Vale.Stdcalls.X64.Cpuid open FStar.Mul open Vale.Interop.Base module IX64 = Vale.Interop.X64 module VSig = Vale.AsLowStar.ValeSig module LSig = Vale.AsLowStar.LowStarSig module V = Vale.X64.Decls module IA = Vale.Interop.Assumptions module W = Vale.AsLowStar.Wrapper open Vale.X64.MemoryAdapters module VC = Vale.Lib.X64.Cpuidstdcall (* A little utility to trigger normalization in types *) noextract let as_t (#a:Type) (x:normal a) : a = x noextract let as_normal_t (#a:Type) (x:a) : normal a = x [@__reduce__] noextract let dom: IX64.arity_ok_stdcall td = [] (* Need to rearrange the order of arguments *) [@__reduce__] noextract let aesni_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_aesni_stdcall c va_s0 IA.win [@__reduce__] noextract let aesni_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_aesni_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let aesni_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires aesni_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ aesni_post code va_s0 va_s1 f)) = VC.va_lemma_Check_aesni_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let aesni_lemma = as_t #(VSig.vale_sig_stdcall aesni_pre aesni_post) aesni_lemma' noextract let code_aesni = VC.va_code_Check_aesni_stdcall IA.win (* Here's the type expected for the check_aesni wrapper *) [@__reduce__] noextract let lowstar_aesni_t = IX64.as_lowstar_sig_t_weak_stdcall code_aesni dom [] _ _ (W.mk_prediction code_aesni dom [] (aesni_lemma code_aesni IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let sha_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_sha_stdcall c va_s0 IA.win [@__reduce__] noextract let sha_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_sha_stdcall c va_s0 IA.win va_s1 f open Vale.X64.Machine_s open Vale.X64.State #set-options "--z3rlimit 20" (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let sha_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires sha_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ sha_post code va_s0 va_s1 f)) = VC.va_lemma_Check_sha_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let sha_lemma = as_t #(VSig.vale_sig_stdcall sha_pre sha_post) sha_lemma' noextract let code_sha = VC.va_code_Check_sha_stdcall IA.win (* Here's the type expected for the check_aesni wrapper *) [@__reduce__] noextract let lowstar_sha_t = IX64.as_lowstar_sig_t_weak_stdcall code_sha dom [] _ _ (W.mk_prediction code_sha dom [] (sha_lemma code_sha IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let adx_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_adx_bmi2_stdcall c va_s0 IA.win [@__reduce__] noextract let adx_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_adx_bmi2_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let adx_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires adx_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ adx_post code va_s0 va_s1 f)) = VC.va_lemma_Check_adx_bmi2_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let adx_lemma = as_t #(VSig.vale_sig_stdcall adx_pre adx_post) adx_lemma' noextract let code_adx = VC.va_code_Check_adx_bmi2_stdcall IA.win (* Here's the type expected for the check_adx wrapper *) [@__reduce__] noextract let lowstar_adx_t = IX64.as_lowstar_sig_t_weak_stdcall code_adx dom [] _ _ (W.mk_prediction code_adx dom [] (adx_lemma code_adx IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let avx_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_avx_stdcall c va_s0 IA.win [@__reduce__] noextract let avx_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_avx_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let avx_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires avx_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ avx_post code va_s0 va_s1 f)) = VC.va_lemma_Check_avx_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let avx_lemma = as_t #(VSig.vale_sig_stdcall avx_pre avx_post) avx_lemma' noextract let code_avx = VC.va_code_Check_avx_stdcall IA.win (* Here's the type expected for the check_avx wrapper *) [@__reduce__] noextract let lowstar_avx_t = IX64.as_lowstar_sig_t_weak_stdcall code_avx dom [] _ _ (W.mk_prediction code_avx dom [] (avx_lemma code_avx IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let avx2_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_avx2_stdcall c va_s0 IA.win [@__reduce__] noextract let avx2_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_avx2_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let avx2_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires avx2_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ avx2_post code va_s0 va_s1 f)) = VC.va_lemma_Check_avx2_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let avx2_lemma = as_t #(VSig.vale_sig_stdcall avx2_pre avx2_post) avx2_lemma' noextract let code_avx2 = VC.va_code_Check_avx2_stdcall IA.win (* Here's the type expected for the check_avx wrapper *) [@__reduce__] noextract let lowstar_avx2_t = IX64.as_lowstar_sig_t_weak_stdcall code_avx2 dom [] _ _ (W.mk_prediction code_avx2 dom [] (avx2_lemma code_avx2 IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let movbe_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_movbe_stdcall c va_s0 IA.win [@__reduce__] noextract let movbe_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_movbe_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let movbe_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires movbe_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ movbe_post code va_s0 va_s1 f)) = VC.va_lemma_Check_movbe_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let movbe_lemma = as_t #(VSig.vale_sig_stdcall movbe_pre movbe_post) movbe_lemma' noextract let code_movbe = VC.va_code_Check_movbe_stdcall IA.win (* Here's the type expected for the check_movbe wrapper *) [@__reduce__] noextract let lowstar_movbe_t = IX64.as_lowstar_sig_t_weak_stdcall code_movbe dom [] _ _ (W.mk_prediction code_movbe dom [] (movbe_lemma code_movbe IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let sse_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_sse_stdcall c va_s0 IA.win [@__reduce__] noextract let sse_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_sse_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let sse_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires sse_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ sse_post code va_s0 va_s1 f)) = VC.va_lemma_Check_sse_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let sse_lemma = as_t #(VSig.vale_sig_stdcall sse_pre sse_post) sse_lemma' noextract let code_sse = VC.va_code_Check_sse_stdcall IA.win (* Here's the type expected for the check_sse wrapper *) [@__reduce__] noextract let lowstar_sse_t = IX64.as_lowstar_sig_t_weak_stdcall code_sse dom [] _ _ (W.mk_prediction code_sse dom [] (sse_lemma code_sse IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let rdrand_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_rdrand_stdcall c va_s0 IA.win [@__reduce__] noextract let rdrand_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_rdrand_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let rdrand_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires rdrand_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ rdrand_post code va_s0 va_s1 f)) = VC.va_lemma_Check_rdrand_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let rdrand_lemma = as_t #(VSig.vale_sig_stdcall rdrand_pre rdrand_post) rdrand_lemma' noextract let code_rdrand = VC.va_code_Check_rdrand_stdcall IA.win (* Here's the type expected for the check_rdrand wrapper *) [@__reduce__] noextract let lowstar_rdrand_t = IX64.as_lowstar_sig_t_weak_stdcall code_rdrand dom [] _ _ (W.mk_prediction code_rdrand dom [] (rdrand_lemma code_rdrand IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let avx512_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_avx512_stdcall c va_s0 IA.win [@__reduce__] noextract let avx512_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_avx512_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let avx512_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires avx512_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ avx512_post code va_s0 va_s1 f)) = VC.va_lemma_Check_avx512_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let avx512_lemma = as_t #(VSig.vale_sig_stdcall avx512_pre avx512_post) avx512_lemma' noextract let code_avx512 = VC.va_code_Check_avx512_stdcall IA.win (* Here's the type expected for the check_avx wrapper *) [@__reduce__] noextract let lowstar_avx512_t = IX64.as_lowstar_sig_t_weak_stdcall code_avx512 dom [] _ _ (W.mk_prediction code_avx512 dom [] (avx512_lemma code_avx512 IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let osxsave_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_osxsave_stdcall c va_s0 IA.win [@__reduce__] noextract let osxsave_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_osxsave_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let osxsave_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires osxsave_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ osxsave_post code va_s0 va_s1 f)) = VC.va_lemma_Check_osxsave_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let osxsave_lemma = as_t #(VSig.vale_sig_stdcall osxsave_pre osxsave_post) osxsave_lemma' noextract let code_osxsave = VC.va_code_Check_osxsave_stdcall IA.win (* Here's the type expected for the check_osxsave wrapper *) [@__reduce__] noextract let lowstar_osxsave_t = IX64.as_lowstar_sig_t_weak_stdcall code_osxsave dom [] _ _ (W.mk_prediction code_osxsave dom [] (osxsave_lemma code_osxsave IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract

Vale.Stdcalls.X64.Cpuid.fsti

val avx_xcr0_pre:VSig.vale_pre dom

Vale.Stdcalls.X64.Cpuid.avx_xcr0_pre

Vale.AsLowStar.ValeSig.vale_pre Vale.Stdcalls.X64.Cpuid.dom

Prims.Tot

let code_avx2 = VC.va_code_Check_avx2_stdcall IA.win

let code_avx2 =

VC.va_code_Check_avx2_stdcall IA.win

module Vale.Stdcalls.X64.Cpuid open FStar.Mul open Vale.Interop.Base module IX64 = Vale.Interop.X64 module VSig = Vale.AsLowStar.ValeSig module LSig = Vale.AsLowStar.LowStarSig module V = Vale.X64.Decls module IA = Vale.Interop.Assumptions module W = Vale.AsLowStar.Wrapper open Vale.X64.MemoryAdapters module VC = Vale.Lib.X64.Cpuidstdcall (* A little utility to trigger normalization in types *) noextract let as_t (#a:Type) (x:normal a) : a = x noextract let as_normal_t (#a:Type) (x:a) : normal a = x [@__reduce__] noextract let dom: IX64.arity_ok_stdcall td = [] (* Need to rearrange the order of arguments *) [@__reduce__] noextract let aesni_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_aesni_stdcall c va_s0 IA.win [@__reduce__] noextract let aesni_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_aesni_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let aesni_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires aesni_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ aesni_post code va_s0 va_s1 f)) = VC.va_lemma_Check_aesni_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let aesni_lemma = as_t #(VSig.vale_sig_stdcall aesni_pre aesni_post) aesni_lemma' noextract let code_aesni = VC.va_code_Check_aesni_stdcall IA.win (* Here's the type expected for the check_aesni wrapper *) [@__reduce__] noextract let lowstar_aesni_t = IX64.as_lowstar_sig_t_weak_stdcall code_aesni dom [] _ _ (W.mk_prediction code_aesni dom [] (aesni_lemma code_aesni IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let sha_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_sha_stdcall c va_s0 IA.win [@__reduce__] noextract let sha_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_sha_stdcall c va_s0 IA.win va_s1 f open Vale.X64.Machine_s open Vale.X64.State #set-options "--z3rlimit 20" (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let sha_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires sha_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ sha_post code va_s0 va_s1 f)) = VC.va_lemma_Check_sha_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let sha_lemma = as_t #(VSig.vale_sig_stdcall sha_pre sha_post) sha_lemma' noextract let code_sha = VC.va_code_Check_sha_stdcall IA.win (* Here's the type expected for the check_aesni wrapper *) [@__reduce__] noextract let lowstar_sha_t = IX64.as_lowstar_sig_t_weak_stdcall code_sha dom [] _ _ (W.mk_prediction code_sha dom [] (sha_lemma code_sha IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let adx_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_adx_bmi2_stdcall c va_s0 IA.win [@__reduce__] noextract let adx_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_adx_bmi2_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let adx_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires adx_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ adx_post code va_s0 va_s1 f)) = VC.va_lemma_Check_adx_bmi2_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let adx_lemma = as_t #(VSig.vale_sig_stdcall adx_pre adx_post) adx_lemma' noextract let code_adx = VC.va_code_Check_adx_bmi2_stdcall IA.win (* Here's the type expected for the check_adx wrapper *) [@__reduce__] noextract let lowstar_adx_t = IX64.as_lowstar_sig_t_weak_stdcall code_adx dom [] _ _ (W.mk_prediction code_adx dom [] (adx_lemma code_adx IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let avx_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_avx_stdcall c va_s0 IA.win [@__reduce__] noextract let avx_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_avx_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let avx_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires avx_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ avx_post code va_s0 va_s1 f)) = VC.va_lemma_Check_avx_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let avx_lemma = as_t #(VSig.vale_sig_stdcall avx_pre avx_post) avx_lemma' noextract let code_avx = VC.va_code_Check_avx_stdcall IA.win (* Here's the type expected for the check_avx wrapper *) [@__reduce__] noextract let lowstar_avx_t = IX64.as_lowstar_sig_t_weak_stdcall code_avx dom [] _ _ (W.mk_prediction code_avx dom [] (avx_lemma code_avx IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let avx2_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_avx2_stdcall c va_s0 IA.win [@__reduce__] noextract let avx2_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_avx2_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let avx2_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires avx2_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ avx2_post code va_s0 va_s1 f)) = VC.va_lemma_Check_avx2_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let avx2_lemma = as_t #(VSig.vale_sig_stdcall avx2_pre avx2_post) avx2_lemma'

Vale.Stdcalls.X64.Cpuid.fsti

val code_avx2 : Vale.X64.Decls.va_code

Vale.Stdcalls.X64.Cpuid.code_avx2

Vale.X64.Decls.va_code

Prims.Tot

val avx_pre:VSig.vale_pre dom

let avx_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_avx_stdcall c va_s0 IA.win

val avx_pre:VSig.vale_pre dom let avx_pre:VSig.vale_pre dom =

fun (c: V.va_code) (va_s0: V.va_state) -> VC.va_req_Check_avx_stdcall c va_s0 IA.win

module Vale.Stdcalls.X64.Cpuid open FStar.Mul open Vale.Interop.Base module IX64 = Vale.Interop.X64 module VSig = Vale.AsLowStar.ValeSig module LSig = Vale.AsLowStar.LowStarSig module V = Vale.X64.Decls module IA = Vale.Interop.Assumptions module W = Vale.AsLowStar.Wrapper open Vale.X64.MemoryAdapters module VC = Vale.Lib.X64.Cpuidstdcall (* A little utility to trigger normalization in types *) noextract let as_t (#a:Type) (x:normal a) : a = x noextract let as_normal_t (#a:Type) (x:a) : normal a = x [@__reduce__] noextract let dom: IX64.arity_ok_stdcall td = [] (* Need to rearrange the order of arguments *) [@__reduce__] noextract let aesni_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_aesni_stdcall c va_s0 IA.win [@__reduce__] noextract let aesni_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_aesni_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let aesni_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires aesni_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ aesni_post code va_s0 va_s1 f)) = VC.va_lemma_Check_aesni_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let aesni_lemma = as_t #(VSig.vale_sig_stdcall aesni_pre aesni_post) aesni_lemma' noextract let code_aesni = VC.va_code_Check_aesni_stdcall IA.win (* Here's the type expected for the check_aesni wrapper *) [@__reduce__] noextract let lowstar_aesni_t = IX64.as_lowstar_sig_t_weak_stdcall code_aesni dom [] _ _ (W.mk_prediction code_aesni dom [] (aesni_lemma code_aesni IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let sha_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_sha_stdcall c va_s0 IA.win [@__reduce__] noextract let sha_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_sha_stdcall c va_s0 IA.win va_s1 f open Vale.X64.Machine_s open Vale.X64.State #set-options "--z3rlimit 20" (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let sha_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires sha_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ sha_post code va_s0 va_s1 f)) = VC.va_lemma_Check_sha_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let sha_lemma = as_t #(VSig.vale_sig_stdcall sha_pre sha_post) sha_lemma' noextract let code_sha = VC.va_code_Check_sha_stdcall IA.win (* Here's the type expected for the check_aesni wrapper *) [@__reduce__] noextract let lowstar_sha_t = IX64.as_lowstar_sig_t_weak_stdcall code_sha dom [] _ _ (W.mk_prediction code_sha dom [] (sha_lemma code_sha IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let adx_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_adx_bmi2_stdcall c va_s0 IA.win [@__reduce__] noextract let adx_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_adx_bmi2_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let adx_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires adx_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ adx_post code va_s0 va_s1 f)) = VC.va_lemma_Check_adx_bmi2_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let adx_lemma = as_t #(VSig.vale_sig_stdcall adx_pre adx_post) adx_lemma' noextract let code_adx = VC.va_code_Check_adx_bmi2_stdcall IA.win (* Here's the type expected for the check_adx wrapper *) [@__reduce__] noextract let lowstar_adx_t = IX64.as_lowstar_sig_t_weak_stdcall code_adx dom [] _ _ (W.mk_prediction code_adx dom [] (adx_lemma code_adx IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract

Vale.Stdcalls.X64.Cpuid.fsti

val avx_pre:VSig.vale_pre dom

Vale.Stdcalls.X64.Cpuid.avx_pre

Vale.AsLowStar.ValeSig.vale_pre Vale.Stdcalls.X64.Cpuid.dom

Prims.Tot

val sse_pre:VSig.vale_pre dom

let sse_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_sse_stdcall c va_s0 IA.win

val sse_pre:VSig.vale_pre dom let sse_pre:VSig.vale_pre dom =

fun (c: V.va_code) (va_s0: V.va_state) -> VC.va_req_Check_sse_stdcall c va_s0 IA.win

module Vale.Stdcalls.X64.Cpuid open FStar.Mul open Vale.Interop.Base module IX64 = Vale.Interop.X64 module VSig = Vale.AsLowStar.ValeSig module LSig = Vale.AsLowStar.LowStarSig module V = Vale.X64.Decls module IA = Vale.Interop.Assumptions module W = Vale.AsLowStar.Wrapper open Vale.X64.MemoryAdapters module VC = Vale.Lib.X64.Cpuidstdcall (* A little utility to trigger normalization in types *) noextract let as_t (#a:Type) (x:normal a) : a = x noextract let as_normal_t (#a:Type) (x:a) : normal a = x [@__reduce__] noextract let dom: IX64.arity_ok_stdcall td = [] (* Need to rearrange the order of arguments *) [@__reduce__] noextract let aesni_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_aesni_stdcall c va_s0 IA.win [@__reduce__] noextract let aesni_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_aesni_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let aesni_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires aesni_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ aesni_post code va_s0 va_s1 f)) = VC.va_lemma_Check_aesni_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let aesni_lemma = as_t #(VSig.vale_sig_stdcall aesni_pre aesni_post) aesni_lemma' noextract let code_aesni = VC.va_code_Check_aesni_stdcall IA.win (* Here's the type expected for the check_aesni wrapper *) [@__reduce__] noextract let lowstar_aesni_t = IX64.as_lowstar_sig_t_weak_stdcall code_aesni dom [] _ _ (W.mk_prediction code_aesni dom [] (aesni_lemma code_aesni IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let sha_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_sha_stdcall c va_s0 IA.win [@__reduce__] noextract let sha_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_sha_stdcall c va_s0 IA.win va_s1 f open Vale.X64.Machine_s open Vale.X64.State #set-options "--z3rlimit 20" (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let sha_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires sha_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ sha_post code va_s0 va_s1 f)) = VC.va_lemma_Check_sha_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let sha_lemma = as_t #(VSig.vale_sig_stdcall sha_pre sha_post) sha_lemma' noextract let code_sha = VC.va_code_Check_sha_stdcall IA.win (* Here's the type expected for the check_aesni wrapper *) [@__reduce__] noextract let lowstar_sha_t = IX64.as_lowstar_sig_t_weak_stdcall code_sha dom [] _ _ (W.mk_prediction code_sha dom [] (sha_lemma code_sha IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let adx_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_adx_bmi2_stdcall c va_s0 IA.win [@__reduce__] noextract let adx_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_adx_bmi2_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let adx_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires adx_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ adx_post code va_s0 va_s1 f)) = VC.va_lemma_Check_adx_bmi2_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let adx_lemma = as_t #(VSig.vale_sig_stdcall adx_pre adx_post) adx_lemma' noextract let code_adx = VC.va_code_Check_adx_bmi2_stdcall IA.win (* Here's the type expected for the check_adx wrapper *) [@__reduce__] noextract let lowstar_adx_t = IX64.as_lowstar_sig_t_weak_stdcall code_adx dom [] _ _ (W.mk_prediction code_adx dom [] (adx_lemma code_adx IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let avx_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_avx_stdcall c va_s0 IA.win [@__reduce__] noextract let avx_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_avx_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let avx_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires avx_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ avx_post code va_s0 va_s1 f)) = VC.va_lemma_Check_avx_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let avx_lemma = as_t #(VSig.vale_sig_stdcall avx_pre avx_post) avx_lemma' noextract let code_avx = VC.va_code_Check_avx_stdcall IA.win (* Here's the type expected for the check_avx wrapper *) [@__reduce__] noextract let lowstar_avx_t = IX64.as_lowstar_sig_t_weak_stdcall code_avx dom [] _ _ (W.mk_prediction code_avx dom [] (avx_lemma code_avx IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let avx2_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_avx2_stdcall c va_s0 IA.win [@__reduce__] noextract let avx2_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_avx2_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let avx2_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires avx2_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ avx2_post code va_s0 va_s1 f)) = VC.va_lemma_Check_avx2_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let avx2_lemma = as_t #(VSig.vale_sig_stdcall avx2_pre avx2_post) avx2_lemma' noextract let code_avx2 = VC.va_code_Check_avx2_stdcall IA.win (* Here's the type expected for the check_avx wrapper *) [@__reduce__] noextract let lowstar_avx2_t = IX64.as_lowstar_sig_t_weak_stdcall code_avx2 dom [] _ _ (W.mk_prediction code_avx2 dom [] (avx2_lemma code_avx2 IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let movbe_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_movbe_stdcall c va_s0 IA.win [@__reduce__] noextract let movbe_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_movbe_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let movbe_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires movbe_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ movbe_post code va_s0 va_s1 f)) = VC.va_lemma_Check_movbe_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let movbe_lemma = as_t #(VSig.vale_sig_stdcall movbe_pre movbe_post) movbe_lemma' noextract let code_movbe = VC.va_code_Check_movbe_stdcall IA.win (* Here's the type expected for the check_movbe wrapper *) [@__reduce__] noextract let lowstar_movbe_t = IX64.as_lowstar_sig_t_weak_stdcall code_movbe dom [] _ _ (W.mk_prediction code_movbe dom [] (movbe_lemma code_movbe IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract

Vale.Stdcalls.X64.Cpuid.fsti

val sse_pre:VSig.vale_pre dom

Vale.Stdcalls.X64.Cpuid.sse_pre

Vale.AsLowStar.ValeSig.vale_pre Vale.Stdcalls.X64.Cpuid.dom

Prims.Tot

let code_avx = VC.va_code_Check_avx_stdcall IA.win

let code_avx =

VC.va_code_Check_avx_stdcall IA.win

module Vale.Stdcalls.X64.Cpuid open FStar.Mul open Vale.Interop.Base module IX64 = Vale.Interop.X64 module VSig = Vale.AsLowStar.ValeSig module LSig = Vale.AsLowStar.LowStarSig module V = Vale.X64.Decls module IA = Vale.Interop.Assumptions module W = Vale.AsLowStar.Wrapper open Vale.X64.MemoryAdapters module VC = Vale.Lib.X64.Cpuidstdcall (* A little utility to trigger normalization in types *) noextract let as_t (#a:Type) (x:normal a) : a = x noextract let as_normal_t (#a:Type) (x:a) : normal a = x [@__reduce__] noextract let dom: IX64.arity_ok_stdcall td = [] (* Need to rearrange the order of arguments *) [@__reduce__] noextract let aesni_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_aesni_stdcall c va_s0 IA.win [@__reduce__] noextract let aesni_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_aesni_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let aesni_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires aesni_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ aesni_post code va_s0 va_s1 f)) = VC.va_lemma_Check_aesni_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let aesni_lemma = as_t #(VSig.vale_sig_stdcall aesni_pre aesni_post) aesni_lemma' noextract let code_aesni = VC.va_code_Check_aesni_stdcall IA.win (* Here's the type expected for the check_aesni wrapper *) [@__reduce__] noextract let lowstar_aesni_t = IX64.as_lowstar_sig_t_weak_stdcall code_aesni dom [] _ _ (W.mk_prediction code_aesni dom [] (aesni_lemma code_aesni IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let sha_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_sha_stdcall c va_s0 IA.win [@__reduce__] noextract let sha_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_sha_stdcall c va_s0 IA.win va_s1 f open Vale.X64.Machine_s open Vale.X64.State #set-options "--z3rlimit 20" (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let sha_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires sha_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ sha_post code va_s0 va_s1 f)) = VC.va_lemma_Check_sha_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let sha_lemma = as_t #(VSig.vale_sig_stdcall sha_pre sha_post) sha_lemma' noextract let code_sha = VC.va_code_Check_sha_stdcall IA.win (* Here's the type expected for the check_aesni wrapper *) [@__reduce__] noextract let lowstar_sha_t = IX64.as_lowstar_sig_t_weak_stdcall code_sha dom [] _ _ (W.mk_prediction code_sha dom [] (sha_lemma code_sha IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let adx_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_adx_bmi2_stdcall c va_s0 IA.win [@__reduce__] noextract let adx_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_adx_bmi2_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let adx_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires adx_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ adx_post code va_s0 va_s1 f)) = VC.va_lemma_Check_adx_bmi2_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let adx_lemma = as_t #(VSig.vale_sig_stdcall adx_pre adx_post) adx_lemma' noextract let code_adx = VC.va_code_Check_adx_bmi2_stdcall IA.win (* Here's the type expected for the check_adx wrapper *) [@__reduce__] noextract let lowstar_adx_t = IX64.as_lowstar_sig_t_weak_stdcall code_adx dom [] _ _ (W.mk_prediction code_adx dom [] (adx_lemma code_adx IA.win)) (* Need to rearrange the order of arguments *) [@__reduce__] noextract let avx_pre : VSig.vale_pre dom = fun (c:V.va_code) (va_s0:V.va_state) -> VC.va_req_Check_avx_stdcall c va_s0 IA.win [@__reduce__] noextract let avx_post : VSig.vale_post dom = fun (c:V.va_code) (va_s0:V.va_state) (va_s1:V.va_state) (f:V.va_fuel) -> VC.va_ens_Check_avx_stdcall c va_s0 IA.win va_s1 f (* The vale lemma doesn't quite suffice to prove the modifies clause expected of the interop layer *) [@__reduce__] noextract let avx_lemma' (code:V.va_code) (_win:bool) (va_s0:V.va_state) : Ghost (V.va_state & V.va_fuel) (requires avx_pre code va_s0) (ensures (fun (va_s1, f) -> V.eval_code code va_s0 f va_s1 /\ VSig.vale_calling_conventions_stdcall va_s0 va_s1 /\ avx_post code va_s0 va_s1 f)) = VC.va_lemma_Check_avx_stdcall code va_s0 IA.win (* Prove that vm_lemma' has the required type *) noextract let avx_lemma = as_t #(VSig.vale_sig_stdcall avx_pre avx_post) avx_lemma'

Vale.Stdcalls.X64.Cpuid.fsti

val code_avx : Vale.X64.Decls.va_code

Vale.Stdcalls.X64.Cpuid.code_avx

Vale.X64.Decls.va_code

Prims.Tot

val avx_xcr0_post:VSig.vale_post dom