Datasets:

microsoft

/

FStarDataSet

like 2

Follow

Microsoft 4,776

FStar.ST.ST

val of_seq (#a:Type0) (s:seq a) : ST (array a) (requires fun _ -> True) (ensures create_post s)

let of_seq #a s = ST.alloc s

val of_seq (#a:Type0) (s:seq a) : ST (array a) (requires fun _ -> True) (ensures create_post s) let of_seq #a s =

ST.alloc s

(* Copyright 2008-2014 Nikhil Swamy and 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. *) (** F* standard library mutable arrays module. @summary Mutable arrays *) module FStar.Array #set-options "--max_fuel 0 --initial_fuel 0 --initial_ifuel 0 --max_ifuel 0" open FStar.All open FStar.Seq open FStar.Ref let array a = ref (seq a) let as_ref #_ arr = arr let op_At_Bar #a s1 s2 = let s1' = !s1 in let s2' = !s2 in ST.alloc (Seq.append s1' s2')

FStar.Array.fst

val of_seq (#a:Type0) (s:seq a) : ST (array a) (requires fun _ -> True) (ensures create_post s)

FStar.Array.of_seq

s: FStar.Seq.Base.seq a -> FStar.ST.ST (FStar.Array.array a)

FStar.ST.ST

val to_seq (#a:Type0) (s:array a) : ST (seq a) (requires (fun h -> contains h s)) (ensures (fun h0 x h1 -> (sel h0 s == x /\ h0 == h1)))

let to_seq #a s = !s

val to_seq (#a:Type0) (s:array a) : ST (seq a) (requires (fun h -> contains h s)) (ensures (fun h0 x h1 -> (sel h0 s == x /\ h0 == h1))) let to_seq #a s =

!s

(* Copyright 2008-2014 Nikhil Swamy and 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. *) (** F* standard library mutable arrays module. @summary Mutable arrays *) module FStar.Array #set-options "--max_fuel 0 --initial_fuel 0 --initial_ifuel 0 --max_ifuel 0" open FStar.All open FStar.Seq open FStar.Ref let array a = ref (seq a) let as_ref #_ arr = arr let op_At_Bar #a s1 s2 = let s1' = !s1 in let s2' = !s2 in ST.alloc (Seq.append s1' s2') let of_seq #a s = ST.alloc s

FStar.Array.fst

val to_seq (#a:Type0) (s:array a) : ST (seq a) (requires (fun h -> contains h s)) (ensures (fun h0 x h1 -> (sel h0 s == x /\ h0 == h1)))

FStar.Array.to_seq

s: FStar.Array.array a -> FStar.ST.ST (FStar.Seq.Base.seq a)

FStar.ST.ST

val index (#a:Type0) (x:array a) (n:nat) : ST a (requires (fun h -> contains h x /\ n < Seq.length (sel h x))) (ensures (fun h0 v h1 -> n < Seq.length (sel h0 x) /\ h0 == h1 /\ v == Seq.index (sel h0 x) n))

let index #a x n = let s = to_seq x in Seq.index s n

val index (#a:Type0) (x:array a) (n:nat) : ST a (requires (fun h -> contains h x /\ n < Seq.length (sel h x))) (ensures (fun h0 v h1 -> n < Seq.length (sel h0 x) /\ h0 == h1 /\ v == Seq.index (sel h0 x) n)) let index #a x n =

let s = to_seq x in Seq.index s n

(* Copyright 2008-2014 Nikhil Swamy and 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. *) (** F* standard library mutable arrays module. @summary Mutable arrays *) module FStar.Array #set-options "--max_fuel 0 --initial_fuel 0 --initial_ifuel 0 --max_ifuel 0" open FStar.All open FStar.Seq open FStar.Ref let array a = ref (seq a) let as_ref #_ arr = arr let op_At_Bar #a s1 s2 = let s1' = !s1 in let s2' = !s2 in ST.alloc (Seq.append s1' s2') let of_seq #a s = ST.alloc s let to_seq #a s = !s let of_list #a l = of_seq (Seq.seq_of_list l) let create #a n init = ST.alloc (Seq.create n init)

FStar.Array.fst

val index (#a:Type0) (x:array a) (n:nat) : ST a (requires (fun h -> contains h x /\ n < Seq.length (sel h x))) (ensures (fun h0 v h1 -> n < Seq.length (sel h0 x) /\ h0 == h1 /\ v == Seq.index (sel h0 x) n))

FStar.Array.index

x: FStar.Array.array a -> n: Prims.nat -> FStar.ST.ST a

FStar.ST.ST

val length (#a:Type0) (x:array a) : ST nat (requires (fun h -> contains h x)) (ensures (fun h0 y h1 -> y = length (sel h0 x) /\ h0 == h1))

let length #a x = let s = !x in Seq.length s

val length (#a:Type0) (x:array a) : ST nat (requires (fun h -> contains h x)) (ensures (fun h0 y h1 -> y = length (sel h0 x) /\ h0 == h1)) let length #a x =

let s = !x in Seq.length s

(* Copyright 2008-2014 Nikhil Swamy and 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. *) (** F* standard library mutable arrays module. @summary Mutable arrays *) module FStar.Array #set-options "--max_fuel 0 --initial_fuel 0 --initial_ifuel 0 --max_ifuel 0" open FStar.All open FStar.Seq open FStar.Ref let array a = ref (seq a) let as_ref #_ arr = arr let op_At_Bar #a s1 s2 = let s1' = !s1 in let s2' = !s2 in ST.alloc (Seq.append s1' s2') let of_seq #a s = ST.alloc s let to_seq #a s = !s let of_list #a l = of_seq (Seq.seq_of_list l) let create #a n init = ST.alloc (Seq.create n init) let index #a x n = let s = to_seq x in Seq.index s n let upd #a x n v = let s = !x in let s' = Seq.upd s n v in x:= s'

FStar.Array.fst

val length (#a:Type0) (x:array a) : ST nat (requires (fun h -> contains h x)) (ensures (fun h0 y h1 -> y = length (sel h0 x) /\ h0 == h1))

FStar.Array.length

x: FStar.Array.array a -> FStar.ST.ST Prims.nat

FStar.ST.ST

val op_At_Bar (#a:Type0) (s1:array a) (s2:array a) : ST (array a) (requires (fun h -> contains h s1 /\ contains h s2)) (ensures (fun h0 s h1 -> contains h0 s1 /\ contains h0 s2 /\ contains h1 s /\ sel h1 s == Seq.append (sel h0 s1) (sel h0 s2) /\ modifies Set.empty h0 h1))

let op_At_Bar #a s1 s2 = let s1' = !s1 in let s2' = !s2 in ST.alloc (Seq.append s1' s2')

val op_At_Bar (#a:Type0) (s1:array a) (s2:array a) : ST (array a) (requires (fun h -> contains h s1 /\ contains h s2)) (ensures (fun h0 s h1 -> contains h0 s1 /\ contains h0 s2 /\ contains h1 s /\ sel h1 s == Seq.append (sel h0 s1) (sel h0 s2) /\ modifies Set.empty h0 h1)) let op_At_Bar #a s1 s2 =

let s1' = !s1 in let s2' = !s2 in ST.alloc (Seq.append s1' s2')

(* Copyright 2008-2014 Nikhil Swamy and 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. *) (** F* standard library mutable arrays module. @summary Mutable arrays *) module FStar.Array #set-options "--max_fuel 0 --initial_fuel 0 --initial_ifuel 0 --max_ifuel 0" open FStar.All open FStar.Seq open FStar.Ref let array a = ref (seq a) let as_ref #_ arr = arr

FStar.Array.fst

val op_At_Bar (#a:Type0) (s1:array a) (s2:array a) : ST (array a) (requires (fun h -> contains h s1 /\ contains h s2)) (ensures (fun h0 s h1 -> contains h0 s1 /\ contains h0 s2 /\ contains h1 s /\ sel h1 s == Seq.append (sel h0 s1) (sel h0 s2) /\ modifies Set.empty h0 h1))

FStar.Array.op_At_Bar

s1: FStar.Array.array a -> s2: FStar.Array.array a -> FStar.ST.ST (FStar.Array.array a)

FStar.ST.ST

val upd (#a:Type0) (x:array a) (n:nat) (v:a) :ST unit (requires (fun h -> contains h x /\ n < Seq.length (sel h x))) (ensures (fun h0 u h1 -> n < Seq.length (sel h0 x) /\ contains h1 x /\ modifies (Set.singleton (addr_of x)) h0 h1 /\ sel h1 x == Seq.upd (sel h0 x) n v))

let upd #a x n v = let s = !x in let s' = Seq.upd s n v in x:= s'

val upd (#a:Type0) (x:array a) (n:nat) (v:a) :ST unit (requires (fun h -> contains h x /\ n < Seq.length (sel h x))) (ensures (fun h0 u h1 -> n < Seq.length (sel h0 x) /\ contains h1 x /\ modifies (Set.singleton (addr_of x)) h0 h1 /\ sel h1 x == Seq.upd (sel h0 x) n v)) let upd #a x n v =

let s = !x in let s' = Seq.upd s n v in x := s'

(* Copyright 2008-2014 Nikhil Swamy and 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. *) (** F* standard library mutable arrays module. @summary Mutable arrays *) module FStar.Array #set-options "--max_fuel 0 --initial_fuel 0 --initial_ifuel 0 --max_ifuel 0" open FStar.All open FStar.Seq open FStar.Ref let array a = ref (seq a) let as_ref #_ arr = arr let op_At_Bar #a s1 s2 = let s1' = !s1 in let s2' = !s2 in ST.alloc (Seq.append s1' s2') let of_seq #a s = ST.alloc s let to_seq #a s = !s let of_list #a l = of_seq (Seq.seq_of_list l) let create #a n init = ST.alloc (Seq.create n init) let index #a x n = let s = to_seq x in Seq.index s n

FStar.Array.fst

val upd (#a:Type0) (x:array a) (n:nat) (v:a) :ST unit (requires (fun h -> contains h x /\ n < Seq.length (sel h x))) (ensures (fun h0 u h1 -> n < Seq.length (sel h0 x) /\ contains h1 x /\ modifies (Set.singleton (addr_of x)) h0 h1 /\ sel h1 x == Seq.upd (sel h0 x) n v))

FStar.Array.upd

x: FStar.Array.array a -> n: Prims.nat -> v: a -> FStar.ST.ST Prims.unit

FStar.ST.ST

val op (#a:Type0) (f:seq a -> seq a) (x:array a) : ST unit (requires (fun h -> contains h x)) (ensures (fun h0 u h1 -> modifies (Set.singleton (addr_of x)) h0 h1 /\ sel h1 x == f (sel h0 x)))

let op #a f x = let s = !x in let s' = f s in x := s'

val op (#a:Type0) (f:seq a -> seq a) (x:array a) : ST unit (requires (fun h -> contains h x)) (ensures (fun h0 u h1 -> modifies (Set.singleton (addr_of x)) h0 h1 /\ sel h1 x == f (sel h0 x))) let op #a f x =

let s = !x in let s' = f s in x := s'

(* Copyright 2008-2014 Nikhil Swamy and 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. *) (** F* standard library mutable arrays module. @summary Mutable arrays *) module FStar.Array #set-options "--max_fuel 0 --initial_fuel 0 --initial_ifuel 0 --max_ifuel 0" open FStar.All open FStar.Seq open FStar.Ref let array a = ref (seq a) let as_ref #_ arr = arr let op_At_Bar #a s1 s2 = let s1' = !s1 in let s2' = !s2 in ST.alloc (Seq.append s1' s2') let of_seq #a s = ST.alloc s let to_seq #a s = !s let of_list #a l = of_seq (Seq.seq_of_list l) let create #a n init = ST.alloc (Seq.create n init) let index #a x n = let s = to_seq x in Seq.index s n let upd #a x n v = let s = !x in let s' = Seq.upd s n v in x:= s' let length #a x = let s = !x in Seq.length s

FStar.Array.fst

val op (#a:Type0) (f:seq a -> seq a) (x:array a) : ST unit (requires (fun h -> contains h x)) (ensures (fun h0 u h1 -> modifies (Set.singleton (addr_of x)) h0 h1 /\ sel h1 x == f (sel h0 x)))

FStar.Array.op

f: (_: FStar.Seq.Base.seq a -> FStar.Seq.Base.seq a) -> x: FStar.Array.array a -> FStar.ST.ST Prims.unit

FStar.ST.ST

val create (#a:Type0) (n:nat) (init:a) : ST (array a) (requires (fun h -> True)) (ensures (fun h0 x h1 -> x `unused_in` h0 /\ contains h1 x /\ modifies Set.empty h0 h1 /\ sel h1 x == Seq.create n init))

let create #a n init = ST.alloc (Seq.create n init)

val create (#a:Type0) (n:nat) (init:a) : ST (array a) (requires (fun h -> True)) (ensures (fun h0 x h1 -> x `unused_in` h0 /\ contains h1 x /\ modifies Set.empty h0 h1 /\ sel h1 x == Seq.create n init)) let create #a n init =

ST.alloc (Seq.create n init)

(* Copyright 2008-2014 Nikhil Swamy and 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. *) (** F* standard library mutable arrays module. @summary Mutable arrays *) module FStar.Array #set-options "--max_fuel 0 --initial_fuel 0 --initial_ifuel 0 --max_ifuel 0" open FStar.All open FStar.Seq open FStar.Ref let array a = ref (seq a) let as_ref #_ arr = arr let op_At_Bar #a s1 s2 = let s1' = !s1 in let s2' = !s2 in ST.alloc (Seq.append s1' s2') let of_seq #a s = ST.alloc s let to_seq #a s = !s let of_list #a l = of_seq (Seq.seq_of_list l)

FStar.Array.fst

val create (#a:Type0) (n:nat) (init:a) : ST (array a) (requires (fun h -> True)) (ensures (fun h0 x h1 -> x `unused_in` h0 /\ contains h1 x /\ modifies Set.empty h0 h1 /\ sel h1 x == Seq.create n init))

FStar.Array.create

n: Prims.nat -> init: a -> FStar.ST.ST (FStar.Array.array a)

FStar.ST.ST

val swap (#a:Type0) (x:array a) (i:nat) (j:nat{i <= j}) : ST unit (requires (fun h -> contains h x /\ j < Seq.length (sel h x))) (ensures (fun h0 _u h1 -> j < Seq.length (sel h0 x) /\ contains h1 x /\ modifies (Set.singleton (addr_of x)) h0 h1 /\ sel h1 x == Seq.swap (sel h0 x) i j))

let swap #a x i j = let tmpi = index x i in let tmpj = index x j in upd x j tmpi; upd x i tmpj

val swap (#a:Type0) (x:array a) (i:nat) (j:nat{i <= j}) : ST unit (requires (fun h -> contains h x /\ j < Seq.length (sel h x))) (ensures (fun h0 _u h1 -> j < Seq.length (sel h0 x) /\ contains h1 x /\ modifies (Set.singleton (addr_of x)) h0 h1 /\ sel h1 x == Seq.swap (sel h0 x) i j)) let swap #a x i j =

let tmpi = index x i in let tmpj = index x j in upd x j tmpi; upd x i tmpj

(* Copyright 2008-2014 Nikhil Swamy and 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. *) (** F* standard library mutable arrays module. @summary Mutable arrays *) module FStar.Array #set-options "--max_fuel 0 --initial_fuel 0 --initial_ifuel 0 --max_ifuel 0" open FStar.All open FStar.Seq open FStar.Ref let array a = ref (seq a) let as_ref #_ arr = arr let op_At_Bar #a s1 s2 = let s1' = !s1 in let s2' = !s2 in ST.alloc (Seq.append s1' s2') let of_seq #a s = ST.alloc s let to_seq #a s = !s let of_list #a l = of_seq (Seq.seq_of_list l) let create #a n init = ST.alloc (Seq.create n init) let index #a x n = let s = to_seq x in Seq.index s n let upd #a x n v = let s = !x in let s' = Seq.upd s n v in x:= s' let length #a x = let s = !x in Seq.length s let op #a f x = let s = !x in let s' = f s in x := s'

FStar.Array.fst

val swap (#a:Type0) (x:array a) (i:nat) (j:nat{i <= j}) : ST unit (requires (fun h -> contains h x /\ j < Seq.length (sel h x))) (ensures (fun h0 _u h1 -> j < Seq.length (sel h0 x) /\ contains h1 x /\ modifies (Set.singleton (addr_of x)) h0 h1 /\ sel h1 x == Seq.swap (sel h0 x) i j))

FStar.Array.swap

x: FStar.Array.array a -> i: Prims.nat -> j: Prims.nat{i <= j} -> FStar.ST.ST Prims.unit

FStar.ST.ST

val copy (#a:Type0) (s:array a) : ST (array a) (requires (fun h -> contains h s /\ Seq.length (sel h s) > 0)) (ensures (fun h0 r h1 -> modifies Set.empty h0 h1 /\ r `unused_in` h0 /\ contains h1 r /\ sel h1 r == sel h0 s))

let copy #a s = let cpy = create (length s) (index s 0) in copy_aux s cpy 0; cpy

val copy (#a:Type0) (s:array a) : ST (array a) (requires (fun h -> contains h s /\ Seq.length (sel h s) > 0)) (ensures (fun h0 r h1 -> modifies Set.empty h0 h1 /\ r `unused_in` h0 /\ contains h1 r /\ sel h1 r == sel h0 s)) let copy #a s =

let cpy = create (length s) (index s 0) in copy_aux s cpy 0; cpy

(* Copyright 2008-2014 Nikhil Swamy and 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. *) (** F* standard library mutable arrays module. @summary Mutable arrays *) module FStar.Array #set-options "--max_fuel 0 --initial_fuel 0 --initial_ifuel 0 --max_ifuel 0" open FStar.All open FStar.Seq open FStar.Ref let array a = ref (seq a) let as_ref #_ arr = arr let op_At_Bar #a s1 s2 = let s1' = !s1 in let s2' = !s2 in ST.alloc (Seq.append s1' s2') let of_seq #a s = ST.alloc s let to_seq #a s = !s let of_list #a l = of_seq (Seq.seq_of_list l) let create #a n init = ST.alloc (Seq.create n init) let index #a x n = let s = to_seq x in Seq.index s n let upd #a x n v = let s = !x in let s' = Seq.upd s n v in x:= s' let length #a x = let s = !x in Seq.length s let op #a f x = let s = !x in let s' = f s in x := s' let swap #a x i j = let tmpi = index x i in let tmpj = index x j in upd x j tmpi; upd x i tmpj val copy_aux: #a:Type -> s:array a -> cpy:array a -> ctr:nat -> ST unit (requires (fun h -> (contains h s /\ contains h cpy /\ addr_of s <> addr_of cpy) /\ (Seq.length (sel h cpy) = Seq.length (sel h s)) /\ (ctr <= Seq.length (sel h cpy)) /\ (forall (i:nat). i < ctr ==> Seq.index (sel h s) i == Seq.index (sel h cpy) i))) (ensures (fun h0 u h1 -> (contains h1 s /\ contains h1 cpy /\ addr_of s <> addr_of cpy ) /\ (modifies (only cpy) h0 h1) /\ (Seq.equal (sel h1 cpy) (sel h1 s)))) let rec copy_aux #a s cpy ctr = match length cpy - ctr with | 0 -> () | _ -> upd cpy ctr (index s ctr); copy_aux s cpy (ctr+1)

FStar.Array.fst

val copy (#a:Type0) (s:array a) : ST (array a) (requires (fun h -> contains h s /\ Seq.length (sel h s) > 0)) (ensures (fun h0 r h1 -> modifies Set.empty h0 h1 /\ r `unused_in` h0 /\ contains h1 r /\ sel h1 r == sel h0 s))

FStar.Array.copy

s: FStar.Array.array a -> FStar.ST.ST (FStar.Array.array a)

FStar.ST.ST

val sub (#a:Type0) (s:array a) (idx:nat) (len:nat) : ST (array a) (requires (fun h -> contains h s /\ Seq.length (sel h s) > 0 /\ idx + len <= Seq.length (sel h s))) (ensures (fun h0 t h1 -> contains h1 t /\ t `unused_in` h0 /\ modifies Set.empty h0 h1 /\ Seq.slice (sel h0 s) idx (idx + len) == sel h1 t))

let sub #a s idx len = let h0 = ST.get () in let t = create len (index s 0) in blit s idx t 0 len; let h1 = ST.get () in assert (Seq.equal (Seq.slice (sel h0 s) idx (idx + len)) (sel h1 t)); t

val sub (#a:Type0) (s:array a) (idx:nat) (len:nat) : ST (array a) (requires (fun h -> contains h s /\ Seq.length (sel h s) > 0 /\ idx + len <= Seq.length (sel h s))) (ensures (fun h0 t h1 -> contains h1 t /\ t `unused_in` h0 /\ modifies Set.empty h0 h1 /\ Seq.slice (sel h0 s) idx (idx + len) == sel h1 t)) let sub #a s idx len =

let h0 = ST.get () in let t = create len (index s 0) in blit s idx t 0 len; let h1 = ST.get () in assert (Seq.equal (Seq.slice (sel h0 s) idx (idx + len)) (sel h1 t)); t

(* Copyright 2008-2014 Nikhil Swamy and 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. *) (** F* standard library mutable arrays module. @summary Mutable arrays *) module FStar.Array #set-options "--max_fuel 0 --initial_fuel 0 --initial_ifuel 0 --max_ifuel 0" open FStar.All open FStar.Seq open FStar.Ref let array a = ref (seq a) let as_ref #_ arr = arr let op_At_Bar #a s1 s2 = let s1' = !s1 in let s2' = !s2 in ST.alloc (Seq.append s1' s2') let of_seq #a s = ST.alloc s let to_seq #a s = !s let of_list #a l = of_seq (Seq.seq_of_list l) let create #a n init = ST.alloc (Seq.create n init) let index #a x n = let s = to_seq x in Seq.index s n let upd #a x n v = let s = !x in let s' = Seq.upd s n v in x:= s' let length #a x = let s = !x in Seq.length s let op #a f x = let s = !x in let s' = f s in x := s' let swap #a x i j = let tmpi = index x i in let tmpj = index x j in upd x j tmpi; upd x i tmpj val copy_aux: #a:Type -> s:array a -> cpy:array a -> ctr:nat -> ST unit (requires (fun h -> (contains h s /\ contains h cpy /\ addr_of s <> addr_of cpy) /\ (Seq.length (sel h cpy) = Seq.length (sel h s)) /\ (ctr <= Seq.length (sel h cpy)) /\ (forall (i:nat). i < ctr ==> Seq.index (sel h s) i == Seq.index (sel h cpy) i))) (ensures (fun h0 u h1 -> (contains h1 s /\ contains h1 cpy /\ addr_of s <> addr_of cpy ) /\ (modifies (only cpy) h0 h1) /\ (Seq.equal (sel h1 cpy) (sel h1 s)))) let rec copy_aux #a s cpy ctr = match length cpy - ctr with | 0 -> () | _ -> upd cpy ctr (index s ctr); copy_aux s cpy (ctr+1) let copy #a s = let cpy = create (length s) (index s 0) in copy_aux s cpy 0; cpy private val blit_aux: #a:Type -> s:array a -> s_idx:nat -> t:array a -> t_idx:nat -> len:nat -> ctr:nat -> ST unit (requires (fun h -> (contains h s /\ contains h t /\ addr_of s <> addr_of t) /\ (Seq.length (sel h s) >= s_idx + len) /\ (Seq.length (sel h t) >= t_idx + len) /\ (ctr <= len) /\ (forall (i:nat). i < ctr ==> Seq.index (sel h s) (s_idx+i) == Seq.index (sel h t) (t_idx+i)))) (ensures (fun h0 u h1 -> (contains h1 s /\ contains h1 t /\ addr_of s <> addr_of t) /\ (modifies (only t) h0 h1) /\ (Seq.length (sel h1 s) >= s_idx + len) /\ (Seq.length (sel h1 t) >= t_idx + len) /\ (Seq.length (sel h0 s) = Seq.length (sel h1 s)) /\ (Seq.length (sel h0 t) = Seq.length (sel h1 t)) /\ (forall (i:nat). i < len ==> Seq.index (sel h1 s) (s_idx+i) == Seq.index (sel h1 t) (t_idx+i)) /\ (forall (i:nat). (i < Seq.length (sel h1 t) /\ (i < t_idx \/ i >= t_idx + len)) ==> Seq.index (sel h1 t) i == Seq.index (sel h0 t) i) )) #set-options "--z3rlimit 60" let rec blit_aux #a s s_idx t t_idx len ctr = match len - ctr with | 0 -> () | _ -> upd t (t_idx + ctr) (index s (s_idx + ctr)); blit_aux s s_idx t t_idx len (ctr+1) #set-options "--z3rlimit 5" private val blit: #a:Type -> s:array a -> s_idx:nat -> t:array a -> t_idx:nat -> len:nat -> ST unit (requires (fun h -> (contains h s) /\ (contains h t) /\ (addr_of s <> addr_of t) /\ (Seq.length (sel h s) >= s_idx + len) /\ (Seq.length (sel h t) >= t_idx + len))) (ensures (fun h0 u h1 -> (contains h1 s /\ contains h1 t /\ addr_of s <> addr_of t) /\ (Seq.length (sel h1 s) >= s_idx + len) /\ (Seq.length (sel h1 t) >= t_idx + len) /\ (Seq.length (sel h0 s) = Seq.length (sel h1 s)) /\ (Seq.length (sel h0 t) = Seq.length (sel h1 t)) /\ (modifies (only t) h0 h1) /\ (forall (i:nat). i < len ==> Seq.index (sel h1 s) (s_idx+i) == Seq.index (sel h1 t) (t_idx+i)) /\ (forall (i:nat).{:pattern (Seq.index (sel h1 t) i)} (i < Seq.length (sel h1 t) /\ (i < t_idx \/ i >= t_idx + len)) ==> (Seq.index (sel h1 t) i == Seq.index (sel h0 t) i)) )) let blit #a s s_idx t t_idx len = blit_aux s s_idx t t_idx len 0

FStar.Array.fst

val sub (#a:Type0) (s:array a) (idx:nat) (len:nat) : ST (array a) (requires (fun h -> contains h s /\ Seq.length (sel h s) > 0 /\ idx + len <= Seq.length (sel h s))) (ensures (fun h0 t h1 -> contains h1 t /\ t `unused_in` h0 /\ modifies Set.empty h0 h1 /\ Seq.slice (sel h0 s) idx (idx + len) == sel h1 t))

FStar.Array.sub

s: FStar.Array.array a -> idx: Prims.nat -> len: Prims.nat -> FStar.ST.ST (FStar.Array.array a)

FStar.ST.ST

val copy_aux: #a:Type -> s:array a -> cpy:array a -> ctr:nat -> ST unit (requires (fun h -> (contains h s /\ contains h cpy /\ addr_of s <> addr_of cpy) /\ (Seq.length (sel h cpy) = Seq.length (sel h s)) /\ (ctr <= Seq.length (sel h cpy)) /\ (forall (i:nat). i < ctr ==> Seq.index (sel h s) i == Seq.index (sel h cpy) i))) (ensures (fun h0 u h1 -> (contains h1 s /\ contains h1 cpy /\ addr_of s <> addr_of cpy ) /\ (modifies (only cpy) h0 h1) /\ (Seq.equal (sel h1 cpy) (sel h1 s))))

let rec copy_aux #a s cpy ctr = match length cpy - ctr with | 0 -> () | _ -> upd cpy ctr (index s ctr); copy_aux s cpy (ctr+1)

val copy_aux: #a:Type -> s:array a -> cpy:array a -> ctr:nat -> ST unit (requires (fun h -> (contains h s /\ contains h cpy /\ addr_of s <> addr_of cpy) /\ (Seq.length (sel h cpy) = Seq.length (sel h s)) /\ (ctr <= Seq.length (sel h cpy)) /\ (forall (i:nat). i < ctr ==> Seq.index (sel h s) i == Seq.index (sel h cpy) i))) (ensures (fun h0 u h1 -> (contains h1 s /\ contains h1 cpy /\ addr_of s <> addr_of cpy ) /\ (modifies (only cpy) h0 h1) /\ (Seq.equal (sel h1 cpy) (sel h1 s)))) let rec copy_aux #a s cpy ctr =

match length cpy - ctr with | 0 -> () | _ -> upd cpy ctr (index s ctr); copy_aux s cpy (ctr + 1)

(* Copyright 2008-2014 Nikhil Swamy and 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. *) (** F* standard library mutable arrays module. @summary Mutable arrays *) module FStar.Array #set-options "--max_fuel 0 --initial_fuel 0 --initial_ifuel 0 --max_ifuel 0" open FStar.All open FStar.Seq open FStar.Ref let array a = ref (seq a) let as_ref #_ arr = arr let op_At_Bar #a s1 s2 = let s1' = !s1 in let s2' = !s2 in ST.alloc (Seq.append s1' s2') let of_seq #a s = ST.alloc s let to_seq #a s = !s let of_list #a l = of_seq (Seq.seq_of_list l) let create #a n init = ST.alloc (Seq.create n init) let index #a x n = let s = to_seq x in Seq.index s n let upd #a x n v = let s = !x in let s' = Seq.upd s n v in x:= s' let length #a x = let s = !x in Seq.length s let op #a f x = let s = !x in let s' = f s in x := s' let swap #a x i j = let tmpi = index x i in let tmpj = index x j in upd x j tmpi; upd x i tmpj val copy_aux: #a:Type -> s:array a -> cpy:array a -> ctr:nat -> ST unit (requires (fun h -> (contains h s /\ contains h cpy /\ addr_of s <> addr_of cpy) /\ (Seq.length (sel h cpy) = Seq.length (sel h s)) /\ (ctr <= Seq.length (sel h cpy)) /\ (forall (i:nat). i < ctr ==> Seq.index (sel h s) i == Seq.index (sel h cpy) i))) (ensures (fun h0 u h1 -> (contains h1 s /\ contains h1 cpy /\ addr_of s <> addr_of cpy ) /\ (modifies (only cpy) h0 h1) /\ (Seq.equal (sel h1 cpy) (sel h1 s))))

FStar.Array.fst

val copy_aux: #a:Type -> s:array a -> cpy:array a -> ctr:nat -> ST unit (requires (fun h -> (contains h s /\ contains h cpy /\ addr_of s <> addr_of cpy) /\ (Seq.length (sel h cpy) = Seq.length (sel h s)) /\ (ctr <= Seq.length (sel h cpy)) /\ (forall (i:nat). i < ctr ==> Seq.index (sel h s) i == Seq.index (sel h cpy) i))) (ensures (fun h0 u h1 -> (contains h1 s /\ contains h1 cpy /\ addr_of s <> addr_of cpy ) /\ (modifies (only cpy) h0 h1) /\ (Seq.equal (sel h1 cpy) (sel h1 s))))

FStar.Array.copy_aux

s: FStar.Array.array a -> cpy: FStar.Array.array a -> ctr: Prims.nat -> FStar.ST.ST Prims.unit

FStar.ST.ST

val blit: #a:Type -> s:array a -> s_idx:nat -> t:array a -> t_idx:nat -> len:nat -> ST unit (requires (fun h -> (contains h s) /\ (contains h t) /\ (addr_of s <> addr_of t) /\ (Seq.length (sel h s) >= s_idx + len) /\ (Seq.length (sel h t) >= t_idx + len))) (ensures (fun h0 u h1 -> (contains h1 s /\ contains h1 t /\ addr_of s <> addr_of t) /\ (Seq.length (sel h1 s) >= s_idx + len) /\ (Seq.length (sel h1 t) >= t_idx + len) /\ (Seq.length (sel h0 s) = Seq.length (sel h1 s)) /\ (Seq.length (sel h0 t) = Seq.length (sel h1 t)) /\ (modifies (only t) h0 h1) /\ (forall (i:nat). i < len ==> Seq.index (sel h1 s) (s_idx+i) == Seq.index (sel h1 t) (t_idx+i)) /\ (forall (i:nat).{:pattern (Seq.index (sel h1 t) i)} (i < Seq.length (sel h1 t) /\ (i < t_idx \/ i >= t_idx + len)) ==> (Seq.index (sel h1 t) i == Seq.index (sel h0 t) i)) ))

let blit #a s s_idx t t_idx len = blit_aux s s_idx t t_idx len 0

val blit: #a:Type -> s:array a -> s_idx:nat -> t:array a -> t_idx:nat -> len:nat -> ST unit (requires (fun h -> (contains h s) /\ (contains h t) /\ (addr_of s <> addr_of t) /\ (Seq.length (sel h s) >= s_idx + len) /\ (Seq.length (sel h t) >= t_idx + len))) (ensures (fun h0 u h1 -> (contains h1 s /\ contains h1 t /\ addr_of s <> addr_of t) /\ (Seq.length (sel h1 s) >= s_idx + len) /\ (Seq.length (sel h1 t) >= t_idx + len) /\ (Seq.length (sel h0 s) = Seq.length (sel h1 s)) /\ (Seq.length (sel h0 t) = Seq.length (sel h1 t)) /\ (modifies (only t) h0 h1) /\ (forall (i:nat). i < len ==> Seq.index (sel h1 s) (s_idx+i) == Seq.index (sel h1 t) (t_idx+i)) /\ (forall (i:nat).{:pattern (Seq.index (sel h1 t) i)} (i < Seq.length (sel h1 t) /\ (i < t_idx \/ i >= t_idx + len)) ==> (Seq.index (sel h1 t) i == Seq.index (sel h0 t) i)) )) let blit #a s s_idx t t_idx len =

blit_aux s s_idx t t_idx len 0

(* Copyright 2008-2014 Nikhil Swamy and 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. *) (** F* standard library mutable arrays module. @summary Mutable arrays *) module FStar.Array #set-options "--max_fuel 0 --initial_fuel 0 --initial_ifuel 0 --max_ifuel 0" open FStar.All open FStar.Seq open FStar.Ref let array a = ref (seq a) let as_ref #_ arr = arr let op_At_Bar #a s1 s2 = let s1' = !s1 in let s2' = !s2 in ST.alloc (Seq.append s1' s2') let of_seq #a s = ST.alloc s let to_seq #a s = !s let of_list #a l = of_seq (Seq.seq_of_list l) let create #a n init = ST.alloc (Seq.create n init) let index #a x n = let s = to_seq x in Seq.index s n let upd #a x n v = let s = !x in let s' = Seq.upd s n v in x:= s' let length #a x = let s = !x in Seq.length s let op #a f x = let s = !x in let s' = f s in x := s' let swap #a x i j = let tmpi = index x i in let tmpj = index x j in upd x j tmpi; upd x i tmpj val copy_aux: #a:Type -> s:array a -> cpy:array a -> ctr:nat -> ST unit (requires (fun h -> (contains h s /\ contains h cpy /\ addr_of s <> addr_of cpy) /\ (Seq.length (sel h cpy) = Seq.length (sel h s)) /\ (ctr <= Seq.length (sel h cpy)) /\ (forall (i:nat). i < ctr ==> Seq.index (sel h s) i == Seq.index (sel h cpy) i))) (ensures (fun h0 u h1 -> (contains h1 s /\ contains h1 cpy /\ addr_of s <> addr_of cpy ) /\ (modifies (only cpy) h0 h1) /\ (Seq.equal (sel h1 cpy) (sel h1 s)))) let rec copy_aux #a s cpy ctr = match length cpy - ctr with | 0 -> () | _ -> upd cpy ctr (index s ctr); copy_aux s cpy (ctr+1) let copy #a s = let cpy = create (length s) (index s 0) in copy_aux s cpy 0; cpy private val blit_aux: #a:Type -> s:array a -> s_idx:nat -> t:array a -> t_idx:nat -> len:nat -> ctr:nat -> ST unit (requires (fun h -> (contains h s /\ contains h t /\ addr_of s <> addr_of t) /\ (Seq.length (sel h s) >= s_idx + len) /\ (Seq.length (sel h t) >= t_idx + len) /\ (ctr <= len) /\ (forall (i:nat). i < ctr ==> Seq.index (sel h s) (s_idx+i) == Seq.index (sel h t) (t_idx+i)))) (ensures (fun h0 u h1 -> (contains h1 s /\ contains h1 t /\ addr_of s <> addr_of t) /\ (modifies (only t) h0 h1) /\ (Seq.length (sel h1 s) >= s_idx + len) /\ (Seq.length (sel h1 t) >= t_idx + len) /\ (Seq.length (sel h0 s) = Seq.length (sel h1 s)) /\ (Seq.length (sel h0 t) = Seq.length (sel h1 t)) /\ (forall (i:nat). i < len ==> Seq.index (sel h1 s) (s_idx+i) == Seq.index (sel h1 t) (t_idx+i)) /\ (forall (i:nat). (i < Seq.length (sel h1 t) /\ (i < t_idx \/ i >= t_idx + len)) ==> Seq.index (sel h1 t) i == Seq.index (sel h0 t) i) )) #set-options "--z3rlimit 60" let rec blit_aux #a s s_idx t t_idx len ctr = match len - ctr with | 0 -> () | _ -> upd t (t_idx + ctr) (index s (s_idx + ctr)); blit_aux s s_idx t t_idx len (ctr+1) #set-options "--z3rlimit 5" private val blit: #a:Type -> s:array a -> s_idx:nat -> t:array a -> t_idx:nat -> len:nat -> ST unit (requires (fun h -> (contains h s) /\ (contains h t) /\ (addr_of s <> addr_of t) /\ (Seq.length (sel h s) >= s_idx + len) /\ (Seq.length (sel h t) >= t_idx + len))) (ensures (fun h0 u h1 -> (contains h1 s /\ contains h1 t /\ addr_of s <> addr_of t) /\ (Seq.length (sel h1 s) >= s_idx + len) /\ (Seq.length (sel h1 t) >= t_idx + len) /\ (Seq.length (sel h0 s) = Seq.length (sel h1 s)) /\ (Seq.length (sel h0 t) = Seq.length (sel h1 t)) /\ (modifies (only t) h0 h1) /\ (forall (i:nat). i < len ==> Seq.index (sel h1 s) (s_idx+i) == Seq.index (sel h1 t) (t_idx+i)) /\ (forall (i:nat).{:pattern (Seq.index (sel h1 t) i)} (i < Seq.length (sel h1 t) /\ (i < t_idx \/ i >= t_idx + len)) ==> (Seq.index (sel h1 t) i == Seq.index (sel h0 t) i)) ))

FStar.Array.fst

val blit: #a:Type -> s:array a -> s_idx:nat -> t:array a -> t_idx:nat -> len:nat -> ST unit (requires (fun h -> (contains h s) /\ (contains h t) /\ (addr_of s <> addr_of t) /\ (Seq.length (sel h s) >= s_idx + len) /\ (Seq.length (sel h t) >= t_idx + len))) (ensures (fun h0 u h1 -> (contains h1 s /\ contains h1 t /\ addr_of s <> addr_of t) /\ (Seq.length (sel h1 s) >= s_idx + len) /\ (Seq.length (sel h1 t) >= t_idx + len) /\ (Seq.length (sel h0 s) = Seq.length (sel h1 s)) /\ (Seq.length (sel h0 t) = Seq.length (sel h1 t)) /\ (modifies (only t) h0 h1) /\ (forall (i:nat). i < len ==> Seq.index (sel h1 s) (s_idx+i) == Seq.index (sel h1 t) (t_idx+i)) /\ (forall (i:nat).{:pattern (Seq.index (sel h1 t) i)} (i < Seq.length (sel h1 t) /\ (i < t_idx \/ i >= t_idx + len)) ==> (Seq.index (sel h1 t) i == Seq.index (sel h0 t) i)) ))

FStar.Array.blit

s: FStar.Array.array a -> s_idx: Prims.nat -> t: FStar.Array.array a -> t_idx: Prims.nat -> len: Prims.nat -> FStar.ST.ST Prims.unit

FStar.ST.ST

val blit_aux: #a:Type -> s:array a -> s_idx:nat -> t:array a -> t_idx:nat -> len:nat -> ctr:nat -> ST unit (requires (fun h -> (contains h s /\ contains h t /\ addr_of s <> addr_of t) /\ (Seq.length (sel h s) >= s_idx + len) /\ (Seq.length (sel h t) >= t_idx + len) /\ (ctr <= len) /\ (forall (i:nat). i < ctr ==> Seq.index (sel h s) (s_idx+i) == Seq.index (sel h t) (t_idx+i)))) (ensures (fun h0 u h1 -> (contains h1 s /\ contains h1 t /\ addr_of s <> addr_of t) /\ (modifies (only t) h0 h1) /\ (Seq.length (sel h1 s) >= s_idx + len) /\ (Seq.length (sel h1 t) >= t_idx + len) /\ (Seq.length (sel h0 s) = Seq.length (sel h1 s)) /\ (Seq.length (sel h0 t) = Seq.length (sel h1 t)) /\ (forall (i:nat). i < len ==> Seq.index (sel h1 s) (s_idx+i) == Seq.index (sel h1 t) (t_idx+i)) /\ (forall (i:nat). (i < Seq.length (sel h1 t) /\ (i < t_idx \/ i >= t_idx + len)) ==> Seq.index (sel h1 t) i == Seq.index (sel h0 t) i) ))

let rec blit_aux #a s s_idx t t_idx len ctr = match len - ctr with | 0 -> () | _ -> upd t (t_idx + ctr) (index s (s_idx + ctr)); blit_aux s s_idx t t_idx len (ctr+1)

val blit_aux: #a:Type -> s:array a -> s_idx:nat -> t:array a -> t_idx:nat -> len:nat -> ctr:nat -> ST unit (requires (fun h -> (contains h s /\ contains h t /\ addr_of s <> addr_of t) /\ (Seq.length (sel h s) >= s_idx + len) /\ (Seq.length (sel h t) >= t_idx + len) /\ (ctr <= len) /\ (forall (i:nat). i < ctr ==> Seq.index (sel h s) (s_idx+i) == Seq.index (sel h t) (t_idx+i)))) (ensures (fun h0 u h1 -> (contains h1 s /\ contains h1 t /\ addr_of s <> addr_of t) /\ (modifies (only t) h0 h1) /\ (Seq.length (sel h1 s) >= s_idx + len) /\ (Seq.length (sel h1 t) >= t_idx + len) /\ (Seq.length (sel h0 s) = Seq.length (sel h1 s)) /\ (Seq.length (sel h0 t) = Seq.length (sel h1 t)) /\ (forall (i:nat). i < len ==> Seq.index (sel h1 s) (s_idx+i) == Seq.index (sel h1 t) (t_idx+i)) /\ (forall (i:nat). (i < Seq.length (sel h1 t) /\ (i < t_idx \/ i >= t_idx + len)) ==> Seq.index (sel h1 t) i == Seq.index (sel h0 t) i) )) let rec blit_aux #a s s_idx t t_idx len ctr =

match len - ctr with | 0 -> () | _ -> upd t (t_idx + ctr) (index s (s_idx + ctr)); blit_aux s s_idx t t_idx len (ctr + 1)

(* Copyright 2008-2014 Nikhil Swamy and 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. *) (** F* standard library mutable arrays module. @summary Mutable arrays *) module FStar.Array #set-options "--max_fuel 0 --initial_fuel 0 --initial_ifuel 0 --max_ifuel 0" open FStar.All open FStar.Seq open FStar.Ref let array a = ref (seq a) let as_ref #_ arr = arr let op_At_Bar #a s1 s2 = let s1' = !s1 in let s2' = !s2 in ST.alloc (Seq.append s1' s2') let of_seq #a s = ST.alloc s let to_seq #a s = !s let of_list #a l = of_seq (Seq.seq_of_list l) let create #a n init = ST.alloc (Seq.create n init) let index #a x n = let s = to_seq x in Seq.index s n let upd #a x n v = let s = !x in let s' = Seq.upd s n v in x:= s' let length #a x = let s = !x in Seq.length s let op #a f x = let s = !x in let s' = f s in x := s' let swap #a x i j = let tmpi = index x i in let tmpj = index x j in upd x j tmpi; upd x i tmpj val copy_aux: #a:Type -> s:array a -> cpy:array a -> ctr:nat -> ST unit (requires (fun h -> (contains h s /\ contains h cpy /\ addr_of s <> addr_of cpy) /\ (Seq.length (sel h cpy) = Seq.length (sel h s)) /\ (ctr <= Seq.length (sel h cpy)) /\ (forall (i:nat). i < ctr ==> Seq.index (sel h s) i == Seq.index (sel h cpy) i))) (ensures (fun h0 u h1 -> (contains h1 s /\ contains h1 cpy /\ addr_of s <> addr_of cpy ) /\ (modifies (only cpy) h0 h1) /\ (Seq.equal (sel h1 cpy) (sel h1 s)))) let rec copy_aux #a s cpy ctr = match length cpy - ctr with | 0 -> () | _ -> upd cpy ctr (index s ctr); copy_aux s cpy (ctr+1) let copy #a s = let cpy = create (length s) (index s 0) in copy_aux s cpy 0; cpy private val blit_aux: #a:Type -> s:array a -> s_idx:nat -> t:array a -> t_idx:nat -> len:nat -> ctr:nat -> ST unit (requires (fun h -> (contains h s /\ contains h t /\ addr_of s <> addr_of t) /\ (Seq.length (sel h s) >= s_idx + len) /\ (Seq.length (sel h t) >= t_idx + len) /\ (ctr <= len) /\ (forall (i:nat). i < ctr ==> Seq.index (sel h s) (s_idx+i) == Seq.index (sel h t) (t_idx+i)))) (ensures (fun h0 u h1 -> (contains h1 s /\ contains h1 t /\ addr_of s <> addr_of t) /\ (modifies (only t) h0 h1) /\ (Seq.length (sel h1 s) >= s_idx + len) /\ (Seq.length (sel h1 t) >= t_idx + len) /\ (Seq.length (sel h0 s) = Seq.length (sel h1 s)) /\ (Seq.length (sel h0 t) = Seq.length (sel h1 t)) /\ (forall (i:nat). i < len ==> Seq.index (sel h1 s) (s_idx+i) == Seq.index (sel h1 t) (t_idx+i)) /\ (forall (i:nat). (i < Seq.length (sel h1 t) /\ (i < t_idx \/ i >= t_idx + len)) ==> Seq.index (sel h1 t) i == Seq.index (sel h0 t) i) )) #set-options "--z3rlimit 60"

FStar.Array.fst

val blit_aux: #a:Type -> s:array a -> s_idx:nat -> t:array a -> t_idx:nat -> len:nat -> ctr:nat -> ST unit (requires (fun h -> (contains h s /\ contains h t /\ addr_of s <> addr_of t) /\ (Seq.length (sel h s) >= s_idx + len) /\ (Seq.length (sel h t) >= t_idx + len) /\ (ctr <= len) /\ (forall (i:nat). i < ctr ==> Seq.index (sel h s) (s_idx+i) == Seq.index (sel h t) (t_idx+i)))) (ensures (fun h0 u h1 -> (contains h1 s /\ contains h1 t /\ addr_of s <> addr_of t) /\ (modifies (only t) h0 h1) /\ (Seq.length (sel h1 s) >= s_idx + len) /\ (Seq.length (sel h1 t) >= t_idx + len) /\ (Seq.length (sel h0 s) = Seq.length (sel h1 s)) /\ (Seq.length (sel h0 t) = Seq.length (sel h1 t)) /\ (forall (i:nat). i < len ==> Seq.index (sel h1 s) (s_idx+i) == Seq.index (sel h1 t) (t_idx+i)) /\ (forall (i:nat). (i < Seq.length (sel h1 t) /\ (i < t_idx \/ i >= t_idx + len)) ==> Seq.index (sel h1 t) i == Seq.index (sel h0 t) i) ))

FStar.Array.blit_aux

s: FStar.Array.array a -> s_idx: Prims.nat -> t: FStar.Array.array a -> t_idx: Prims.nat -> len: Prims.nat -> ctr: Prims.nat -> FStar.ST.ST Prims.unit

Prims.Tot

val lte (a b: t) : Tot bool

let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b)

val lte (a b: t) : Tot bool let lte (a b: t) : Tot bool =

lte #n (v a) (v b)

(* Copyright 2008-2019 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.Int128 (**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****) unfold let n = 128 open FStar.Int open FStar.Mul #set-options "--max_fuel 0 --max_ifuel 0" (* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly * a copy-paste of this module. *) new val t : eqtype val v (x:t) : Tot (int_t n) val int_to_t: x:int_t n -> Pure t (requires True) (ensures (fun y -> v y = x)) val uv_inv (x : t) : Lemma (ensures (int_to_t (v x) == x)) [SMTPat (v x)] val vu_inv (x : int_t n) : Lemma (ensures (v (int_to_t x) == x)) [SMTPat (int_to_t x)] val v_inj (x1 x2: t): Lemma (requires (v x1 == v x2)) (ensures (x1 == x2)) val zero : x:t{v x = 0} val one : x:t{v x = 1} val add (a:t) (b:t) : Pure t (requires (size (v a + v b) n)) (ensures (fun c -> v a + v b = v c)) (* Subtraction primitives *) val sub (a:t) (b:t) : Pure t (requires (size (v a - v b) n)) (ensures (fun c -> v a - v b = v c)) (* Multiplication primitives *) val mul (a:t) (b:t) : Pure t (requires (size (v a * v b) n)) (ensures (fun c -> v a * v b = v c)) (* Division primitives *) val div (a:t) (b:t{v b <> 0}) : Pure t // division overflows on INT_MIN / -1 (requires (size (v a / v b) n)) (ensures (fun c -> v a / v b = v c)) (* Modulo primitives *) (* If a/b is not representable the result of a%b is undefind *) val rem (a:t) (b:t{v b <> 0}) : Pure t (requires (size (v a / v b) n)) (ensures (fun c -> FStar.Int.mod (v a) (v b) = v c)) (* Bitwise operators *) val logand (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logand` v y = v z)) val logxor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logxor` v y == v z)) val logor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logor` v y == v z)) val lognot (x:t) : Pure t (requires True) (ensures (fun z -> lognot (v x) == v z)) (* Shift operators *) (** If a is negative the result is implementation-defined *) val shift_right (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c)) (** If a is negative or a * pow2 s is not representable the result is undefined *) val shift_left (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c)) val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t (requires (UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c)) (* Comparison operators *) let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b) let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b) let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b)

FStar.Int128.fsti

val lte (a b: t) : Tot bool

FStar.Int128.lte

a: FStar.Int128.t -> b: FStar.Int128.t -> Prims.bool

Prims.Tot

val lt (a b: t) : Tot bool

let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b)

val lt (a b: t) : Tot bool let lt (a b: t) : Tot bool =

lt #n (v a) (v b)

(* Copyright 2008-2019 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.Int128 (**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****) unfold let n = 128 open FStar.Int open FStar.Mul #set-options "--max_fuel 0 --max_ifuel 0" (* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly * a copy-paste of this module. *) new val t : eqtype val v (x:t) : Tot (int_t n) val int_to_t: x:int_t n -> Pure t (requires True) (ensures (fun y -> v y = x)) val uv_inv (x : t) : Lemma (ensures (int_to_t (v x) == x)) [SMTPat (v x)] val vu_inv (x : int_t n) : Lemma (ensures (v (int_to_t x) == x)) [SMTPat (int_to_t x)] val v_inj (x1 x2: t): Lemma (requires (v x1 == v x2)) (ensures (x1 == x2)) val zero : x:t{v x = 0} val one : x:t{v x = 1} val add (a:t) (b:t) : Pure t (requires (size (v a + v b) n)) (ensures (fun c -> v a + v b = v c)) (* Subtraction primitives *) val sub (a:t) (b:t) : Pure t (requires (size (v a - v b) n)) (ensures (fun c -> v a - v b = v c)) (* Multiplication primitives *) val mul (a:t) (b:t) : Pure t (requires (size (v a * v b) n)) (ensures (fun c -> v a * v b = v c)) (* Division primitives *) val div (a:t) (b:t{v b <> 0}) : Pure t // division overflows on INT_MIN / -1 (requires (size (v a / v b) n)) (ensures (fun c -> v a / v b = v c)) (* Modulo primitives *) (* If a/b is not representable the result of a%b is undefind *) val rem (a:t) (b:t{v b <> 0}) : Pure t (requires (size (v a / v b) n)) (ensures (fun c -> FStar.Int.mod (v a) (v b) = v c)) (* Bitwise operators *) val logand (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logand` v y = v z)) val logxor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logxor` v y == v z)) val logor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logor` v y == v z)) val lognot (x:t) : Pure t (requires True) (ensures (fun z -> lognot (v x) == v z)) (* Shift operators *) (** If a is negative the result is implementation-defined *) val shift_right (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c)) (** If a is negative or a * pow2 s is not representable the result is undefined *) val shift_left (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c)) val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t (requires (UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c)) (* Comparison operators *) let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b) let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b)

FStar.Int128.fsti

val lt (a b: t) : Tot bool

FStar.Int128.lt

a: FStar.Int128.t -> b: FStar.Int128.t -> Prims.bool

Prims.Tot

let n = 128

let n =

128

(* Copyright 2008-2019 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.Int128 (**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)

FStar.Int128.fsti

val n : Prims.int

FStar.Int128.n

Prims.int

Prims.Tot

val eq (a b: t) : Tot bool

let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b)

val eq (a b: t) : Tot bool let eq (a b: t) : Tot bool =

eq #n (v a) (v b)

(* Copyright 2008-2019 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.Int128 (**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****) unfold let n = 128 open FStar.Int open FStar.Mul #set-options "--max_fuel 0 --max_ifuel 0" (* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly * a copy-paste of this module. *) new val t : eqtype val v (x:t) : Tot (int_t n) val int_to_t: x:int_t n -> Pure t (requires True) (ensures (fun y -> v y = x)) val uv_inv (x : t) : Lemma (ensures (int_to_t (v x) == x)) [SMTPat (v x)] val vu_inv (x : int_t n) : Lemma (ensures (v (int_to_t x) == x)) [SMTPat (int_to_t x)] val v_inj (x1 x2: t): Lemma (requires (v x1 == v x2)) (ensures (x1 == x2)) val zero : x:t{v x = 0} val one : x:t{v x = 1} val add (a:t) (b:t) : Pure t (requires (size (v a + v b) n)) (ensures (fun c -> v a + v b = v c)) (* Subtraction primitives *) val sub (a:t) (b:t) : Pure t (requires (size (v a - v b) n)) (ensures (fun c -> v a - v b = v c)) (* Multiplication primitives *) val mul (a:t) (b:t) : Pure t (requires (size (v a * v b) n)) (ensures (fun c -> v a * v b = v c)) (* Division primitives *) val div (a:t) (b:t{v b <> 0}) : Pure t // division overflows on INT_MIN / -1 (requires (size (v a / v b) n)) (ensures (fun c -> v a / v b = v c)) (* Modulo primitives *) (* If a/b is not representable the result of a%b is undefind *) val rem (a:t) (b:t{v b <> 0}) : Pure t (requires (size (v a / v b) n)) (ensures (fun c -> FStar.Int.mod (v a) (v b) = v c)) (* Bitwise operators *) val logand (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logand` v y = v z)) val logxor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logxor` v y == v z)) val logor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logor` v y == v z)) val lognot (x:t) : Pure t (requires True) (ensures (fun z -> lognot (v x) == v z)) (* Shift operators *) (** If a is negative the result is implementation-defined *) val shift_right (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c)) (** If a is negative or a * pow2 s is not representable the result is undefined *) val shift_left (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c)) val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t (requires (UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c))

FStar.Int128.fsti

val eq (a b: t) : Tot bool

FStar.Int128.eq

a: FStar.Int128.t -> b: FStar.Int128.t -> Prims.bool

Prims.Pure

let op_Amp_Hat = logand

let op_Amp_Hat =

logand

(* Copyright 2008-2019 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.Int128 (**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****) unfold let n = 128 open FStar.Int open FStar.Mul #set-options "--max_fuel 0 --max_ifuel 0" (* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly * a copy-paste of this module. *) new val t : eqtype val v (x:t) : Tot (int_t n) val int_to_t: x:int_t n -> Pure t (requires True) (ensures (fun y -> v y = x)) val uv_inv (x : t) : Lemma (ensures (int_to_t (v x) == x)) [SMTPat (v x)] val vu_inv (x : int_t n) : Lemma (ensures (v (int_to_t x) == x)) [SMTPat (int_to_t x)] val v_inj (x1 x2: t): Lemma (requires (v x1 == v x2)) (ensures (x1 == x2)) val zero : x:t{v x = 0} val one : x:t{v x = 1} val add (a:t) (b:t) : Pure t (requires (size (v a + v b) n)) (ensures (fun c -> v a + v b = v c)) (* Subtraction primitives *) val sub (a:t) (b:t) : Pure t (requires (size (v a - v b) n)) (ensures (fun c -> v a - v b = v c)) (* Multiplication primitives *) val mul (a:t) (b:t) : Pure t (requires (size (v a * v b) n)) (ensures (fun c -> v a * v b = v c)) (* Division primitives *) val div (a:t) (b:t{v b <> 0}) : Pure t // division overflows on INT_MIN / -1 (requires (size (v a / v b) n)) (ensures (fun c -> v a / v b = v c)) (* Modulo primitives *) (* If a/b is not representable the result of a%b is undefind *) val rem (a:t) (b:t{v b <> 0}) : Pure t (requires (size (v a / v b) n)) (ensures (fun c -> FStar.Int.mod (v a) (v b) = v c)) (* Bitwise operators *) val logand (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logand` v y = v z)) val logxor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logxor` v y == v z)) val logor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logor` v y == v z)) val lognot (x:t) : Pure t (requires True) (ensures (fun z -> lognot (v x) == v z)) (* Shift operators *) (** If a is negative the result is implementation-defined *) val shift_right (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c)) (** If a is negative or a * pow2 s is not representable the result is undefined *) val shift_left (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c)) val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t (requires (UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c)) (* Comparison operators *) let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b) let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b) let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b) let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b) let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b) (* Infix notations *) unfold let op_Plus_Hat = add unfold let op_Subtraction_Hat = sub unfold let op_Star_Hat = mul unfold let op_Slash_Hat = div unfold let op_Percent_Hat = rem

FStar.Int128.fsti

val op_Amp_Hat : x: FStar.Int128.t -> y: FStar.Int128.t -> Prims.Pure FStar.Int128.t

FStar.Int128.op_Amp_Hat

x: FStar.Int128.t -> y: FStar.Int128.t -> Prims.Pure FStar.Int128.t

Prims.Pure

let op_Bar_Hat = logor

let op_Bar_Hat =

logor

(* Copyright 2008-2019 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.Int128 (**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****) unfold let n = 128 open FStar.Int open FStar.Mul #set-options "--max_fuel 0 --max_ifuel 0" (* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly * a copy-paste of this module. *) new val t : eqtype val v (x:t) : Tot (int_t n) val int_to_t: x:int_t n -> Pure t (requires True) (ensures (fun y -> v y = x)) val uv_inv (x : t) : Lemma (ensures (int_to_t (v x) == x)) [SMTPat (v x)] val vu_inv (x : int_t n) : Lemma (ensures (v (int_to_t x) == x)) [SMTPat (int_to_t x)] val v_inj (x1 x2: t): Lemma (requires (v x1 == v x2)) (ensures (x1 == x2)) val zero : x:t{v x = 0} val one : x:t{v x = 1} val add (a:t) (b:t) : Pure t (requires (size (v a + v b) n)) (ensures (fun c -> v a + v b = v c)) (* Subtraction primitives *) val sub (a:t) (b:t) : Pure t (requires (size (v a - v b) n)) (ensures (fun c -> v a - v b = v c)) (* Multiplication primitives *) val mul (a:t) (b:t) : Pure t (requires (size (v a * v b) n)) (ensures (fun c -> v a * v b = v c)) (* Division primitives *) val div (a:t) (b:t{v b <> 0}) : Pure t // division overflows on INT_MIN / -1 (requires (size (v a / v b) n)) (ensures (fun c -> v a / v b = v c)) (* Modulo primitives *) (* If a/b is not representable the result of a%b is undefind *) val rem (a:t) (b:t{v b <> 0}) : Pure t (requires (size (v a / v b) n)) (ensures (fun c -> FStar.Int.mod (v a) (v b) = v c)) (* Bitwise operators *) val logand (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logand` v y = v z)) val logxor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logxor` v y == v z)) val logor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logor` v y == v z)) val lognot (x:t) : Pure t (requires True) (ensures (fun z -> lognot (v x) == v z)) (* Shift operators *) (** If a is negative the result is implementation-defined *) val shift_right (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c)) (** If a is negative or a * pow2 s is not representable the result is undefined *) val shift_left (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c)) val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t (requires (UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c)) (* Comparison operators *) let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b) let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b) let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b) let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b) let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b) (* Infix notations *) unfold let op_Plus_Hat = add unfold let op_Subtraction_Hat = sub unfold let op_Star_Hat = mul unfold let op_Slash_Hat = div unfold let op_Percent_Hat = rem unfold let op_Hat_Hat = logxor

FStar.Int128.fsti

val op_Bar_Hat : x: FStar.Int128.t -> y: FStar.Int128.t -> Prims.Pure FStar.Int128.t

FStar.Int128.op_Bar_Hat

x: FStar.Int128.t -> y: FStar.Int128.t -> Prims.Pure FStar.Int128.t

Prims.Pure

let op_Subtraction_Hat = sub

let op_Subtraction_Hat =

sub

(* Copyright 2008-2019 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.Int128 (**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****) unfold let n = 128 open FStar.Int open FStar.Mul #set-options "--max_fuel 0 --max_ifuel 0" (* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly * a copy-paste of this module. *) new val t : eqtype val v (x:t) : Tot (int_t n) val int_to_t: x:int_t n -> Pure t (requires True) (ensures (fun y -> v y = x)) val uv_inv (x : t) : Lemma (ensures (int_to_t (v x) == x)) [SMTPat (v x)] val vu_inv (x : int_t n) : Lemma (ensures (v (int_to_t x) == x)) [SMTPat (int_to_t x)] val v_inj (x1 x2: t): Lemma (requires (v x1 == v x2)) (ensures (x1 == x2)) val zero : x:t{v x = 0} val one : x:t{v x = 1} val add (a:t) (b:t) : Pure t (requires (size (v a + v b) n)) (ensures (fun c -> v a + v b = v c)) (* Subtraction primitives *) val sub (a:t) (b:t) : Pure t (requires (size (v a - v b) n)) (ensures (fun c -> v a - v b = v c)) (* Multiplication primitives *) val mul (a:t) (b:t) : Pure t (requires (size (v a * v b) n)) (ensures (fun c -> v a * v b = v c)) (* Division primitives *) val div (a:t) (b:t{v b <> 0}) : Pure t // division overflows on INT_MIN / -1 (requires (size (v a / v b) n)) (ensures (fun c -> v a / v b = v c)) (* Modulo primitives *) (* If a/b is not representable the result of a%b is undefind *) val rem (a:t) (b:t{v b <> 0}) : Pure t (requires (size (v a / v b) n)) (ensures (fun c -> FStar.Int.mod (v a) (v b) = v c)) (* Bitwise operators *) val logand (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logand` v y = v z)) val logxor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logxor` v y == v z)) val logor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logor` v y == v z)) val lognot (x:t) : Pure t (requires True) (ensures (fun z -> lognot (v x) == v z)) (* Shift operators *) (** If a is negative the result is implementation-defined *) val shift_right (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c)) (** If a is negative or a * pow2 s is not representable the result is undefined *) val shift_left (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c)) val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t (requires (UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c)) (* Comparison operators *) let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b) let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b) let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b) let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b) let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b) (* Infix notations *)

FStar.Int128.fsti

val op_Subtraction_Hat : a: FStar.Int128.t -> b: FStar.Int128.t -> Prims.Pure FStar.Int128.t

FStar.Int128.op_Subtraction_Hat

a: FStar.Int128.t -> b: FStar.Int128.t -> Prims.Pure FStar.Int128.t

Prims.Pure

let op_Slash_Hat = div

let op_Slash_Hat =

div

(* Copyright 2008-2019 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.Int128 (**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****) unfold let n = 128 open FStar.Int open FStar.Mul #set-options "--max_fuel 0 --max_ifuel 0" (* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly * a copy-paste of this module. *) new val t : eqtype val v (x:t) : Tot (int_t n) val int_to_t: x:int_t n -> Pure t (requires True) (ensures (fun y -> v y = x)) val uv_inv (x : t) : Lemma (ensures (int_to_t (v x) == x)) [SMTPat (v x)] val vu_inv (x : int_t n) : Lemma (ensures (v (int_to_t x) == x)) [SMTPat (int_to_t x)] val v_inj (x1 x2: t): Lemma (requires (v x1 == v x2)) (ensures (x1 == x2)) val zero : x:t{v x = 0} val one : x:t{v x = 1} val add (a:t) (b:t) : Pure t (requires (size (v a + v b) n)) (ensures (fun c -> v a + v b = v c)) (* Subtraction primitives *) val sub (a:t) (b:t) : Pure t (requires (size (v a - v b) n)) (ensures (fun c -> v a - v b = v c)) (* Multiplication primitives *) val mul (a:t) (b:t) : Pure t (requires (size (v a * v b) n)) (ensures (fun c -> v a * v b = v c)) (* Division primitives *) val div (a:t) (b:t{v b <> 0}) : Pure t // division overflows on INT_MIN / -1 (requires (size (v a / v b) n)) (ensures (fun c -> v a / v b = v c)) (* Modulo primitives *) (* If a/b is not representable the result of a%b is undefind *) val rem (a:t) (b:t{v b <> 0}) : Pure t (requires (size (v a / v b) n)) (ensures (fun c -> FStar.Int.mod (v a) (v b) = v c)) (* Bitwise operators *) val logand (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logand` v y = v z)) val logxor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logxor` v y == v z)) val logor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logor` v y == v z)) val lognot (x:t) : Pure t (requires True) (ensures (fun z -> lognot (v x) == v z)) (* Shift operators *) (** If a is negative the result is implementation-defined *) val shift_right (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c)) (** If a is negative or a * pow2 s is not representable the result is undefined *) val shift_left (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c)) val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t (requires (UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c)) (* Comparison operators *) let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b) let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b) let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b) let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b) let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b) (* Infix notations *) unfold let op_Plus_Hat = add unfold let op_Subtraction_Hat = sub

FStar.Int128.fsti

val op_Slash_Hat : a: FStar.Int128.t -> b: FStar.Int128.t{FStar.Int128.v b <> 0} -> Prims.Pure FStar.Int128.t

FStar.Int128.op_Slash_Hat

a: FStar.Int128.t -> b: FStar.Int128.t{FStar.Int128.v b <> 0} -> Prims.Pure FStar.Int128.t

Prims.Pure

let op_Less_Less_Hat = shift_left

let op_Less_Less_Hat =

shift_left

(* Copyright 2008-2019 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.Int128 (**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****) unfold let n = 128 open FStar.Int open FStar.Mul #set-options "--max_fuel 0 --max_ifuel 0" (* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly * a copy-paste of this module. *) new val t : eqtype val v (x:t) : Tot (int_t n) val int_to_t: x:int_t n -> Pure t (requires True) (ensures (fun y -> v y = x)) val uv_inv (x : t) : Lemma (ensures (int_to_t (v x) == x)) [SMTPat (v x)] val vu_inv (x : int_t n) : Lemma (ensures (v (int_to_t x) == x)) [SMTPat (int_to_t x)] val v_inj (x1 x2: t): Lemma (requires (v x1 == v x2)) (ensures (x1 == x2)) val zero : x:t{v x = 0} val one : x:t{v x = 1} val add (a:t) (b:t) : Pure t (requires (size (v a + v b) n)) (ensures (fun c -> v a + v b = v c)) (* Subtraction primitives *) val sub (a:t) (b:t) : Pure t (requires (size (v a - v b) n)) (ensures (fun c -> v a - v b = v c)) (* Multiplication primitives *) val mul (a:t) (b:t) : Pure t (requires (size (v a * v b) n)) (ensures (fun c -> v a * v b = v c)) (* Division primitives *) val div (a:t) (b:t{v b <> 0}) : Pure t // division overflows on INT_MIN / -1 (requires (size (v a / v b) n)) (ensures (fun c -> v a / v b = v c)) (* Modulo primitives *) (* If a/b is not representable the result of a%b is undefind *) val rem (a:t) (b:t{v b <> 0}) : Pure t (requires (size (v a / v b) n)) (ensures (fun c -> FStar.Int.mod (v a) (v b) = v c)) (* Bitwise operators *) val logand (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logand` v y = v z)) val logxor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logxor` v y == v z)) val logor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logor` v y == v z)) val lognot (x:t) : Pure t (requires True) (ensures (fun z -> lognot (v x) == v z)) (* Shift operators *) (** If a is negative the result is implementation-defined *) val shift_right (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c)) (** If a is negative or a * pow2 s is not representable the result is undefined *) val shift_left (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c)) val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t (requires (UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c)) (* Comparison operators *) let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b) let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b) let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b) let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b) let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b) (* Infix notations *) unfold let op_Plus_Hat = add unfold let op_Subtraction_Hat = sub unfold let op_Star_Hat = mul unfold let op_Slash_Hat = div unfold let op_Percent_Hat = rem unfold let op_Hat_Hat = logxor unfold let op_Amp_Hat = logand

FStar.Int128.fsti

val op_Less_Less_Hat : a: FStar.Int128.t -> s: FStar.UInt32.t -> Prims.Pure FStar.Int128.t

FStar.Int128.op_Less_Less_Hat

a: FStar.Int128.t -> s: FStar.UInt32.t -> Prims.Pure FStar.Int128.t

Prims.Pure

let op_Percent_Hat = rem

let op_Percent_Hat =

rem

(* Copyright 2008-2019 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.Int128 (**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****) unfold let n = 128 open FStar.Int open FStar.Mul #set-options "--max_fuel 0 --max_ifuel 0" (* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly * a copy-paste of this module. *) new val t : eqtype val v (x:t) : Tot (int_t n) val int_to_t: x:int_t n -> Pure t (requires True) (ensures (fun y -> v y = x)) val uv_inv (x : t) : Lemma (ensures (int_to_t (v x) == x)) [SMTPat (v x)] val vu_inv (x : int_t n) : Lemma (ensures (v (int_to_t x) == x)) [SMTPat (int_to_t x)] val v_inj (x1 x2: t): Lemma (requires (v x1 == v x2)) (ensures (x1 == x2)) val zero : x:t{v x = 0} val one : x:t{v x = 1} val add (a:t) (b:t) : Pure t (requires (size (v a + v b) n)) (ensures (fun c -> v a + v b = v c)) (* Subtraction primitives *) val sub (a:t) (b:t) : Pure t (requires (size (v a - v b) n)) (ensures (fun c -> v a - v b = v c)) (* Multiplication primitives *) val mul (a:t) (b:t) : Pure t (requires (size (v a * v b) n)) (ensures (fun c -> v a * v b = v c)) (* Division primitives *) val div (a:t) (b:t{v b <> 0}) : Pure t // division overflows on INT_MIN / -1 (requires (size (v a / v b) n)) (ensures (fun c -> v a / v b = v c)) (* Modulo primitives *) (* If a/b is not representable the result of a%b is undefind *) val rem (a:t) (b:t{v b <> 0}) : Pure t (requires (size (v a / v b) n)) (ensures (fun c -> FStar.Int.mod (v a) (v b) = v c)) (* Bitwise operators *) val logand (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logand` v y = v z)) val logxor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logxor` v y == v z)) val logor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logor` v y == v z)) val lognot (x:t) : Pure t (requires True) (ensures (fun z -> lognot (v x) == v z)) (* Shift operators *) (** If a is negative the result is implementation-defined *) val shift_right (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c)) (** If a is negative or a * pow2 s is not representable the result is undefined *) val shift_left (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c)) val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t (requires (UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c)) (* Comparison operators *) let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b) let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b) let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b) let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b) let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b) (* Infix notations *) unfold let op_Plus_Hat = add unfold let op_Subtraction_Hat = sub unfold let op_Star_Hat = mul

FStar.Int128.fsti

val op_Percent_Hat : a: FStar.Int128.t -> b: FStar.Int128.t{FStar.Int128.v b <> 0} -> Prims.Pure FStar.Int128.t

FStar.Int128.op_Percent_Hat

a: FStar.Int128.t -> b: FStar.Int128.t{FStar.Int128.v b <> 0} -> Prims.Pure FStar.Int128.t

Prims.Tot

let op_Greater_Hat = gt

let op_Greater_Hat =

gt

(* Copyright 2008-2019 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.Int128 (**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****) unfold let n = 128 open FStar.Int open FStar.Mul #set-options "--max_fuel 0 --max_ifuel 0" (* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly * a copy-paste of this module. *) new val t : eqtype val v (x:t) : Tot (int_t n) val int_to_t: x:int_t n -> Pure t (requires True) (ensures (fun y -> v y = x)) val uv_inv (x : t) : Lemma (ensures (int_to_t (v x) == x)) [SMTPat (v x)] val vu_inv (x : int_t n) : Lemma (ensures (v (int_to_t x) == x)) [SMTPat (int_to_t x)] val v_inj (x1 x2: t): Lemma (requires (v x1 == v x2)) (ensures (x1 == x2)) val zero : x:t{v x = 0} val one : x:t{v x = 1} val add (a:t) (b:t) : Pure t (requires (size (v a + v b) n)) (ensures (fun c -> v a + v b = v c)) (* Subtraction primitives *) val sub (a:t) (b:t) : Pure t (requires (size (v a - v b) n)) (ensures (fun c -> v a - v b = v c)) (* Multiplication primitives *) val mul (a:t) (b:t) : Pure t (requires (size (v a * v b) n)) (ensures (fun c -> v a * v b = v c)) (* Division primitives *) val div (a:t) (b:t{v b <> 0}) : Pure t // division overflows on INT_MIN / -1 (requires (size (v a / v b) n)) (ensures (fun c -> v a / v b = v c)) (* Modulo primitives *) (* If a/b is not representable the result of a%b is undefind *) val rem (a:t) (b:t{v b <> 0}) : Pure t (requires (size (v a / v b) n)) (ensures (fun c -> FStar.Int.mod (v a) (v b) = v c)) (* Bitwise operators *) val logand (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logand` v y = v z)) val logxor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logxor` v y == v z)) val logor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logor` v y == v z)) val lognot (x:t) : Pure t (requires True) (ensures (fun z -> lognot (v x) == v z)) (* Shift operators *) (** If a is negative the result is implementation-defined *) val shift_right (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c)) (** If a is negative or a * pow2 s is not representable the result is undefined *) val shift_left (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c)) val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t (requires (UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c)) (* Comparison operators *) let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b) let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b) let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b) let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b) let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b) (* Infix notations *) unfold let op_Plus_Hat = add unfold let op_Subtraction_Hat = sub unfold let op_Star_Hat = mul unfold let op_Slash_Hat = div unfold let op_Percent_Hat = rem unfold let op_Hat_Hat = logxor unfold let op_Amp_Hat = logand unfold let op_Bar_Hat = logor unfold let op_Less_Less_Hat = shift_left unfold let op_Greater_Greater_Hat = shift_right unfold let op_Greater_Greater_Greater_Hat = shift_arithmetic_right

FStar.Int128.fsti

val op_Greater_Hat : a: FStar.Int128.t -> b: FStar.Int128.t -> Prims.bool

FStar.Int128.op_Greater_Hat

a: FStar.Int128.t -> b: FStar.Int128.t -> Prims.bool

Prims.Tot

let op_Equals_Hat = eq

let op_Equals_Hat =

eq

(* Copyright 2008-2019 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.Int128 (**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****) unfold let n = 128 open FStar.Int open FStar.Mul #set-options "--max_fuel 0 --max_ifuel 0" (* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly * a copy-paste of this module. *) new val t : eqtype val v (x:t) : Tot (int_t n) val int_to_t: x:int_t n -> Pure t (requires True) (ensures (fun y -> v y = x)) val uv_inv (x : t) : Lemma (ensures (int_to_t (v x) == x)) [SMTPat (v x)] val vu_inv (x : int_t n) : Lemma (ensures (v (int_to_t x) == x)) [SMTPat (int_to_t x)] val v_inj (x1 x2: t): Lemma (requires (v x1 == v x2)) (ensures (x1 == x2)) val zero : x:t{v x = 0} val one : x:t{v x = 1} val add (a:t) (b:t) : Pure t (requires (size (v a + v b) n)) (ensures (fun c -> v a + v b = v c)) (* Subtraction primitives *) val sub (a:t) (b:t) : Pure t (requires (size (v a - v b) n)) (ensures (fun c -> v a - v b = v c)) (* Multiplication primitives *) val mul (a:t) (b:t) : Pure t (requires (size (v a * v b) n)) (ensures (fun c -> v a * v b = v c)) (* Division primitives *) val div (a:t) (b:t{v b <> 0}) : Pure t // division overflows on INT_MIN / -1 (requires (size (v a / v b) n)) (ensures (fun c -> v a / v b = v c)) (* Modulo primitives *) (* If a/b is not representable the result of a%b is undefind *) val rem (a:t) (b:t{v b <> 0}) : Pure t (requires (size (v a / v b) n)) (ensures (fun c -> FStar.Int.mod (v a) (v b) = v c)) (* Bitwise operators *) val logand (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logand` v y = v z)) val logxor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logxor` v y == v z)) val logor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logor` v y == v z)) val lognot (x:t) : Pure t (requires True) (ensures (fun z -> lognot (v x) == v z)) (* Shift operators *) (** If a is negative the result is implementation-defined *) val shift_right (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c)) (** If a is negative or a * pow2 s is not representable the result is undefined *) val shift_left (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c)) val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t (requires (UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c)) (* Comparison operators *) let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b) let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b) let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b) let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b) let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b) (* Infix notations *) unfold let op_Plus_Hat = add unfold let op_Subtraction_Hat = sub unfold let op_Star_Hat = mul unfold let op_Slash_Hat = div unfold let op_Percent_Hat = rem unfold let op_Hat_Hat = logxor unfold let op_Amp_Hat = logand unfold let op_Bar_Hat = logor unfold let op_Less_Less_Hat = shift_left unfold let op_Greater_Greater_Hat = shift_right

FStar.Int128.fsti

val op_Equals_Hat : a: FStar.Int128.t -> b: FStar.Int128.t -> Prims.bool

FStar.Int128.op_Equals_Hat

a: FStar.Int128.t -> b: FStar.Int128.t -> Prims.bool

Prims.Tot

let op_Less_Hat = lt

let op_Less_Hat =

lt

(* Copyright 2008-2019 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.Int128 (**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****) unfold let n = 128 open FStar.Int open FStar.Mul #set-options "--max_fuel 0 --max_ifuel 0" (* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly * a copy-paste of this module. *) new val t : eqtype val v (x:t) : Tot (int_t n) val int_to_t: x:int_t n -> Pure t (requires True) (ensures (fun y -> v y = x)) val uv_inv (x : t) : Lemma (ensures (int_to_t (v x) == x)) [SMTPat (v x)] val vu_inv (x : int_t n) : Lemma (ensures (v (int_to_t x) == x)) [SMTPat (int_to_t x)] val v_inj (x1 x2: t): Lemma (requires (v x1 == v x2)) (ensures (x1 == x2)) val zero : x:t{v x = 0} val one : x:t{v x = 1} val add (a:t) (b:t) : Pure t (requires (size (v a + v b) n)) (ensures (fun c -> v a + v b = v c)) (* Subtraction primitives *) val sub (a:t) (b:t) : Pure t (requires (size (v a - v b) n)) (ensures (fun c -> v a - v b = v c)) (* Multiplication primitives *) val mul (a:t) (b:t) : Pure t (requires (size (v a * v b) n)) (ensures (fun c -> v a * v b = v c)) (* Division primitives *) val div (a:t) (b:t{v b <> 0}) : Pure t // division overflows on INT_MIN / -1 (requires (size (v a / v b) n)) (ensures (fun c -> v a / v b = v c)) (* Modulo primitives *) (* If a/b is not representable the result of a%b is undefind *) val rem (a:t) (b:t{v b <> 0}) : Pure t (requires (size (v a / v b) n)) (ensures (fun c -> FStar.Int.mod (v a) (v b) = v c)) (* Bitwise operators *) val logand (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logand` v y = v z)) val logxor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logxor` v y == v z)) val logor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logor` v y == v z)) val lognot (x:t) : Pure t (requires True) (ensures (fun z -> lognot (v x) == v z)) (* Shift operators *) (** If a is negative the result is implementation-defined *) val shift_right (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c)) (** If a is negative or a * pow2 s is not representable the result is undefined *) val shift_left (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c)) val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t (requires (UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c)) (* Comparison operators *) let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b) let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b) let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b) let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b) let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b) (* Infix notations *) unfold let op_Plus_Hat = add unfold let op_Subtraction_Hat = sub unfold let op_Star_Hat = mul unfold let op_Slash_Hat = div unfold let op_Percent_Hat = rem unfold let op_Hat_Hat = logxor unfold let op_Amp_Hat = logand unfold let op_Bar_Hat = logor unfold let op_Less_Less_Hat = shift_left unfold let op_Greater_Greater_Hat = shift_right unfold let op_Greater_Greater_Greater_Hat = shift_arithmetic_right unfold let op_Equals_Hat = eq unfold let op_Greater_Hat = gt

FStar.Int128.fsti

val op_Less_Hat : a: FStar.Int128.t -> b: FStar.Int128.t -> Prims.bool

FStar.Int128.op_Less_Hat

a: FStar.Int128.t -> b: FStar.Int128.t -> Prims.bool

Prims.Tot

let op_Less_Equals_Hat = lte

let op_Less_Equals_Hat =

lte

(* Copyright 2008-2019 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.Int128 (**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****) unfold let n = 128 open FStar.Int open FStar.Mul #set-options "--max_fuel 0 --max_ifuel 0" (* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly * a copy-paste of this module. *) new val t : eqtype val v (x:t) : Tot (int_t n) val int_to_t: x:int_t n -> Pure t (requires True) (ensures (fun y -> v y = x)) val uv_inv (x : t) : Lemma (ensures (int_to_t (v x) == x)) [SMTPat (v x)] val vu_inv (x : int_t n) : Lemma (ensures (v (int_to_t x) == x)) [SMTPat (int_to_t x)] val v_inj (x1 x2: t): Lemma (requires (v x1 == v x2)) (ensures (x1 == x2)) val zero : x:t{v x = 0} val one : x:t{v x = 1} val add (a:t) (b:t) : Pure t (requires (size (v a + v b) n)) (ensures (fun c -> v a + v b = v c)) (* Subtraction primitives *) val sub (a:t) (b:t) : Pure t (requires (size (v a - v b) n)) (ensures (fun c -> v a - v b = v c)) (* Multiplication primitives *) val mul (a:t) (b:t) : Pure t (requires (size (v a * v b) n)) (ensures (fun c -> v a * v b = v c)) (* Division primitives *) val div (a:t) (b:t{v b <> 0}) : Pure t // division overflows on INT_MIN / -1 (requires (size (v a / v b) n)) (ensures (fun c -> v a / v b = v c)) (* Modulo primitives *) (* If a/b is not representable the result of a%b is undefind *) val rem (a:t) (b:t{v b <> 0}) : Pure t (requires (size (v a / v b) n)) (ensures (fun c -> FStar.Int.mod (v a) (v b) = v c)) (* Bitwise operators *) val logand (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logand` v y = v z)) val logxor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logxor` v y == v z)) val logor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logor` v y == v z)) val lognot (x:t) : Pure t (requires True) (ensures (fun z -> lognot (v x) == v z)) (* Shift operators *) (** If a is negative the result is implementation-defined *) val shift_right (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c)) (** If a is negative or a * pow2 s is not representable the result is undefined *) val shift_left (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c)) val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t (requires (UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c)) (* Comparison operators *) let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b) let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b) let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b) let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b) let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b) (* Infix notations *) unfold let op_Plus_Hat = add unfold let op_Subtraction_Hat = sub unfold let op_Star_Hat = mul unfold let op_Slash_Hat = div unfold let op_Percent_Hat = rem unfold let op_Hat_Hat = logxor unfold let op_Amp_Hat = logand unfold let op_Bar_Hat = logor unfold let op_Less_Less_Hat = shift_left unfold let op_Greater_Greater_Hat = shift_right unfold let op_Greater_Greater_Greater_Hat = shift_arithmetic_right unfold let op_Equals_Hat = eq unfold let op_Greater_Hat = gt unfold let op_Greater_Equals_Hat = gte

FStar.Int128.fsti

val op_Less_Equals_Hat : a: FStar.Int128.t -> b: FStar.Int128.t -> Prims.bool

FStar.Int128.op_Less_Equals_Hat

a: FStar.Int128.t -> b: FStar.Int128.t -> Prims.bool

Prims.Tot

val gt (a b: t) : Tot bool

let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b)

val gt (a b: t) : Tot bool let gt (a b: t) : Tot bool =

gt #n (v a) (v b)

(* Copyright 2008-2019 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.Int128 (**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****) unfold let n = 128 open FStar.Int open FStar.Mul #set-options "--max_fuel 0 --max_ifuel 0" (* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly * a copy-paste of this module. *) new val t : eqtype val v (x:t) : Tot (int_t n) val int_to_t: x:int_t n -> Pure t (requires True) (ensures (fun y -> v y = x)) val uv_inv (x : t) : Lemma (ensures (int_to_t (v x) == x)) [SMTPat (v x)] val vu_inv (x : int_t n) : Lemma (ensures (v (int_to_t x) == x)) [SMTPat (int_to_t x)] val v_inj (x1 x2: t): Lemma (requires (v x1 == v x2)) (ensures (x1 == x2)) val zero : x:t{v x = 0} val one : x:t{v x = 1} val add (a:t) (b:t) : Pure t (requires (size (v a + v b) n)) (ensures (fun c -> v a + v b = v c)) (* Subtraction primitives *) val sub (a:t) (b:t) : Pure t (requires (size (v a - v b) n)) (ensures (fun c -> v a - v b = v c)) (* Multiplication primitives *) val mul (a:t) (b:t) : Pure t (requires (size (v a * v b) n)) (ensures (fun c -> v a * v b = v c)) (* Division primitives *) val div (a:t) (b:t{v b <> 0}) : Pure t // division overflows on INT_MIN / -1 (requires (size (v a / v b) n)) (ensures (fun c -> v a / v b = v c)) (* Modulo primitives *) (* If a/b is not representable the result of a%b is undefind *) val rem (a:t) (b:t{v b <> 0}) : Pure t (requires (size (v a / v b) n)) (ensures (fun c -> FStar.Int.mod (v a) (v b) = v c)) (* Bitwise operators *) val logand (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logand` v y = v z)) val logxor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logxor` v y == v z)) val logor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logor` v y == v z)) val lognot (x:t) : Pure t (requires True) (ensures (fun z -> lognot (v x) == v z)) (* Shift operators *) (** If a is negative the result is implementation-defined *) val shift_right (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c)) (** If a is negative or a * pow2 s is not representable the result is undefined *) val shift_left (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c)) val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t (requires (UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c)) (* Comparison operators *)

FStar.Int128.fsti

val gt (a b: t) : Tot bool

FStar.Int128.gt

a: FStar.Int128.t -> b: FStar.Int128.t -> Prims.bool

Prims.Tot

val gte (a b: t) : Tot bool

let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b)

val gte (a b: t) : Tot bool let gte (a b: t) : Tot bool =

gte #n (v a) (v b)

(* Copyright 2008-2019 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.Int128 (**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****) unfold let n = 128 open FStar.Int open FStar.Mul #set-options "--max_fuel 0 --max_ifuel 0" (* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly * a copy-paste of this module. *) new val t : eqtype val v (x:t) : Tot (int_t n) val int_to_t: x:int_t n -> Pure t (requires True) (ensures (fun y -> v y = x)) val uv_inv (x : t) : Lemma (ensures (int_to_t (v x) == x)) [SMTPat (v x)] val vu_inv (x : int_t n) : Lemma (ensures (v (int_to_t x) == x)) [SMTPat (int_to_t x)] val v_inj (x1 x2: t): Lemma (requires (v x1 == v x2)) (ensures (x1 == x2)) val zero : x:t{v x = 0} val one : x:t{v x = 1} val add (a:t) (b:t) : Pure t (requires (size (v a + v b) n)) (ensures (fun c -> v a + v b = v c)) (* Subtraction primitives *) val sub (a:t) (b:t) : Pure t (requires (size (v a - v b) n)) (ensures (fun c -> v a - v b = v c)) (* Multiplication primitives *) val mul (a:t) (b:t) : Pure t (requires (size (v a * v b) n)) (ensures (fun c -> v a * v b = v c)) (* Division primitives *) val div (a:t) (b:t{v b <> 0}) : Pure t // division overflows on INT_MIN / -1 (requires (size (v a / v b) n)) (ensures (fun c -> v a / v b = v c)) (* Modulo primitives *) (* If a/b is not representable the result of a%b is undefind *) val rem (a:t) (b:t{v b <> 0}) : Pure t (requires (size (v a / v b) n)) (ensures (fun c -> FStar.Int.mod (v a) (v b) = v c)) (* Bitwise operators *) val logand (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logand` v y = v z)) val logxor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logxor` v y == v z)) val logor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logor` v y == v z)) val lognot (x:t) : Pure t (requires True) (ensures (fun z -> lognot (v x) == v z)) (* Shift operators *) (** If a is negative the result is implementation-defined *) val shift_right (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c)) (** If a is negative or a * pow2 s is not representable the result is undefined *) val shift_left (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c)) val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t (requires (UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c)) (* Comparison operators *) let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b)

FStar.Int128.fsti

val gte (a b: t) : Tot bool

FStar.Int128.gte

a: FStar.Int128.t -> b: FStar.Int128.t -> Prims.bool

Prims.Pure

let op_Star_Hat = mul

let op_Star_Hat =

mul

(* Copyright 2008-2019 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.Int128 (**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****) unfold let n = 128 open FStar.Int open FStar.Mul #set-options "--max_fuel 0 --max_ifuel 0" (* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly * a copy-paste of this module. *) new val t : eqtype val v (x:t) : Tot (int_t n) val int_to_t: x:int_t n -> Pure t (requires True) (ensures (fun y -> v y = x)) val uv_inv (x : t) : Lemma (ensures (int_to_t (v x) == x)) [SMTPat (v x)] val vu_inv (x : int_t n) : Lemma (ensures (v (int_to_t x) == x)) [SMTPat (int_to_t x)] val v_inj (x1 x2: t): Lemma (requires (v x1 == v x2)) (ensures (x1 == x2)) val zero : x:t{v x = 0} val one : x:t{v x = 1} val add (a:t) (b:t) : Pure t (requires (size (v a + v b) n)) (ensures (fun c -> v a + v b = v c)) (* Subtraction primitives *) val sub (a:t) (b:t) : Pure t (requires (size (v a - v b) n)) (ensures (fun c -> v a - v b = v c)) (* Multiplication primitives *) val mul (a:t) (b:t) : Pure t (requires (size (v a * v b) n)) (ensures (fun c -> v a * v b = v c)) (* Division primitives *) val div (a:t) (b:t{v b <> 0}) : Pure t // division overflows on INT_MIN / -1 (requires (size (v a / v b) n)) (ensures (fun c -> v a / v b = v c)) (* Modulo primitives *) (* If a/b is not representable the result of a%b is undefind *) val rem (a:t) (b:t{v b <> 0}) : Pure t (requires (size (v a / v b) n)) (ensures (fun c -> FStar.Int.mod (v a) (v b) = v c)) (* Bitwise operators *) val logand (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logand` v y = v z)) val logxor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logxor` v y == v z)) val logor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logor` v y == v z)) val lognot (x:t) : Pure t (requires True) (ensures (fun z -> lognot (v x) == v z)) (* Shift operators *) (** If a is negative the result is implementation-defined *) val shift_right (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c)) (** If a is negative or a * pow2 s is not representable the result is undefined *) val shift_left (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c)) val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t (requires (UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c)) (* Comparison operators *) let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b) let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b) let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b) let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b) let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b) (* Infix notations *) unfold let op_Plus_Hat = add

FStar.Int128.fsti

val op_Star_Hat : a: FStar.Int128.t -> b: FStar.Int128.t -> Prims.Pure FStar.Int128.t

FStar.Int128.op_Star_Hat

a: FStar.Int128.t -> b: FStar.Int128.t -> Prims.Pure FStar.Int128.t

Prims.Pure

let op_Plus_Hat = add

let op_Plus_Hat =

add

(* Copyright 2008-2019 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.Int128 (**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****) unfold let n = 128 open FStar.Int open FStar.Mul #set-options "--max_fuel 0 --max_ifuel 0" (* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly * a copy-paste of this module. *) new val t : eqtype val v (x:t) : Tot (int_t n) val int_to_t: x:int_t n -> Pure t (requires True) (ensures (fun y -> v y = x)) val uv_inv (x : t) : Lemma (ensures (int_to_t (v x) == x)) [SMTPat (v x)] val vu_inv (x : int_t n) : Lemma (ensures (v (int_to_t x) == x)) [SMTPat (int_to_t x)] val v_inj (x1 x2: t): Lemma (requires (v x1 == v x2)) (ensures (x1 == x2)) val zero : x:t{v x = 0} val one : x:t{v x = 1} val add (a:t) (b:t) : Pure t (requires (size (v a + v b) n)) (ensures (fun c -> v a + v b = v c)) (* Subtraction primitives *) val sub (a:t) (b:t) : Pure t (requires (size (v a - v b) n)) (ensures (fun c -> v a - v b = v c)) (* Multiplication primitives *) val mul (a:t) (b:t) : Pure t (requires (size (v a * v b) n)) (ensures (fun c -> v a * v b = v c)) (* Division primitives *) val div (a:t) (b:t{v b <> 0}) : Pure t // division overflows on INT_MIN / -1 (requires (size (v a / v b) n)) (ensures (fun c -> v a / v b = v c)) (* Modulo primitives *) (* If a/b is not representable the result of a%b is undefind *) val rem (a:t) (b:t{v b <> 0}) : Pure t (requires (size (v a / v b) n)) (ensures (fun c -> FStar.Int.mod (v a) (v b) = v c)) (* Bitwise operators *) val logand (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logand` v y = v z)) val logxor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logxor` v y == v z)) val logor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logor` v y == v z)) val lognot (x:t) : Pure t (requires True) (ensures (fun z -> lognot (v x) == v z)) (* Shift operators *) (** If a is negative the result is implementation-defined *) val shift_right (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c)) (** If a is negative or a * pow2 s is not representable the result is undefined *) val shift_left (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c)) val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t (requires (UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c)) (* Comparison operators *) let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b) let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b) let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b) let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b) let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b)

FStar.Int128.fsti

val op_Plus_Hat : a: FStar.Int128.t -> b: FStar.Int128.t -> Prims.Pure FStar.Int128.t

FStar.Int128.op_Plus_Hat

a: FStar.Int128.t -> b: FStar.Int128.t -> Prims.Pure FStar.Int128.t

Prims.Pure

let op_Greater_Greater_Hat = shift_right

let op_Greater_Greater_Hat =

shift_right

(* Copyright 2008-2019 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.Int128 (**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****) unfold let n = 128 open FStar.Int open FStar.Mul #set-options "--max_fuel 0 --max_ifuel 0" (* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly * a copy-paste of this module. *) new val t : eqtype val v (x:t) : Tot (int_t n) val int_to_t: x:int_t n -> Pure t (requires True) (ensures (fun y -> v y = x)) val uv_inv (x : t) : Lemma (ensures (int_to_t (v x) == x)) [SMTPat (v x)] val vu_inv (x : int_t n) : Lemma (ensures (v (int_to_t x) == x)) [SMTPat (int_to_t x)] val v_inj (x1 x2: t): Lemma (requires (v x1 == v x2)) (ensures (x1 == x2)) val zero : x:t{v x = 0} val one : x:t{v x = 1} val add (a:t) (b:t) : Pure t (requires (size (v a + v b) n)) (ensures (fun c -> v a + v b = v c)) (* Subtraction primitives *) val sub (a:t) (b:t) : Pure t (requires (size (v a - v b) n)) (ensures (fun c -> v a - v b = v c)) (* Multiplication primitives *) val mul (a:t) (b:t) : Pure t (requires (size (v a * v b) n)) (ensures (fun c -> v a * v b = v c)) (* Division primitives *) val div (a:t) (b:t{v b <> 0}) : Pure t // division overflows on INT_MIN / -1 (requires (size (v a / v b) n)) (ensures (fun c -> v a / v b = v c)) (* Modulo primitives *) (* If a/b is not representable the result of a%b is undefind *) val rem (a:t) (b:t{v b <> 0}) : Pure t (requires (size (v a / v b) n)) (ensures (fun c -> FStar.Int.mod (v a) (v b) = v c)) (* Bitwise operators *) val logand (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logand` v y = v z)) val logxor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logxor` v y == v z)) val logor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logor` v y == v z)) val lognot (x:t) : Pure t (requires True) (ensures (fun z -> lognot (v x) == v z)) (* Shift operators *) (** If a is negative the result is implementation-defined *) val shift_right (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c)) (** If a is negative or a * pow2 s is not representable the result is undefined *) val shift_left (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c)) val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t (requires (UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c)) (* Comparison operators *) let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b) let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b) let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b) let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b) let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b) (* Infix notations *) unfold let op_Plus_Hat = add unfold let op_Subtraction_Hat = sub unfold let op_Star_Hat = mul unfold let op_Slash_Hat = div unfold let op_Percent_Hat = rem unfold let op_Hat_Hat = logxor unfold let op_Amp_Hat = logand unfold let op_Bar_Hat = logor

FStar.Int128.fsti

val op_Greater_Greater_Hat : a: FStar.Int128.t -> s: FStar.UInt32.t -> Prims.Pure FStar.Int128.t

FStar.Int128.op_Greater_Greater_Hat

a: FStar.Int128.t -> s: FStar.UInt32.t -> Prims.Pure FStar.Int128.t

Prims.Pure

let op_Greater_Greater_Greater_Hat = shift_arithmetic_right

let op_Greater_Greater_Greater_Hat =

shift_arithmetic_right

(* Copyright 2008-2019 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.Int128 (**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****) unfold let n = 128 open FStar.Int open FStar.Mul #set-options "--max_fuel 0 --max_ifuel 0" (* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly * a copy-paste of this module. *) new val t : eqtype val v (x:t) : Tot (int_t n) val int_to_t: x:int_t n -> Pure t (requires True) (ensures (fun y -> v y = x)) val uv_inv (x : t) : Lemma (ensures (int_to_t (v x) == x)) [SMTPat (v x)] val vu_inv (x : int_t n) : Lemma (ensures (v (int_to_t x) == x)) [SMTPat (int_to_t x)] val v_inj (x1 x2: t): Lemma (requires (v x1 == v x2)) (ensures (x1 == x2)) val zero : x:t{v x = 0} val one : x:t{v x = 1} val add (a:t) (b:t) : Pure t (requires (size (v a + v b) n)) (ensures (fun c -> v a + v b = v c)) (* Subtraction primitives *) val sub (a:t) (b:t) : Pure t (requires (size (v a - v b) n)) (ensures (fun c -> v a - v b = v c)) (* Multiplication primitives *) val mul (a:t) (b:t) : Pure t (requires (size (v a * v b) n)) (ensures (fun c -> v a * v b = v c)) (* Division primitives *) val div (a:t) (b:t{v b <> 0}) : Pure t // division overflows on INT_MIN / -1 (requires (size (v a / v b) n)) (ensures (fun c -> v a / v b = v c)) (* Modulo primitives *) (* If a/b is not representable the result of a%b is undefind *) val rem (a:t) (b:t{v b <> 0}) : Pure t (requires (size (v a / v b) n)) (ensures (fun c -> FStar.Int.mod (v a) (v b) = v c)) (* Bitwise operators *) val logand (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logand` v y = v z)) val logxor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logxor` v y == v z)) val logor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logor` v y == v z)) val lognot (x:t) : Pure t (requires True) (ensures (fun z -> lognot (v x) == v z)) (* Shift operators *) (** If a is negative the result is implementation-defined *) val shift_right (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c)) (** If a is negative or a * pow2 s is not representable the result is undefined *) val shift_left (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c)) val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t (requires (UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c)) (* Comparison operators *) let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b) let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b) let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b) let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b) let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b) (* Infix notations *) unfold let op_Plus_Hat = add unfold let op_Subtraction_Hat = sub unfold let op_Star_Hat = mul unfold let op_Slash_Hat = div unfold let op_Percent_Hat = rem unfold let op_Hat_Hat = logxor unfold let op_Amp_Hat = logand unfold let op_Bar_Hat = logor unfold let op_Less_Less_Hat = shift_left

FStar.Int128.fsti

val op_Greater_Greater_Greater_Hat : a: FStar.Int128.t -> s: FStar.UInt32.t -> Prims.Pure FStar.Int128.t

FStar.Int128.op_Greater_Greater_Greater_Hat

a: FStar.Int128.t -> s: FStar.UInt32.t -> Prims.Pure FStar.Int128.t

Prims.Tot

let op_Greater_Equals_Hat = gte

let op_Greater_Equals_Hat =

gte

(* Copyright 2008-2019 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.Int128 (**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****) unfold let n = 128 open FStar.Int open FStar.Mul #set-options "--max_fuel 0 --max_ifuel 0" (* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly * a copy-paste of this module. *) new val t : eqtype val v (x:t) : Tot (int_t n) val int_to_t: x:int_t n -> Pure t (requires True) (ensures (fun y -> v y = x)) val uv_inv (x : t) : Lemma (ensures (int_to_t (v x) == x)) [SMTPat (v x)] val vu_inv (x : int_t n) : Lemma (ensures (v (int_to_t x) == x)) [SMTPat (int_to_t x)] val v_inj (x1 x2: t): Lemma (requires (v x1 == v x2)) (ensures (x1 == x2)) val zero : x:t{v x = 0} val one : x:t{v x = 1} val add (a:t) (b:t) : Pure t (requires (size (v a + v b) n)) (ensures (fun c -> v a + v b = v c)) (* Subtraction primitives *) val sub (a:t) (b:t) : Pure t (requires (size (v a - v b) n)) (ensures (fun c -> v a - v b = v c)) (* Multiplication primitives *) val mul (a:t) (b:t) : Pure t (requires (size (v a * v b) n)) (ensures (fun c -> v a * v b = v c)) (* Division primitives *) val div (a:t) (b:t{v b <> 0}) : Pure t // division overflows on INT_MIN / -1 (requires (size (v a / v b) n)) (ensures (fun c -> v a / v b = v c)) (* Modulo primitives *) (* If a/b is not representable the result of a%b is undefind *) val rem (a:t) (b:t{v b <> 0}) : Pure t (requires (size (v a / v b) n)) (ensures (fun c -> FStar.Int.mod (v a) (v b) = v c)) (* Bitwise operators *) val logand (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logand` v y = v z)) val logxor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logxor` v y == v z)) val logor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logor` v y == v z)) val lognot (x:t) : Pure t (requires True) (ensures (fun z -> lognot (v x) == v z)) (* Shift operators *) (** If a is negative the result is implementation-defined *) val shift_right (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c)) (** If a is negative or a * pow2 s is not representable the result is undefined *) val shift_left (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c)) val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t (requires (UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c)) (* Comparison operators *) let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b) let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b) let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b) let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b) let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b) (* Infix notations *) unfold let op_Plus_Hat = add unfold let op_Subtraction_Hat = sub unfold let op_Star_Hat = mul unfold let op_Slash_Hat = div unfold let op_Percent_Hat = rem unfold let op_Hat_Hat = logxor unfold let op_Amp_Hat = logand unfold let op_Bar_Hat = logor unfold let op_Less_Less_Hat = shift_left unfold let op_Greater_Greater_Hat = shift_right unfold let op_Greater_Greater_Greater_Hat = shift_arithmetic_right unfold let op_Equals_Hat = eq

FStar.Int128.fsti

val op_Greater_Equals_Hat : a: FStar.Int128.t -> b: FStar.Int128.t -> Prims.bool

FStar.Int128.op_Greater_Equals_Hat

a: FStar.Int128.t -> b: FStar.Int128.t -> Prims.bool

Prims.Pure

let op_Hat_Hat = logxor

let op_Hat_Hat =

logxor

(* Copyright 2008-2019 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.Int128 (**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****) unfold let n = 128 open FStar.Int open FStar.Mul #set-options "--max_fuel 0 --max_ifuel 0" (* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly * a copy-paste of this module. *) new val t : eqtype val v (x:t) : Tot (int_t n) val int_to_t: x:int_t n -> Pure t (requires True) (ensures (fun y -> v y = x)) val uv_inv (x : t) : Lemma (ensures (int_to_t (v x) == x)) [SMTPat (v x)] val vu_inv (x : int_t n) : Lemma (ensures (v (int_to_t x) == x)) [SMTPat (int_to_t x)] val v_inj (x1 x2: t): Lemma (requires (v x1 == v x2)) (ensures (x1 == x2)) val zero : x:t{v x = 0} val one : x:t{v x = 1} val add (a:t) (b:t) : Pure t (requires (size (v a + v b) n)) (ensures (fun c -> v a + v b = v c)) (* Subtraction primitives *) val sub (a:t) (b:t) : Pure t (requires (size (v a - v b) n)) (ensures (fun c -> v a - v b = v c)) (* Multiplication primitives *) val mul (a:t) (b:t) : Pure t (requires (size (v a * v b) n)) (ensures (fun c -> v a * v b = v c)) (* Division primitives *) val div (a:t) (b:t{v b <> 0}) : Pure t // division overflows on INT_MIN / -1 (requires (size (v a / v b) n)) (ensures (fun c -> v a / v b = v c)) (* Modulo primitives *) (* If a/b is not representable the result of a%b is undefind *) val rem (a:t) (b:t{v b <> 0}) : Pure t (requires (size (v a / v b) n)) (ensures (fun c -> FStar.Int.mod (v a) (v b) = v c)) (* Bitwise operators *) val logand (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logand` v y = v z)) val logxor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logxor` v y == v z)) val logor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logor` v y == v z)) val lognot (x:t) : Pure t (requires True) (ensures (fun z -> lognot (v x) == v z)) (* Shift operators *) (** If a is negative the result is implementation-defined *) val shift_right (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c)) (** If a is negative or a * pow2 s is not representable the result is undefined *) val shift_left (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c)) val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t (requires (UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c)) (* Comparison operators *) let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b) let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b) let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b) let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b) let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b) (* Infix notations *) unfold let op_Plus_Hat = add unfold let op_Subtraction_Hat = sub unfold let op_Star_Hat = mul unfold let op_Slash_Hat = div

FStar.Int128.fsti

val op_Hat_Hat : x: FStar.Int128.t -> y: FStar.Int128.t -> Prims.Pure FStar.Int128.t

FStar.Int128.op_Hat_Hat

x: FStar.Int128.t -> y: FStar.Int128.t -> Prims.Pure FStar.Int128.t

Prims.Tot

val ct_abs (a: t{min_int n < v a}) : Tot (b: t{v b = abs (v a)})

let ct_abs (a:t{min_int n < v a}) : Tot (b:t{v b = abs (v a)}) = let mask = a >>>^ UInt32.uint_to_t (n - 1) in if 0 <= v a then begin sign_bit_positive (v a); nth_lemma (v mask) (FStar.Int.zero _); logxor_lemma_1 (v a) end else begin sign_bit_negative (v a); nth_lemma (v mask) (ones _); logxor_lemma_2 (v a); lognot_negative (v a); UInt.lemma_lognot_value #n (to_uint (v a)) end; (a ^^ mask) -^ mask

val ct_abs (a: t{min_int n < v a}) : Tot (b: t{v b = abs (v a)}) let ct_abs (a: t{min_int n < v a}) : Tot (b: t{v b = abs (v a)}) =

let mask = a >>>^ UInt32.uint_to_t (n - 1) in if 0 <= v a then (sign_bit_positive (v a); nth_lemma (v mask) (FStar.Int.zero _); logxor_lemma_1 (v a)) else (sign_bit_negative (v a); nth_lemma (v mask) (ones _); logxor_lemma_2 (v a); lognot_negative (v a); UInt.lemma_lognot_value #n (to_uint (v a))); (a ^^ mask) -^ mask

(* Copyright 2008-2019 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.Int128 (**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****) unfold let n = 128 open FStar.Int open FStar.Mul #set-options "--max_fuel 0 --max_ifuel 0" (* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly * a copy-paste of this module. *) new val t : eqtype val v (x:t) : Tot (int_t n) val int_to_t: x:int_t n -> Pure t (requires True) (ensures (fun y -> v y = x)) val uv_inv (x : t) : Lemma (ensures (int_to_t (v x) == x)) [SMTPat (v x)] val vu_inv (x : int_t n) : Lemma (ensures (v (int_to_t x) == x)) [SMTPat (int_to_t x)] val v_inj (x1 x2: t): Lemma (requires (v x1 == v x2)) (ensures (x1 == x2)) val zero : x:t{v x = 0} val one : x:t{v x = 1} val add (a:t) (b:t) : Pure t (requires (size (v a + v b) n)) (ensures (fun c -> v a + v b = v c)) (* Subtraction primitives *) val sub (a:t) (b:t) : Pure t (requires (size (v a - v b) n)) (ensures (fun c -> v a - v b = v c)) (* Multiplication primitives *) val mul (a:t) (b:t) : Pure t (requires (size (v a * v b) n)) (ensures (fun c -> v a * v b = v c)) (* Division primitives *) val div (a:t) (b:t{v b <> 0}) : Pure t // division overflows on INT_MIN / -1 (requires (size (v a / v b) n)) (ensures (fun c -> v a / v b = v c)) (* Modulo primitives *) (* If a/b is not representable the result of a%b is undefind *) val rem (a:t) (b:t{v b <> 0}) : Pure t (requires (size (v a / v b) n)) (ensures (fun c -> FStar.Int.mod (v a) (v b) = v c)) (* Bitwise operators *) val logand (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logand` v y = v z)) val logxor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logxor` v y == v z)) val logor (x:t) (y:t) : Pure t (requires True) (ensures (fun z -> v x `logor` v y == v z)) val lognot (x:t) : Pure t (requires True) (ensures (fun z -> lognot (v x) == v z)) (* Shift operators *) (** If a is negative the result is implementation-defined *) val shift_right (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c)) (** If a is negative or a * pow2 s is not representable the result is undefined *) val shift_left (a:t) (s:UInt32.t) : Pure t (requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c)) val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t (requires (UInt32.v s < n)) (ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c)) (* Comparison operators *) let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b) let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b) let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b) let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b) let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b) (* Infix notations *) unfold let op_Plus_Hat = add unfold let op_Subtraction_Hat = sub unfold let op_Star_Hat = mul unfold let op_Slash_Hat = div unfold let op_Percent_Hat = rem unfold let op_Hat_Hat = logxor unfold let op_Amp_Hat = logand unfold let op_Bar_Hat = logor unfold let op_Less_Less_Hat = shift_left unfold let op_Greater_Greater_Hat = shift_right unfold let op_Greater_Greater_Greater_Hat = shift_arithmetic_right unfold let op_Equals_Hat = eq unfold let op_Greater_Hat = gt unfold let op_Greater_Equals_Hat = gte unfold let op_Less_Hat = lt unfold let op_Less_Equals_Hat = lte

FStar.Int128.fsti

val ct_abs (a: t{min_int n < v a}) : Tot (b: t{v b = abs (v a)})

FStar.Int128.ct_abs

a: FStar.Int128.t{FStar.Int.min_int FStar.Int128.n < FStar.Int128.v a} -> b: FStar.Int128.t{FStar.Int128.v b = Prims.abs (FStar.Int128.v a)}

Prims.Tot

val make_instr_annotate (#outs: list instr_out) (#args: list instr_operand) (#havoc_flags: flag_havoc) (i: instr_t outs args havoc_flags) (ann: S.instr_annotation (InstrTypeRecord i)) : make_instr_t outs args

let make_instr_annotate (#outs:list instr_out) (#args:list instr_operand) (#havoc_flags:flag_havoc) (i:instr_t outs args havoc_flags) (ann:S.instr_annotation (InstrTypeRecord i)) : make_instr_t outs args = make_instr_outs outs args (fun oprs -> BC.Instr (InstrTypeRecord i) oprs ann)

val make_instr_annotate (#outs: list instr_out) (#args: list instr_operand) (#havoc_flags: flag_havoc) (i: instr_t outs args havoc_flags) (ann: S.instr_annotation (InstrTypeRecord i)) : make_instr_t outs args let make_instr_annotate (#outs: list instr_out) (#args: list instr_operand) (#havoc_flags: flag_havoc) (i: instr_t outs args havoc_flags) (ann: S.instr_annotation (InstrTypeRecord i)) : make_instr_t outs args =

make_instr_outs outs args (fun oprs -> BC.Instr (InstrTypeRecord i) oprs ann)

module Vale.X64.InsLemmas open FStar.Mul open Vale.Arch.HeapImpl open Vale.X64.Machine_s open Vale.X64.Instruction_s open Vale.X64.State open Vale.X64.StateLemmas open Vale.X64.Decls open Vale.X64.Memory module BC = Vale.X64.Bytes_Code_s module S = Vale.X64.Machine_Semantics_s let has_taint128 (o:operand128) (t:taint) : bool = match o with | OMem (_, t') | OStack (_, t') -> t = t' | _ -> true val lemma_valid_src_operand64_and_taint (o:operand64) (s:vale_state) : Lemma (requires valid_operand o s) (ensures S.valid_src_operand64_and_taint o (state_to_S s)) [SMTPat (S.valid_src_operand64_and_taint o (state_to_S s))] val lemma_valid_src_operand128_and_taint (o:operand128) (s:vale_state) : Lemma (requires valid_operand128 o s) (ensures S.valid_src_operand128_and_taint o (state_to_S s)) [SMTPat (S.valid_src_operand128_and_taint o (state_to_S s))] [@instr_attr] let rec make_instr_t_args (args:list instr_operand) : Type0 = match normal args with | [] -> S.ins | (IOpEx i)::args -> arrow (instr_operand_t i) (make_instr_t_args args) | (IOpIm _)::args -> make_instr_t_args args [@instr_attr] let rec make_instr_t (outs:list instr_out) (args:list instr_operand) : Type0 = match normal outs with | [] -> make_instr_t_args args | (_, IOpEx i)::outs -> arrow (instr_operand_t i) (make_instr_t outs args) | (_, IOpIm _)::outs -> make_instr_t outs args [@instr_attr] let rec make_instr_args (args:list instr_operand) (k:arrow (instr_operands_t_args args) S.ins) : make_instr_t_args args = match args with | [] -> k () | (IOpEx i)::args -> fun (o:instr_operand_t i) -> let k = coerce #(arrow (instr_operand_t i & instr_operands_t_args args) S.ins) k in // REVIEW: workaround for F* -> OCaml bug let k (oprs:instr_operands_t_args args) : S.ins = k (o, oprs) in make_instr_args args k | (IOpIm i)::args -> coerce (make_instr_args args (coerce #(arrow (instr_operands_t_args args) S.ins) k)) [@instr_attr] let rec make_instr_outs (outs:list instr_out) (args:list instr_operand) (k:arrow (instr_operands_t outs args) S.ins) : make_instr_t outs args = match outs with | [] -> make_instr_args args k | (b, IOpEx i)::outs -> fun (o:instr_operand_t i) -> let k = coerce #(arrow (instr_operand_t i & instr_operands_t outs args) S.ins) k in // REVIEW: workaround for F* -> OCaml bug let k (oprs:instr_operands_t outs args) = k (o, oprs) in make_instr_outs outs args k | (_, IOpIm i)::outs -> coerce (make_instr_outs outs args (coerce #(arrow (instr_operands_t outs args) S.ins) k)) [@instr_attr] let make_instr (#outs:list instr_out) (#args:list instr_operand) (#havoc_flags:flag_havoc) (i:instr_t outs args havoc_flags) : make_instr_t outs args = make_instr_outs outs args (fun oprs -> BC.Instr (InstrTypeRecord i) oprs S.AnnotateNone) [@instr_attr] let make_instr_annotate (#outs:list instr_out) (#args:list instr_operand) (#havoc_flags:flag_havoc) (i:instr_t outs args havoc_flags) (ann:S.instr_annotation (InstrTypeRecord i))

Vale.X64.InsLemmas.fsti

val make_instr_annotate (#outs: list instr_out) (#args: list instr_operand) (#havoc_flags: flag_havoc) (i: instr_t outs args havoc_flags) (ann: S.instr_annotation (InstrTypeRecord i)) : make_instr_t outs args

Vale.X64.InsLemmas.make_instr_annotate

i: Vale.X64.Instruction_s.instr_t outs args havoc_flags -> ann: Vale.X64.Machine_Semantics_s.instr_annotation (Vale.X64.Instruction_s.InstrTypeRecord i) -> Vale.X64.InsLemmas.make_instr_t outs args

Prims.Tot

val make_instr (#outs: list instr_out) (#args: list instr_operand) (#havoc_flags: flag_havoc) (i: instr_t outs args havoc_flags) : make_instr_t outs args

let make_instr (#outs:list instr_out) (#args:list instr_operand) (#havoc_flags:flag_havoc) (i:instr_t outs args havoc_flags) : make_instr_t outs args = make_instr_outs outs args (fun oprs -> BC.Instr (InstrTypeRecord i) oprs S.AnnotateNone)

val make_instr (#outs: list instr_out) (#args: list instr_operand) (#havoc_flags: flag_havoc) (i: instr_t outs args havoc_flags) : make_instr_t outs args let make_instr (#outs: list instr_out) (#args: list instr_operand) (#havoc_flags: flag_havoc) (i: instr_t outs args havoc_flags) : make_instr_t outs args =

make_instr_outs outs args (fun oprs -> BC.Instr (InstrTypeRecord i) oprs S.AnnotateNone)

module Vale.X64.InsLemmas open FStar.Mul open Vale.Arch.HeapImpl open Vale.X64.Machine_s open Vale.X64.Instruction_s open Vale.X64.State open Vale.X64.StateLemmas open Vale.X64.Decls open Vale.X64.Memory module BC = Vale.X64.Bytes_Code_s module S = Vale.X64.Machine_Semantics_s let has_taint128 (o:operand128) (t:taint) : bool = match o with | OMem (_, t') | OStack (_, t') -> t = t' | _ -> true val lemma_valid_src_operand64_and_taint (o:operand64) (s:vale_state) : Lemma (requires valid_operand o s) (ensures S.valid_src_operand64_and_taint o (state_to_S s)) [SMTPat (S.valid_src_operand64_and_taint o (state_to_S s))] val lemma_valid_src_operand128_and_taint (o:operand128) (s:vale_state) : Lemma (requires valid_operand128 o s) (ensures S.valid_src_operand128_and_taint o (state_to_S s)) [SMTPat (S.valid_src_operand128_and_taint o (state_to_S s))] [@instr_attr] let rec make_instr_t_args (args:list instr_operand) : Type0 = match normal args with | [] -> S.ins | (IOpEx i)::args -> arrow (instr_operand_t i) (make_instr_t_args args) | (IOpIm _)::args -> make_instr_t_args args [@instr_attr] let rec make_instr_t (outs:list instr_out) (args:list instr_operand) : Type0 = match normal outs with | [] -> make_instr_t_args args | (_, IOpEx i)::outs -> arrow (instr_operand_t i) (make_instr_t outs args) | (_, IOpIm _)::outs -> make_instr_t outs args [@instr_attr] let rec make_instr_args (args:list instr_operand) (k:arrow (instr_operands_t_args args) S.ins) : make_instr_t_args args = match args with | [] -> k () | (IOpEx i)::args -> fun (o:instr_operand_t i) -> let k = coerce #(arrow (instr_operand_t i & instr_operands_t_args args) S.ins) k in // REVIEW: workaround for F* -> OCaml bug let k (oprs:instr_operands_t_args args) : S.ins = k (o, oprs) in make_instr_args args k | (IOpIm i)::args -> coerce (make_instr_args args (coerce #(arrow (instr_operands_t_args args) S.ins) k)) [@instr_attr] let rec make_instr_outs (outs:list instr_out) (args:list instr_operand) (k:arrow (instr_operands_t outs args) S.ins) : make_instr_t outs args = match outs with | [] -> make_instr_args args k | (b, IOpEx i)::outs -> fun (o:instr_operand_t i) -> let k = coerce #(arrow (instr_operand_t i & instr_operands_t outs args) S.ins) k in // REVIEW: workaround for F* -> OCaml bug let k (oprs:instr_operands_t outs args) = k (o, oprs) in make_instr_outs outs args k | (_, IOpIm i)::outs -> coerce (make_instr_outs outs args (coerce #(arrow (instr_operands_t outs args) S.ins) k)) [@instr_attr] let make_instr (#outs:list instr_out) (#args:list instr_operand) (#havoc_flags:flag_havoc) (i:instr_t outs args havoc_flags)

Vale.X64.InsLemmas.fsti

val make_instr (#outs: list instr_out) (#args: list instr_operand) (#havoc_flags: flag_havoc) (i: instr_t outs args havoc_flags) : make_instr_t outs args

Vale.X64.InsLemmas.make_instr

i: Vale.X64.Instruction_s.instr_t outs args havoc_flags -> Vale.X64.InsLemmas.make_instr_t outs args

Prims.Tot

val has_taint128 (o: operand128) (t: taint) : bool

let has_taint128 (o:operand128) (t:taint) : bool = match o with | OMem (_, t') | OStack (_, t') -> t = t' | _ -> true

val has_taint128 (o: operand128) (t: taint) : bool let has_taint128 (o: operand128) (t: taint) : bool =

match o with | OMem (_, t') | OStack (_, t') -> t = t' | _ -> true

module Vale.X64.InsLemmas open FStar.Mul open Vale.Arch.HeapImpl open Vale.X64.Machine_s open Vale.X64.Instruction_s open Vale.X64.State open Vale.X64.StateLemmas open Vale.X64.Decls open Vale.X64.Memory module BC = Vale.X64.Bytes_Code_s module S = Vale.X64.Machine_Semantics_s

Vale.X64.InsLemmas.fsti

val has_taint128 (o: operand128) (t: taint) : bool

Vale.X64.InsLemmas.has_taint128

o: Vale.X64.Machine_s.operand128 -> t: Vale.Arch.HeapTypes_s.taint -> Prims.bool

Prims.Tot

val make_instr_t_args (args: list instr_operand) : Type0

let rec make_instr_t_args (args:list instr_operand) : Type0 = match normal args with | [] -> S.ins | (IOpEx i)::args -> arrow (instr_operand_t i) (make_instr_t_args args) | (IOpIm _)::args -> make_instr_t_args args

val make_instr_t_args (args: list instr_operand) : Type0 let rec make_instr_t_args (args: list instr_operand) : Type0 =

match normal args with | [] -> S.ins | IOpEx i :: args -> arrow (instr_operand_t i) (make_instr_t_args args) | IOpIm _ :: args -> make_instr_t_args args

module Vale.X64.InsLemmas open FStar.Mul open Vale.Arch.HeapImpl open Vale.X64.Machine_s open Vale.X64.Instruction_s open Vale.X64.State open Vale.X64.StateLemmas open Vale.X64.Decls open Vale.X64.Memory module BC = Vale.X64.Bytes_Code_s module S = Vale.X64.Machine_Semantics_s let has_taint128 (o:operand128) (t:taint) : bool = match o with | OMem (_, t') | OStack (_, t') -> t = t' | _ -> true val lemma_valid_src_operand64_and_taint (o:operand64) (s:vale_state) : Lemma (requires valid_operand o s) (ensures S.valid_src_operand64_and_taint o (state_to_S s)) [SMTPat (S.valid_src_operand64_and_taint o (state_to_S s))] val lemma_valid_src_operand128_and_taint (o:operand128) (s:vale_state) : Lemma (requires valid_operand128 o s) (ensures S.valid_src_operand128_and_taint o (state_to_S s)) [SMTPat (S.valid_src_operand128_and_taint o (state_to_S s))] [@instr_attr]

Vale.X64.InsLemmas.fsti

val make_instr_t_args (args: list instr_operand) : Type0

Vale.X64.InsLemmas.make_instr_t_args

args: Prims.list Vale.X64.Instruction_s.instr_operand -> Type0

Prims.Tot

val make_instr_t (outs: list instr_out) (args: list instr_operand) : Type0

let rec make_instr_t (outs:list instr_out) (args:list instr_operand) : Type0 = match normal outs with | [] -> make_instr_t_args args | (_, IOpEx i)::outs -> arrow (instr_operand_t i) (make_instr_t outs args) | (_, IOpIm _)::outs -> make_instr_t outs args

val make_instr_t (outs: list instr_out) (args: list instr_operand) : Type0 let rec make_instr_t (outs: list instr_out) (args: list instr_operand) : Type0 =

match normal outs with | [] -> make_instr_t_args args | (_, IOpEx i) :: outs -> arrow (instr_operand_t i) (make_instr_t outs args) | (_, IOpIm _) :: outs -> make_instr_t outs args

module Vale.X64.InsLemmas open FStar.Mul open Vale.Arch.HeapImpl open Vale.X64.Machine_s open Vale.X64.Instruction_s open Vale.X64.State open Vale.X64.StateLemmas open Vale.X64.Decls open Vale.X64.Memory module BC = Vale.X64.Bytes_Code_s module S = Vale.X64.Machine_Semantics_s let has_taint128 (o:operand128) (t:taint) : bool = match o with | OMem (_, t') | OStack (_, t') -> t = t' | _ -> true val lemma_valid_src_operand64_and_taint (o:operand64) (s:vale_state) : Lemma (requires valid_operand o s) (ensures S.valid_src_operand64_and_taint o (state_to_S s)) [SMTPat (S.valid_src_operand64_and_taint o (state_to_S s))] val lemma_valid_src_operand128_and_taint (o:operand128) (s:vale_state) : Lemma (requires valid_operand128 o s) (ensures S.valid_src_operand128_and_taint o (state_to_S s)) [SMTPat (S.valid_src_operand128_and_taint o (state_to_S s))] [@instr_attr] let rec make_instr_t_args (args:list instr_operand) : Type0 = match normal args with | [] -> S.ins | (IOpEx i)::args -> arrow (instr_operand_t i) (make_instr_t_args args) | (IOpIm _)::args -> make_instr_t_args args [@instr_attr]

Vale.X64.InsLemmas.fsti

val make_instr_t (outs: list instr_out) (args: list instr_operand) : Type0

Vale.X64.InsLemmas.make_instr_t

outs: Prims.list Vale.X64.Instruction_s.instr_out -> args: Prims.list Vale.X64.Instruction_s.instr_operand -> Type0

Prims.Tot

val make_instr_outs (outs: list instr_out) (args: list instr_operand) (k: arrow (instr_operands_t outs args) S.ins) : make_instr_t outs args

let rec make_instr_outs (outs:list instr_out) (args:list instr_operand) (k:arrow (instr_operands_t outs args) S.ins) : make_instr_t outs args = match outs with | [] -> make_instr_args args k | (b, IOpEx i)::outs -> fun (o:instr_operand_t i) -> let k = coerce #(arrow (instr_operand_t i & instr_operands_t outs args) S.ins) k in // REVIEW: workaround for F* -> OCaml bug let k (oprs:instr_operands_t outs args) = k (o, oprs) in make_instr_outs outs args k | (_, IOpIm i)::outs -> coerce (make_instr_outs outs args (coerce #(arrow (instr_operands_t outs args) S.ins) k))

val make_instr_outs (outs: list instr_out) (args: list instr_operand) (k: arrow (instr_operands_t outs args) S.ins) : make_instr_t outs args let rec make_instr_outs (outs: list instr_out) (args: list instr_operand) (k: arrow (instr_operands_t outs args) S.ins) : make_instr_t outs args =

match outs with | [] -> make_instr_args args k | (b, IOpEx i) :: outs -> fun (o: instr_operand_t i) -> let k = coerce #(arrow (instr_operand_t i & instr_operands_t outs args) S.ins) k in let k (oprs: instr_operands_t outs args) = k (o, oprs) in make_instr_outs outs args k | (_, IOpIm i) :: outs -> coerce (make_instr_outs outs args (coerce #(arrow (instr_operands_t outs args) S.ins) k))

module Vale.X64.InsLemmas open FStar.Mul open Vale.Arch.HeapImpl open Vale.X64.Machine_s open Vale.X64.Instruction_s open Vale.X64.State open Vale.X64.StateLemmas open Vale.X64.Decls open Vale.X64.Memory module BC = Vale.X64.Bytes_Code_s module S = Vale.X64.Machine_Semantics_s let has_taint128 (o:operand128) (t:taint) : bool = match o with | OMem (_, t') | OStack (_, t') -> t = t' | _ -> true val lemma_valid_src_operand64_and_taint (o:operand64) (s:vale_state) : Lemma (requires valid_operand o s) (ensures S.valid_src_operand64_and_taint o (state_to_S s)) [SMTPat (S.valid_src_operand64_and_taint o (state_to_S s))] val lemma_valid_src_operand128_and_taint (o:operand128) (s:vale_state) : Lemma (requires valid_operand128 o s) (ensures S.valid_src_operand128_and_taint o (state_to_S s)) [SMTPat (S.valid_src_operand128_and_taint o (state_to_S s))] [@instr_attr] let rec make_instr_t_args (args:list instr_operand) : Type0 = match normal args with | [] -> S.ins | (IOpEx i)::args -> arrow (instr_operand_t i) (make_instr_t_args args) | (IOpIm _)::args -> make_instr_t_args args [@instr_attr] let rec make_instr_t (outs:list instr_out) (args:list instr_operand) : Type0 = match normal outs with | [] -> make_instr_t_args args | (_, IOpEx i)::outs -> arrow (instr_operand_t i) (make_instr_t outs args) | (_, IOpIm _)::outs -> make_instr_t outs args [@instr_attr] let rec make_instr_args (args:list instr_operand) (k:arrow (instr_operands_t_args args) S.ins) : make_instr_t_args args = match args with | [] -> k () | (IOpEx i)::args -> fun (o:instr_operand_t i) -> let k = coerce #(arrow (instr_operand_t i & instr_operands_t_args args) S.ins) k in // REVIEW: workaround for F* -> OCaml bug let k (oprs:instr_operands_t_args args) : S.ins = k (o, oprs) in make_instr_args args k | (IOpIm i)::args -> coerce (make_instr_args args (coerce #(arrow (instr_operands_t_args args) S.ins) k)) [@instr_attr] let rec make_instr_outs (outs:list instr_out) (args:list instr_operand) (k:arrow (instr_operands_t outs args) S.ins)

Vale.X64.InsLemmas.fsti

val make_instr_outs (outs: list instr_out) (args: list instr_operand) (k: arrow (instr_operands_t outs args) S.ins) : make_instr_t outs args

Vale.X64.InsLemmas.make_instr_outs

outs: Prims.list Vale.X64.Instruction_s.instr_out -> args: Prims.list Vale.X64.Instruction_s.instr_operand -> k: Vale.X64.Instruction_s.arrow (Vale.X64.Instruction_s.instr_operands_t outs args) Vale.X64.Machine_Semantics_s.ins -> Vale.X64.InsLemmas.make_instr_t outs args

Prims.Tot

val make_instr_args (args: list instr_operand) (k: arrow (instr_operands_t_args args) S.ins) : make_instr_t_args args

let rec make_instr_args (args:list instr_operand) (k:arrow (instr_operands_t_args args) S.ins) : make_instr_t_args args = match args with | [] -> k () | (IOpEx i)::args -> fun (o:instr_operand_t i) -> let k = coerce #(arrow (instr_operand_t i & instr_operands_t_args args) S.ins) k in // REVIEW: workaround for F* -> OCaml bug let k (oprs:instr_operands_t_args args) : S.ins = k (o, oprs) in make_instr_args args k | (IOpIm i)::args -> coerce (make_instr_args args (coerce #(arrow (instr_operands_t_args args) S.ins) k))

val make_instr_args (args: list instr_operand) (k: arrow (instr_operands_t_args args) S.ins) : make_instr_t_args args let rec make_instr_args (args: list instr_operand) (k: arrow (instr_operands_t_args args) S.ins) : make_instr_t_args args =

match args with | [] -> k () | IOpEx i :: args -> fun (o: instr_operand_t i) -> let k = coerce #(arrow (instr_operand_t i & instr_operands_t_args args) S.ins) k in let k (oprs: instr_operands_t_args args) : S.ins = k (o, oprs) in make_instr_args args k | IOpIm i :: args -> coerce (make_instr_args args (coerce #(arrow (instr_operands_t_args args) S.ins) k))

module Vale.X64.InsLemmas open FStar.Mul open Vale.Arch.HeapImpl open Vale.X64.Machine_s open Vale.X64.Instruction_s open Vale.X64.State open Vale.X64.StateLemmas open Vale.X64.Decls open Vale.X64.Memory module BC = Vale.X64.Bytes_Code_s module S = Vale.X64.Machine_Semantics_s let has_taint128 (o:operand128) (t:taint) : bool = match o with | OMem (_, t') | OStack (_, t') -> t = t' | _ -> true val lemma_valid_src_operand64_and_taint (o:operand64) (s:vale_state) : Lemma (requires valid_operand o s) (ensures S.valid_src_operand64_and_taint o (state_to_S s)) [SMTPat (S.valid_src_operand64_and_taint o (state_to_S s))] val lemma_valid_src_operand128_and_taint (o:operand128) (s:vale_state) : Lemma (requires valid_operand128 o s) (ensures S.valid_src_operand128_and_taint o (state_to_S s)) [SMTPat (S.valid_src_operand128_and_taint o (state_to_S s))] [@instr_attr] let rec make_instr_t_args (args:list instr_operand) : Type0 = match normal args with | [] -> S.ins | (IOpEx i)::args -> arrow (instr_operand_t i) (make_instr_t_args args) | (IOpIm _)::args -> make_instr_t_args args [@instr_attr] let rec make_instr_t (outs:list instr_out) (args:list instr_operand) : Type0 = match normal outs with | [] -> make_instr_t_args args | (_, IOpEx i)::outs -> arrow (instr_operand_t i) (make_instr_t outs args) | (_, IOpIm _)::outs -> make_instr_t outs args [@instr_attr] let rec make_instr_args (args:list instr_operand) (k:arrow (instr_operands_t_args args) S.ins)

Vale.X64.InsLemmas.fsti

val make_instr_args (args: list instr_operand) (k: arrow (instr_operands_t_args args) S.ins) : make_instr_t_args args

Vale.X64.InsLemmas.make_instr_args

args: Prims.list Vale.X64.Instruction_s.instr_operand -> k: Vale.X64.Instruction_s.arrow (Vale.X64.Instruction_s.instr_operands_t_args args) Vale.X64.Machine_Semantics_s.ins -> Vale.X64.InsLemmas.make_instr_t_args args

Prims.Tot

val implies_elim: p: Type -> q: Type -> squash (p ==> q) -> f: (unit -> Tot (squash p)) -> squash q

let implies_elim (p:Type) (q:Type) (_:squash (p ==> q)) (f:unit -> Tot (squash p)) : squash q = f()

val implies_elim: p: Type -> q: Type -> squash (p ==> q) -> f: (unit -> Tot (squash p)) -> squash q let implies_elim (p: Type) (q: Type) (_: squash (p ==> q)) (f: (unit -> Tot (squash p))) : squash q =

f ()

(* Copyright 2021 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.Classical.Sugar /// This module provides a few combinators that are targeted /// by the desugaring phase of the F* front end /// /// The combinators it provides are fairly standard, except for one /// subtlety. In F*, the typechecking of terms formed using the /// logical connectives is biased from left to right. That is: /// /// * In [p /\ q] and [p ==> q], the well-typedness of [q] is in a /// context assuming [squash p] /// /// * In [p \/ q], the well-typedness of [q] is in a context assuming /// [squash (~p)] /// /// So, many of these combinators reflect that bias by taking as /// instantiations for [q] functions that depend on [squash p] or /// [squash (~p)]. /// /// The other subtlety is that the when using these combinators, we /// encapsulate any proof terms provided by the caller within a /// thunk. This is to ensure that if, for instance, the caller simply /// admits a goal, that they do not inadvertently discard any proof /// obligations in the remainder of their programs. /// /// For example, consider the difference between /// /// 1. exists_intro a p v (admit()); rest /// /// and /// /// 2. exists_intro a p v (fun _ -> admit()); rest /// /// In (1) the proof of rest is admitted also. (** Eliminate a universal quantifier by providing an instantiation *) val forall_elim (#a:Type) (#p:a -> Type) (v:a) (f:squash (forall (x:a). p x)) : Tot (squash (p v)) (** Eliminate an existential quantifier into a proof of a goal [q] *) val exists_elim (#t:Type) (#p:t -> Type) (#q:Type) ($s_ex_p: squash (exists (x:t). p x)) (f: (x:t -> squash (p x) -> Tot (squash q))) : Tot (squash q) (** Eliminate an implication, by providing a proof of the hypothesis Note, the proof is thunked *) let implies_elim (p:Type) (q:Type) (_:squash (p ==> q)) (f:unit -> Tot (squash p))

FStar.Classical.Sugar.fsti

val implies_elim: p: Type -> q: Type -> squash (p ==> q) -> f: (unit -> Tot (squash p)) -> squash q

FStar.Classical.Sugar.implies_elim

p: Type0 -> q: Type0 -> _: Prims.squash (p ==> q) -> f: (_: Prims.unit -> Prims.squash p) -> Prims.squash q

FStar.HyperStack.ST.Stack

val crypto_box_beforenm: k:lbuffer uint8 32ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h k /\ live h pk /\ live h sk /\ disjoint k pk /\ disjoint k sk) (ensures fun h0 r h1 -> modifies1 k h0 h1 /\ (let key = SB.box_beforenm (as_seq h0 pk) (as_seq h0 sk) in match r with | 0ul -> Some? key /\ as_seq h1 k == Some?.v key | _ -> None? key))

let crypto_box_beforenm k pk sk = Hacl.Impl.Box.box_beforenm k pk sk

val crypto_box_beforenm: k:lbuffer uint8 32ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h k /\ live h pk /\ live h sk /\ disjoint k pk /\ disjoint k sk) (ensures fun h0 r h1 -> modifies1 k h0 h1 /\ (let key = SB.box_beforenm (as_seq h0 pk) (as_seq h0 sk) in match r with | 0ul -> Some? key /\ as_seq h1 k == Some?.v key | _ -> None? key)) let crypto_box_beforenm k pk sk =

Hacl.Impl.Box.box_beforenm k pk sk

module Hacl.NaCl open FStar.HyperStack.All open FStar.HyperStack open FStar.Mul open Lib.IntTypes open Lib.Buffer open Lib.ByteBuffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module SB = Spec.Box module SS = Spec.SecretBox #set-options "--max_fuel 50 --max_fuel 0 --max_ifuel 0" [@@ Comment "Encrypt a message with a key and nonce. Note: `c` and `m` can point to the same memory for in-place encryption. @param c Pointer to `mlen` bytes where the ciphertext is written to. @param tag Pointer to 16 (tag length) bytes where the authentication tag is written to. @param m Pointer to `mlen` bytes where the message is read from. @param mlen Length of message. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_detached: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == SS.secretbox_detached (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_secretbox_detached c tag m mlen n k = Hacl.Impl.SecretBox.secretbox_detached mlen c tag k n m; 0ul [@@ Comment "Verify and decrypt a ciphertext produced with `Hacl_NaCl_crypto_secretbox_detached`. Note: `m` and `c` can point to the same memory for in-place decryption. @param m Pointer to `mlen` bytes where the message is written to. @param c Pointer to `mlen` bytes where the ciphertext is read from. @param tag Pointer to 16 (tag length) bytes where the authentication tag is read from. @param mlen Length of message (and ciphertext). @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_open_detached: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_detached (as_seq h0 k) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg)) let crypto_secretbox_open_detached m c tag mlen n k = Hacl.Impl.SecretBox.secretbox_open_detached mlen m k n c tag [@@ Comment "Encrypt a message with a key and nonce. @param c Pointer to 16 (tag length) + `mlen` bytes where the ciphertext is written to. @param m Pointer to `mlen` bytes where the message is read from. @param mlen Length of message. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_easy: c:buffer uint8 -> m:buffer uint8 -> mlen:size_t{length c = v mlen + 16 /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 c h0 h1 /\ as_seq #MUT #uint8 #(mlen +! 16ul) h1 c == SS.secretbox_easy (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_secretbox_easy c m mlen n k = Hacl.Impl.SecretBox.secretbox_easy mlen c k n m; 0ul #set-options "--z3rlimit 100" [@@ Comment "Verify and decrypt a ciphertext produced with `crypto_secretbox_easy`. @param m Pointer to `mlen` bytes where the message is written to. @param c Pointer to `clen` bytes where the ciphertext is read from. The authentication tag must be included. @param clen Length of ciphertext. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_open_easy: m:buffer uint8 -> c:buffer uint8 -> clen:size_t{length c = v clen /\ v clen = length m + 16} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint m n /\ disjoint c n) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_easy (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #clen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #(clen -! 16ul) h1 m == Some?.v msg | _ -> None? msg)) let crypto_secretbox_open_easy m c clen n k = Hacl.Impl.SecretBox.secretbox_open_easy (clen -! 16ul) m k n c [@@ Comment "Compute a shared secret key given a public key and secret key. @param k Pointer to 32 (`crypto_box_BEFORENMBYTES`) bytes of memory where the shared secret is written to. @param pk Pointer to 32 bytes of memory where **their** public key is read from. @param sk Pointer to 32 bytes of memory where **my** secret key is read from."] val crypto_box_beforenm: k:lbuffer uint8 32ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h k /\ live h pk /\ live h sk /\ disjoint k pk /\ disjoint k sk) (ensures fun h0 r h1 -> modifies1 k h0 h1 /\ (let key = SB.box_beforenm (as_seq h0 pk) (as_seq h0 sk) in match r with | 0ul -> Some? key /\ as_seq h1 k == Some?.v key | _ -> None? key))

Hacl.NaCl.fst

val crypto_box_beforenm: k:lbuffer uint8 32ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h k /\ live h pk /\ live h sk /\ disjoint k pk /\ disjoint k sk) (ensures fun h0 r h1 -> modifies1 k h0 h1 /\ (let key = SB.box_beforenm (as_seq h0 pk) (as_seq h0 sk) in match r with | 0ul -> Some? key /\ as_seq h1 k == Some?.v key | _ -> None? key))

Hacl.NaCl.crypto_box_beforenm

k: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> pk: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> sk: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> FStar.HyperStack.ST.Stack Lib.IntTypes.size_t

FStar.HyperStack.ST.Stack

val crypto_box_open_detached: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h pk /\ live h sk /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SB.box_open_detached (as_seq h0 pk) (as_seq h0 sk) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg))

let crypto_box_open_detached m c tag mlen n pk sk = Hacl.Impl.Box.box_open_detached mlen m pk sk n c tag

val crypto_box_open_detached: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h pk /\ live h sk /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SB.box_open_detached (as_seq h0 pk) (as_seq h0 sk) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg)) let crypto_box_open_detached m c tag mlen n pk sk =

Hacl.Impl.Box.box_open_detached mlen m pk sk n c tag

module Hacl.NaCl open FStar.HyperStack.All open FStar.HyperStack open FStar.Mul open Lib.IntTypes open Lib.Buffer open Lib.ByteBuffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module SB = Spec.Box module SS = Spec.SecretBox #set-options "--max_fuel 50 --max_fuel 0 --max_ifuel 0" [@@ Comment "Encrypt a message with a key and nonce. Note: `c` and `m` can point to the same memory for in-place encryption. @param c Pointer to `mlen` bytes where the ciphertext is written to. @param tag Pointer to 16 (tag length) bytes where the authentication tag is written to. @param m Pointer to `mlen` bytes where the message is read from. @param mlen Length of message. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_detached: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == SS.secretbox_detached (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_secretbox_detached c tag m mlen n k = Hacl.Impl.SecretBox.secretbox_detached mlen c tag k n m; 0ul [@@ Comment "Verify and decrypt a ciphertext produced with `Hacl_NaCl_crypto_secretbox_detached`. Note: `m` and `c` can point to the same memory for in-place decryption. @param m Pointer to `mlen` bytes where the message is written to. @param c Pointer to `mlen` bytes where the ciphertext is read from. @param tag Pointer to 16 (tag length) bytes where the authentication tag is read from. @param mlen Length of message (and ciphertext). @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_open_detached: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_detached (as_seq h0 k) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg)) let crypto_secretbox_open_detached m c tag mlen n k = Hacl.Impl.SecretBox.secretbox_open_detached mlen m k n c tag [@@ Comment "Encrypt a message with a key and nonce. @param c Pointer to 16 (tag length) + `mlen` bytes where the ciphertext is written to. @param m Pointer to `mlen` bytes where the message is read from. @param mlen Length of message. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_easy: c:buffer uint8 -> m:buffer uint8 -> mlen:size_t{length c = v mlen + 16 /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 c h0 h1 /\ as_seq #MUT #uint8 #(mlen +! 16ul) h1 c == SS.secretbox_easy (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_secretbox_easy c m mlen n k = Hacl.Impl.SecretBox.secretbox_easy mlen c k n m; 0ul #set-options "--z3rlimit 100" [@@ Comment "Verify and decrypt a ciphertext produced with `crypto_secretbox_easy`. @param m Pointer to `mlen` bytes where the message is written to. @param c Pointer to `clen` bytes where the ciphertext is read from. The authentication tag must be included. @param clen Length of ciphertext. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_open_easy: m:buffer uint8 -> c:buffer uint8 -> clen:size_t{length c = v clen /\ v clen = length m + 16} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint m n /\ disjoint c n) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_easy (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #clen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #(clen -! 16ul) h1 m == Some?.v msg | _ -> None? msg)) let crypto_secretbox_open_easy m c clen n k = Hacl.Impl.SecretBox.secretbox_open_easy (clen -! 16ul) m k n c [@@ Comment "Compute a shared secret key given a public key and secret key. @param k Pointer to 32 (`crypto_box_BEFORENMBYTES`) bytes of memory where the shared secret is written to. @param pk Pointer to 32 bytes of memory where **their** public key is read from. @param sk Pointer to 32 bytes of memory where **my** secret key is read from."] val crypto_box_beforenm: k:lbuffer uint8 32ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h k /\ live h pk /\ live h sk /\ disjoint k pk /\ disjoint k sk) (ensures fun h0 r h1 -> modifies1 k h0 h1 /\ (let key = SB.box_beforenm (as_seq h0 pk) (as_seq h0 sk) in match r with | 0ul -> Some? key /\ as_seq h1 k == Some?.v key | _ -> None? key)) let crypto_box_beforenm k pk sk = Hacl.Impl.Box.box_beforenm k pk sk [@@ Comment "See `crypto_box_detached`."] val crypto_box_detached_afternm: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == SB.box_detached_afternm (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_box_detached_afternm c tag m mlen n k = Hacl.Impl.Box.box_detached_afternm mlen c tag k n m [@@ Comment "Encrypt a message using the recipient's public key, the sender's secret key, and a nonce. @param c Pointer to `mlen` bytes of memory where the ciphertext is written to. @param tag Pointer to 16 (tag length) bytes of memory where the authentication tag is written to. @param m Pointer to `mlen` bytes of memory where the message is read from. @param mlen Length of the message. @param n Pointer to 24 (`crypto_box_NONCEBYTES`) bytes of memory where the nonce is read from. @param pk Pointer to 32 bytes of memory where **their** public key is read from. @param sk Pointer to 32 bytes of memory where **my** secret key is read from."] val crypto_box_detached: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h sk /\ live h pk /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (let tag_cipher = SB.box_detached (as_seq h0 sk) (as_seq h0 pk) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m) in match r with | 0ul -> Some? tag_cipher /\ (let (tag_s, cipher_s) = Some?.v tag_cipher in (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == (tag_s, cipher_s)) | _ -> None? tag_cipher)) let crypto_box_detached c tag m mlen n pk sk = Hacl.Impl.Box.box_detached mlen c tag sk pk n m [@@ Comment "See `crypto_box_open_detached`."] val crypto_box_open_detached_afternm: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SB.box_open_detached_afternm (as_seq h0 k) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg)) let crypto_box_open_detached_afternm m c tag mlen n k = Hacl.Impl.Box.box_open_detached_afternm mlen m k n c tag [@@ Comment "Verify and decrypt a ciphertext produced by `crypto_box_detached`. @param m Pointer to `mlen` bytes of memory where the decrypted message is written to. @param c Pointer to `mlen` bytes of memory where the ciphertext is read from. Note: the ciphertext must include the tag. @param tag Pointer to 16 (tag length) bytes of memory where the authentication tag is read from. @param mlen Length of the message (and ciphertext). @param n Pointer to 24 (`crypto_box_NONCEBYTES`) bytes of memory where the nonce is read from. @param pk Pointer to 32 bytes of memory where the public key of the sender is read from. @param sk Pointer to 32 bytes of memory where the secret key of the recipient is read from."] val crypto_box_open_detached: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h pk /\ live h sk /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SB.box_open_detached (as_seq h0 pk) (as_seq h0 sk) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg))

Hacl.NaCl.fst

val crypto_box_open_detached: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h pk /\ live h sk /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SB.box_open_detached (as_seq h0 pk) (as_seq h0 sk) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg))

Hacl.NaCl.crypto_box_open_detached

m: Lib.Buffer.buffer Lib.IntTypes.uint8 -> c: Lib.Buffer.buffer Lib.IntTypes.uint8 -> tag: Lib.Buffer.lbuffer Lib.IntTypes.uint8 16ul -> mlen: Lib.IntTypes.size_t {Lib.Buffer.length c = Lib.IntTypes.v mlen /\ Lib.Buffer.length m = Lib.IntTypes.v mlen} -> n: Lib.Buffer.lbuffer Lib.IntTypes.uint8 24ul -> pk: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> sk: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> FStar.HyperStack.ST.Stack Lib.IntTypes.size_t

FStar.HyperStack.ST.Stack

val crypto_box_detached: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h sk /\ live h pk /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (let tag_cipher = SB.box_detached (as_seq h0 sk) (as_seq h0 pk) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m) in match r with | 0ul -> Some? tag_cipher /\ (let (tag_s, cipher_s) = Some?.v tag_cipher in (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == (tag_s, cipher_s)) | _ -> None? tag_cipher))

let crypto_box_detached c tag m mlen n pk sk = Hacl.Impl.Box.box_detached mlen c tag sk pk n m

val crypto_box_detached: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h sk /\ live h pk /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (let tag_cipher = SB.box_detached (as_seq h0 sk) (as_seq h0 pk) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m) in match r with | 0ul -> Some? tag_cipher /\ (let (tag_s, cipher_s) = Some?.v tag_cipher in (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == (tag_s, cipher_s)) | _ -> None? tag_cipher)) let crypto_box_detached c tag m mlen n pk sk =

Hacl.Impl.Box.box_detached mlen c tag sk pk n m

module Hacl.NaCl open FStar.HyperStack.All open FStar.HyperStack open FStar.Mul open Lib.IntTypes open Lib.Buffer open Lib.ByteBuffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module SB = Spec.Box module SS = Spec.SecretBox #set-options "--max_fuel 50 --max_fuel 0 --max_ifuel 0" [@@ Comment "Encrypt a message with a key and nonce. Note: `c` and `m` can point to the same memory for in-place encryption. @param c Pointer to `mlen` bytes where the ciphertext is written to. @param tag Pointer to 16 (tag length) bytes where the authentication tag is written to. @param m Pointer to `mlen` bytes where the message is read from. @param mlen Length of message. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_detached: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == SS.secretbox_detached (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_secretbox_detached c tag m mlen n k = Hacl.Impl.SecretBox.secretbox_detached mlen c tag k n m; 0ul [@@ Comment "Verify and decrypt a ciphertext produced with `Hacl_NaCl_crypto_secretbox_detached`. Note: `m` and `c` can point to the same memory for in-place decryption. @param m Pointer to `mlen` bytes where the message is written to. @param c Pointer to `mlen` bytes where the ciphertext is read from. @param tag Pointer to 16 (tag length) bytes where the authentication tag is read from. @param mlen Length of message (and ciphertext). @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_open_detached: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_detached (as_seq h0 k) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg)) let crypto_secretbox_open_detached m c tag mlen n k = Hacl.Impl.SecretBox.secretbox_open_detached mlen m k n c tag [@@ Comment "Encrypt a message with a key and nonce. @param c Pointer to 16 (tag length) + `mlen` bytes where the ciphertext is written to. @param m Pointer to `mlen` bytes where the message is read from. @param mlen Length of message. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_easy: c:buffer uint8 -> m:buffer uint8 -> mlen:size_t{length c = v mlen + 16 /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 c h0 h1 /\ as_seq #MUT #uint8 #(mlen +! 16ul) h1 c == SS.secretbox_easy (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_secretbox_easy c m mlen n k = Hacl.Impl.SecretBox.secretbox_easy mlen c k n m; 0ul #set-options "--z3rlimit 100" [@@ Comment "Verify and decrypt a ciphertext produced with `crypto_secretbox_easy`. @param m Pointer to `mlen` bytes where the message is written to. @param c Pointer to `clen` bytes where the ciphertext is read from. The authentication tag must be included. @param clen Length of ciphertext. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_open_easy: m:buffer uint8 -> c:buffer uint8 -> clen:size_t{length c = v clen /\ v clen = length m + 16} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint m n /\ disjoint c n) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_easy (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #clen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #(clen -! 16ul) h1 m == Some?.v msg | _ -> None? msg)) let crypto_secretbox_open_easy m c clen n k = Hacl.Impl.SecretBox.secretbox_open_easy (clen -! 16ul) m k n c [@@ Comment "Compute a shared secret key given a public key and secret key. @param k Pointer to 32 (`crypto_box_BEFORENMBYTES`) bytes of memory where the shared secret is written to. @param pk Pointer to 32 bytes of memory where **their** public key is read from. @param sk Pointer to 32 bytes of memory where **my** secret key is read from."] val crypto_box_beforenm: k:lbuffer uint8 32ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h k /\ live h pk /\ live h sk /\ disjoint k pk /\ disjoint k sk) (ensures fun h0 r h1 -> modifies1 k h0 h1 /\ (let key = SB.box_beforenm (as_seq h0 pk) (as_seq h0 sk) in match r with | 0ul -> Some? key /\ as_seq h1 k == Some?.v key | _ -> None? key)) let crypto_box_beforenm k pk sk = Hacl.Impl.Box.box_beforenm k pk sk [@@ Comment "See `crypto_box_detached`."] val crypto_box_detached_afternm: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == SB.box_detached_afternm (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_box_detached_afternm c tag m mlen n k = Hacl.Impl.Box.box_detached_afternm mlen c tag k n m [@@ Comment "Encrypt a message using the recipient's public key, the sender's secret key, and a nonce. @param c Pointer to `mlen` bytes of memory where the ciphertext is written to. @param tag Pointer to 16 (tag length) bytes of memory where the authentication tag is written to. @param m Pointer to `mlen` bytes of memory where the message is read from. @param mlen Length of the message. @param n Pointer to 24 (`crypto_box_NONCEBYTES`) bytes of memory where the nonce is read from. @param pk Pointer to 32 bytes of memory where **their** public key is read from. @param sk Pointer to 32 bytes of memory where **my** secret key is read from."] val crypto_box_detached: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h sk /\ live h pk /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (let tag_cipher = SB.box_detached (as_seq h0 sk) (as_seq h0 pk) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m) in match r with | 0ul -> Some? tag_cipher /\ (let (tag_s, cipher_s) = Some?.v tag_cipher in (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == (tag_s, cipher_s)) | _ -> None? tag_cipher))

Hacl.NaCl.fst

val crypto_box_detached: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h sk /\ live h pk /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (let tag_cipher = SB.box_detached (as_seq h0 sk) (as_seq h0 pk) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m) in match r with | 0ul -> Some? tag_cipher /\ (let (tag_s, cipher_s) = Some?.v tag_cipher in (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == (tag_s, cipher_s)) | _ -> None? tag_cipher))

Hacl.NaCl.crypto_box_detached

c: Lib.Buffer.buffer Lib.IntTypes.uint8 -> tag: Lib.Buffer.lbuffer Lib.IntTypes.uint8 16ul -> m: Lib.Buffer.buffer Lib.IntTypes.uint8 -> mlen: Lib.IntTypes.size_t {Lib.Buffer.length c = Lib.IntTypes.v mlen /\ Lib.Buffer.length m = Lib.IntTypes.v mlen} -> n: Lib.Buffer.lbuffer Lib.IntTypes.uint8 24ul -> pk: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> sk: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> FStar.HyperStack.ST.Stack Lib.IntTypes.size_t

FStar.HyperStack.ST.Stack

val crypto_box_open_detached_afternm: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SB.box_open_detached_afternm (as_seq h0 k) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg))

let crypto_box_open_detached_afternm m c tag mlen n k = Hacl.Impl.Box.box_open_detached_afternm mlen m k n c tag

val crypto_box_open_detached_afternm: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SB.box_open_detached_afternm (as_seq h0 k) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg)) let crypto_box_open_detached_afternm m c tag mlen n k =

Hacl.Impl.Box.box_open_detached_afternm mlen m k n c tag

module Hacl.NaCl open FStar.HyperStack.All open FStar.HyperStack open FStar.Mul open Lib.IntTypes open Lib.Buffer open Lib.ByteBuffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module SB = Spec.Box module SS = Spec.SecretBox #set-options "--max_fuel 50 --max_fuel 0 --max_ifuel 0" [@@ Comment "Encrypt a message with a key and nonce. Note: `c` and `m` can point to the same memory for in-place encryption. @param c Pointer to `mlen` bytes where the ciphertext is written to. @param tag Pointer to 16 (tag length) bytes where the authentication tag is written to. @param m Pointer to `mlen` bytes where the message is read from. @param mlen Length of message. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_detached: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == SS.secretbox_detached (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_secretbox_detached c tag m mlen n k = Hacl.Impl.SecretBox.secretbox_detached mlen c tag k n m; 0ul [@@ Comment "Verify and decrypt a ciphertext produced with `Hacl_NaCl_crypto_secretbox_detached`. Note: `m` and `c` can point to the same memory for in-place decryption. @param m Pointer to `mlen` bytes where the message is written to. @param c Pointer to `mlen` bytes where the ciphertext is read from. @param tag Pointer to 16 (tag length) bytes where the authentication tag is read from. @param mlen Length of message (and ciphertext). @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_open_detached: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_detached (as_seq h0 k) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg)) let crypto_secretbox_open_detached m c tag mlen n k = Hacl.Impl.SecretBox.secretbox_open_detached mlen m k n c tag [@@ Comment "Encrypt a message with a key and nonce. @param c Pointer to 16 (tag length) + `mlen` bytes where the ciphertext is written to. @param m Pointer to `mlen` bytes where the message is read from. @param mlen Length of message. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_easy: c:buffer uint8 -> m:buffer uint8 -> mlen:size_t{length c = v mlen + 16 /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 c h0 h1 /\ as_seq #MUT #uint8 #(mlen +! 16ul) h1 c == SS.secretbox_easy (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_secretbox_easy c m mlen n k = Hacl.Impl.SecretBox.secretbox_easy mlen c k n m; 0ul #set-options "--z3rlimit 100" [@@ Comment "Verify and decrypt a ciphertext produced with `crypto_secretbox_easy`. @param m Pointer to `mlen` bytes where the message is written to. @param c Pointer to `clen` bytes where the ciphertext is read from. The authentication tag must be included. @param clen Length of ciphertext. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_open_easy: m:buffer uint8 -> c:buffer uint8 -> clen:size_t{length c = v clen /\ v clen = length m + 16} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint m n /\ disjoint c n) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_easy (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #clen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #(clen -! 16ul) h1 m == Some?.v msg | _ -> None? msg)) let crypto_secretbox_open_easy m c clen n k = Hacl.Impl.SecretBox.secretbox_open_easy (clen -! 16ul) m k n c [@@ Comment "Compute a shared secret key given a public key and secret key. @param k Pointer to 32 (`crypto_box_BEFORENMBYTES`) bytes of memory where the shared secret is written to. @param pk Pointer to 32 bytes of memory where **their** public key is read from. @param sk Pointer to 32 bytes of memory where **my** secret key is read from."] val crypto_box_beforenm: k:lbuffer uint8 32ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h k /\ live h pk /\ live h sk /\ disjoint k pk /\ disjoint k sk) (ensures fun h0 r h1 -> modifies1 k h0 h1 /\ (let key = SB.box_beforenm (as_seq h0 pk) (as_seq h0 sk) in match r with | 0ul -> Some? key /\ as_seq h1 k == Some?.v key | _ -> None? key)) let crypto_box_beforenm k pk sk = Hacl.Impl.Box.box_beforenm k pk sk [@@ Comment "See `crypto_box_detached`."] val crypto_box_detached_afternm: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == SB.box_detached_afternm (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_box_detached_afternm c tag m mlen n k = Hacl.Impl.Box.box_detached_afternm mlen c tag k n m [@@ Comment "Encrypt a message using the recipient's public key, the sender's secret key, and a nonce. @param c Pointer to `mlen` bytes of memory where the ciphertext is written to. @param tag Pointer to 16 (tag length) bytes of memory where the authentication tag is written to. @param m Pointer to `mlen` bytes of memory where the message is read from. @param mlen Length of the message. @param n Pointer to 24 (`crypto_box_NONCEBYTES`) bytes of memory where the nonce is read from. @param pk Pointer to 32 bytes of memory where **their** public key is read from. @param sk Pointer to 32 bytes of memory where **my** secret key is read from."] val crypto_box_detached: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h sk /\ live h pk /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (let tag_cipher = SB.box_detached (as_seq h0 sk) (as_seq h0 pk) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m) in match r with | 0ul -> Some? tag_cipher /\ (let (tag_s, cipher_s) = Some?.v tag_cipher in (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == (tag_s, cipher_s)) | _ -> None? tag_cipher)) let crypto_box_detached c tag m mlen n pk sk = Hacl.Impl.Box.box_detached mlen c tag sk pk n m [@@ Comment "See `crypto_box_open_detached`."] val crypto_box_open_detached_afternm: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SB.box_open_detached_afternm (as_seq h0 k) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg))

Hacl.NaCl.fst

val crypto_box_open_detached_afternm: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SB.box_open_detached_afternm (as_seq h0 k) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg))

Hacl.NaCl.crypto_box_open_detached_afternm

m: Lib.Buffer.buffer Lib.IntTypes.uint8 -> c: Lib.Buffer.buffer Lib.IntTypes.uint8 -> tag: Lib.Buffer.lbuffer Lib.IntTypes.uint8 16ul -> mlen: Lib.IntTypes.size_t {Lib.Buffer.length c = Lib.IntTypes.v mlen /\ Lib.Buffer.length m = Lib.IntTypes.v mlen} -> n: Lib.Buffer.lbuffer Lib.IntTypes.uint8 24ul -> k: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> FStar.HyperStack.ST.Stack Lib.IntTypes.size_t

FStar.HyperStack.ST.Stack

val crypto_secretbox_open_detached: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_detached (as_seq h0 k) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg))

let crypto_secretbox_open_detached m c tag mlen n k = Hacl.Impl.SecretBox.secretbox_open_detached mlen m k n c tag

val crypto_secretbox_open_detached: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_detached (as_seq h0 k) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg)) let crypto_secretbox_open_detached m c tag mlen n k =

Hacl.Impl.SecretBox.secretbox_open_detached mlen m k n c tag

module Hacl.NaCl open FStar.HyperStack.All open FStar.HyperStack open FStar.Mul open Lib.IntTypes open Lib.Buffer open Lib.ByteBuffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module SB = Spec.Box module SS = Spec.SecretBox #set-options "--max_fuel 50 --max_fuel 0 --max_ifuel 0" [@@ Comment "Encrypt a message with a key and nonce. Note: `c` and `m` can point to the same memory for in-place encryption. @param c Pointer to `mlen` bytes where the ciphertext is written to. @param tag Pointer to 16 (tag length) bytes where the authentication tag is written to. @param m Pointer to `mlen` bytes where the message is read from. @param mlen Length of message. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_detached: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == SS.secretbox_detached (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_secretbox_detached c tag m mlen n k = Hacl.Impl.SecretBox.secretbox_detached mlen c tag k n m; 0ul [@@ Comment "Verify and decrypt a ciphertext produced with `Hacl_NaCl_crypto_secretbox_detached`. Note: `m` and `c` can point to the same memory for in-place decryption. @param m Pointer to `mlen` bytes where the message is written to. @param c Pointer to `mlen` bytes where the ciphertext is read from. @param tag Pointer to 16 (tag length) bytes where the authentication tag is read from. @param mlen Length of message (and ciphertext). @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_open_detached: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_detached (as_seq h0 k) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg))

Hacl.NaCl.fst

val crypto_secretbox_open_detached: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_detached (as_seq h0 k) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg))

Hacl.NaCl.crypto_secretbox_open_detached

m: Lib.Buffer.buffer Lib.IntTypes.uint8 -> c: Lib.Buffer.buffer Lib.IntTypes.uint8 -> tag: Lib.Buffer.lbuffer Lib.IntTypes.uint8 16ul -> mlen: Lib.IntTypes.size_t {Lib.Buffer.length c = Lib.IntTypes.v mlen /\ Lib.Buffer.length m = Lib.IntTypes.v mlen} -> n: Lib.Buffer.lbuffer Lib.IntTypes.uint8 24ul -> k: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> FStar.HyperStack.ST.Stack Lib.IntTypes.size_t

FStar.HyperStack.ST.Stack

val crypto_box_easy_afternm: c:buffer uint8 -> m:buffer uint8 -> mlen:size_t{length c = v mlen + 16 /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 c h0 h1 /\ as_seq #MUT #uint8 #(mlen +! 16ul) h1 c == SB.box_easy_afternm (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m))

let crypto_box_easy_afternm c m mlen n k = Hacl.Impl.Box.box_easy_afternm mlen c k n m

val crypto_box_easy_afternm: c:buffer uint8 -> m:buffer uint8 -> mlen:size_t{length c = v mlen + 16 /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 c h0 h1 /\ as_seq #MUT #uint8 #(mlen +! 16ul) h1 c == SB.box_easy_afternm (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_box_easy_afternm c m mlen n k =

Hacl.Impl.Box.box_easy_afternm mlen c k n m

module Hacl.NaCl open FStar.HyperStack.All open FStar.HyperStack open FStar.Mul open Lib.IntTypes open Lib.Buffer open Lib.ByteBuffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module SB = Spec.Box module SS = Spec.SecretBox #set-options "--max_fuel 50 --max_fuel 0 --max_ifuel 0" [@@ Comment "Encrypt a message with a key and nonce. Note: `c` and `m` can point to the same memory for in-place encryption. @param c Pointer to `mlen` bytes where the ciphertext is written to. @param tag Pointer to 16 (tag length) bytes where the authentication tag is written to. @param m Pointer to `mlen` bytes where the message is read from. @param mlen Length of message. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_detached: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == SS.secretbox_detached (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_secretbox_detached c tag m mlen n k = Hacl.Impl.SecretBox.secretbox_detached mlen c tag k n m; 0ul [@@ Comment "Verify and decrypt a ciphertext produced with `Hacl_NaCl_crypto_secretbox_detached`. Note: `m` and `c` can point to the same memory for in-place decryption. @param m Pointer to `mlen` bytes where the message is written to. @param c Pointer to `mlen` bytes where the ciphertext is read from. @param tag Pointer to 16 (tag length) bytes where the authentication tag is read from. @param mlen Length of message (and ciphertext). @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_open_detached: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_detached (as_seq h0 k) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg)) let crypto_secretbox_open_detached m c tag mlen n k = Hacl.Impl.SecretBox.secretbox_open_detached mlen m k n c tag [@@ Comment "Encrypt a message with a key and nonce. @param c Pointer to 16 (tag length) + `mlen` bytes where the ciphertext is written to. @param m Pointer to `mlen` bytes where the message is read from. @param mlen Length of message. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_easy: c:buffer uint8 -> m:buffer uint8 -> mlen:size_t{length c = v mlen + 16 /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 c h0 h1 /\ as_seq #MUT #uint8 #(mlen +! 16ul) h1 c == SS.secretbox_easy (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_secretbox_easy c m mlen n k = Hacl.Impl.SecretBox.secretbox_easy mlen c k n m; 0ul #set-options "--z3rlimit 100" [@@ Comment "Verify and decrypt a ciphertext produced with `crypto_secretbox_easy`. @param m Pointer to `mlen` bytes where the message is written to. @param c Pointer to `clen` bytes where the ciphertext is read from. The authentication tag must be included. @param clen Length of ciphertext. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_open_easy: m:buffer uint8 -> c:buffer uint8 -> clen:size_t{length c = v clen /\ v clen = length m + 16} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint m n /\ disjoint c n) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_easy (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #clen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #(clen -! 16ul) h1 m == Some?.v msg | _ -> None? msg)) let crypto_secretbox_open_easy m c clen n k = Hacl.Impl.SecretBox.secretbox_open_easy (clen -! 16ul) m k n c [@@ Comment "Compute a shared secret key given a public key and secret key. @param k Pointer to 32 (`crypto_box_BEFORENMBYTES`) bytes of memory where the shared secret is written to. @param pk Pointer to 32 bytes of memory where **their** public key is read from. @param sk Pointer to 32 bytes of memory where **my** secret key is read from."] val crypto_box_beforenm: k:lbuffer uint8 32ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h k /\ live h pk /\ live h sk /\ disjoint k pk /\ disjoint k sk) (ensures fun h0 r h1 -> modifies1 k h0 h1 /\ (let key = SB.box_beforenm (as_seq h0 pk) (as_seq h0 sk) in match r with | 0ul -> Some? key /\ as_seq h1 k == Some?.v key | _ -> None? key)) let crypto_box_beforenm k pk sk = Hacl.Impl.Box.box_beforenm k pk sk [@@ Comment "See `crypto_box_detached`."] val crypto_box_detached_afternm: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == SB.box_detached_afternm (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_box_detached_afternm c tag m mlen n k = Hacl.Impl.Box.box_detached_afternm mlen c tag k n m [@@ Comment "Encrypt a message using the recipient's public key, the sender's secret key, and a nonce. @param c Pointer to `mlen` bytes of memory where the ciphertext is written to. @param tag Pointer to 16 (tag length) bytes of memory where the authentication tag is written to. @param m Pointer to `mlen` bytes of memory where the message is read from. @param mlen Length of the message. @param n Pointer to 24 (`crypto_box_NONCEBYTES`) bytes of memory where the nonce is read from. @param pk Pointer to 32 bytes of memory where **their** public key is read from. @param sk Pointer to 32 bytes of memory where **my** secret key is read from."] val crypto_box_detached: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h sk /\ live h pk /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (let tag_cipher = SB.box_detached (as_seq h0 sk) (as_seq h0 pk) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m) in match r with | 0ul -> Some? tag_cipher /\ (let (tag_s, cipher_s) = Some?.v tag_cipher in (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == (tag_s, cipher_s)) | _ -> None? tag_cipher)) let crypto_box_detached c tag m mlen n pk sk = Hacl.Impl.Box.box_detached mlen c tag sk pk n m [@@ Comment "See `crypto_box_open_detached`."] val crypto_box_open_detached_afternm: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SB.box_open_detached_afternm (as_seq h0 k) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg)) let crypto_box_open_detached_afternm m c tag mlen n k = Hacl.Impl.Box.box_open_detached_afternm mlen m k n c tag [@@ Comment "Verify and decrypt a ciphertext produced by `crypto_box_detached`. @param m Pointer to `mlen` bytes of memory where the decrypted message is written to. @param c Pointer to `mlen` bytes of memory where the ciphertext is read from. Note: the ciphertext must include the tag. @param tag Pointer to 16 (tag length) bytes of memory where the authentication tag is read from. @param mlen Length of the message (and ciphertext). @param n Pointer to 24 (`crypto_box_NONCEBYTES`) bytes of memory where the nonce is read from. @param pk Pointer to 32 bytes of memory where the public key of the sender is read from. @param sk Pointer to 32 bytes of memory where the secret key of the recipient is read from."] val crypto_box_open_detached: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h pk /\ live h sk /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SB.box_open_detached (as_seq h0 pk) (as_seq h0 sk) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg)) let crypto_box_open_detached m c tag mlen n pk sk = Hacl.Impl.Box.box_open_detached mlen m pk sk n c tag [@@ Comment "See `crypto_box_easy`."] val crypto_box_easy_afternm: c:buffer uint8 -> m:buffer uint8 -> mlen:size_t{length c = v mlen + 16 /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 c h0 h1 /\ as_seq #MUT #uint8 #(mlen +! 16ul) h1 c == SB.box_easy_afternm (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m))

Hacl.NaCl.fst

val crypto_box_easy_afternm: c:buffer uint8 -> m:buffer uint8 -> mlen:size_t{length c = v mlen + 16 /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 c h0 h1 /\ as_seq #MUT #uint8 #(mlen +! 16ul) h1 c == SB.box_easy_afternm (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m))

Hacl.NaCl.crypto_box_easy_afternm

c: Lib.Buffer.buffer Lib.IntTypes.uint8 -> m: Lib.Buffer.buffer Lib.IntTypes.uint8 -> mlen: Lib.IntTypes.size_t { Lib.Buffer.length c = Lib.IntTypes.v mlen + 16 /\ Lib.Buffer.length m = Lib.IntTypes.v mlen } -> n: Lib.Buffer.lbuffer Lib.IntTypes.uint8 24ul -> k: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> FStar.HyperStack.ST.Stack Lib.IntTypes.size_t

FStar.HyperStack.ST.Stack

val crypto_box_detached_afternm: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == SB.box_detached_afternm (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m))

let crypto_box_detached_afternm c tag m mlen n k = Hacl.Impl.Box.box_detached_afternm mlen c tag k n m

val crypto_box_detached_afternm: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == SB.box_detached_afternm (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_box_detached_afternm c tag m mlen n k =

Hacl.Impl.Box.box_detached_afternm mlen c tag k n m

module Hacl.NaCl open FStar.HyperStack.All open FStar.HyperStack open FStar.Mul open Lib.IntTypes open Lib.Buffer open Lib.ByteBuffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module SB = Spec.Box module SS = Spec.SecretBox #set-options "--max_fuel 50 --max_fuel 0 --max_ifuel 0" [@@ Comment "Encrypt a message with a key and nonce. Note: `c` and `m` can point to the same memory for in-place encryption. @param c Pointer to `mlen` bytes where the ciphertext is written to. @param tag Pointer to 16 (tag length) bytes where the authentication tag is written to. @param m Pointer to `mlen` bytes where the message is read from. @param mlen Length of message. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_detached: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == SS.secretbox_detached (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_secretbox_detached c tag m mlen n k = Hacl.Impl.SecretBox.secretbox_detached mlen c tag k n m; 0ul [@@ Comment "Verify and decrypt a ciphertext produced with `Hacl_NaCl_crypto_secretbox_detached`. Note: `m` and `c` can point to the same memory for in-place decryption. @param m Pointer to `mlen` bytes where the message is written to. @param c Pointer to `mlen` bytes where the ciphertext is read from. @param tag Pointer to 16 (tag length) bytes where the authentication tag is read from. @param mlen Length of message (and ciphertext). @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_open_detached: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_detached (as_seq h0 k) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg)) let crypto_secretbox_open_detached m c tag mlen n k = Hacl.Impl.SecretBox.secretbox_open_detached mlen m k n c tag [@@ Comment "Encrypt a message with a key and nonce. @param c Pointer to 16 (tag length) + `mlen` bytes where the ciphertext is written to. @param m Pointer to `mlen` bytes where the message is read from. @param mlen Length of message. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_easy: c:buffer uint8 -> m:buffer uint8 -> mlen:size_t{length c = v mlen + 16 /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 c h0 h1 /\ as_seq #MUT #uint8 #(mlen +! 16ul) h1 c == SS.secretbox_easy (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_secretbox_easy c m mlen n k = Hacl.Impl.SecretBox.secretbox_easy mlen c k n m; 0ul #set-options "--z3rlimit 100" [@@ Comment "Verify and decrypt a ciphertext produced with `crypto_secretbox_easy`. @param m Pointer to `mlen` bytes where the message is written to. @param c Pointer to `clen` bytes where the ciphertext is read from. The authentication tag must be included. @param clen Length of ciphertext. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_open_easy: m:buffer uint8 -> c:buffer uint8 -> clen:size_t{length c = v clen /\ v clen = length m + 16} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint m n /\ disjoint c n) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_easy (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #clen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #(clen -! 16ul) h1 m == Some?.v msg | _ -> None? msg)) let crypto_secretbox_open_easy m c clen n k = Hacl.Impl.SecretBox.secretbox_open_easy (clen -! 16ul) m k n c [@@ Comment "Compute a shared secret key given a public key and secret key. @param k Pointer to 32 (`crypto_box_BEFORENMBYTES`) bytes of memory where the shared secret is written to. @param pk Pointer to 32 bytes of memory where **their** public key is read from. @param sk Pointer to 32 bytes of memory where **my** secret key is read from."] val crypto_box_beforenm: k:lbuffer uint8 32ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h k /\ live h pk /\ live h sk /\ disjoint k pk /\ disjoint k sk) (ensures fun h0 r h1 -> modifies1 k h0 h1 /\ (let key = SB.box_beforenm (as_seq h0 pk) (as_seq h0 sk) in match r with | 0ul -> Some? key /\ as_seq h1 k == Some?.v key | _ -> None? key)) let crypto_box_beforenm k pk sk = Hacl.Impl.Box.box_beforenm k pk sk [@@ Comment "See `crypto_box_detached`."] val crypto_box_detached_afternm: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == SB.box_detached_afternm (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m))

Hacl.NaCl.fst

val crypto_box_detached_afternm: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == SB.box_detached_afternm (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m))

Hacl.NaCl.crypto_box_detached_afternm

c: Lib.Buffer.buffer Lib.IntTypes.uint8 -> tag: Lib.Buffer.lbuffer Lib.IntTypes.uint8 16ul -> m: Lib.Buffer.buffer Lib.IntTypes.uint8 -> mlen: Lib.IntTypes.size_t {Lib.Buffer.length c = Lib.IntTypes.v mlen /\ Lib.Buffer.length m = Lib.IntTypes.v mlen} -> n: Lib.Buffer.lbuffer Lib.IntTypes.uint8 24ul -> k: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> FStar.HyperStack.ST.Stack Lib.IntTypes.size_t

FStar.HyperStack.ST.Stack

val crypto_secretbox_easy: c:buffer uint8 -> m:buffer uint8 -> mlen:size_t{length c = v mlen + 16 /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 c h0 h1 /\ as_seq #MUT #uint8 #(mlen +! 16ul) h1 c == SS.secretbox_easy (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m))

let crypto_secretbox_easy c m mlen n k = Hacl.Impl.SecretBox.secretbox_easy mlen c k n m; 0ul

val crypto_secretbox_easy: c:buffer uint8 -> m:buffer uint8 -> mlen:size_t{length c = v mlen + 16 /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 c h0 h1 /\ as_seq #MUT #uint8 #(mlen +! 16ul) h1 c == SS.secretbox_easy (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_secretbox_easy c m mlen n k =

Hacl.Impl.SecretBox.secretbox_easy mlen c k n m; 0ul

module Hacl.NaCl open FStar.HyperStack.All open FStar.HyperStack open FStar.Mul open Lib.IntTypes open Lib.Buffer open Lib.ByteBuffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module SB = Spec.Box module SS = Spec.SecretBox #set-options "--max_fuel 50 --max_fuel 0 --max_ifuel 0" [@@ Comment "Encrypt a message with a key and nonce. Note: `c` and `m` can point to the same memory for in-place encryption. @param c Pointer to `mlen` bytes where the ciphertext is written to. @param tag Pointer to 16 (tag length) bytes where the authentication tag is written to. @param m Pointer to `mlen` bytes where the message is read from. @param mlen Length of message. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_detached: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == SS.secretbox_detached (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_secretbox_detached c tag m mlen n k = Hacl.Impl.SecretBox.secretbox_detached mlen c tag k n m; 0ul [@@ Comment "Verify and decrypt a ciphertext produced with `Hacl_NaCl_crypto_secretbox_detached`. Note: `m` and `c` can point to the same memory for in-place decryption. @param m Pointer to `mlen` bytes where the message is written to. @param c Pointer to `mlen` bytes where the ciphertext is read from. @param tag Pointer to 16 (tag length) bytes where the authentication tag is read from. @param mlen Length of message (and ciphertext). @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_open_detached: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_detached (as_seq h0 k) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg)) let crypto_secretbox_open_detached m c tag mlen n k = Hacl.Impl.SecretBox.secretbox_open_detached mlen m k n c tag [@@ Comment "Encrypt a message with a key and nonce. @param c Pointer to 16 (tag length) + `mlen` bytes where the ciphertext is written to. @param m Pointer to `mlen` bytes where the message is read from. @param mlen Length of message. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_easy: c:buffer uint8 -> m:buffer uint8 -> mlen:size_t{length c = v mlen + 16 /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 c h0 h1 /\ as_seq #MUT #uint8 #(mlen +! 16ul) h1 c == SS.secretbox_easy (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m))

Hacl.NaCl.fst

val crypto_secretbox_easy: c:buffer uint8 -> m:buffer uint8 -> mlen:size_t{length c = v mlen + 16 /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 c h0 h1 /\ as_seq #MUT #uint8 #(mlen +! 16ul) h1 c == SS.secretbox_easy (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m))

Hacl.NaCl.crypto_secretbox_easy

c: Lib.Buffer.buffer Lib.IntTypes.uint8 -> m: Lib.Buffer.buffer Lib.IntTypes.uint8 -> mlen: Lib.IntTypes.size_t { Lib.Buffer.length c = Lib.IntTypes.v mlen + 16 /\ Lib.Buffer.length m = Lib.IntTypes.v mlen } -> n: Lib.Buffer.lbuffer Lib.IntTypes.uint8 24ul -> k: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> FStar.HyperStack.ST.Stack Lib.IntTypes.size_t

FStar.HyperStack.ST.Stack

val crypto_box_easy: c:buffer uint8 -> m:buffer uint8 -> mlen:size_t{length c = v mlen + 16 /\ length m = v mlen} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h sk /\ live h pk /\ live h n /\ disjoint m c /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 c h0 h1 /\ (let cipher = SB.box_easy (as_seq h0 sk) (as_seq h0 pk) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m) in match r with | 0ul -> Some? cipher /\ as_seq #MUT #uint8 #(mlen +! 16ul) h1 c == Some?.v cipher | _ -> None? cipher))

let crypto_box_easy c m mlen n pk sk = Hacl.Impl.Box.box_easy mlen c sk pk n m

val crypto_box_easy: c:buffer uint8 -> m:buffer uint8 -> mlen:size_t{length c = v mlen + 16 /\ length m = v mlen} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h sk /\ live h pk /\ live h n /\ disjoint m c /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 c h0 h1 /\ (let cipher = SB.box_easy (as_seq h0 sk) (as_seq h0 pk) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m) in match r with | 0ul -> Some? cipher /\ as_seq #MUT #uint8 #(mlen +! 16ul) h1 c == Some?.v cipher | _ -> None? cipher)) let crypto_box_easy c m mlen n pk sk =

Hacl.Impl.Box.box_easy mlen c sk pk n m

module Hacl.NaCl open FStar.HyperStack.All open FStar.HyperStack open FStar.Mul open Lib.IntTypes open Lib.Buffer open Lib.ByteBuffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module SB = Spec.Box module SS = Spec.SecretBox #set-options "--max_fuel 50 --max_fuel 0 --max_ifuel 0" [@@ Comment "Encrypt a message with a key and nonce. Note: `c` and `m` can point to the same memory for in-place encryption. @param c Pointer to `mlen` bytes where the ciphertext is written to. @param tag Pointer to 16 (tag length) bytes where the authentication tag is written to. @param m Pointer to `mlen` bytes where the message is read from. @param mlen Length of message. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_detached: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == SS.secretbox_detached (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_secretbox_detached c tag m mlen n k = Hacl.Impl.SecretBox.secretbox_detached mlen c tag k n m; 0ul [@@ Comment "Verify and decrypt a ciphertext produced with `Hacl_NaCl_crypto_secretbox_detached`. Note: `m` and `c` can point to the same memory for in-place decryption. @param m Pointer to `mlen` bytes where the message is written to. @param c Pointer to `mlen` bytes where the ciphertext is read from. @param tag Pointer to 16 (tag length) bytes where the authentication tag is read from. @param mlen Length of message (and ciphertext). @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_open_detached: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_detached (as_seq h0 k) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg)) let crypto_secretbox_open_detached m c tag mlen n k = Hacl.Impl.SecretBox.secretbox_open_detached mlen m k n c tag [@@ Comment "Encrypt a message with a key and nonce. @param c Pointer to 16 (tag length) + `mlen` bytes where the ciphertext is written to. @param m Pointer to `mlen` bytes where the message is read from. @param mlen Length of message. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_easy: c:buffer uint8 -> m:buffer uint8 -> mlen:size_t{length c = v mlen + 16 /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 c h0 h1 /\ as_seq #MUT #uint8 #(mlen +! 16ul) h1 c == SS.secretbox_easy (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_secretbox_easy c m mlen n k = Hacl.Impl.SecretBox.secretbox_easy mlen c k n m; 0ul #set-options "--z3rlimit 100" [@@ Comment "Verify and decrypt a ciphertext produced with `crypto_secretbox_easy`. @param m Pointer to `mlen` bytes where the message is written to. @param c Pointer to `clen` bytes where the ciphertext is read from. The authentication tag must be included. @param clen Length of ciphertext. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_open_easy: m:buffer uint8 -> c:buffer uint8 -> clen:size_t{length c = v clen /\ v clen = length m + 16} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint m n /\ disjoint c n) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_easy (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #clen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #(clen -! 16ul) h1 m == Some?.v msg | _ -> None? msg)) let crypto_secretbox_open_easy m c clen n k = Hacl.Impl.SecretBox.secretbox_open_easy (clen -! 16ul) m k n c [@@ Comment "Compute a shared secret key given a public key and secret key. @param k Pointer to 32 (`crypto_box_BEFORENMBYTES`) bytes of memory where the shared secret is written to. @param pk Pointer to 32 bytes of memory where **their** public key is read from. @param sk Pointer to 32 bytes of memory where **my** secret key is read from."] val crypto_box_beforenm: k:lbuffer uint8 32ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h k /\ live h pk /\ live h sk /\ disjoint k pk /\ disjoint k sk) (ensures fun h0 r h1 -> modifies1 k h0 h1 /\ (let key = SB.box_beforenm (as_seq h0 pk) (as_seq h0 sk) in match r with | 0ul -> Some? key /\ as_seq h1 k == Some?.v key | _ -> None? key)) let crypto_box_beforenm k pk sk = Hacl.Impl.Box.box_beforenm k pk sk [@@ Comment "See `crypto_box_detached`."] val crypto_box_detached_afternm: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == SB.box_detached_afternm (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_box_detached_afternm c tag m mlen n k = Hacl.Impl.Box.box_detached_afternm mlen c tag k n m [@@ Comment "Encrypt a message using the recipient's public key, the sender's secret key, and a nonce. @param c Pointer to `mlen` bytes of memory where the ciphertext is written to. @param tag Pointer to 16 (tag length) bytes of memory where the authentication tag is written to. @param m Pointer to `mlen` bytes of memory where the message is read from. @param mlen Length of the message. @param n Pointer to 24 (`crypto_box_NONCEBYTES`) bytes of memory where the nonce is read from. @param pk Pointer to 32 bytes of memory where **their** public key is read from. @param sk Pointer to 32 bytes of memory where **my** secret key is read from."] val crypto_box_detached: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h sk /\ live h pk /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (let tag_cipher = SB.box_detached (as_seq h0 sk) (as_seq h0 pk) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m) in match r with | 0ul -> Some? tag_cipher /\ (let (tag_s, cipher_s) = Some?.v tag_cipher in (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == (tag_s, cipher_s)) | _ -> None? tag_cipher)) let crypto_box_detached c tag m mlen n pk sk = Hacl.Impl.Box.box_detached mlen c tag sk pk n m [@@ Comment "See `crypto_box_open_detached`."] val crypto_box_open_detached_afternm: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SB.box_open_detached_afternm (as_seq h0 k) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg)) let crypto_box_open_detached_afternm m c tag mlen n k = Hacl.Impl.Box.box_open_detached_afternm mlen m k n c tag [@@ Comment "Verify and decrypt a ciphertext produced by `crypto_box_detached`. @param m Pointer to `mlen` bytes of memory where the decrypted message is written to. @param c Pointer to `mlen` bytes of memory where the ciphertext is read from. Note: the ciphertext must include the tag. @param tag Pointer to 16 (tag length) bytes of memory where the authentication tag is read from. @param mlen Length of the message (and ciphertext). @param n Pointer to 24 (`crypto_box_NONCEBYTES`) bytes of memory where the nonce is read from. @param pk Pointer to 32 bytes of memory where the public key of the sender is read from. @param sk Pointer to 32 bytes of memory where the secret key of the recipient is read from."] val crypto_box_open_detached: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h pk /\ live h sk /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SB.box_open_detached (as_seq h0 pk) (as_seq h0 sk) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg)) let crypto_box_open_detached m c tag mlen n pk sk = Hacl.Impl.Box.box_open_detached mlen m pk sk n c tag [@@ Comment "See `crypto_box_easy`."] val crypto_box_easy_afternm: c:buffer uint8 -> m:buffer uint8 -> mlen:size_t{length c = v mlen + 16 /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 c h0 h1 /\ as_seq #MUT #uint8 #(mlen +! 16ul) h1 c == SB.box_easy_afternm (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_box_easy_afternm c m mlen n k = Hacl.Impl.Box.box_easy_afternm mlen c k n m [@@ Comment "Encrypt a message using the recipient's public key, the sender's secret key, and a nonce. @param c Pointer to 16 (tag length) + `mlen` bytes of memory where the authentication tag and ciphertext is written to. @param m Pointer to `mlen` bytes of memory where the message is read from. @param mlen Length of the message. @param n Pointer to 24 (`crypto_box_NONCEBYTES`) bytes of memory where the nonce is read from. @param pk Pointer to 32 bytes of memory where the public key of the recipient is read from. @param sk Pointer to 32 bytes of memory where the secret key of the sender is read from."] val crypto_box_easy: c:buffer uint8 -> m:buffer uint8 -> mlen:size_t{length c = v mlen + 16 /\ length m = v mlen} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h sk /\ live h pk /\ live h n /\ disjoint m c /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 c h0 h1 /\ (let cipher = SB.box_easy (as_seq h0 sk) (as_seq h0 pk) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m) in match r with | 0ul -> Some? cipher /\ as_seq #MUT #uint8 #(mlen +! 16ul) h1 c == Some?.v cipher | _ -> None? cipher))

Hacl.NaCl.fst

val crypto_box_easy: c:buffer uint8 -> m:buffer uint8 -> mlen:size_t{length c = v mlen + 16 /\ length m = v mlen} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h sk /\ live h pk /\ live h n /\ disjoint m c /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 c h0 h1 /\ (let cipher = SB.box_easy (as_seq h0 sk) (as_seq h0 pk) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m) in match r with | 0ul -> Some? cipher /\ as_seq #MUT #uint8 #(mlen +! 16ul) h1 c == Some?.v cipher | _ -> None? cipher))

Hacl.NaCl.crypto_box_easy

c: Lib.Buffer.buffer Lib.IntTypes.uint8 -> m: Lib.Buffer.buffer Lib.IntTypes.uint8 -> mlen: Lib.IntTypes.size_t { Lib.Buffer.length c = Lib.IntTypes.v mlen + 16 /\ Lib.Buffer.length m = Lib.IntTypes.v mlen } -> n: Lib.Buffer.lbuffer Lib.IntTypes.uint8 24ul -> pk: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> sk: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> FStar.HyperStack.ST.Stack Lib.IntTypes.size_t

FStar.HyperStack.ST.Stack

val crypto_box_open_easy_afternm: m:buffer uint8 -> c:buffer uint8 -> clen:size_t{length c = v clen /\ v clen = length m + 16} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint m n /\ disjoint c n) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SB.box_open_easy_afternm (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #clen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #(clen -! 16ul) h1 m == Some?.v msg | _ -> None? msg))

let crypto_box_open_easy_afternm m c clen n k = Hacl.Impl.Box.box_open_easy_afternm (clen -! 16ul) m k n c

val crypto_box_open_easy_afternm: m:buffer uint8 -> c:buffer uint8 -> clen:size_t{length c = v clen /\ v clen = length m + 16} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint m n /\ disjoint c n) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SB.box_open_easy_afternm (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #clen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #(clen -! 16ul) h1 m == Some?.v msg | _ -> None? msg)) let crypto_box_open_easy_afternm m c clen n k =

Hacl.Impl.Box.box_open_easy_afternm (clen -! 16ul) m k n c

module Hacl.NaCl open FStar.HyperStack.All open FStar.HyperStack open FStar.Mul open Lib.IntTypes open Lib.Buffer open Lib.ByteBuffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module SB = Spec.Box module SS = Spec.SecretBox #set-options "--max_fuel 50 --max_fuel 0 --max_ifuel 0" [@@ Comment "Encrypt a message with a key and nonce. Note: `c` and `m` can point to the same memory for in-place encryption. @param c Pointer to `mlen` bytes where the ciphertext is written to. @param tag Pointer to 16 (tag length) bytes where the authentication tag is written to. @param m Pointer to `mlen` bytes where the message is read from. @param mlen Length of message. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_detached: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == SS.secretbox_detached (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_secretbox_detached c tag m mlen n k = Hacl.Impl.SecretBox.secretbox_detached mlen c tag k n m; 0ul [@@ Comment "Verify and decrypt a ciphertext produced with `Hacl_NaCl_crypto_secretbox_detached`. Note: `m` and `c` can point to the same memory for in-place decryption. @param m Pointer to `mlen` bytes where the message is written to. @param c Pointer to `mlen` bytes where the ciphertext is read from. @param tag Pointer to 16 (tag length) bytes where the authentication tag is read from. @param mlen Length of message (and ciphertext). @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_open_detached: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_detached (as_seq h0 k) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg)) let crypto_secretbox_open_detached m c tag mlen n k = Hacl.Impl.SecretBox.secretbox_open_detached mlen m k n c tag [@@ Comment "Encrypt a message with a key and nonce. @param c Pointer to 16 (tag length) + `mlen` bytes where the ciphertext is written to. @param m Pointer to `mlen` bytes where the message is read from. @param mlen Length of message. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_easy: c:buffer uint8 -> m:buffer uint8 -> mlen:size_t{length c = v mlen + 16 /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 c h0 h1 /\ as_seq #MUT #uint8 #(mlen +! 16ul) h1 c == SS.secretbox_easy (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_secretbox_easy c m mlen n k = Hacl.Impl.SecretBox.secretbox_easy mlen c k n m; 0ul #set-options "--z3rlimit 100" [@@ Comment "Verify and decrypt a ciphertext produced with `crypto_secretbox_easy`. @param m Pointer to `mlen` bytes where the message is written to. @param c Pointer to `clen` bytes where the ciphertext is read from. The authentication tag must be included. @param clen Length of ciphertext. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_open_easy: m:buffer uint8 -> c:buffer uint8 -> clen:size_t{length c = v clen /\ v clen = length m + 16} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint m n /\ disjoint c n) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_easy (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #clen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #(clen -! 16ul) h1 m == Some?.v msg | _ -> None? msg)) let crypto_secretbox_open_easy m c clen n k = Hacl.Impl.SecretBox.secretbox_open_easy (clen -! 16ul) m k n c [@@ Comment "Compute a shared secret key given a public key and secret key. @param k Pointer to 32 (`crypto_box_BEFORENMBYTES`) bytes of memory where the shared secret is written to. @param pk Pointer to 32 bytes of memory where **their** public key is read from. @param sk Pointer to 32 bytes of memory where **my** secret key is read from."] val crypto_box_beforenm: k:lbuffer uint8 32ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h k /\ live h pk /\ live h sk /\ disjoint k pk /\ disjoint k sk) (ensures fun h0 r h1 -> modifies1 k h0 h1 /\ (let key = SB.box_beforenm (as_seq h0 pk) (as_seq h0 sk) in match r with | 0ul -> Some? key /\ as_seq h1 k == Some?.v key | _ -> None? key)) let crypto_box_beforenm k pk sk = Hacl.Impl.Box.box_beforenm k pk sk [@@ Comment "See `crypto_box_detached`."] val crypto_box_detached_afternm: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == SB.box_detached_afternm (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_box_detached_afternm c tag m mlen n k = Hacl.Impl.Box.box_detached_afternm mlen c tag k n m [@@ Comment "Encrypt a message using the recipient's public key, the sender's secret key, and a nonce. @param c Pointer to `mlen` bytes of memory where the ciphertext is written to. @param tag Pointer to 16 (tag length) bytes of memory where the authentication tag is written to. @param m Pointer to `mlen` bytes of memory where the message is read from. @param mlen Length of the message. @param n Pointer to 24 (`crypto_box_NONCEBYTES`) bytes of memory where the nonce is read from. @param pk Pointer to 32 bytes of memory where **their** public key is read from. @param sk Pointer to 32 bytes of memory where **my** secret key is read from."] val crypto_box_detached: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h sk /\ live h pk /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (let tag_cipher = SB.box_detached (as_seq h0 sk) (as_seq h0 pk) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m) in match r with | 0ul -> Some? tag_cipher /\ (let (tag_s, cipher_s) = Some?.v tag_cipher in (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == (tag_s, cipher_s)) | _ -> None? tag_cipher)) let crypto_box_detached c tag m mlen n pk sk = Hacl.Impl.Box.box_detached mlen c tag sk pk n m [@@ Comment "See `crypto_box_open_detached`."] val crypto_box_open_detached_afternm: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SB.box_open_detached_afternm (as_seq h0 k) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg)) let crypto_box_open_detached_afternm m c tag mlen n k = Hacl.Impl.Box.box_open_detached_afternm mlen m k n c tag [@@ Comment "Verify and decrypt a ciphertext produced by `crypto_box_detached`. @param m Pointer to `mlen` bytes of memory where the decrypted message is written to. @param c Pointer to `mlen` bytes of memory where the ciphertext is read from. Note: the ciphertext must include the tag. @param tag Pointer to 16 (tag length) bytes of memory where the authentication tag is read from. @param mlen Length of the message (and ciphertext). @param n Pointer to 24 (`crypto_box_NONCEBYTES`) bytes of memory where the nonce is read from. @param pk Pointer to 32 bytes of memory where the public key of the sender is read from. @param sk Pointer to 32 bytes of memory where the secret key of the recipient is read from."] val crypto_box_open_detached: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h pk /\ live h sk /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SB.box_open_detached (as_seq h0 pk) (as_seq h0 sk) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg)) let crypto_box_open_detached m c tag mlen n pk sk = Hacl.Impl.Box.box_open_detached mlen m pk sk n c tag [@@ Comment "See `crypto_box_easy`."] val crypto_box_easy_afternm: c:buffer uint8 -> m:buffer uint8 -> mlen:size_t{length c = v mlen + 16 /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 c h0 h1 /\ as_seq #MUT #uint8 #(mlen +! 16ul) h1 c == SB.box_easy_afternm (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_box_easy_afternm c m mlen n k = Hacl.Impl.Box.box_easy_afternm mlen c k n m [@@ Comment "Encrypt a message using the recipient's public key, the sender's secret key, and a nonce. @param c Pointer to 16 (tag length) + `mlen` bytes of memory where the authentication tag and ciphertext is written to. @param m Pointer to `mlen` bytes of memory where the message is read from. @param mlen Length of the message. @param n Pointer to 24 (`crypto_box_NONCEBYTES`) bytes of memory where the nonce is read from. @param pk Pointer to 32 bytes of memory where the public key of the recipient is read from. @param sk Pointer to 32 bytes of memory where the secret key of the sender is read from."] val crypto_box_easy: c:buffer uint8 -> m:buffer uint8 -> mlen:size_t{length c = v mlen + 16 /\ length m = v mlen} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h sk /\ live h pk /\ live h n /\ disjoint m c /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 c h0 h1 /\ (let cipher = SB.box_easy (as_seq h0 sk) (as_seq h0 pk) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m) in match r with | 0ul -> Some? cipher /\ as_seq #MUT #uint8 #(mlen +! 16ul) h1 c == Some?.v cipher | _ -> None? cipher)) let crypto_box_easy c m mlen n pk sk = Hacl.Impl.Box.box_easy mlen c sk pk n m [@@ Comment "See `crypto_box_open_easy`."] val crypto_box_open_easy_afternm: m:buffer uint8 -> c:buffer uint8 -> clen:size_t{length c = v clen /\ v clen = length m + 16} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint m n /\ disjoint c n) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SB.box_open_easy_afternm (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #clen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #(clen -! 16ul) h1 m == Some?.v msg | _ -> None? msg))

Hacl.NaCl.fst

val crypto_box_open_easy_afternm: m:buffer uint8 -> c:buffer uint8 -> clen:size_t{length c = v clen /\ v clen = length m + 16} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint m n /\ disjoint c n) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SB.box_open_easy_afternm (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #clen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #(clen -! 16ul) h1 m == Some?.v msg | _ -> None? msg))

Hacl.NaCl.crypto_box_open_easy_afternm

m: Lib.Buffer.buffer Lib.IntTypes.uint8 -> c: Lib.Buffer.buffer Lib.IntTypes.uint8 -> clen: Lib.IntTypes.size_t { Lib.Buffer.length c = Lib.IntTypes.v clen /\ Lib.IntTypes.v clen = Lib.Buffer.length m + 16 } -> n: Lib.Buffer.lbuffer Lib.IntTypes.uint8 24ul -> k: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> FStar.HyperStack.ST.Stack Lib.IntTypes.size_t

FStar.HyperStack.ST.Stack

val crypto_box_open_easy: m:buffer uint8 -> c:buffer uint8 -> clen:size_t{length c = v clen /\ v clen = length m + 16} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h pk /\ live h sk /\ live h n /\ disjoint m c /\ disjoint m n /\ disjoint c n) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SB.box_open_easy (as_seq h0 pk) (as_seq h0 sk) (as_seq h0 n) (as_seq #MUT #uint8 #clen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #(clen -! 16ul) h1 m == Some?.v msg | _ -> None? msg))

let crypto_box_open_easy m c clen n pk sk = Hacl.Impl.Box.box_open_easy (clen -! 16ul) m pk sk n c

val crypto_box_open_easy: m:buffer uint8 -> c:buffer uint8 -> clen:size_t{length c = v clen /\ v clen = length m + 16} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h pk /\ live h sk /\ live h n /\ disjoint m c /\ disjoint m n /\ disjoint c n) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SB.box_open_easy (as_seq h0 pk) (as_seq h0 sk) (as_seq h0 n) (as_seq #MUT #uint8 #clen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #(clen -! 16ul) h1 m == Some?.v msg | _ -> None? msg)) let crypto_box_open_easy m c clen n pk sk =

Hacl.Impl.Box.box_open_easy (clen -! 16ul) m pk sk n c

module Hacl.NaCl open FStar.HyperStack.All open FStar.HyperStack open FStar.Mul open Lib.IntTypes open Lib.Buffer open Lib.ByteBuffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module SB = Spec.Box module SS = Spec.SecretBox #set-options "--max_fuel 50 --max_fuel 0 --max_ifuel 0" [@@ Comment "Encrypt a message with a key and nonce. Note: `c` and `m` can point to the same memory for in-place encryption. @param c Pointer to `mlen` bytes where the ciphertext is written to. @param tag Pointer to 16 (tag length) bytes where the authentication tag is written to. @param m Pointer to `mlen` bytes where the message is read from. @param mlen Length of message. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_detached: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == SS.secretbox_detached (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_secretbox_detached c tag m mlen n k = Hacl.Impl.SecretBox.secretbox_detached mlen c tag k n m; 0ul [@@ Comment "Verify and decrypt a ciphertext produced with `Hacl_NaCl_crypto_secretbox_detached`. Note: `m` and `c` can point to the same memory for in-place decryption. @param m Pointer to `mlen` bytes where the message is written to. @param c Pointer to `mlen` bytes where the ciphertext is read from. @param tag Pointer to 16 (tag length) bytes where the authentication tag is read from. @param mlen Length of message (and ciphertext). @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_open_detached: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_detached (as_seq h0 k) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg)) let crypto_secretbox_open_detached m c tag mlen n k = Hacl.Impl.SecretBox.secretbox_open_detached mlen m k n c tag [@@ Comment "Encrypt a message with a key and nonce. @param c Pointer to 16 (tag length) + `mlen` bytes where the ciphertext is written to. @param m Pointer to `mlen` bytes where the message is read from. @param mlen Length of message. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_easy: c:buffer uint8 -> m:buffer uint8 -> mlen:size_t{length c = v mlen + 16 /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 c h0 h1 /\ as_seq #MUT #uint8 #(mlen +! 16ul) h1 c == SS.secretbox_easy (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_secretbox_easy c m mlen n k = Hacl.Impl.SecretBox.secretbox_easy mlen c k n m; 0ul #set-options "--z3rlimit 100" [@@ Comment "Verify and decrypt a ciphertext produced with `crypto_secretbox_easy`. @param m Pointer to `mlen` bytes where the message is written to. @param c Pointer to `clen` bytes where the ciphertext is read from. The authentication tag must be included. @param clen Length of ciphertext. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_open_easy: m:buffer uint8 -> c:buffer uint8 -> clen:size_t{length c = v clen /\ v clen = length m + 16} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint m n /\ disjoint c n) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_easy (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #clen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #(clen -! 16ul) h1 m == Some?.v msg | _ -> None? msg)) let crypto_secretbox_open_easy m c clen n k = Hacl.Impl.SecretBox.secretbox_open_easy (clen -! 16ul) m k n c [@@ Comment "Compute a shared secret key given a public key and secret key. @param k Pointer to 32 (`crypto_box_BEFORENMBYTES`) bytes of memory where the shared secret is written to. @param pk Pointer to 32 bytes of memory where **their** public key is read from. @param sk Pointer to 32 bytes of memory where **my** secret key is read from."] val crypto_box_beforenm: k:lbuffer uint8 32ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h k /\ live h pk /\ live h sk /\ disjoint k pk /\ disjoint k sk) (ensures fun h0 r h1 -> modifies1 k h0 h1 /\ (let key = SB.box_beforenm (as_seq h0 pk) (as_seq h0 sk) in match r with | 0ul -> Some? key /\ as_seq h1 k == Some?.v key | _ -> None? key)) let crypto_box_beforenm k pk sk = Hacl.Impl.Box.box_beforenm k pk sk [@@ Comment "See `crypto_box_detached`."] val crypto_box_detached_afternm: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == SB.box_detached_afternm (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_box_detached_afternm c tag m mlen n k = Hacl.Impl.Box.box_detached_afternm mlen c tag k n m [@@ Comment "Encrypt a message using the recipient's public key, the sender's secret key, and a nonce. @param c Pointer to `mlen` bytes of memory where the ciphertext is written to. @param tag Pointer to 16 (tag length) bytes of memory where the authentication tag is written to. @param m Pointer to `mlen` bytes of memory where the message is read from. @param mlen Length of the message. @param n Pointer to 24 (`crypto_box_NONCEBYTES`) bytes of memory where the nonce is read from. @param pk Pointer to 32 bytes of memory where **their** public key is read from. @param sk Pointer to 32 bytes of memory where **my** secret key is read from."] val crypto_box_detached: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h sk /\ live h pk /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (let tag_cipher = SB.box_detached (as_seq h0 sk) (as_seq h0 pk) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m) in match r with | 0ul -> Some? tag_cipher /\ (let (tag_s, cipher_s) = Some?.v tag_cipher in (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == (tag_s, cipher_s)) | _ -> None? tag_cipher)) let crypto_box_detached c tag m mlen n pk sk = Hacl.Impl.Box.box_detached mlen c tag sk pk n m [@@ Comment "See `crypto_box_open_detached`."] val crypto_box_open_detached_afternm: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SB.box_open_detached_afternm (as_seq h0 k) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg)) let crypto_box_open_detached_afternm m c tag mlen n k = Hacl.Impl.Box.box_open_detached_afternm mlen m k n c tag [@@ Comment "Verify and decrypt a ciphertext produced by `crypto_box_detached`. @param m Pointer to `mlen` bytes of memory where the decrypted message is written to. @param c Pointer to `mlen` bytes of memory where the ciphertext is read from. Note: the ciphertext must include the tag. @param tag Pointer to 16 (tag length) bytes of memory where the authentication tag is read from. @param mlen Length of the message (and ciphertext). @param n Pointer to 24 (`crypto_box_NONCEBYTES`) bytes of memory where the nonce is read from. @param pk Pointer to 32 bytes of memory where the public key of the sender is read from. @param sk Pointer to 32 bytes of memory where the secret key of the recipient is read from."] val crypto_box_open_detached: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h pk /\ live h sk /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SB.box_open_detached (as_seq h0 pk) (as_seq h0 sk) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg)) let crypto_box_open_detached m c tag mlen n pk sk = Hacl.Impl.Box.box_open_detached mlen m pk sk n c tag [@@ Comment "See `crypto_box_easy`."] val crypto_box_easy_afternm: c:buffer uint8 -> m:buffer uint8 -> mlen:size_t{length c = v mlen + 16 /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 c h0 h1 /\ as_seq #MUT #uint8 #(mlen +! 16ul) h1 c == SB.box_easy_afternm (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_box_easy_afternm c m mlen n k = Hacl.Impl.Box.box_easy_afternm mlen c k n m [@@ Comment "Encrypt a message using the recipient's public key, the sender's secret key, and a nonce. @param c Pointer to 16 (tag length) + `mlen` bytes of memory where the authentication tag and ciphertext is written to. @param m Pointer to `mlen` bytes of memory where the message is read from. @param mlen Length of the message. @param n Pointer to 24 (`crypto_box_NONCEBYTES`) bytes of memory where the nonce is read from. @param pk Pointer to 32 bytes of memory where the public key of the recipient is read from. @param sk Pointer to 32 bytes of memory where the secret key of the sender is read from."] val crypto_box_easy: c:buffer uint8 -> m:buffer uint8 -> mlen:size_t{length c = v mlen + 16 /\ length m = v mlen} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h sk /\ live h pk /\ live h n /\ disjoint m c /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 c h0 h1 /\ (let cipher = SB.box_easy (as_seq h0 sk) (as_seq h0 pk) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m) in match r with | 0ul -> Some? cipher /\ as_seq #MUT #uint8 #(mlen +! 16ul) h1 c == Some?.v cipher | _ -> None? cipher)) let crypto_box_easy c m mlen n pk sk = Hacl.Impl.Box.box_easy mlen c sk pk n m [@@ Comment "See `crypto_box_open_easy`."] val crypto_box_open_easy_afternm: m:buffer uint8 -> c:buffer uint8 -> clen:size_t{length c = v clen /\ v clen = length m + 16} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint m n /\ disjoint c n) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SB.box_open_easy_afternm (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #clen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #(clen -! 16ul) h1 m == Some?.v msg | _ -> None? msg)) let crypto_box_open_easy_afternm m c clen n k = Hacl.Impl.Box.box_open_easy_afternm (clen -! 16ul) m k n c [@@ Comment "Verify and decrypt a ciphertext produced by `crypto_box_easy`. @param m Pointer to `clen` - 16 (tag length) bytes of memory where the decrypted message is written to. @param c Pointer to `clen` bytes of memory where the ciphertext is read from. Note: the ciphertext must include the tag. @param clen Length of the ciphertext. @param n Pointer to 24 (`crypto_box_NONCEBYTES`) bytes of memory where the nonce is read from. @param pk Pointer to 32 bytes of memory where the public key of the sender is read from. @param sk Pointer to 32 bytes of memory where the secret key of the recipient is read from."] val crypto_box_open_easy: m:buffer uint8 -> c:buffer uint8 -> clen:size_t{length c = v clen /\ v clen = length m + 16} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h pk /\ live h sk /\ live h n /\ disjoint m c /\ disjoint m n /\ disjoint c n) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SB.box_open_easy (as_seq h0 pk) (as_seq h0 sk) (as_seq h0 n) (as_seq #MUT #uint8 #clen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #(clen -! 16ul) h1 m == Some?.v msg | _ -> None? msg))

Hacl.NaCl.fst

val crypto_box_open_easy: m:buffer uint8 -> c:buffer uint8 -> clen:size_t{length c = v clen /\ v clen = length m + 16} -> n:lbuffer uint8 24ul -> pk:lbuffer uint8 32ul -> sk:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h pk /\ live h sk /\ live h n /\ disjoint m c /\ disjoint m n /\ disjoint c n) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SB.box_open_easy (as_seq h0 pk) (as_seq h0 sk) (as_seq h0 n) (as_seq #MUT #uint8 #clen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #(clen -! 16ul) h1 m == Some?.v msg | _ -> None? msg))

Hacl.NaCl.crypto_box_open_easy

m: Lib.Buffer.buffer Lib.IntTypes.uint8 -> c: Lib.Buffer.buffer Lib.IntTypes.uint8 -> clen: Lib.IntTypes.size_t { Lib.Buffer.length c = Lib.IntTypes.v clen /\ Lib.IntTypes.v clen = Lib.Buffer.length m + 16 } -> n: Lib.Buffer.lbuffer Lib.IntTypes.uint8 24ul -> pk: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> sk: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> FStar.HyperStack.ST.Stack Lib.IntTypes.size_t

FStar.HyperStack.ST.Stack

val crypto_secretbox_open_easy: m:buffer uint8 -> c:buffer uint8 -> clen:size_t{length c = v clen /\ v clen = length m + 16} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint m n /\ disjoint c n) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_easy (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #clen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #(clen -! 16ul) h1 m == Some?.v msg | _ -> None? msg))

let crypto_secretbox_open_easy m c clen n k = Hacl.Impl.SecretBox.secretbox_open_easy (clen -! 16ul) m k n c

val crypto_secretbox_open_easy: m:buffer uint8 -> c:buffer uint8 -> clen:size_t{length c = v clen /\ v clen = length m + 16} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint m n /\ disjoint c n) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_easy (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #clen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #(clen -! 16ul) h1 m == Some?.v msg | _ -> None? msg)) let crypto_secretbox_open_easy m c clen n k =

Hacl.Impl.SecretBox.secretbox_open_easy (clen -! 16ul) m k n c

module Hacl.NaCl open FStar.HyperStack.All open FStar.HyperStack open FStar.Mul open Lib.IntTypes open Lib.Buffer open Lib.ByteBuffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module SB = Spec.Box module SS = Spec.SecretBox #set-options "--max_fuel 50 --max_fuel 0 --max_ifuel 0" [@@ Comment "Encrypt a message with a key and nonce. Note: `c` and `m` can point to the same memory for in-place encryption. @param c Pointer to `mlen` bytes where the ciphertext is written to. @param tag Pointer to 16 (tag length) bytes where the authentication tag is written to. @param m Pointer to `mlen` bytes where the message is read from. @param mlen Length of message. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_detached: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == SS.secretbox_detached (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_secretbox_detached c tag m mlen n k = Hacl.Impl.SecretBox.secretbox_detached mlen c tag k n m; 0ul [@@ Comment "Verify and decrypt a ciphertext produced with `Hacl_NaCl_crypto_secretbox_detached`. Note: `m` and `c` can point to the same memory for in-place decryption. @param m Pointer to `mlen` bytes where the message is written to. @param c Pointer to `mlen` bytes where the ciphertext is read from. @param tag Pointer to 16 (tag length) bytes where the authentication tag is read from. @param mlen Length of message (and ciphertext). @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_open_detached: m:buffer uint8 -> c:buffer uint8 -> tag:lbuffer uint8 16ul -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_detached (as_seq h0 k) (as_seq h0 n) (as_seq h0 tag) (as_seq #MUT #uint8 #mlen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #mlen h1 m == Some?.v msg | _ -> None? msg)) let crypto_secretbox_open_detached m c tag mlen n k = Hacl.Impl.SecretBox.secretbox_open_detached mlen m k n c tag [@@ Comment "Encrypt a message with a key and nonce. @param c Pointer to 16 (tag length) + `mlen` bytes where the ciphertext is written to. @param m Pointer to `mlen` bytes where the message is read from. @param mlen Length of message. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_easy: c:buffer uint8 -> m:buffer uint8 -> mlen:size_t{length c = v mlen + 16 /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies1 c h0 h1 /\ as_seq #MUT #uint8 #(mlen +! 16ul) h1 c == SS.secretbox_easy (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_secretbox_easy c m mlen n k = Hacl.Impl.SecretBox.secretbox_easy mlen c k n m; 0ul #set-options "--z3rlimit 100" [@@ Comment "Verify and decrypt a ciphertext produced with `crypto_secretbox_easy`. @param m Pointer to `mlen` bytes where the message is written to. @param c Pointer to `clen` bytes where the ciphertext is read from. The authentication tag must be included. @param clen Length of ciphertext. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_open_easy: m:buffer uint8 -> c:buffer uint8 -> clen:size_t{length c = v clen /\ v clen = length m + 16} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint m n /\ disjoint c n) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_easy (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #clen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #(clen -! 16ul) h1 m == Some?.v msg | _ -> None? msg))

Hacl.NaCl.fst

val crypto_secretbox_open_easy: m:buffer uint8 -> c:buffer uint8 -> clen:size_t{length c = v clen /\ v clen = length m + 16} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ disjoint m c /\ disjoint m n /\ disjoint c n) (ensures fun h0 r h1 -> modifies1 m h0 h1 /\ (let msg = SS.secretbox_open_easy (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #clen h0 c) in match r with | 0ul -> Some? msg /\ as_seq #MUT #uint8 #(clen -! 16ul) h1 m == Some?.v msg | _ -> None? msg))

Hacl.NaCl.crypto_secretbox_open_easy

m: Lib.Buffer.buffer Lib.IntTypes.uint8 -> c: Lib.Buffer.buffer Lib.IntTypes.uint8 -> clen: Lib.IntTypes.size_t { Lib.Buffer.length c = Lib.IntTypes.v clen /\ Lib.IntTypes.v clen = Lib.Buffer.length m + 16 } -> n: Lib.Buffer.lbuffer Lib.IntTypes.uint8 24ul -> k: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> FStar.HyperStack.ST.Stack Lib.IntTypes.size_t

FStar.HyperStack.ST.Stack

val crypto_secretbox_detached: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == SS.secretbox_detached (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m))

let crypto_secretbox_detached c tag m mlen n k = Hacl.Impl.SecretBox.secretbox_detached mlen c tag k n m; 0ul

val crypto_secretbox_detached: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == SS.secretbox_detached (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m)) let crypto_secretbox_detached c tag m mlen n k =

Hacl.Impl.SecretBox.secretbox_detached mlen c tag k n m; 0ul

module Hacl.NaCl open FStar.HyperStack.All open FStar.HyperStack open FStar.Mul open Lib.IntTypes open Lib.Buffer open Lib.ByteBuffer module ST = FStar.HyperStack.ST module LSeq = Lib.Sequence module SB = Spec.Box module SS = Spec.SecretBox #set-options "--max_fuel 50 --max_fuel 0 --max_ifuel 0" [@@ Comment "Encrypt a message with a key and nonce. Note: `c` and `m` can point to the same memory for in-place encryption. @param c Pointer to `mlen` bytes where the ciphertext is written to. @param tag Pointer to 16 (tag length) bytes where the authentication tag is written to. @param m Pointer to `mlen` bytes where the message is read from. @param mlen Length of message. @param n Pointer to 24 (`crypto_secretbox_NONCEBYTES`) bytes where the nonce is read from. @param k Pointer to 32 (`crypto_secretbox_KEYBYTES`) bytes where the key is read from."] val crypto_secretbox_detached: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == SS.secretbox_detached (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m))

Hacl.NaCl.fst

val crypto_secretbox_detached: c:buffer uint8 -> tag:lbuffer uint8 16ul -> m:buffer uint8 -> mlen:size_t{length c = v mlen /\ length m = v mlen} -> n:lbuffer uint8 24ul -> k:lbuffer uint8 32ul -> Stack size_t (requires fun h -> live h c /\ live h m /\ live h k /\ live h n /\ live h tag /\ disjoint tag c /\ eq_or_disjoint (m <: lbuffer uint8 mlen) (c <: lbuffer uint8 mlen) /\ disjoint tag m /\ disjoint n m /\ disjoint n c) (ensures fun h0 r h1 -> modifies2 c tag h0 h1 /\ (as_seq h1 tag, as_seq #MUT #uint8 #mlen h1 c) == SS.secretbox_detached (as_seq h0 k) (as_seq h0 n) (as_seq #MUT #uint8 #mlen h0 m))

Hacl.NaCl.crypto_secretbox_detached

c: Lib.Buffer.buffer Lib.IntTypes.uint8 -> tag: Lib.Buffer.lbuffer Lib.IntTypes.uint8 16ul -> m: Lib.Buffer.buffer Lib.IntTypes.uint8 -> mlen: Lib.IntTypes.size_t {Lib.Buffer.length c = Lib.IntTypes.v mlen /\ Lib.Buffer.length m = Lib.IntTypes.v mlen} -> n: Lib.Buffer.lbuffer Lib.IntTypes.uint8 24ul -> k: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> FStar.HyperStack.ST.Stack Lib.IntTypes.size_t

Prims.Tot

let qelem = lbuffer uint64 qnlimb

let qelem =

lbuffer uint64 qnlimb

module Hacl.K256.Scalar 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 BSeq = Lib.ByteSequence module S = Spec.K256 module SG = Hacl.Spec.K256.GLV module BD = Hacl.Bignum.Definitions #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let qnlimb = 4ul

Hacl.K256.Scalar.fsti

val qelem : Type0

Hacl.K256.Scalar.qelem

Type0

Prims.GTot

let qe_lt_q (h:mem) (e:qelem) = qas_nat h e < S.q

let qe_lt_q (h: mem) (e: qelem) =

qas_nat h e < S.q

module Hacl.K256.Scalar 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 BSeq = Lib.ByteSequence module S = Spec.K256 module SG = Hacl.Spec.K256.GLV module BD = Hacl.Bignum.Definitions #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let qnlimb = 4ul inline_for_extraction noextract let qelem = lbuffer uint64 qnlimb noextract let qas_nat (h:mem) (e:qelem) : GTot nat = BD.bn_v #U64 #qnlimb h e noextract let qeval (h:mem) (e:qelem) : GTot S.qelem = qas_nat h e % S.q

Hacl.K256.Scalar.fsti

val qe_lt_q : h: FStar.Monotonic.HyperStack.mem -> e: Hacl.K256.Scalar.qelem -> Prims.GTot Prims.bool

Hacl.K256.Scalar.qe_lt_q

h: FStar.Monotonic.HyperStack.mem -> e: Hacl.K256.Scalar.qelem -> Prims.GTot Prims.bool

Prims.Tot

let qelem4 = uint64 & uint64 & uint64 & uint64

let qelem4 =

uint64 & uint64 & uint64 & uint64

module Hacl.K256.Scalar 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 BSeq = Lib.ByteSequence module S = Spec.K256 module SG = Hacl.Spec.K256.GLV module BD = Hacl.Bignum.Definitions #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let qnlimb = 4ul inline_for_extraction noextract let qelem = lbuffer uint64 qnlimb noextract let qas_nat (h:mem) (e:qelem) : GTot nat = BD.bn_v #U64 #qnlimb h e noextract let qeval (h:mem) (e:qelem) : GTot S.qelem = qas_nat h e % S.q noextract let qe_lt_q (h:mem) (e:qelem) = qas_nat h e < S.q

Hacl.K256.Scalar.fsti

val qelem4 : Type0

Hacl.K256.Scalar.qelem4

Type0

Prims.Tot

let qas_nat4 (f:qelem4) = let (f0, f1, f2, f3) = f in v f0 + v f1 * pow2 64 + v f2 * pow2 128 + v f3 * pow2 192

let qas_nat4 (f: qelem4) =

let f0, f1, f2, f3 = f in v f0 + v f1 * pow2 64 + v f2 * pow2 128 + v f3 * pow2 192

module Hacl.K256.Scalar 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 BSeq = Lib.ByteSequence module S = Spec.K256 module SG = Hacl.Spec.K256.GLV module BD = Hacl.Bignum.Definitions #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let qnlimb = 4ul inline_for_extraction noextract let qelem = lbuffer uint64 qnlimb noextract let qas_nat (h:mem) (e:qelem) : GTot nat = BD.bn_v #U64 #qnlimb h e noextract let qeval (h:mem) (e:qelem) : GTot S.qelem = qas_nat h e % S.q noextract let qe_lt_q (h:mem) (e:qelem) = qas_nat h e < S.q inline_for_extraction noextract let qelem4 = uint64 & uint64 & uint64 & uint64

Hacl.K256.Scalar.fsti

val qas_nat4 : f: Hacl.K256.Scalar.qelem4 -> Prims.int

Hacl.K256.Scalar.qas_nat4

f: Hacl.K256.Scalar.qelem4 -> Prims.int

Prims.Tot

let qnlimb = 4ul

let qnlimb =

4ul

module Hacl.K256.Scalar 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 BSeq = Lib.ByteSequence module S = Spec.K256 module SG = Hacl.Spec.K256.GLV module BD = Hacl.Bignum.Definitions #set-options "--z3rlimit 50 --fuel 0 --ifuel 0"

Hacl.K256.Scalar.fsti

val qnlimb : FStar.UInt32.t

Hacl.K256.Scalar.qnlimb

FStar.UInt32.t

Prims.GTot

val qas_nat (h: mem) (e: qelem) : GTot nat

let qas_nat (h:mem) (e:qelem) : GTot nat = BD.bn_v #U64 #qnlimb h e

val qas_nat (h: mem) (e: qelem) : GTot nat let qas_nat (h: mem) (e: qelem) : GTot nat =

BD.bn_v #U64 #qnlimb h e

module Hacl.K256.Scalar 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 BSeq = Lib.ByteSequence module S = Spec.K256 module SG = Hacl.Spec.K256.GLV module BD = Hacl.Bignum.Definitions #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let qnlimb = 4ul inline_for_extraction noextract let qelem = lbuffer uint64 qnlimb

Hacl.K256.Scalar.fsti

val qas_nat (h: mem) (e: qelem) : GTot nat

Hacl.K256.Scalar.qas_nat

h: FStar.Monotonic.HyperStack.mem -> e: Hacl.K256.Scalar.qelem -> Prims.GTot Prims.nat

Prims.GTot

val qeval (h: mem) (e: qelem) : GTot S.qelem

let qeval (h:mem) (e:qelem) : GTot S.qelem = qas_nat h e % S.q

val qeval (h: mem) (e: qelem) : GTot S.qelem let qeval (h: mem) (e: qelem) : GTot S.qelem =

qas_nat h e % S.q

module Hacl.K256.Scalar 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 BSeq = Lib.ByteSequence module S = Spec.K256 module SG = Hacl.Spec.K256.GLV module BD = Hacl.Bignum.Definitions #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let qnlimb = 4ul inline_for_extraction noextract let qelem = lbuffer uint64 qnlimb noextract let qas_nat (h:mem) (e:qelem) : GTot nat = BD.bn_v #U64 #qnlimb h e

Hacl.K256.Scalar.fsti

val qeval (h: mem) (e: qelem) : GTot S.qelem

Hacl.K256.Scalar.qeval

h: FStar.Monotonic.HyperStack.mem -> e: Hacl.K256.Scalar.qelem -> Prims.GTot Spec.K256.PointOps.qelem

Prims.Tot

let abcd_idx = (n: nat { n < 4 } )

let abcd_idx =

(n: nat{n < 4})

module Spec.MD5 (* Source: https://tools.ietf.org/html/rfc1321 *) open Lib.IntTypes open Spec.Hash.Definitions (* Section 3.3 *) inline_for_extraction let init_as_list : list uint32 = [ u32 0x67452301; u32 0xefcdab89; u32 0x98badcfe; u32 0x10325476; ] let init : words_state MD5 = Seq.seq_of_list init_as_list (* Section 3.4 *) inline_for_extraction let f (x y z: uint32) : Tot uint32 = (x &. y) |. ((~. x) &. z) inline_for_extraction let g (x y z: uint32) : Tot uint32 = (x &. z) |. (y &. (~. z)) inline_for_extraction let h (x y z: uint32) : Tot uint32 = x ^. y ^. z inline_for_extraction let i (x y z: uint32) : Tot uint32 = y ^. (x |. ~. z) (* Table T: specified in 3.4, defined in Appendix A.3, function MD5Transform *) inline_for_extraction let t_as_list : list uint32 = [ u32 0xd76aa478; u32 0xe8c7b756; u32 0x242070db; u32 0xc1bdceee; u32 0xf57c0faf; u32 0x4787c62a; u32 0xa8304613; u32 0xfd469501; u32 0x698098d8; u32 0x8b44f7af; u32 0xffff5bb1; u32 0x895cd7be; u32 0x6b901122; u32 0xfd987193; u32 0xa679438e; u32 0x49b40821; u32 0xf61e2562; u32 0xc040b340; u32 0x265e5a51; u32 0xe9b6c7aa; u32 0xd62f105d; u32 0x02441453; u32 0xd8a1e681; u32 0xe7d3fbc8; u32 0x21e1cde6; u32 0xc33707d6; u32 0xf4d50d87; u32 0x455a14ed; u32 0xa9e3e905; u32 0xfcefa3f8; u32 0x676f02d9; u32 0x8d2a4c8a; u32 0xfffa3942; u32 0x8771f681; u32 0x6d9d6122; u32 0xfde5380c; u32 0xa4beea44; u32 0x4bdecfa9; u32 0xf6bb4b60; u32 0xbebfbc70; u32 0x289b7ec6; u32 0xeaa127fa; u32 0xd4ef3085; u32 0x4881d05; u32 0xd9d4d039; u32 0xe6db99e5; u32 0x1fa27cf8; u32 0xc4ac5665; u32 0xf4292244; u32 0x432aff97; u32 0xab9423a7; u32 0xfc93a039; u32 0x655b59c3; u32 0x8f0ccc92; u32 0xffeff47d; u32 0x85845dd1; u32 0x6fa87e4f; u32 0xfe2ce6e0; u32 0xa3014314; u32 0x4e0811a1; u32 0xf7537e82; u32 0xbd3af235; u32 0x2ad7d2bb; u32 0xeb86d391; ] module L = FStar.List.Tot let t : Seq.lseq uint32 64 = assert_norm (L.length t_as_list == 64); Seq.seq_of_list t_as_list

Spec.MD5.fst

val abcd_idx : Type0

Spec.MD5.abcd_idx

Type0

Prims.Tot

let x_t = Seq.lseq uint32 16

let x_t =

Seq.lseq uint32 16

module Spec.MD5 (* Source: https://tools.ietf.org/html/rfc1321 *) open Lib.IntTypes open Spec.Hash.Definitions (* Section 3.3 *) inline_for_extraction let init_as_list : list uint32 = [ u32 0x67452301; u32 0xefcdab89; u32 0x98badcfe; u32 0x10325476; ] let init : words_state MD5 = Seq.seq_of_list init_as_list (* Section 3.4 *) inline_for_extraction let f (x y z: uint32) : Tot uint32 = (x &. y) |. ((~. x) &. z) inline_for_extraction let g (x y z: uint32) : Tot uint32 = (x &. z) |. (y &. (~. z)) inline_for_extraction let h (x y z: uint32) : Tot uint32 = x ^. y ^. z inline_for_extraction let i (x y z: uint32) : Tot uint32 = y ^. (x |. ~. z) (* Table T: specified in 3.4, defined in Appendix A.3, function MD5Transform *) inline_for_extraction let t_as_list : list uint32 = [ u32 0xd76aa478; u32 0xe8c7b756; u32 0x242070db; u32 0xc1bdceee; u32 0xf57c0faf; u32 0x4787c62a; u32 0xa8304613; u32 0xfd469501; u32 0x698098d8; u32 0x8b44f7af; u32 0xffff5bb1; u32 0x895cd7be; u32 0x6b901122; u32 0xfd987193; u32 0xa679438e; u32 0x49b40821; u32 0xf61e2562; u32 0xc040b340; u32 0x265e5a51; u32 0xe9b6c7aa; u32 0xd62f105d; u32 0x02441453; u32 0xd8a1e681; u32 0xe7d3fbc8; u32 0x21e1cde6; u32 0xc33707d6; u32 0xf4d50d87; u32 0x455a14ed; u32 0xa9e3e905; u32 0xfcefa3f8; u32 0x676f02d9; u32 0x8d2a4c8a; u32 0xfffa3942; u32 0x8771f681; u32 0x6d9d6122; u32 0xfde5380c; u32 0xa4beea44; u32 0x4bdecfa9; u32 0xf6bb4b60; u32 0xbebfbc70; u32 0x289b7ec6; u32 0xeaa127fa; u32 0xd4ef3085; u32 0x4881d05; u32 0xd9d4d039; u32 0xe6db99e5; u32 0x1fa27cf8; u32 0xc4ac5665; u32 0xf4292244; u32 0x432aff97; u32 0xab9423a7; u32 0xfc93a039; u32 0x655b59c3; u32 0x8f0ccc92; u32 0xffeff47d; u32 0x85845dd1; u32 0x6fa87e4f; u32 0xfe2ce6e0; u32 0xa3014314; u32 0x4e0811a1; u32 0xf7537e82; u32 0xbd3af235; u32 0x2ad7d2bb; u32 0xeb86d391; ] module L = FStar.List.Tot let t : Seq.lseq uint32 64 = assert_norm (L.length t_as_list == 64); Seq.seq_of_list t_as_list let abcd_idx = (n: nat { n < 4 } ) let abcd_t = Seq.lseq uint32 4

Spec.MD5.fst

val x_t : Type0

Spec.MD5.x_t

Type0

Prims.Tot

let x_idx = (n: nat { n < 16 } )

let x_idx =

(n: nat{n < 16})

module Spec.MD5 (* Source: https://tools.ietf.org/html/rfc1321 *) open Lib.IntTypes open Spec.Hash.Definitions (* Section 3.3 *) inline_for_extraction let init_as_list : list uint32 = [ u32 0x67452301; u32 0xefcdab89; u32 0x98badcfe; u32 0x10325476; ] let init : words_state MD5 = Seq.seq_of_list init_as_list (* Section 3.4 *) inline_for_extraction let f (x y z: uint32) : Tot uint32 = (x &. y) |. ((~. x) &. z) inline_for_extraction let g (x y z: uint32) : Tot uint32 = (x &. z) |. (y &. (~. z)) inline_for_extraction let h (x y z: uint32) : Tot uint32 = x ^. y ^. z inline_for_extraction let i (x y z: uint32) : Tot uint32 = y ^. (x |. ~. z) (* Table T: specified in 3.4, defined in Appendix A.3, function MD5Transform *) inline_for_extraction let t_as_list : list uint32 = [ u32 0xd76aa478; u32 0xe8c7b756; u32 0x242070db; u32 0xc1bdceee; u32 0xf57c0faf; u32 0x4787c62a; u32 0xa8304613; u32 0xfd469501; u32 0x698098d8; u32 0x8b44f7af; u32 0xffff5bb1; u32 0x895cd7be; u32 0x6b901122; u32 0xfd987193; u32 0xa679438e; u32 0x49b40821; u32 0xf61e2562; u32 0xc040b340; u32 0x265e5a51; u32 0xe9b6c7aa; u32 0xd62f105d; u32 0x02441453; u32 0xd8a1e681; u32 0xe7d3fbc8; u32 0x21e1cde6; u32 0xc33707d6; u32 0xf4d50d87; u32 0x455a14ed; u32 0xa9e3e905; u32 0xfcefa3f8; u32 0x676f02d9; u32 0x8d2a4c8a; u32 0xfffa3942; u32 0x8771f681; u32 0x6d9d6122; u32 0xfde5380c; u32 0xa4beea44; u32 0x4bdecfa9; u32 0xf6bb4b60; u32 0xbebfbc70; u32 0x289b7ec6; u32 0xeaa127fa; u32 0xd4ef3085; u32 0x4881d05; u32 0xd9d4d039; u32 0xe6db99e5; u32 0x1fa27cf8; u32 0xc4ac5665; u32 0xf4292244; u32 0x432aff97; u32 0xab9423a7; u32 0xfc93a039; u32 0x655b59c3; u32 0x8f0ccc92; u32 0xffeff47d; u32 0x85845dd1; u32 0x6fa87e4f; u32 0xfe2ce6e0; u32 0xa3014314; u32 0x4e0811a1; u32 0xf7537e82; u32 0xbd3af235; u32 0x2ad7d2bb; u32 0xeb86d391; ] module L = FStar.List.Tot let t : Seq.lseq uint32 64 = assert_norm (L.length t_as_list == 64); Seq.seq_of_list t_as_list let abcd_idx = (n: nat { n < 4 } ) let abcd_t = Seq.lseq uint32 4

Spec.MD5.fst

val x_idx : Type0

Spec.MD5.x_idx

Type0

Prims.Tot

let t_idx = (n: nat { 1 <= n /\ n <= 64 } )

let t_idx =

(n: nat{1 <= n /\ n <= 64})

module Spec.MD5 (* Source: https://tools.ietf.org/html/rfc1321 *) open Lib.IntTypes open Spec.Hash.Definitions (* Section 3.3 *) inline_for_extraction let init_as_list : list uint32 = [ u32 0x67452301; u32 0xefcdab89; u32 0x98badcfe; u32 0x10325476; ] let init : words_state MD5 = Seq.seq_of_list init_as_list (* Section 3.4 *) inline_for_extraction let f (x y z: uint32) : Tot uint32 = (x &. y) |. ((~. x) &. z) inline_for_extraction let g (x y z: uint32) : Tot uint32 = (x &. z) |. (y &. (~. z)) inline_for_extraction let h (x y z: uint32) : Tot uint32 = x ^. y ^. z inline_for_extraction let i (x y z: uint32) : Tot uint32 = y ^. (x |. ~. z) (* Table T: specified in 3.4, defined in Appendix A.3, function MD5Transform *) inline_for_extraction let t_as_list : list uint32 = [ u32 0xd76aa478; u32 0xe8c7b756; u32 0x242070db; u32 0xc1bdceee; u32 0xf57c0faf; u32 0x4787c62a; u32 0xa8304613; u32 0xfd469501; u32 0x698098d8; u32 0x8b44f7af; u32 0xffff5bb1; u32 0x895cd7be; u32 0x6b901122; u32 0xfd987193; u32 0xa679438e; u32 0x49b40821; u32 0xf61e2562; u32 0xc040b340; u32 0x265e5a51; u32 0xe9b6c7aa; u32 0xd62f105d; u32 0x02441453; u32 0xd8a1e681; u32 0xe7d3fbc8; u32 0x21e1cde6; u32 0xc33707d6; u32 0xf4d50d87; u32 0x455a14ed; u32 0xa9e3e905; u32 0xfcefa3f8; u32 0x676f02d9; u32 0x8d2a4c8a; u32 0xfffa3942; u32 0x8771f681; u32 0x6d9d6122; u32 0xfde5380c; u32 0xa4beea44; u32 0x4bdecfa9; u32 0xf6bb4b60; u32 0xbebfbc70; u32 0x289b7ec6; u32 0xeaa127fa; u32 0xd4ef3085; u32 0x4881d05; u32 0xd9d4d039; u32 0xe6db99e5; u32 0x1fa27cf8; u32 0xc4ac5665; u32 0xf4292244; u32 0x432aff97; u32 0xab9423a7; u32 0xfc93a039; u32 0x655b59c3; u32 0x8f0ccc92; u32 0xffeff47d; u32 0x85845dd1; u32 0x6fa87e4f; u32 0xfe2ce6e0; u32 0xa3014314; u32 0x4e0811a1; u32 0xf7537e82; u32 0xbd3af235; u32 0x2ad7d2bb; u32 0xeb86d391; ] module L = FStar.List.Tot let t : Seq.lseq uint32 64 = assert_norm (L.length t_as_list == 64); Seq.seq_of_list t_as_list let abcd_idx = (n: nat { n < 4 } ) let abcd_t = Seq.lseq uint32 4 let x_idx = (n: nat { n < 16 } ) let x_t = Seq.lseq uint32 16

Spec.MD5.fst

val t_idx : Type0

Spec.MD5.t_idx

Type0

Prims.Tot

let round4_op = round_op_gen i

let round4_op =

round_op_gen i

module Spec.MD5 (* Source: https://tools.ietf.org/html/rfc1321 *) open Lib.IntTypes open Spec.Hash.Definitions (* Section 3.3 *) inline_for_extraction let init_as_list : list uint32 = [ u32 0x67452301; u32 0xefcdab89; u32 0x98badcfe; u32 0x10325476; ] let init : words_state MD5 = Seq.seq_of_list init_as_list (* Section 3.4 *) inline_for_extraction let f (x y z: uint32) : Tot uint32 = (x &. y) |. ((~. x) &. z) inline_for_extraction let g (x y z: uint32) : Tot uint32 = (x &. z) |. (y &. (~. z)) inline_for_extraction let h (x y z: uint32) : Tot uint32 = x ^. y ^. z inline_for_extraction let i (x y z: uint32) : Tot uint32 = y ^. (x |. ~. z) (* Table T: specified in 3.4, defined in Appendix A.3, function MD5Transform *) inline_for_extraction let t_as_list : list uint32 = [ u32 0xd76aa478; u32 0xe8c7b756; u32 0x242070db; u32 0xc1bdceee; u32 0xf57c0faf; u32 0x4787c62a; u32 0xa8304613; u32 0xfd469501; u32 0x698098d8; u32 0x8b44f7af; u32 0xffff5bb1; u32 0x895cd7be; u32 0x6b901122; u32 0xfd987193; u32 0xa679438e; u32 0x49b40821; u32 0xf61e2562; u32 0xc040b340; u32 0x265e5a51; u32 0xe9b6c7aa; u32 0xd62f105d; u32 0x02441453; u32 0xd8a1e681; u32 0xe7d3fbc8; u32 0x21e1cde6; u32 0xc33707d6; u32 0xf4d50d87; u32 0x455a14ed; u32 0xa9e3e905; u32 0xfcefa3f8; u32 0x676f02d9; u32 0x8d2a4c8a; u32 0xfffa3942; u32 0x8771f681; u32 0x6d9d6122; u32 0xfde5380c; u32 0xa4beea44; u32 0x4bdecfa9; u32 0xf6bb4b60; u32 0xbebfbc70; u32 0x289b7ec6; u32 0xeaa127fa; u32 0xd4ef3085; u32 0x4881d05; u32 0xd9d4d039; u32 0xe6db99e5; u32 0x1fa27cf8; u32 0xc4ac5665; u32 0xf4292244; u32 0x432aff97; u32 0xab9423a7; u32 0xfc93a039; u32 0x655b59c3; u32 0x8f0ccc92; u32 0xffeff47d; u32 0x85845dd1; u32 0x6fa87e4f; u32 0xfe2ce6e0; u32 0xa3014314; u32 0x4e0811a1; u32 0xf7537e82; u32 0xbd3af235; u32 0x2ad7d2bb; u32 0xeb86d391; ] module L = FStar.List.Tot let t : Seq.lseq uint32 64 = assert_norm (L.length t_as_list == 64); Seq.seq_of_list t_as_list let abcd_idx = (n: nat { n < 4 } ) let abcd_t = Seq.lseq uint32 4 let x_idx = (n: nat { n < 16 } ) let x_t = Seq.lseq uint32 16 let t_idx = (n: nat { 1 <= n /\ n <= 64 } ) inline_for_extraction let rotate_idx = rotval U32 let round_op_gen_aux (f: (uint32 -> uint32 -> uint32 -> Tot uint32)) (abcd: abcd_t) (x: x_t) (a b c d: abcd_idx) (k: x_idx) (s: rotate_idx) (i: t_idx) : Tot abcd_t = let va = Seq.index abcd a in let vb = Seq.index abcd b in let vc = Seq.index abcd c in let vd = Seq.index abcd d in Seq.upd abcd a (vb +. ((va +. f vb vc vd +. Seq.index x k +. Seq.index t (i - 1)) <<<. s)) [@"opaque_to_smt"] let round_op_gen = round_op_gen_aux (* Round 1 *) let round1_op = round_op_gen f let ia : abcd_idx = 0 let ib : abcd_idx = 1 let ic : abcd_idx = 2 let id : abcd_idx = 3 let round1_aux (abcd: abcd_t) (x: x_t) : Tot abcd_t = let abcd = round1_op abcd x ia ib ic id 0 7ul 1 in let abcd = round1_op abcd x id ia ib ic 1 12ul 2 in let abcd = round1_op abcd x ic id ia ib 2 17ul 3 in let abcd = round1_op abcd x ib ic id ia 3 22ul 4 in let abcd = round1_op abcd x ia ib ic id 4 7ul 5 in let abcd = round1_op abcd x id ia ib ic 5 12ul 6 in let abcd = round1_op abcd x ic id ia ib 6 17ul 7 in let abcd = round1_op abcd x ib ic id ia 7 22ul 8 in let abcd = round1_op abcd x ia ib ic id 8 7ul 9 in let abcd = round1_op abcd x id ia ib ic 9 12ul 10 in let abcd = round1_op abcd x ic id ia ib 10 17ul 11 in let abcd = round1_op abcd x ib ic id ia 11 22ul 12 in let abcd = round1_op abcd x ia ib ic id 12 7ul 13 in let abcd = round1_op abcd x id ia ib ic 13 12ul 14 in let abcd = round1_op abcd x ic id ia ib 14 17ul 15 in let abcd = round1_op abcd x ib ic id ia 15 22ul 16 in abcd [@"opaque_to_smt"] let round1 = round1_aux let round2_op = round_op_gen g let round2_aux (abcd: abcd_t) (x: x_t) : Tot abcd_t = let abcd = round2_op abcd x ia ib ic id 1 5ul 17 in let abcd = round2_op abcd x id ia ib ic 6 9ul 18 in let abcd = round2_op abcd x ic id ia ib 11 14ul 19 in let abcd = round2_op abcd x ib ic id ia 0 20ul 20 in let abcd = round2_op abcd x ia ib ic id 5 5ul 21 in let abcd = round2_op abcd x id ia ib ic 10 9ul 22 in let abcd = round2_op abcd x ic id ia ib 15 14ul 23 in let abcd = round2_op abcd x ib ic id ia 4 20ul 24 in let abcd = round2_op abcd x ia ib ic id 9 5ul 25 in let abcd = round2_op abcd x id ia ib ic 14 9ul 26 in let abcd = round2_op abcd x ic id ia ib 3 14ul 27 in let abcd = round2_op abcd x ib ic id ia 8 20ul 28 in let abcd = round2_op abcd x ia ib ic id 13 5ul 29 in let abcd = round2_op abcd x id ia ib ic 2 9ul 30 in let abcd = round2_op abcd x ic id ia ib 7 14ul 31 in let abcd = round2_op abcd x ib ic id ia 12 20ul 32 in abcd [@"opaque_to_smt"] let round2 = round2_aux let round3_op = round_op_gen h let round3_aux (abcd: abcd_t) (x: x_t) : Tot abcd_t = let abcd = round3_op abcd x ia ib ic id 5 4ul 33 in let abcd = round3_op abcd x id ia ib ic 8 11ul 34 in let abcd = round3_op abcd x ic id ia ib 11 16ul 35 in let abcd = round3_op abcd x ib ic id ia 14 23ul 36 in let abcd = round3_op abcd x ia ib ic id 1 4ul 37 in let abcd = round3_op abcd x id ia ib ic 4 11ul 38 in let abcd = round3_op abcd x ic id ia ib 7 16ul 39 in let abcd = round3_op abcd x ib ic id ia 10 23ul 40 in let abcd = round3_op abcd x ia ib ic id 13 4ul 41 in let abcd = round3_op abcd x id ia ib ic 0 11ul 42 in let abcd = round3_op abcd x ic id ia ib 3 16ul 43 in let abcd = round3_op abcd x ib ic id ia 6 23ul 44 in let abcd = round3_op abcd x ia ib ic id 9 4ul 45 in let abcd = round3_op abcd x id ia ib ic 12 11ul 46 in let abcd = round3_op abcd x ic id ia ib 15 16ul 47 in let abcd = round3_op abcd x ib ic id ia 2 23ul 48 in abcd [@"opaque_to_smt"] let round3 = round3_aux

Spec.MD5.fst

val round4_op : abcd: Spec.MD5.abcd_t -> x: Spec.MD5.x_t -> a: Spec.MD5.abcd_idx -> b: Spec.MD5.abcd_idx -> c: Spec.MD5.abcd_idx -> d: Spec.MD5.abcd_idx -> k: Spec.MD5.x_idx -> s: Spec.MD5.rotate_idx -> i: Spec.MD5.t_idx -> Spec.MD5.abcd_t

Spec.MD5.round4_op

abcd: Spec.MD5.abcd_t -> x: Spec.MD5.x_t -> a: Spec.MD5.abcd_idx -> b: Spec.MD5.abcd_idx -> c: Spec.MD5.abcd_idx -> d: Spec.MD5.abcd_idx -> k: Spec.MD5.x_idx -> s: Spec.MD5.rotate_idx -> i: Spec.MD5.t_idx -> Spec.MD5.abcd_t

Prims.Tot

val i (x y z: uint32) : Tot uint32

let i (x y z: uint32) : Tot uint32 = y ^. (x |. ~. z)

val i (x y z: uint32) : Tot uint32 let i (x y z: uint32) : Tot uint32 =

y ^. (x |. ~.z)

module Spec.MD5 (* Source: https://tools.ietf.org/html/rfc1321 *) open Lib.IntTypes open Spec.Hash.Definitions (* Section 3.3 *) inline_for_extraction let init_as_list : list uint32 = [ u32 0x67452301; u32 0xefcdab89; u32 0x98badcfe; u32 0x10325476; ] let init : words_state MD5 = Seq.seq_of_list init_as_list (* Section 3.4 *) inline_for_extraction let f (x y z: uint32) : Tot uint32 = (x &. y) |. ((~. x) &. z) inline_for_extraction let g (x y z: uint32) : Tot uint32 = (x &. z) |. (y &. (~. z)) inline_for_extraction let h (x y z: uint32) : Tot uint32 = x ^. y ^. z inline_for_extraction

Spec.MD5.fst

val i (x y z: uint32) : Tot uint32

Spec.MD5.i

x: Lib.IntTypes.uint32 -> y: Lib.IntTypes.uint32 -> z: Lib.IntTypes.uint32 -> Lib.IntTypes.uint32

Prims.Tot

val f (x y z: uint32) : Tot uint32

let f (x y z: uint32) : Tot uint32 = (x &. y) |. ((~. x) &. z)

val f (x y z: uint32) : Tot uint32 let f (x y z: uint32) : Tot uint32 =

(x &. y) |. ((~.x) &. z)

module Spec.MD5 (* Source: https://tools.ietf.org/html/rfc1321 *) open Lib.IntTypes open Spec.Hash.Definitions (* Section 3.3 *) inline_for_extraction let init_as_list : list uint32 = [ u32 0x67452301; u32 0xefcdab89; u32 0x98badcfe; u32 0x10325476; ] let init : words_state MD5 = Seq.seq_of_list init_as_list (* Section 3.4 *) inline_for_extraction

Spec.MD5.fst

val f (x y z: uint32) : Tot uint32

Spec.MD5.f

x: Lib.IntTypes.uint32 -> y: Lib.IntTypes.uint32 -> z: Lib.IntTypes.uint32 -> Lib.IntTypes.uint32

Prims.Tot

let rotate_idx = rotval U32

let rotate_idx =

rotval U32

module Spec.MD5 (* Source: https://tools.ietf.org/html/rfc1321 *) open Lib.IntTypes open Spec.Hash.Definitions (* Section 3.3 *) inline_for_extraction let init_as_list : list uint32 = [ u32 0x67452301; u32 0xefcdab89; u32 0x98badcfe; u32 0x10325476; ] let init : words_state MD5 = Seq.seq_of_list init_as_list (* Section 3.4 *) inline_for_extraction let f (x y z: uint32) : Tot uint32 = (x &. y) |. ((~. x) &. z) inline_for_extraction let g (x y z: uint32) : Tot uint32 = (x &. z) |. (y &. (~. z)) inline_for_extraction let h (x y z: uint32) : Tot uint32 = x ^. y ^. z inline_for_extraction let i (x y z: uint32) : Tot uint32 = y ^. (x |. ~. z) (* Table T: specified in 3.4, defined in Appendix A.3, function MD5Transform *) inline_for_extraction let t_as_list : list uint32 = [ u32 0xd76aa478; u32 0xe8c7b756; u32 0x242070db; u32 0xc1bdceee; u32 0xf57c0faf; u32 0x4787c62a; u32 0xa8304613; u32 0xfd469501; u32 0x698098d8; u32 0x8b44f7af; u32 0xffff5bb1; u32 0x895cd7be; u32 0x6b901122; u32 0xfd987193; u32 0xa679438e; u32 0x49b40821; u32 0xf61e2562; u32 0xc040b340; u32 0x265e5a51; u32 0xe9b6c7aa; u32 0xd62f105d; u32 0x02441453; u32 0xd8a1e681; u32 0xe7d3fbc8; u32 0x21e1cde6; u32 0xc33707d6; u32 0xf4d50d87; u32 0x455a14ed; u32 0xa9e3e905; u32 0xfcefa3f8; u32 0x676f02d9; u32 0x8d2a4c8a; u32 0xfffa3942; u32 0x8771f681; u32 0x6d9d6122; u32 0xfde5380c; u32 0xa4beea44; u32 0x4bdecfa9; u32 0xf6bb4b60; u32 0xbebfbc70; u32 0x289b7ec6; u32 0xeaa127fa; u32 0xd4ef3085; u32 0x4881d05; u32 0xd9d4d039; u32 0xe6db99e5; u32 0x1fa27cf8; u32 0xc4ac5665; u32 0xf4292244; u32 0x432aff97; u32 0xab9423a7; u32 0xfc93a039; u32 0x655b59c3; u32 0x8f0ccc92; u32 0xffeff47d; u32 0x85845dd1; u32 0x6fa87e4f; u32 0xfe2ce6e0; u32 0xa3014314; u32 0x4e0811a1; u32 0xf7537e82; u32 0xbd3af235; u32 0x2ad7d2bb; u32 0xeb86d391; ] module L = FStar.List.Tot let t : Seq.lseq uint32 64 = assert_norm (L.length t_as_list == 64); Seq.seq_of_list t_as_list let abcd_idx = (n: nat { n < 4 } ) let abcd_t = Seq.lseq uint32 4 let x_idx = (n: nat { n < 16 } ) let x_t = Seq.lseq uint32 16 let t_idx = (n: nat { 1 <= n /\ n <= 64 } )

Spec.MD5.fst

val rotate_idx : Type0

Spec.MD5.rotate_idx

Type0

Prims.Tot

let round4 = round4_aux

let round4 =

round4_aux

module Spec.MD5 (* Source: https://tools.ietf.org/html/rfc1321 *) open Lib.IntTypes open Spec.Hash.Definitions (* Section 3.3 *) inline_for_extraction let init_as_list : list uint32 = [ u32 0x67452301; u32 0xefcdab89; u32 0x98badcfe; u32 0x10325476; ] let init : words_state MD5 = Seq.seq_of_list init_as_list (* Section 3.4 *) inline_for_extraction let f (x y z: uint32) : Tot uint32 = (x &. y) |. ((~. x) &. z) inline_for_extraction let g (x y z: uint32) : Tot uint32 = (x &. z) |. (y &. (~. z)) inline_for_extraction let h (x y z: uint32) : Tot uint32 = x ^. y ^. z inline_for_extraction let i (x y z: uint32) : Tot uint32 = y ^. (x |. ~. z) (* Table T: specified in 3.4, defined in Appendix A.3, function MD5Transform *) inline_for_extraction let t_as_list : list uint32 = [ u32 0xd76aa478; u32 0xe8c7b756; u32 0x242070db; u32 0xc1bdceee; u32 0xf57c0faf; u32 0x4787c62a; u32 0xa8304613; u32 0xfd469501; u32 0x698098d8; u32 0x8b44f7af; u32 0xffff5bb1; u32 0x895cd7be; u32 0x6b901122; u32 0xfd987193; u32 0xa679438e; u32 0x49b40821; u32 0xf61e2562; u32 0xc040b340; u32 0x265e5a51; u32 0xe9b6c7aa; u32 0xd62f105d; u32 0x02441453; u32 0xd8a1e681; u32 0xe7d3fbc8; u32 0x21e1cde6; u32 0xc33707d6; u32 0xf4d50d87; u32 0x455a14ed; u32 0xa9e3e905; u32 0xfcefa3f8; u32 0x676f02d9; u32 0x8d2a4c8a; u32 0xfffa3942; u32 0x8771f681; u32 0x6d9d6122; u32 0xfde5380c; u32 0xa4beea44; u32 0x4bdecfa9; u32 0xf6bb4b60; u32 0xbebfbc70; u32 0x289b7ec6; u32 0xeaa127fa; u32 0xd4ef3085; u32 0x4881d05; u32 0xd9d4d039; u32 0xe6db99e5; u32 0x1fa27cf8; u32 0xc4ac5665; u32 0xf4292244; u32 0x432aff97; u32 0xab9423a7; u32 0xfc93a039; u32 0x655b59c3; u32 0x8f0ccc92; u32 0xffeff47d; u32 0x85845dd1; u32 0x6fa87e4f; u32 0xfe2ce6e0; u32 0xa3014314; u32 0x4e0811a1; u32 0xf7537e82; u32 0xbd3af235; u32 0x2ad7d2bb; u32 0xeb86d391; ] module L = FStar.List.Tot let t : Seq.lseq uint32 64 = assert_norm (L.length t_as_list == 64); Seq.seq_of_list t_as_list let abcd_idx = (n: nat { n < 4 } ) let abcd_t = Seq.lseq uint32 4 let x_idx = (n: nat { n < 16 } ) let x_t = Seq.lseq uint32 16 let t_idx = (n: nat { 1 <= n /\ n <= 64 } ) inline_for_extraction let rotate_idx = rotval U32 let round_op_gen_aux (f: (uint32 -> uint32 -> uint32 -> Tot uint32)) (abcd: abcd_t) (x: x_t) (a b c d: abcd_idx) (k: x_idx) (s: rotate_idx) (i: t_idx) : Tot abcd_t = let va = Seq.index abcd a in let vb = Seq.index abcd b in let vc = Seq.index abcd c in let vd = Seq.index abcd d in Seq.upd abcd a (vb +. ((va +. f vb vc vd +. Seq.index x k +. Seq.index t (i - 1)) <<<. s)) [@"opaque_to_smt"] let round_op_gen = round_op_gen_aux (* Round 1 *) let round1_op = round_op_gen f let ia : abcd_idx = 0 let ib : abcd_idx = 1 let ic : abcd_idx = 2 let id : abcd_idx = 3 let round1_aux (abcd: abcd_t) (x: x_t) : Tot abcd_t = let abcd = round1_op abcd x ia ib ic id 0 7ul 1 in let abcd = round1_op abcd x id ia ib ic 1 12ul 2 in let abcd = round1_op abcd x ic id ia ib 2 17ul 3 in let abcd = round1_op abcd x ib ic id ia 3 22ul 4 in let abcd = round1_op abcd x ia ib ic id 4 7ul 5 in let abcd = round1_op abcd x id ia ib ic 5 12ul 6 in let abcd = round1_op abcd x ic id ia ib 6 17ul 7 in let abcd = round1_op abcd x ib ic id ia 7 22ul 8 in let abcd = round1_op abcd x ia ib ic id 8 7ul 9 in let abcd = round1_op abcd x id ia ib ic 9 12ul 10 in let abcd = round1_op abcd x ic id ia ib 10 17ul 11 in let abcd = round1_op abcd x ib ic id ia 11 22ul 12 in let abcd = round1_op abcd x ia ib ic id 12 7ul 13 in let abcd = round1_op abcd x id ia ib ic 13 12ul 14 in let abcd = round1_op abcd x ic id ia ib 14 17ul 15 in let abcd = round1_op abcd x ib ic id ia 15 22ul 16 in abcd [@"opaque_to_smt"] let round1 = round1_aux let round2_op = round_op_gen g let round2_aux (abcd: abcd_t) (x: x_t) : Tot abcd_t = let abcd = round2_op abcd x ia ib ic id 1 5ul 17 in let abcd = round2_op abcd x id ia ib ic 6 9ul 18 in let abcd = round2_op abcd x ic id ia ib 11 14ul 19 in let abcd = round2_op abcd x ib ic id ia 0 20ul 20 in let abcd = round2_op abcd x ia ib ic id 5 5ul 21 in let abcd = round2_op abcd x id ia ib ic 10 9ul 22 in let abcd = round2_op abcd x ic id ia ib 15 14ul 23 in let abcd = round2_op abcd x ib ic id ia 4 20ul 24 in let abcd = round2_op abcd x ia ib ic id 9 5ul 25 in let abcd = round2_op abcd x id ia ib ic 14 9ul 26 in let abcd = round2_op abcd x ic id ia ib 3 14ul 27 in let abcd = round2_op abcd x ib ic id ia 8 20ul 28 in let abcd = round2_op abcd x ia ib ic id 13 5ul 29 in let abcd = round2_op abcd x id ia ib ic 2 9ul 30 in let abcd = round2_op abcd x ic id ia ib 7 14ul 31 in let abcd = round2_op abcd x ib ic id ia 12 20ul 32 in abcd [@"opaque_to_smt"] let round2 = round2_aux let round3_op = round_op_gen h let round3_aux (abcd: abcd_t) (x: x_t) : Tot abcd_t = let abcd = round3_op abcd x ia ib ic id 5 4ul 33 in let abcd = round3_op abcd x id ia ib ic 8 11ul 34 in let abcd = round3_op abcd x ic id ia ib 11 16ul 35 in let abcd = round3_op abcd x ib ic id ia 14 23ul 36 in let abcd = round3_op abcd x ia ib ic id 1 4ul 37 in let abcd = round3_op abcd x id ia ib ic 4 11ul 38 in let abcd = round3_op abcd x ic id ia ib 7 16ul 39 in let abcd = round3_op abcd x ib ic id ia 10 23ul 40 in let abcd = round3_op abcd x ia ib ic id 13 4ul 41 in let abcd = round3_op abcd x id ia ib ic 0 11ul 42 in let abcd = round3_op abcd x ic id ia ib 3 16ul 43 in let abcd = round3_op abcd x ib ic id ia 6 23ul 44 in let abcd = round3_op abcd x ia ib ic id 9 4ul 45 in let abcd = round3_op abcd x id ia ib ic 12 11ul 46 in let abcd = round3_op abcd x ic id ia ib 15 16ul 47 in let abcd = round3_op abcd x ib ic id ia 2 23ul 48 in abcd [@"opaque_to_smt"] let round3 = round3_aux let round4_op = round_op_gen i let round4_aux (abcd: abcd_t) (x: x_t) : Tot abcd_t = let abcd = round4_op abcd x ia ib ic id 0 6ul 49 in let abcd = round4_op abcd x id ia ib ic 7 10ul 50 in let abcd = round4_op abcd x ic id ia ib 14 15ul 51 in let abcd = round4_op abcd x ib ic id ia 5 21ul 52 in let abcd = round4_op abcd x ia ib ic id 12 6ul 53 in let abcd = round4_op abcd x id ia ib ic 3 10ul 54 in let abcd = round4_op abcd x ic id ia ib 10 15ul 55 in let abcd = round4_op abcd x ib ic id ia 1 21ul 56 in let abcd = round4_op abcd x ia ib ic id 8 6ul 57 in let abcd = round4_op abcd x id ia ib ic 15 10ul 58 in let abcd = round4_op abcd x ic id ia ib 6 15ul 59 in let abcd = round4_op abcd x ib ic id ia 13 21ul 60 in let abcd = round4_op abcd x ia ib ic id 4 6ul 61 in let abcd = round4_op abcd x id ia ib ic 11 10ul 62 in let abcd = round4_op abcd x ic id ia ib 2 15ul 63 in let abcd = round4_op abcd x ib ic id ia 9 21ul 64 in abcd

Spec.MD5.fst

val round4 : abcd: Spec.MD5.abcd_t -> x: Spec.MD5.x_t -> Spec.MD5.abcd_t

Spec.MD5.round4

abcd: Spec.MD5.abcd_t -> x: Spec.MD5.x_t -> Spec.MD5.abcd_t

Prims.Tot

let round3_op = round_op_gen h

let round3_op =

round_op_gen h

module Spec.MD5 (* Source: https://tools.ietf.org/html/rfc1321 *) open Lib.IntTypes open Spec.Hash.Definitions (* Section 3.3 *) inline_for_extraction let init_as_list : list uint32 = [ u32 0x67452301; u32 0xefcdab89; u32 0x98badcfe; u32 0x10325476; ] let init : words_state MD5 = Seq.seq_of_list init_as_list (* Section 3.4 *) inline_for_extraction let f (x y z: uint32) : Tot uint32 = (x &. y) |. ((~. x) &. z) inline_for_extraction let g (x y z: uint32) : Tot uint32 = (x &. z) |. (y &. (~. z)) inline_for_extraction let h (x y z: uint32) : Tot uint32 = x ^. y ^. z inline_for_extraction let i (x y z: uint32) : Tot uint32 = y ^. (x |. ~. z) (* Table T: specified in 3.4, defined in Appendix A.3, function MD5Transform *) inline_for_extraction let t_as_list : list uint32 = [ u32 0xd76aa478; u32 0xe8c7b756; u32 0x242070db; u32 0xc1bdceee; u32 0xf57c0faf; u32 0x4787c62a; u32 0xa8304613; u32 0xfd469501; u32 0x698098d8; u32 0x8b44f7af; u32 0xffff5bb1; u32 0x895cd7be; u32 0x6b901122; u32 0xfd987193; u32 0xa679438e; u32 0x49b40821; u32 0xf61e2562; u32 0xc040b340; u32 0x265e5a51; u32 0xe9b6c7aa; u32 0xd62f105d; u32 0x02441453; u32 0xd8a1e681; u32 0xe7d3fbc8; u32 0x21e1cde6; u32 0xc33707d6; u32 0xf4d50d87; u32 0x455a14ed; u32 0xa9e3e905; u32 0xfcefa3f8; u32 0x676f02d9; u32 0x8d2a4c8a; u32 0xfffa3942; u32 0x8771f681; u32 0x6d9d6122; u32 0xfde5380c; u32 0xa4beea44; u32 0x4bdecfa9; u32 0xf6bb4b60; u32 0xbebfbc70; u32 0x289b7ec6; u32 0xeaa127fa; u32 0xd4ef3085; u32 0x4881d05; u32 0xd9d4d039; u32 0xe6db99e5; u32 0x1fa27cf8; u32 0xc4ac5665; u32 0xf4292244; u32 0x432aff97; u32 0xab9423a7; u32 0xfc93a039; u32 0x655b59c3; u32 0x8f0ccc92; u32 0xffeff47d; u32 0x85845dd1; u32 0x6fa87e4f; u32 0xfe2ce6e0; u32 0xa3014314; u32 0x4e0811a1; u32 0xf7537e82; u32 0xbd3af235; u32 0x2ad7d2bb; u32 0xeb86d391; ] module L = FStar.List.Tot let t : Seq.lseq uint32 64 = assert_norm (L.length t_as_list == 64); Seq.seq_of_list t_as_list let abcd_idx = (n: nat { n < 4 } ) let abcd_t = Seq.lseq uint32 4 let x_idx = (n: nat { n < 16 } ) let x_t = Seq.lseq uint32 16 let t_idx = (n: nat { 1 <= n /\ n <= 64 } ) inline_for_extraction let rotate_idx = rotval U32 let round_op_gen_aux (f: (uint32 -> uint32 -> uint32 -> Tot uint32)) (abcd: abcd_t) (x: x_t) (a b c d: abcd_idx) (k: x_idx) (s: rotate_idx) (i: t_idx) : Tot abcd_t = let va = Seq.index abcd a in let vb = Seq.index abcd b in let vc = Seq.index abcd c in let vd = Seq.index abcd d in Seq.upd abcd a (vb +. ((va +. f vb vc vd +. Seq.index x k +. Seq.index t (i - 1)) <<<. s)) [@"opaque_to_smt"] let round_op_gen = round_op_gen_aux (* Round 1 *) let round1_op = round_op_gen f let ia : abcd_idx = 0 let ib : abcd_idx = 1 let ic : abcd_idx = 2 let id : abcd_idx = 3 let round1_aux (abcd: abcd_t) (x: x_t) : Tot abcd_t = let abcd = round1_op abcd x ia ib ic id 0 7ul 1 in let abcd = round1_op abcd x id ia ib ic 1 12ul 2 in let abcd = round1_op abcd x ic id ia ib 2 17ul 3 in let abcd = round1_op abcd x ib ic id ia 3 22ul 4 in let abcd = round1_op abcd x ia ib ic id 4 7ul 5 in let abcd = round1_op abcd x id ia ib ic 5 12ul 6 in let abcd = round1_op abcd x ic id ia ib 6 17ul 7 in let abcd = round1_op abcd x ib ic id ia 7 22ul 8 in let abcd = round1_op abcd x ia ib ic id 8 7ul 9 in let abcd = round1_op abcd x id ia ib ic 9 12ul 10 in let abcd = round1_op abcd x ic id ia ib 10 17ul 11 in let abcd = round1_op abcd x ib ic id ia 11 22ul 12 in let abcd = round1_op abcd x ia ib ic id 12 7ul 13 in let abcd = round1_op abcd x id ia ib ic 13 12ul 14 in let abcd = round1_op abcd x ic id ia ib 14 17ul 15 in let abcd = round1_op abcd x ib ic id ia 15 22ul 16 in abcd [@"opaque_to_smt"] let round1 = round1_aux let round2_op = round_op_gen g let round2_aux (abcd: abcd_t) (x: x_t) : Tot abcd_t = let abcd = round2_op abcd x ia ib ic id 1 5ul 17 in let abcd = round2_op abcd x id ia ib ic 6 9ul 18 in let abcd = round2_op abcd x ic id ia ib 11 14ul 19 in let abcd = round2_op abcd x ib ic id ia 0 20ul 20 in let abcd = round2_op abcd x ia ib ic id 5 5ul 21 in let abcd = round2_op abcd x id ia ib ic 10 9ul 22 in let abcd = round2_op abcd x ic id ia ib 15 14ul 23 in let abcd = round2_op abcd x ib ic id ia 4 20ul 24 in let abcd = round2_op abcd x ia ib ic id 9 5ul 25 in let abcd = round2_op abcd x id ia ib ic 14 9ul 26 in let abcd = round2_op abcd x ic id ia ib 3 14ul 27 in let abcd = round2_op abcd x ib ic id ia 8 20ul 28 in let abcd = round2_op abcd x ia ib ic id 13 5ul 29 in let abcd = round2_op abcd x id ia ib ic 2 9ul 30 in let abcd = round2_op abcd x ic id ia ib 7 14ul 31 in let abcd = round2_op abcd x ib ic id ia 12 20ul 32 in abcd [@"opaque_to_smt"] let round2 = round2_aux

Spec.MD5.fst

val round3_op : abcd: Spec.MD5.abcd_t -> x: Spec.MD5.x_t -> a: Spec.MD5.abcd_idx -> b: Spec.MD5.abcd_idx -> c: Spec.MD5.abcd_idx -> d: Spec.MD5.abcd_idx -> k: Spec.MD5.x_idx -> s: Spec.MD5.rotate_idx -> i: Spec.MD5.t_idx -> Spec.MD5.abcd_t

Spec.MD5.round3_op

abcd: Spec.MD5.abcd_t -> x: Spec.MD5.x_t -> a: Spec.MD5.abcd_idx -> b: Spec.MD5.abcd_idx -> c: Spec.MD5.abcd_idx -> d: Spec.MD5.abcd_idx -> k: Spec.MD5.x_idx -> s: Spec.MD5.rotate_idx -> i: Spec.MD5.t_idx -> Spec.MD5.abcd_t

Prims.Tot

val ib:abcd_idx

let ib : abcd_idx = 1

val ib:abcd_idx let ib:abcd_idx =

1

module Spec.MD5 (* Source: https://tools.ietf.org/html/rfc1321 *) open Lib.IntTypes open Spec.Hash.Definitions (* Section 3.3 *) inline_for_extraction let init_as_list : list uint32 = [ u32 0x67452301; u32 0xefcdab89; u32 0x98badcfe; u32 0x10325476; ] let init : words_state MD5 = Seq.seq_of_list init_as_list (* Section 3.4 *) inline_for_extraction let f (x y z: uint32) : Tot uint32 = (x &. y) |. ((~. x) &. z) inline_for_extraction let g (x y z: uint32) : Tot uint32 = (x &. z) |. (y &. (~. z)) inline_for_extraction let h (x y z: uint32) : Tot uint32 = x ^. y ^. z inline_for_extraction let i (x y z: uint32) : Tot uint32 = y ^. (x |. ~. z) (* Table T: specified in 3.4, defined in Appendix A.3, function MD5Transform *) inline_for_extraction let t_as_list : list uint32 = [ u32 0xd76aa478; u32 0xe8c7b756; u32 0x242070db; u32 0xc1bdceee; u32 0xf57c0faf; u32 0x4787c62a; u32 0xa8304613; u32 0xfd469501; u32 0x698098d8; u32 0x8b44f7af; u32 0xffff5bb1; u32 0x895cd7be; u32 0x6b901122; u32 0xfd987193; u32 0xa679438e; u32 0x49b40821; u32 0xf61e2562; u32 0xc040b340; u32 0x265e5a51; u32 0xe9b6c7aa; u32 0xd62f105d; u32 0x02441453; u32 0xd8a1e681; u32 0xe7d3fbc8; u32 0x21e1cde6; u32 0xc33707d6; u32 0xf4d50d87; u32 0x455a14ed; u32 0xa9e3e905; u32 0xfcefa3f8; u32 0x676f02d9; u32 0x8d2a4c8a; u32 0xfffa3942; u32 0x8771f681; u32 0x6d9d6122; u32 0xfde5380c; u32 0xa4beea44; u32 0x4bdecfa9; u32 0xf6bb4b60; u32 0xbebfbc70; u32 0x289b7ec6; u32 0xeaa127fa; u32 0xd4ef3085; u32 0x4881d05; u32 0xd9d4d039; u32 0xe6db99e5; u32 0x1fa27cf8; u32 0xc4ac5665; u32 0xf4292244; u32 0x432aff97; u32 0xab9423a7; u32 0xfc93a039; u32 0x655b59c3; u32 0x8f0ccc92; u32 0xffeff47d; u32 0x85845dd1; u32 0x6fa87e4f; u32 0xfe2ce6e0; u32 0xa3014314; u32 0x4e0811a1; u32 0xf7537e82; u32 0xbd3af235; u32 0x2ad7d2bb; u32 0xeb86d391; ] module L = FStar.List.Tot let t : Seq.lseq uint32 64 = assert_norm (L.length t_as_list == 64); Seq.seq_of_list t_as_list let abcd_idx = (n: nat { n < 4 } ) let abcd_t = Seq.lseq uint32 4 let x_idx = (n: nat { n < 16 } ) let x_t = Seq.lseq uint32 16 let t_idx = (n: nat { 1 <= n /\ n <= 64 } ) inline_for_extraction let rotate_idx = rotval U32 let round_op_gen_aux (f: (uint32 -> uint32 -> uint32 -> Tot uint32)) (abcd: abcd_t) (x: x_t) (a b c d: abcd_idx) (k: x_idx) (s: rotate_idx) (i: t_idx) : Tot abcd_t = let va = Seq.index abcd a in let vb = Seq.index abcd b in let vc = Seq.index abcd c in let vd = Seq.index abcd d in Seq.upd abcd a (vb +. ((va +. f vb vc vd +. Seq.index x k +. Seq.index t (i - 1)) <<<. s)) [@"opaque_to_smt"] let round_op_gen = round_op_gen_aux (* Round 1 *) let round1_op = round_op_gen f

Spec.MD5.fst

val ib:abcd_idx

Spec.MD5.ib

Spec.MD5.abcd_idx

Prims.Tot

let round1 = round1_aux

let round1 =

round1_aux

module Spec.MD5 (* Source: https://tools.ietf.org/html/rfc1321 *) open Lib.IntTypes open Spec.Hash.Definitions (* Section 3.3 *) inline_for_extraction let init_as_list : list uint32 = [ u32 0x67452301; u32 0xefcdab89; u32 0x98badcfe; u32 0x10325476; ] let init : words_state MD5 = Seq.seq_of_list init_as_list (* Section 3.4 *) inline_for_extraction let f (x y z: uint32) : Tot uint32 = (x &. y) |. ((~. x) &. z) inline_for_extraction let g (x y z: uint32) : Tot uint32 = (x &. z) |. (y &. (~. z)) inline_for_extraction let h (x y z: uint32) : Tot uint32 = x ^. y ^. z inline_for_extraction let i (x y z: uint32) : Tot uint32 = y ^. (x |. ~. z) (* Table T: specified in 3.4, defined in Appendix A.3, function MD5Transform *) inline_for_extraction let t_as_list : list uint32 = [ u32 0xd76aa478; u32 0xe8c7b756; u32 0x242070db; u32 0xc1bdceee; u32 0xf57c0faf; u32 0x4787c62a; u32 0xa8304613; u32 0xfd469501; u32 0x698098d8; u32 0x8b44f7af; u32 0xffff5bb1; u32 0x895cd7be; u32 0x6b901122; u32 0xfd987193; u32 0xa679438e; u32 0x49b40821; u32 0xf61e2562; u32 0xc040b340; u32 0x265e5a51; u32 0xe9b6c7aa; u32 0xd62f105d; u32 0x02441453; u32 0xd8a1e681; u32 0xe7d3fbc8; u32 0x21e1cde6; u32 0xc33707d6; u32 0xf4d50d87; u32 0x455a14ed; u32 0xa9e3e905; u32 0xfcefa3f8; u32 0x676f02d9; u32 0x8d2a4c8a; u32 0xfffa3942; u32 0x8771f681; u32 0x6d9d6122; u32 0xfde5380c; u32 0xa4beea44; u32 0x4bdecfa9; u32 0xf6bb4b60; u32 0xbebfbc70; u32 0x289b7ec6; u32 0xeaa127fa; u32 0xd4ef3085; u32 0x4881d05; u32 0xd9d4d039; u32 0xe6db99e5; u32 0x1fa27cf8; u32 0xc4ac5665; u32 0xf4292244; u32 0x432aff97; u32 0xab9423a7; u32 0xfc93a039; u32 0x655b59c3; u32 0x8f0ccc92; u32 0xffeff47d; u32 0x85845dd1; u32 0x6fa87e4f; u32 0xfe2ce6e0; u32 0xa3014314; u32 0x4e0811a1; u32 0xf7537e82; u32 0xbd3af235; u32 0x2ad7d2bb; u32 0xeb86d391; ] module L = FStar.List.Tot let t : Seq.lseq uint32 64 = assert_norm (L.length t_as_list == 64); Seq.seq_of_list t_as_list let abcd_idx = (n: nat { n < 4 } ) let abcd_t = Seq.lseq uint32 4 let x_idx = (n: nat { n < 16 } ) let x_t = Seq.lseq uint32 16 let t_idx = (n: nat { 1 <= n /\ n <= 64 } ) inline_for_extraction let rotate_idx = rotval U32 let round_op_gen_aux (f: (uint32 -> uint32 -> uint32 -> Tot uint32)) (abcd: abcd_t) (x: x_t) (a b c d: abcd_idx) (k: x_idx) (s: rotate_idx) (i: t_idx) : Tot abcd_t = let va = Seq.index abcd a in let vb = Seq.index abcd b in let vc = Seq.index abcd c in let vd = Seq.index abcd d in Seq.upd abcd a (vb +. ((va +. f vb vc vd +. Seq.index x k +. Seq.index t (i - 1)) <<<. s)) [@"opaque_to_smt"] let round_op_gen = round_op_gen_aux (* Round 1 *) let round1_op = round_op_gen f let ia : abcd_idx = 0 let ib : abcd_idx = 1 let ic : abcd_idx = 2 let id : abcd_idx = 3 let round1_aux (abcd: abcd_t) (x: x_t) : Tot abcd_t = let abcd = round1_op abcd x ia ib ic id 0 7ul 1 in let abcd = round1_op abcd x id ia ib ic 1 12ul 2 in let abcd = round1_op abcd x ic id ia ib 2 17ul 3 in let abcd = round1_op abcd x ib ic id ia 3 22ul 4 in let abcd = round1_op abcd x ia ib ic id 4 7ul 5 in let abcd = round1_op abcd x id ia ib ic 5 12ul 6 in let abcd = round1_op abcd x ic id ia ib 6 17ul 7 in let abcd = round1_op abcd x ib ic id ia 7 22ul 8 in let abcd = round1_op abcd x ia ib ic id 8 7ul 9 in let abcd = round1_op abcd x id ia ib ic 9 12ul 10 in let abcd = round1_op abcd x ic id ia ib 10 17ul 11 in let abcd = round1_op abcd x ib ic id ia 11 22ul 12 in let abcd = round1_op abcd x ia ib ic id 12 7ul 13 in let abcd = round1_op abcd x id ia ib ic 13 12ul 14 in let abcd = round1_op abcd x ic id ia ib 14 17ul 15 in let abcd = round1_op abcd x ib ic id ia 15 22ul 16 in abcd

Spec.MD5.fst

val round1 : abcd: Spec.MD5.abcd_t -> x: Spec.MD5.x_t -> Spec.MD5.abcd_t

Spec.MD5.round1

abcd: Spec.MD5.abcd_t -> x: Spec.MD5.x_t -> Spec.MD5.abcd_t

Prims.Tot

let round2 = round2_aux

let round2 =

round2_aux

module Spec.MD5 (* Source: https://tools.ietf.org/html/rfc1321 *) open Lib.IntTypes open Spec.Hash.Definitions (* Section 3.3 *) inline_for_extraction let init_as_list : list uint32 = [ u32 0x67452301; u32 0xefcdab89; u32 0x98badcfe; u32 0x10325476; ] let init : words_state MD5 = Seq.seq_of_list init_as_list (* Section 3.4 *) inline_for_extraction let f (x y z: uint32) : Tot uint32 = (x &. y) |. ((~. x) &. z) inline_for_extraction let g (x y z: uint32) : Tot uint32 = (x &. z) |. (y &. (~. z)) inline_for_extraction let h (x y z: uint32) : Tot uint32 = x ^. y ^. z inline_for_extraction let i (x y z: uint32) : Tot uint32 = y ^. (x |. ~. z) (* Table T: specified in 3.4, defined in Appendix A.3, function MD5Transform *) inline_for_extraction let t_as_list : list uint32 = [ u32 0xd76aa478; u32 0xe8c7b756; u32 0x242070db; u32 0xc1bdceee; u32 0xf57c0faf; u32 0x4787c62a; u32 0xa8304613; u32 0xfd469501; u32 0x698098d8; u32 0x8b44f7af; u32 0xffff5bb1; u32 0x895cd7be; u32 0x6b901122; u32 0xfd987193; u32 0xa679438e; u32 0x49b40821; u32 0xf61e2562; u32 0xc040b340; u32 0x265e5a51; u32 0xe9b6c7aa; u32 0xd62f105d; u32 0x02441453; u32 0xd8a1e681; u32 0xe7d3fbc8; u32 0x21e1cde6; u32 0xc33707d6; u32 0xf4d50d87; u32 0x455a14ed; u32 0xa9e3e905; u32 0xfcefa3f8; u32 0x676f02d9; u32 0x8d2a4c8a; u32 0xfffa3942; u32 0x8771f681; u32 0x6d9d6122; u32 0xfde5380c; u32 0xa4beea44; u32 0x4bdecfa9; u32 0xf6bb4b60; u32 0xbebfbc70; u32 0x289b7ec6; u32 0xeaa127fa; u32 0xd4ef3085; u32 0x4881d05; u32 0xd9d4d039; u32 0xe6db99e5; u32 0x1fa27cf8; u32 0xc4ac5665; u32 0xf4292244; u32 0x432aff97; u32 0xab9423a7; u32 0xfc93a039; u32 0x655b59c3; u32 0x8f0ccc92; u32 0xffeff47d; u32 0x85845dd1; u32 0x6fa87e4f; u32 0xfe2ce6e0; u32 0xa3014314; u32 0x4e0811a1; u32 0xf7537e82; u32 0xbd3af235; u32 0x2ad7d2bb; u32 0xeb86d391; ] module L = FStar.List.Tot let t : Seq.lseq uint32 64 = assert_norm (L.length t_as_list == 64); Seq.seq_of_list t_as_list let abcd_idx = (n: nat { n < 4 } ) let abcd_t = Seq.lseq uint32 4 let x_idx = (n: nat { n < 16 } ) let x_t = Seq.lseq uint32 16 let t_idx = (n: nat { 1 <= n /\ n <= 64 } ) inline_for_extraction let rotate_idx = rotval U32 let round_op_gen_aux (f: (uint32 -> uint32 -> uint32 -> Tot uint32)) (abcd: abcd_t) (x: x_t) (a b c d: abcd_idx) (k: x_idx) (s: rotate_idx) (i: t_idx) : Tot abcd_t = let va = Seq.index abcd a in let vb = Seq.index abcd b in let vc = Seq.index abcd c in let vd = Seq.index abcd d in Seq.upd abcd a (vb +. ((va +. f vb vc vd +. Seq.index x k +. Seq.index t (i - 1)) <<<. s)) [@"opaque_to_smt"] let round_op_gen = round_op_gen_aux (* Round 1 *) let round1_op = round_op_gen f let ia : abcd_idx = 0 let ib : abcd_idx = 1 let ic : abcd_idx = 2 let id : abcd_idx = 3 let round1_aux (abcd: abcd_t) (x: x_t) : Tot abcd_t = let abcd = round1_op abcd x ia ib ic id 0 7ul 1 in let abcd = round1_op abcd x id ia ib ic 1 12ul 2 in let abcd = round1_op abcd x ic id ia ib 2 17ul 3 in let abcd = round1_op abcd x ib ic id ia 3 22ul 4 in let abcd = round1_op abcd x ia ib ic id 4 7ul 5 in let abcd = round1_op abcd x id ia ib ic 5 12ul 6 in let abcd = round1_op abcd x ic id ia ib 6 17ul 7 in let abcd = round1_op abcd x ib ic id ia 7 22ul 8 in let abcd = round1_op abcd x ia ib ic id 8 7ul 9 in let abcd = round1_op abcd x id ia ib ic 9 12ul 10 in let abcd = round1_op abcd x ic id ia ib 10 17ul 11 in let abcd = round1_op abcd x ib ic id ia 11 22ul 12 in let abcd = round1_op abcd x ia ib ic id 12 7ul 13 in let abcd = round1_op abcd x id ia ib ic 13 12ul 14 in let abcd = round1_op abcd x ic id ia ib 14 17ul 15 in let abcd = round1_op abcd x ib ic id ia 15 22ul 16 in abcd [@"opaque_to_smt"] let round1 = round1_aux let round2_op = round_op_gen g let round2_aux (abcd: abcd_t) (x: x_t) : Tot abcd_t = let abcd = round2_op abcd x ia ib ic id 1 5ul 17 in let abcd = round2_op abcd x id ia ib ic 6 9ul 18 in let abcd = round2_op abcd x ic id ia ib 11 14ul 19 in let abcd = round2_op abcd x ib ic id ia 0 20ul 20 in let abcd = round2_op abcd x ia ib ic id 5 5ul 21 in let abcd = round2_op abcd x id ia ib ic 10 9ul 22 in let abcd = round2_op abcd x ic id ia ib 15 14ul 23 in let abcd = round2_op abcd x ib ic id ia 4 20ul 24 in let abcd = round2_op abcd x ia ib ic id 9 5ul 25 in let abcd = round2_op abcd x id ia ib ic 14 9ul 26 in let abcd = round2_op abcd x ic id ia ib 3 14ul 27 in let abcd = round2_op abcd x ib ic id ia 8 20ul 28 in let abcd = round2_op abcd x ia ib ic id 13 5ul 29 in let abcd = round2_op abcd x id ia ib ic 2 9ul 30 in let abcd = round2_op abcd x ic id ia ib 7 14ul 31 in let abcd = round2_op abcd x ib ic id ia 12 20ul 32 in abcd

Spec.MD5.fst

val round2 : abcd: Spec.MD5.abcd_t -> x: Spec.MD5.x_t -> Spec.MD5.abcd_t

Spec.MD5.round2

abcd: Spec.MD5.abcd_t -> x: Spec.MD5.x_t -> Spec.MD5.abcd_t

Prims.Tot

let round1_op = round_op_gen f

let round1_op =

round_op_gen f

module Spec.MD5 (* Source: https://tools.ietf.org/html/rfc1321 *) open Lib.IntTypes open Spec.Hash.Definitions (* Section 3.3 *) inline_for_extraction let init_as_list : list uint32 = [ u32 0x67452301; u32 0xefcdab89; u32 0x98badcfe; u32 0x10325476; ] let init : words_state MD5 = Seq.seq_of_list init_as_list (* Section 3.4 *) inline_for_extraction let f (x y z: uint32) : Tot uint32 = (x &. y) |. ((~. x) &. z) inline_for_extraction let g (x y z: uint32) : Tot uint32 = (x &. z) |. (y &. (~. z)) inline_for_extraction let h (x y z: uint32) : Tot uint32 = x ^. y ^. z inline_for_extraction let i (x y z: uint32) : Tot uint32 = y ^. (x |. ~. z) (* Table T: specified in 3.4, defined in Appendix A.3, function MD5Transform *) inline_for_extraction let t_as_list : list uint32 = [ u32 0xd76aa478; u32 0xe8c7b756; u32 0x242070db; u32 0xc1bdceee; u32 0xf57c0faf; u32 0x4787c62a; u32 0xa8304613; u32 0xfd469501; u32 0x698098d8; u32 0x8b44f7af; u32 0xffff5bb1; u32 0x895cd7be; u32 0x6b901122; u32 0xfd987193; u32 0xa679438e; u32 0x49b40821; u32 0xf61e2562; u32 0xc040b340; u32 0x265e5a51; u32 0xe9b6c7aa; u32 0xd62f105d; u32 0x02441453; u32 0xd8a1e681; u32 0xe7d3fbc8; u32 0x21e1cde6; u32 0xc33707d6; u32 0xf4d50d87; u32 0x455a14ed; u32 0xa9e3e905; u32 0xfcefa3f8; u32 0x676f02d9; u32 0x8d2a4c8a; u32 0xfffa3942; u32 0x8771f681; u32 0x6d9d6122; u32 0xfde5380c; u32 0xa4beea44; u32 0x4bdecfa9; u32 0xf6bb4b60; u32 0xbebfbc70; u32 0x289b7ec6; u32 0xeaa127fa; u32 0xd4ef3085; u32 0x4881d05; u32 0xd9d4d039; u32 0xe6db99e5; u32 0x1fa27cf8; u32 0xc4ac5665; u32 0xf4292244; u32 0x432aff97; u32 0xab9423a7; u32 0xfc93a039; u32 0x655b59c3; u32 0x8f0ccc92; u32 0xffeff47d; u32 0x85845dd1; u32 0x6fa87e4f; u32 0xfe2ce6e0; u32 0xa3014314; u32 0x4e0811a1; u32 0xf7537e82; u32 0xbd3af235; u32 0x2ad7d2bb; u32 0xeb86d391; ] module L = FStar.List.Tot let t : Seq.lseq uint32 64 = assert_norm (L.length t_as_list == 64); Seq.seq_of_list t_as_list let abcd_idx = (n: nat { n < 4 } ) let abcd_t = Seq.lseq uint32 4 let x_idx = (n: nat { n < 16 } ) let x_t = Seq.lseq uint32 16 let t_idx = (n: nat { 1 <= n /\ n <= 64 } ) inline_for_extraction let rotate_idx = rotval U32 let round_op_gen_aux (f: (uint32 -> uint32 -> uint32 -> Tot uint32)) (abcd: abcd_t) (x: x_t) (a b c d: abcd_idx) (k: x_idx) (s: rotate_idx) (i: t_idx) : Tot abcd_t = let va = Seq.index abcd a in let vb = Seq.index abcd b in let vc = Seq.index abcd c in let vd = Seq.index abcd d in Seq.upd abcd a (vb +. ((va +. f vb vc vd +. Seq.index x k +. Seq.index t (i - 1)) <<<. s)) [@"opaque_to_smt"] let round_op_gen = round_op_gen_aux (* Round 1 *)

Spec.MD5.fst

val round1_op : abcd: Spec.MD5.abcd_t -> x: Spec.MD5.x_t -> a: Spec.MD5.abcd_idx -> b: Spec.MD5.abcd_idx -> c: Spec.MD5.abcd_idx -> d: Spec.MD5.abcd_idx -> k: Spec.MD5.x_idx -> s: Spec.MD5.rotate_idx -> i: Spec.MD5.t_idx -> Spec.MD5.abcd_t

Spec.MD5.round1_op

abcd: Spec.MD5.abcd_t -> x: Spec.MD5.x_t -> a: Spec.MD5.abcd_idx -> b: Spec.MD5.abcd_idx -> c: Spec.MD5.abcd_idx -> d: Spec.MD5.abcd_idx -> k: Spec.MD5.x_idx -> s: Spec.MD5.rotate_idx -> i: Spec.MD5.t_idx -> Spec.MD5.abcd_t

Prims.Tot

let overwrite = overwrite_aux

let overwrite =

overwrite_aux

module Spec.MD5 (* Source: https://tools.ietf.org/html/rfc1321 *) open Lib.IntTypes open Spec.Hash.Definitions (* Section 3.3 *) inline_for_extraction let init_as_list : list uint32 = [ u32 0x67452301; u32 0xefcdab89; u32 0x98badcfe; u32 0x10325476; ] let init : words_state MD5 = Seq.seq_of_list init_as_list (* Section 3.4 *) inline_for_extraction let f (x y z: uint32) : Tot uint32 = (x &. y) |. ((~. x) &. z) inline_for_extraction let g (x y z: uint32) : Tot uint32 = (x &. z) |. (y &. (~. z)) inline_for_extraction let h (x y z: uint32) : Tot uint32 = x ^. y ^. z inline_for_extraction let i (x y z: uint32) : Tot uint32 = y ^. (x |. ~. z) (* Table T: specified in 3.4, defined in Appendix A.3, function MD5Transform *) inline_for_extraction let t_as_list : list uint32 = [ u32 0xd76aa478; u32 0xe8c7b756; u32 0x242070db; u32 0xc1bdceee; u32 0xf57c0faf; u32 0x4787c62a; u32 0xa8304613; u32 0xfd469501; u32 0x698098d8; u32 0x8b44f7af; u32 0xffff5bb1; u32 0x895cd7be; u32 0x6b901122; u32 0xfd987193; u32 0xa679438e; u32 0x49b40821; u32 0xf61e2562; u32 0xc040b340; u32 0x265e5a51; u32 0xe9b6c7aa; u32 0xd62f105d; u32 0x02441453; u32 0xd8a1e681; u32 0xe7d3fbc8; u32 0x21e1cde6; u32 0xc33707d6; u32 0xf4d50d87; u32 0x455a14ed; u32 0xa9e3e905; u32 0xfcefa3f8; u32 0x676f02d9; u32 0x8d2a4c8a; u32 0xfffa3942; u32 0x8771f681; u32 0x6d9d6122; u32 0xfde5380c; u32 0xa4beea44; u32 0x4bdecfa9; u32 0xf6bb4b60; u32 0xbebfbc70; u32 0x289b7ec6; u32 0xeaa127fa; u32 0xd4ef3085; u32 0x4881d05; u32 0xd9d4d039; u32 0xe6db99e5; u32 0x1fa27cf8; u32 0xc4ac5665; u32 0xf4292244; u32 0x432aff97; u32 0xab9423a7; u32 0xfc93a039; u32 0x655b59c3; u32 0x8f0ccc92; u32 0xffeff47d; u32 0x85845dd1; u32 0x6fa87e4f; u32 0xfe2ce6e0; u32 0xa3014314; u32 0x4e0811a1; u32 0xf7537e82; u32 0xbd3af235; u32 0x2ad7d2bb; u32 0xeb86d391; ] module L = FStar.List.Tot let t : Seq.lseq uint32 64 = assert_norm (L.length t_as_list == 64); Seq.seq_of_list t_as_list let abcd_idx = (n: nat { n < 4 } ) let abcd_t = Seq.lseq uint32 4 let x_idx = (n: nat { n < 16 } ) let x_t = Seq.lseq uint32 16 let t_idx = (n: nat { 1 <= n /\ n <= 64 } ) inline_for_extraction let rotate_idx = rotval U32 let round_op_gen_aux (f: (uint32 -> uint32 -> uint32 -> Tot uint32)) (abcd: abcd_t) (x: x_t) (a b c d: abcd_idx) (k: x_idx) (s: rotate_idx) (i: t_idx) : Tot abcd_t = let va = Seq.index abcd a in let vb = Seq.index abcd b in let vc = Seq.index abcd c in let vd = Seq.index abcd d in Seq.upd abcd a (vb +. ((va +. f vb vc vd +. Seq.index x k +. Seq.index t (i - 1)) <<<. s)) [@"opaque_to_smt"] let round_op_gen = round_op_gen_aux (* Round 1 *) let round1_op = round_op_gen f let ia : abcd_idx = 0 let ib : abcd_idx = 1 let ic : abcd_idx = 2 let id : abcd_idx = 3 let round1_aux (abcd: abcd_t) (x: x_t) : Tot abcd_t = let abcd = round1_op abcd x ia ib ic id 0 7ul 1 in let abcd = round1_op abcd x id ia ib ic 1 12ul 2 in let abcd = round1_op abcd x ic id ia ib 2 17ul 3 in let abcd = round1_op abcd x ib ic id ia 3 22ul 4 in let abcd = round1_op abcd x ia ib ic id 4 7ul 5 in let abcd = round1_op abcd x id ia ib ic 5 12ul 6 in let abcd = round1_op abcd x ic id ia ib 6 17ul 7 in let abcd = round1_op abcd x ib ic id ia 7 22ul 8 in let abcd = round1_op abcd x ia ib ic id 8 7ul 9 in let abcd = round1_op abcd x id ia ib ic 9 12ul 10 in let abcd = round1_op abcd x ic id ia ib 10 17ul 11 in let abcd = round1_op abcd x ib ic id ia 11 22ul 12 in let abcd = round1_op abcd x ia ib ic id 12 7ul 13 in let abcd = round1_op abcd x id ia ib ic 13 12ul 14 in let abcd = round1_op abcd x ic id ia ib 14 17ul 15 in let abcd = round1_op abcd x ib ic id ia 15 22ul 16 in abcd [@"opaque_to_smt"] let round1 = round1_aux let round2_op = round_op_gen g let round2_aux (abcd: abcd_t) (x: x_t) : Tot abcd_t = let abcd = round2_op abcd x ia ib ic id 1 5ul 17 in let abcd = round2_op abcd x id ia ib ic 6 9ul 18 in let abcd = round2_op abcd x ic id ia ib 11 14ul 19 in let abcd = round2_op abcd x ib ic id ia 0 20ul 20 in let abcd = round2_op abcd x ia ib ic id 5 5ul 21 in let abcd = round2_op abcd x id ia ib ic 10 9ul 22 in let abcd = round2_op abcd x ic id ia ib 15 14ul 23 in let abcd = round2_op abcd x ib ic id ia 4 20ul 24 in let abcd = round2_op abcd x ia ib ic id 9 5ul 25 in let abcd = round2_op abcd x id ia ib ic 14 9ul 26 in let abcd = round2_op abcd x ic id ia ib 3 14ul 27 in let abcd = round2_op abcd x ib ic id ia 8 20ul 28 in let abcd = round2_op abcd x ia ib ic id 13 5ul 29 in let abcd = round2_op abcd x id ia ib ic 2 9ul 30 in let abcd = round2_op abcd x ic id ia ib 7 14ul 31 in let abcd = round2_op abcd x ib ic id ia 12 20ul 32 in abcd [@"opaque_to_smt"] let round2 = round2_aux let round3_op = round_op_gen h let round3_aux (abcd: abcd_t) (x: x_t) : Tot abcd_t = let abcd = round3_op abcd x ia ib ic id 5 4ul 33 in let abcd = round3_op abcd x id ia ib ic 8 11ul 34 in let abcd = round3_op abcd x ic id ia ib 11 16ul 35 in let abcd = round3_op abcd x ib ic id ia 14 23ul 36 in let abcd = round3_op abcd x ia ib ic id 1 4ul 37 in let abcd = round3_op abcd x id ia ib ic 4 11ul 38 in let abcd = round3_op abcd x ic id ia ib 7 16ul 39 in let abcd = round3_op abcd x ib ic id ia 10 23ul 40 in let abcd = round3_op abcd x ia ib ic id 13 4ul 41 in let abcd = round3_op abcd x id ia ib ic 0 11ul 42 in let abcd = round3_op abcd x ic id ia ib 3 16ul 43 in let abcd = round3_op abcd x ib ic id ia 6 23ul 44 in let abcd = round3_op abcd x ia ib ic id 9 4ul 45 in let abcd = round3_op abcd x id ia ib ic 12 11ul 46 in let abcd = round3_op abcd x ic id ia ib 15 16ul 47 in let abcd = round3_op abcd x ib ic id ia 2 23ul 48 in abcd [@"opaque_to_smt"] let round3 = round3_aux let round4_op = round_op_gen i let round4_aux (abcd: abcd_t) (x: x_t) : Tot abcd_t = let abcd = round4_op abcd x ia ib ic id 0 6ul 49 in let abcd = round4_op abcd x id ia ib ic 7 10ul 50 in let abcd = round4_op abcd x ic id ia ib 14 15ul 51 in let abcd = round4_op abcd x ib ic id ia 5 21ul 52 in let abcd = round4_op abcd x ia ib ic id 12 6ul 53 in let abcd = round4_op abcd x id ia ib ic 3 10ul 54 in let abcd = round4_op abcd x ic id ia ib 10 15ul 55 in let abcd = round4_op abcd x ib ic id ia 1 21ul 56 in let abcd = round4_op abcd x ia ib ic id 8 6ul 57 in let abcd = round4_op abcd x id ia ib ic 15 10ul 58 in let abcd = round4_op abcd x ic id ia ib 6 15ul 59 in let abcd = round4_op abcd x ib ic id ia 13 21ul 60 in let abcd = round4_op abcd x ia ib ic id 4 6ul 61 in let abcd = round4_op abcd x id ia ib ic 11 10ul 62 in let abcd = round4_op abcd x ic id ia ib 2 15ul 63 in let abcd = round4_op abcd x ib ic id ia 9 21ul 64 in abcd [@"opaque_to_smt"] let round4 = round4_aux let rounds_aux (abcd: abcd_t) (x: x_t) : Tot abcd_t = let abcd = round1 abcd x in let abcd = round2 abcd x in let abcd = round3 abcd x in let abcd = round4 abcd x in abcd [@"opaque_to_smt"] let rounds = rounds_aux let overwrite_aux (abcd: abcd_t) (a' b' c' d' : uint32) : Tot abcd_t = let abcd : abcd_t = Seq.upd abcd ia a' in let abcd : abcd_t = Seq.upd abcd ib b' in let abcd : abcd_t = Seq.upd abcd ic c' in let abcd : abcd_t = Seq.upd abcd id d' in abcd

Spec.MD5.fst

val overwrite : abcd: Spec.MD5.abcd_t -> a': Lib.IntTypes.uint32 -> b': Lib.IntTypes.uint32 -> c': Lib.IntTypes.uint32 -> d': Lib.IntTypes.uint32 -> Spec.MD5.abcd_t

Spec.MD5.overwrite

abcd: Spec.MD5.abcd_t -> a': Lib.IntTypes.uint32 -> b': Lib.IntTypes.uint32 -> c': Lib.IntTypes.uint32 -> d': Lib.IntTypes.uint32 -> Spec.MD5.abcd_t

Prims.Tot

let abcd_t = Seq.lseq uint32 4

let abcd_t =

Seq.lseq uint32 4

module Spec.MD5 (* Source: https://tools.ietf.org/html/rfc1321 *) open Lib.IntTypes open Spec.Hash.Definitions (* Section 3.3 *) inline_for_extraction let init_as_list : list uint32 = [ u32 0x67452301; u32 0xefcdab89; u32 0x98badcfe; u32 0x10325476; ] let init : words_state MD5 = Seq.seq_of_list init_as_list (* Section 3.4 *) inline_for_extraction let f (x y z: uint32) : Tot uint32 = (x &. y) |. ((~. x) &. z) inline_for_extraction let g (x y z: uint32) : Tot uint32 = (x &. z) |. (y &. (~. z)) inline_for_extraction let h (x y z: uint32) : Tot uint32 = x ^. y ^. z inline_for_extraction let i (x y z: uint32) : Tot uint32 = y ^. (x |. ~. z) (* Table T: specified in 3.4, defined in Appendix A.3, function MD5Transform *) inline_for_extraction let t_as_list : list uint32 = [ u32 0xd76aa478; u32 0xe8c7b756; u32 0x242070db; u32 0xc1bdceee; u32 0xf57c0faf; u32 0x4787c62a; u32 0xa8304613; u32 0xfd469501; u32 0x698098d8; u32 0x8b44f7af; u32 0xffff5bb1; u32 0x895cd7be; u32 0x6b901122; u32 0xfd987193; u32 0xa679438e; u32 0x49b40821; u32 0xf61e2562; u32 0xc040b340; u32 0x265e5a51; u32 0xe9b6c7aa; u32 0xd62f105d; u32 0x02441453; u32 0xd8a1e681; u32 0xe7d3fbc8; u32 0x21e1cde6; u32 0xc33707d6; u32 0xf4d50d87; u32 0x455a14ed; u32 0xa9e3e905; u32 0xfcefa3f8; u32 0x676f02d9; u32 0x8d2a4c8a; u32 0xfffa3942; u32 0x8771f681; u32 0x6d9d6122; u32 0xfde5380c; u32 0xa4beea44; u32 0x4bdecfa9; u32 0xf6bb4b60; u32 0xbebfbc70; u32 0x289b7ec6; u32 0xeaa127fa; u32 0xd4ef3085; u32 0x4881d05; u32 0xd9d4d039; u32 0xe6db99e5; u32 0x1fa27cf8; u32 0xc4ac5665; u32 0xf4292244; u32 0x432aff97; u32 0xab9423a7; u32 0xfc93a039; u32 0x655b59c3; u32 0x8f0ccc92; u32 0xffeff47d; u32 0x85845dd1; u32 0x6fa87e4f; u32 0xfe2ce6e0; u32 0xa3014314; u32 0x4e0811a1; u32 0xf7537e82; u32 0xbd3af235; u32 0x2ad7d2bb; u32 0xeb86d391; ] module L = FStar.List.Tot let t : Seq.lseq uint32 64 = assert_norm (L.length t_as_list == 64); Seq.seq_of_list t_as_list let abcd_idx = (n: nat { n < 4 } )

Spec.MD5.fst

val abcd_t : Type0

Spec.MD5.abcd_t

Type0

Prims.Tot

let round_op_gen = round_op_gen_aux

let round_op_gen =

round_op_gen_aux

module Spec.MD5 (* Source: https://tools.ietf.org/html/rfc1321 *) open Lib.IntTypes open Spec.Hash.Definitions (* Section 3.3 *) inline_for_extraction let init_as_list : list uint32 = [ u32 0x67452301; u32 0xefcdab89; u32 0x98badcfe; u32 0x10325476; ] let init : words_state MD5 = Seq.seq_of_list init_as_list (* Section 3.4 *) inline_for_extraction let f (x y z: uint32) : Tot uint32 = (x &. y) |. ((~. x) &. z) inline_for_extraction let g (x y z: uint32) : Tot uint32 = (x &. z) |. (y &. (~. z)) inline_for_extraction let h (x y z: uint32) : Tot uint32 = x ^. y ^. z inline_for_extraction let i (x y z: uint32) : Tot uint32 = y ^. (x |. ~. z) (* Table T: specified in 3.4, defined in Appendix A.3, function MD5Transform *) inline_for_extraction let t_as_list : list uint32 = [ u32 0xd76aa478; u32 0xe8c7b756; u32 0x242070db; u32 0xc1bdceee; u32 0xf57c0faf; u32 0x4787c62a; u32 0xa8304613; u32 0xfd469501; u32 0x698098d8; u32 0x8b44f7af; u32 0xffff5bb1; u32 0x895cd7be; u32 0x6b901122; u32 0xfd987193; u32 0xa679438e; u32 0x49b40821; u32 0xf61e2562; u32 0xc040b340; u32 0x265e5a51; u32 0xe9b6c7aa; u32 0xd62f105d; u32 0x02441453; u32 0xd8a1e681; u32 0xe7d3fbc8; u32 0x21e1cde6; u32 0xc33707d6; u32 0xf4d50d87; u32 0x455a14ed; u32 0xa9e3e905; u32 0xfcefa3f8; u32 0x676f02d9; u32 0x8d2a4c8a; u32 0xfffa3942; u32 0x8771f681; u32 0x6d9d6122; u32 0xfde5380c; u32 0xa4beea44; u32 0x4bdecfa9; u32 0xf6bb4b60; u32 0xbebfbc70; u32 0x289b7ec6; u32 0xeaa127fa; u32 0xd4ef3085; u32 0x4881d05; u32 0xd9d4d039; u32 0xe6db99e5; u32 0x1fa27cf8; u32 0xc4ac5665; u32 0xf4292244; u32 0x432aff97; u32 0xab9423a7; u32 0xfc93a039; u32 0x655b59c3; u32 0x8f0ccc92; u32 0xffeff47d; u32 0x85845dd1; u32 0x6fa87e4f; u32 0xfe2ce6e0; u32 0xa3014314; u32 0x4e0811a1; u32 0xf7537e82; u32 0xbd3af235; u32 0x2ad7d2bb; u32 0xeb86d391; ] module L = FStar.List.Tot let t : Seq.lseq uint32 64 = assert_norm (L.length t_as_list == 64); Seq.seq_of_list t_as_list let abcd_idx = (n: nat { n < 4 } ) let abcd_t = Seq.lseq uint32 4 let x_idx = (n: nat { n < 16 } ) let x_t = Seq.lseq uint32 16 let t_idx = (n: nat { 1 <= n /\ n <= 64 } ) inline_for_extraction let rotate_idx = rotval U32 let round_op_gen_aux (f: (uint32 -> uint32 -> uint32 -> Tot uint32)) (abcd: abcd_t) (x: x_t) (a b c d: abcd_idx) (k: x_idx) (s: rotate_idx) (i: t_idx) : Tot abcd_t = let va = Seq.index abcd a in let vb = Seq.index abcd b in let vc = Seq.index abcd c in let vd = Seq.index abcd d in Seq.upd abcd a (vb +. ((va +. f vb vc vd +. Seq.index x k +. Seq.index t (i - 1)) <<<. s))

Spec.MD5.fst

val round_op_gen : f: (_: Lib.IntTypes.uint32 -> _: Lib.IntTypes.uint32 -> _: Lib.IntTypes.uint32 -> Lib.IntTypes.uint32) -> abcd: Spec.MD5.abcd_t -> x: Spec.MD5.x_t -> a: Spec.MD5.abcd_idx -> b: Spec.MD5.abcd_idx -> c: Spec.MD5.abcd_idx -> d: Spec.MD5.abcd_idx -> k: Spec.MD5.x_idx -> s: Spec.MD5.rotate_idx -> i: Spec.MD5.t_idx -> Spec.MD5.abcd_t

Spec.MD5.round_op_gen

f: (_: Lib.IntTypes.uint32 -> _: Lib.IntTypes.uint32 -> _: Lib.IntTypes.uint32 -> Lib.IntTypes.uint32) -> abcd: Spec.MD5.abcd_t -> x: Spec.MD5.x_t -> a: Spec.MD5.abcd_idx -> b: Spec.MD5.abcd_idx -> c: Spec.MD5.abcd_idx -> d: Spec.MD5.abcd_idx -> k: Spec.MD5.x_idx -> s: Spec.MD5.rotate_idx -> i: Spec.MD5.t_idx -> Spec.MD5.abcd_t

Prims.Tot

val h (x y z: uint32) : Tot uint32

let h (x y z: uint32) : Tot uint32 = x ^. y ^. z

val h (x y z: uint32) : Tot uint32 let h (x y z: uint32) : Tot uint32 =

x ^. y ^. z

module Spec.MD5 (* Source: https://tools.ietf.org/html/rfc1321 *) open Lib.IntTypes open Spec.Hash.Definitions (* Section 3.3 *) inline_for_extraction let init_as_list : list uint32 = [ u32 0x67452301; u32 0xefcdab89; u32 0x98badcfe; u32 0x10325476; ] let init : words_state MD5 = Seq.seq_of_list init_as_list (* Section 3.4 *) inline_for_extraction let f (x y z: uint32) : Tot uint32 = (x &. y) |. ((~. x) &. z) inline_for_extraction let g (x y z: uint32) : Tot uint32 = (x &. z) |. (y &. (~. z)) inline_for_extraction

Spec.MD5.fst

val h (x y z: uint32) : Tot uint32

Spec.MD5.h

x: Lib.IntTypes.uint32 -> y: Lib.IntTypes.uint32 -> z: Lib.IntTypes.uint32 -> Lib.IntTypes.uint32

Prims.Tot

val id:abcd_idx

let id : abcd_idx = 3

val id:abcd_idx let id:abcd_idx =

3

module Spec.MD5 (* Source: https://tools.ietf.org/html/rfc1321 *) open Lib.IntTypes open Spec.Hash.Definitions (* Section 3.3 *) inline_for_extraction let init_as_list : list uint32 = [ u32 0x67452301; u32 0xefcdab89; u32 0x98badcfe; u32 0x10325476; ] let init : words_state MD5 = Seq.seq_of_list init_as_list (* Section 3.4 *) inline_for_extraction let f (x y z: uint32) : Tot uint32 = (x &. y) |. ((~. x) &. z) inline_for_extraction let g (x y z: uint32) : Tot uint32 = (x &. z) |. (y &. (~. z)) inline_for_extraction let h (x y z: uint32) : Tot uint32 = x ^. y ^. z inline_for_extraction let i (x y z: uint32) : Tot uint32 = y ^. (x |. ~. z) (* Table T: specified in 3.4, defined in Appendix A.3, function MD5Transform *) inline_for_extraction let t_as_list : list uint32 = [ u32 0xd76aa478; u32 0xe8c7b756; u32 0x242070db; u32 0xc1bdceee; u32 0xf57c0faf; u32 0x4787c62a; u32 0xa8304613; u32 0xfd469501; u32 0x698098d8; u32 0x8b44f7af; u32 0xffff5bb1; u32 0x895cd7be; u32 0x6b901122; u32 0xfd987193; u32 0xa679438e; u32 0x49b40821; u32 0xf61e2562; u32 0xc040b340; u32 0x265e5a51; u32 0xe9b6c7aa; u32 0xd62f105d; u32 0x02441453; u32 0xd8a1e681; u32 0xe7d3fbc8; u32 0x21e1cde6; u32 0xc33707d6; u32 0xf4d50d87; u32 0x455a14ed; u32 0xa9e3e905; u32 0xfcefa3f8; u32 0x676f02d9; u32 0x8d2a4c8a; u32 0xfffa3942; u32 0x8771f681; u32 0x6d9d6122; u32 0xfde5380c; u32 0xa4beea44; u32 0x4bdecfa9; u32 0xf6bb4b60; u32 0xbebfbc70; u32 0x289b7ec6; u32 0xeaa127fa; u32 0xd4ef3085; u32 0x4881d05; u32 0xd9d4d039; u32 0xe6db99e5; u32 0x1fa27cf8; u32 0xc4ac5665; u32 0xf4292244; u32 0x432aff97; u32 0xab9423a7; u32 0xfc93a039; u32 0x655b59c3; u32 0x8f0ccc92; u32 0xffeff47d; u32 0x85845dd1; u32 0x6fa87e4f; u32 0xfe2ce6e0; u32 0xa3014314; u32 0x4e0811a1; u32 0xf7537e82; u32 0xbd3af235; u32 0x2ad7d2bb; u32 0xeb86d391; ] module L = FStar.List.Tot let t : Seq.lseq uint32 64 = assert_norm (L.length t_as_list == 64); Seq.seq_of_list t_as_list let abcd_idx = (n: nat { n < 4 } ) let abcd_t = Seq.lseq uint32 4 let x_idx = (n: nat { n < 16 } ) let x_t = Seq.lseq uint32 16 let t_idx = (n: nat { 1 <= n /\ n <= 64 } ) inline_for_extraction let rotate_idx = rotval U32 let round_op_gen_aux (f: (uint32 -> uint32 -> uint32 -> Tot uint32)) (abcd: abcd_t) (x: x_t) (a b c d: abcd_idx) (k: x_idx) (s: rotate_idx) (i: t_idx) : Tot abcd_t = let va = Seq.index abcd a in let vb = Seq.index abcd b in let vc = Seq.index abcd c in let vd = Seq.index abcd d in Seq.upd abcd a (vb +. ((va +. f vb vc vd +. Seq.index x k +. Seq.index t (i - 1)) <<<. s)) [@"opaque_to_smt"] let round_op_gen = round_op_gen_aux (* Round 1 *) let round1_op = round_op_gen f let ia : abcd_idx = 0 let ib : abcd_idx = 1

Spec.MD5.fst

val id:abcd_idx

Spec.MD5.id

Spec.MD5.abcd_idx

Prims.Tot

let round3 = round3_aux

let round3 =

round3_aux

module Spec.MD5 (* Source: https://tools.ietf.org/html/rfc1321 *) open Lib.IntTypes open Spec.Hash.Definitions (* Section 3.3 *) inline_for_extraction let init_as_list : list uint32 = [ u32 0x67452301; u32 0xefcdab89; u32 0x98badcfe; u32 0x10325476; ] let init : words_state MD5 = Seq.seq_of_list init_as_list (* Section 3.4 *) inline_for_extraction let f (x y z: uint32) : Tot uint32 = (x &. y) |. ((~. x) &. z) inline_for_extraction let g (x y z: uint32) : Tot uint32 = (x &. z) |. (y &. (~. z)) inline_for_extraction let h (x y z: uint32) : Tot uint32 = x ^. y ^. z inline_for_extraction let i (x y z: uint32) : Tot uint32 = y ^. (x |. ~. z) (* Table T: specified in 3.4, defined in Appendix A.3, function MD5Transform *) inline_for_extraction let t_as_list : list uint32 = [ u32 0xd76aa478; u32 0xe8c7b756; u32 0x242070db; u32 0xc1bdceee; u32 0xf57c0faf; u32 0x4787c62a; u32 0xa8304613; u32 0xfd469501; u32 0x698098d8; u32 0x8b44f7af; u32 0xffff5bb1; u32 0x895cd7be; u32 0x6b901122; u32 0xfd987193; u32 0xa679438e; u32 0x49b40821; u32 0xf61e2562; u32 0xc040b340; u32 0x265e5a51; u32 0xe9b6c7aa; u32 0xd62f105d; u32 0x02441453; u32 0xd8a1e681; u32 0xe7d3fbc8; u32 0x21e1cde6; u32 0xc33707d6; u32 0xf4d50d87; u32 0x455a14ed; u32 0xa9e3e905; u32 0xfcefa3f8; u32 0x676f02d9; u32 0x8d2a4c8a; u32 0xfffa3942; u32 0x8771f681; u32 0x6d9d6122; u32 0xfde5380c; u32 0xa4beea44; u32 0x4bdecfa9; u32 0xf6bb4b60; u32 0xbebfbc70; u32 0x289b7ec6; u32 0xeaa127fa; u32 0xd4ef3085; u32 0x4881d05; u32 0xd9d4d039; u32 0xe6db99e5; u32 0x1fa27cf8; u32 0xc4ac5665; u32 0xf4292244; u32 0x432aff97; u32 0xab9423a7; u32 0xfc93a039; u32 0x655b59c3; u32 0x8f0ccc92; u32 0xffeff47d; u32 0x85845dd1; u32 0x6fa87e4f; u32 0xfe2ce6e0; u32 0xa3014314; u32 0x4e0811a1; u32 0xf7537e82; u32 0xbd3af235; u32 0x2ad7d2bb; u32 0xeb86d391; ] module L = FStar.List.Tot let t : Seq.lseq uint32 64 = assert_norm (L.length t_as_list == 64); Seq.seq_of_list t_as_list let abcd_idx = (n: nat { n < 4 } ) let abcd_t = Seq.lseq uint32 4 let x_idx = (n: nat { n < 16 } ) let x_t = Seq.lseq uint32 16 let t_idx = (n: nat { 1 <= n /\ n <= 64 } ) inline_for_extraction let rotate_idx = rotval U32 let round_op_gen_aux (f: (uint32 -> uint32 -> uint32 -> Tot uint32)) (abcd: abcd_t) (x: x_t) (a b c d: abcd_idx) (k: x_idx) (s: rotate_idx) (i: t_idx) : Tot abcd_t = let va = Seq.index abcd a in let vb = Seq.index abcd b in let vc = Seq.index abcd c in let vd = Seq.index abcd d in Seq.upd abcd a (vb +. ((va +. f vb vc vd +. Seq.index x k +. Seq.index t (i - 1)) <<<. s)) [@"opaque_to_smt"] let round_op_gen = round_op_gen_aux (* Round 1 *) let round1_op = round_op_gen f let ia : abcd_idx = 0 let ib : abcd_idx = 1 let ic : abcd_idx = 2 let id : abcd_idx = 3 let round1_aux (abcd: abcd_t) (x: x_t) : Tot abcd_t = let abcd = round1_op abcd x ia ib ic id 0 7ul 1 in let abcd = round1_op abcd x id ia ib ic 1 12ul 2 in let abcd = round1_op abcd x ic id ia ib 2 17ul 3 in let abcd = round1_op abcd x ib ic id ia 3 22ul 4 in let abcd = round1_op abcd x ia ib ic id 4 7ul 5 in let abcd = round1_op abcd x id ia ib ic 5 12ul 6 in let abcd = round1_op abcd x ic id ia ib 6 17ul 7 in let abcd = round1_op abcd x ib ic id ia 7 22ul 8 in let abcd = round1_op abcd x ia ib ic id 8 7ul 9 in let abcd = round1_op abcd x id ia ib ic 9 12ul 10 in let abcd = round1_op abcd x ic id ia ib 10 17ul 11 in let abcd = round1_op abcd x ib ic id ia 11 22ul 12 in let abcd = round1_op abcd x ia ib ic id 12 7ul 13 in let abcd = round1_op abcd x id ia ib ic 13 12ul 14 in let abcd = round1_op abcd x ic id ia ib 14 17ul 15 in let abcd = round1_op abcd x ib ic id ia 15 22ul 16 in abcd [@"opaque_to_smt"] let round1 = round1_aux let round2_op = round_op_gen g let round2_aux (abcd: abcd_t) (x: x_t) : Tot abcd_t = let abcd = round2_op abcd x ia ib ic id 1 5ul 17 in let abcd = round2_op abcd x id ia ib ic 6 9ul 18 in let abcd = round2_op abcd x ic id ia ib 11 14ul 19 in let abcd = round2_op abcd x ib ic id ia 0 20ul 20 in let abcd = round2_op abcd x ia ib ic id 5 5ul 21 in let abcd = round2_op abcd x id ia ib ic 10 9ul 22 in let abcd = round2_op abcd x ic id ia ib 15 14ul 23 in let abcd = round2_op abcd x ib ic id ia 4 20ul 24 in let abcd = round2_op abcd x ia ib ic id 9 5ul 25 in let abcd = round2_op abcd x id ia ib ic 14 9ul 26 in let abcd = round2_op abcd x ic id ia ib 3 14ul 27 in let abcd = round2_op abcd x ib ic id ia 8 20ul 28 in let abcd = round2_op abcd x ia ib ic id 13 5ul 29 in let abcd = round2_op abcd x id ia ib ic 2 9ul 30 in let abcd = round2_op abcd x ic id ia ib 7 14ul 31 in let abcd = round2_op abcd x ib ic id ia 12 20ul 32 in abcd [@"opaque_to_smt"] let round2 = round2_aux let round3_op = round_op_gen h let round3_aux (abcd: abcd_t) (x: x_t) : Tot abcd_t = let abcd = round3_op abcd x ia ib ic id 5 4ul 33 in let abcd = round3_op abcd x id ia ib ic 8 11ul 34 in let abcd = round3_op abcd x ic id ia ib 11 16ul 35 in let abcd = round3_op abcd x ib ic id ia 14 23ul 36 in let abcd = round3_op abcd x ia ib ic id 1 4ul 37 in let abcd = round3_op abcd x id ia ib ic 4 11ul 38 in let abcd = round3_op abcd x ic id ia ib 7 16ul 39 in let abcd = round3_op abcd x ib ic id ia 10 23ul 40 in let abcd = round3_op abcd x ia ib ic id 13 4ul 41 in let abcd = round3_op abcd x id ia ib ic 0 11ul 42 in let abcd = round3_op abcd x ic id ia ib 3 16ul 43 in let abcd = round3_op abcd x ib ic id ia 6 23ul 44 in let abcd = round3_op abcd x ia ib ic id 9 4ul 45 in let abcd = round3_op abcd x id ia ib ic 12 11ul 46 in let abcd = round3_op abcd x ic id ia ib 15 16ul 47 in let abcd = round3_op abcd x ib ic id ia 2 23ul 48 in abcd

Spec.MD5.fst

val round3 : abcd: Spec.MD5.abcd_t -> x: Spec.MD5.x_t -> Spec.MD5.abcd_t

Spec.MD5.round3

abcd: Spec.MD5.abcd_t -> x: Spec.MD5.x_t -> Spec.MD5.abcd_t

Prims.Tot

let round2_op = round_op_gen g

let round2_op =

round_op_gen g

module Spec.MD5 (* Source: https://tools.ietf.org/html/rfc1321 *) open Lib.IntTypes open Spec.Hash.Definitions (* Section 3.3 *) inline_for_extraction let init_as_list : list uint32 = [ u32 0x67452301; u32 0xefcdab89; u32 0x98badcfe; u32 0x10325476; ] let init : words_state MD5 = Seq.seq_of_list init_as_list (* Section 3.4 *) inline_for_extraction let f (x y z: uint32) : Tot uint32 = (x &. y) |. ((~. x) &. z) inline_for_extraction let g (x y z: uint32) : Tot uint32 = (x &. z) |. (y &. (~. z)) inline_for_extraction let h (x y z: uint32) : Tot uint32 = x ^. y ^. z inline_for_extraction let i (x y z: uint32) : Tot uint32 = y ^. (x |. ~. z) (* Table T: specified in 3.4, defined in Appendix A.3, function MD5Transform *) inline_for_extraction let t_as_list : list uint32 = [ u32 0xd76aa478; u32 0xe8c7b756; u32 0x242070db; u32 0xc1bdceee; u32 0xf57c0faf; u32 0x4787c62a; u32 0xa8304613; u32 0xfd469501; u32 0x698098d8; u32 0x8b44f7af; u32 0xffff5bb1; u32 0x895cd7be; u32 0x6b901122; u32 0xfd987193; u32 0xa679438e; u32 0x49b40821; u32 0xf61e2562; u32 0xc040b340; u32 0x265e5a51; u32 0xe9b6c7aa; u32 0xd62f105d; u32 0x02441453; u32 0xd8a1e681; u32 0xe7d3fbc8; u32 0x21e1cde6; u32 0xc33707d6; u32 0xf4d50d87; u32 0x455a14ed; u32 0xa9e3e905; u32 0xfcefa3f8; u32 0x676f02d9; u32 0x8d2a4c8a; u32 0xfffa3942; u32 0x8771f681; u32 0x6d9d6122; u32 0xfde5380c; u32 0xa4beea44; u32 0x4bdecfa9; u32 0xf6bb4b60; u32 0xbebfbc70; u32 0x289b7ec6; u32 0xeaa127fa; u32 0xd4ef3085; u32 0x4881d05; u32 0xd9d4d039; u32 0xe6db99e5; u32 0x1fa27cf8; u32 0xc4ac5665; u32 0xf4292244; u32 0x432aff97; u32 0xab9423a7; u32 0xfc93a039; u32 0x655b59c3; u32 0x8f0ccc92; u32 0xffeff47d; u32 0x85845dd1; u32 0x6fa87e4f; u32 0xfe2ce6e0; u32 0xa3014314; u32 0x4e0811a1; u32 0xf7537e82; u32 0xbd3af235; u32 0x2ad7d2bb; u32 0xeb86d391; ] module L = FStar.List.Tot let t : Seq.lseq uint32 64 = assert_norm (L.length t_as_list == 64); Seq.seq_of_list t_as_list let abcd_idx = (n: nat { n < 4 } ) let abcd_t = Seq.lseq uint32 4 let x_idx = (n: nat { n < 16 } ) let x_t = Seq.lseq uint32 16 let t_idx = (n: nat { 1 <= n /\ n <= 64 } ) inline_for_extraction let rotate_idx = rotval U32 let round_op_gen_aux (f: (uint32 -> uint32 -> uint32 -> Tot uint32)) (abcd: abcd_t) (x: x_t) (a b c d: abcd_idx) (k: x_idx) (s: rotate_idx) (i: t_idx) : Tot abcd_t = let va = Seq.index abcd a in let vb = Seq.index abcd b in let vc = Seq.index abcd c in let vd = Seq.index abcd d in Seq.upd abcd a (vb +. ((va +. f vb vc vd +. Seq.index x k +. Seq.index t (i - 1)) <<<. s)) [@"opaque_to_smt"] let round_op_gen = round_op_gen_aux (* Round 1 *) let round1_op = round_op_gen f let ia : abcd_idx = 0 let ib : abcd_idx = 1 let ic : abcd_idx = 2 let id : abcd_idx = 3 let round1_aux (abcd: abcd_t) (x: x_t) : Tot abcd_t = let abcd = round1_op abcd x ia ib ic id 0 7ul 1 in let abcd = round1_op abcd x id ia ib ic 1 12ul 2 in let abcd = round1_op abcd x ic id ia ib 2 17ul 3 in let abcd = round1_op abcd x ib ic id ia 3 22ul 4 in let abcd = round1_op abcd x ia ib ic id 4 7ul 5 in let abcd = round1_op abcd x id ia ib ic 5 12ul 6 in let abcd = round1_op abcd x ic id ia ib 6 17ul 7 in let abcd = round1_op abcd x ib ic id ia 7 22ul 8 in let abcd = round1_op abcd x ia ib ic id 8 7ul 9 in let abcd = round1_op abcd x id ia ib ic 9 12ul 10 in let abcd = round1_op abcd x ic id ia ib 10 17ul 11 in let abcd = round1_op abcd x ib ic id ia 11 22ul 12 in let abcd = round1_op abcd x ia ib ic id 12 7ul 13 in let abcd = round1_op abcd x id ia ib ic 13 12ul 14 in let abcd = round1_op abcd x ic id ia ib 14 17ul 15 in let abcd = round1_op abcd x ib ic id ia 15 22ul 16 in abcd [@"opaque_to_smt"] let round1 = round1_aux

Spec.MD5.fst

val round2_op : abcd: Spec.MD5.abcd_t -> x: Spec.MD5.x_t -> a: Spec.MD5.abcd_idx -> b: Spec.MD5.abcd_idx -> c: Spec.MD5.abcd_idx -> d: Spec.MD5.abcd_idx -> k: Spec.MD5.x_idx -> s: Spec.MD5.rotate_idx -> i: Spec.MD5.t_idx -> Spec.MD5.abcd_t

Spec.MD5.round2_op

abcd: Spec.MD5.abcd_t -> x: Spec.MD5.x_t -> a: Spec.MD5.abcd_idx -> b: Spec.MD5.abcd_idx -> c: Spec.MD5.abcd_idx -> d: Spec.MD5.abcd_idx -> k: Spec.MD5.x_idx -> s: Spec.MD5.rotate_idx -> i: Spec.MD5.t_idx -> Spec.MD5.abcd_t

Prims.Tot

val rounds_aux (abcd: abcd_t) (x: x_t) : Tot abcd_t