effect
stringclasses 48
values | original_source_type
stringlengths 0
23k
| opens_and_abbrevs
listlengths 2
92
| isa_cross_project_example
bool 1
class | source_definition
stringlengths 9
57.9k
| partial_definition
stringlengths 7
23.3k
| is_div
bool 2
classes | is_type
null | is_proof
bool 2
classes | completed_definiton
stringlengths 1
250k
| dependencies
dict | effect_flags
sequencelengths 0
2
| ideal_premises
sequencelengths 0
236
| mutual_with
sequencelengths 0
11
| file_context
stringlengths 0
407k
| interleaved
bool 1
class | is_simply_typed
bool 2
classes | file_name
stringlengths 5
48
| vconfig
dict | is_simple_lemma
null | source_type
stringlengths 10
23k
| proof_features
sequencelengths 0
1
| name
stringlengths 8
95
| source
dict | verbose_type
stringlengths 1
7.42k
| source_range
dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
FStar.Pervasives.Lemma | val lemma_a_plus_b_mul_pow256 (a b:int) :
Lemma ((a + b * pow2 256) % S.prime == (a + b * 0x1000003D1) % S.prime) | [
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.MathLemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_a_plus_b_mul_pow256 a b =
calc (==) {
(a + b * pow2 256) % S.prime;
(==) { Math.Lemmas.lemma_mod_plus_distr_r a (b * pow2 256) S.prime }
(a + b * pow2 256 % S.prime) % S.prime;
(==) { Math.Lemmas.lemma_mod_mul_distr_r b (pow2 256) S.prime }
(a + b * (pow2 256 % S.prime) % S.prime) % S.prime;
(==) { lemma_prime () }
(a + b * 0x1000003D1 % S.prime) % S.prime;
(==) { Math.Lemmas.lemma_mod_plus_distr_r a (b * 0x1000003D1) S.prime }
(a + b * 0x1000003D1) % S.prime;
} | val lemma_a_plus_b_mul_pow256 (a b:int) :
Lemma ((a + b * pow2 256) % S.prime == (a + b * 0x1000003D1) % S.prime)
let lemma_a_plus_b_mul_pow256 a b = | false | null | true | calc ( == ) {
(a + b * pow2 256) % S.prime;
( == ) { Math.Lemmas.lemma_mod_plus_distr_r a (b * pow2 256) S.prime }
(a + b * pow2 256 % S.prime) % S.prime;
( == ) { Math.Lemmas.lemma_mod_mul_distr_r b (pow2 256) S.prime }
(a + b * (pow2 256 % S.prime) % S.prime) % S.prime;
( == ) { lemma_prime () }
(a + b * 0x1000003D1 % S.prime) % S.prime;
( == ) { Math.Lemmas.lemma_mod_plus_distr_r a (b * 0x1000003D1) S.prime }
(a + b * 0x1000003D1) % S.prime;
} | {
"checked_file": "Hacl.Spec.K256.Field52.Definitions.Lemmas.fst.checked",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.K256.MathLemmas.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.Field52.Definitions.Lemmas.fst"
} | [
"lemma"
] | [
"Prims.int",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Prims.op_Modulus",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.pow2",
"Spec.K256.PointOps.prime",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.lemma_mod_plus_distr_r",
"Prims.squash",
"FStar.Math.Lemmas.lemma_mod_mul_distr_r",
"Hacl.Spec.K256.Field52.Definitions.Lemmas.lemma_prime"
] | [] | module Hacl.Spec.K256.Field52.Definitions.Lemmas
open FStar.Mul
open Lib.IntTypes
open Hacl.Spec.K256.Field52.Definitions
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.K256
module ML = Hacl.Spec.K256.MathLemmas
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
val lemma_as_nat_mod2: x:felem5 ->
Lemma (let (x0,x1,x2,x3,x4) = x in as_nat5 x % 2 = v x0 % 2)
let lemma_as_nat_mod2 x =
let (x0,x1,x2,x3,x4) = x in
assert (as_nat5 x = v x0 + v x1 * pow52 + v x2 * pow104 + v x3 * pow156 + v x4 * pow208);
assert (as_nat5 x % 2 = (v x0 + v x1 * pow52 + v x2 * pow104 + v x3 * pow156 + v x4 * pow208) % 2);
ML.lemma_a_plus_b_pow2_mod2 (v x0 + v x1 * pow52 + v x2 * pow104 + v x3 * pow156) (v x4) 208;
ML.lemma_a_plus_b_pow2_mod2 (v x0 + v x1 * pow52 + v x2 * pow104) (v x3) 156;
ML.lemma_a_plus_b_pow2_mod2 (v x0 + v x1 * pow52) (v x2) 104;
ML.lemma_a_plus_b_pow2_mod2 (v x0) (v x1) 52;
assert (as_nat5 x % 2 = v x0 % 2)
val lemma_nat_from_bytes_be_mod2: f:LSeq.lseq uint8 32 ->
Lemma (BSeq.nat_from_bytes_be f % 2 = v (LSeq.index f 31) % 2)
let lemma_nat_from_bytes_be_mod2 f =
let x0 = LSeq.index f 31 in
BSeq.nat_from_intseq_be_slice_lemma f 31;
BSeq.nat_from_intseq_be_lemma0 (LSeq.slice f 31 32);
assert (BSeq.nat_from_intseq_be f == v x0 + pow2 8 * BSeq.nat_from_intseq_be (LSeq.slice f 0 31));
ML.lemma_a_plus_b_pow2_mod2 (v x0) (BSeq.nat_from_intseq_be (LSeq.slice f 0 31)) 8
val unfold_nat_from_uint64_four: b:LSeq.lseq uint64 4 ->
Lemma (BSeq.nat_from_intseq_be b ==
v (LSeq.index b 3) + v (LSeq.index b 2) * pow2 64 +
v (LSeq.index b 1) * pow2 128 + v (LSeq.index b 0) * pow2 192)
let unfold_nat_from_uint64_four b =
let b0 = v (LSeq.index b 0) in
let b1 = v (LSeq.index b 1) in
let b2 = v (LSeq.index b 2) in
let b3 = v (LSeq.index b 3) in
let res = BSeq.nat_from_intseq_be b in
BSeq.nat_from_intseq_be_slice_lemma b 3;
BSeq.nat_from_intseq_be_lemma0 (Seq.slice b 3 4);
assert (res == b3 + pow2 64 * (BSeq.nat_from_intseq_be (Seq.slice b 0 3)));
BSeq.nat_from_intseq_be_slice_lemma #U64 #SEC #3 (Seq.slice b 0 3) 2;
BSeq.nat_from_intseq_be_lemma0 (Seq.slice b 2 3);
assert (BSeq.nat_from_intseq_be (Seq.slice b 0 3) == b2 + pow2 64 * (BSeq.nat_from_intseq_be (Seq.slice b 0 2)));
BSeq.nat_from_intseq_be_slice_lemma #U64 #SEC #2 (Seq.slice b 0 2) 1;
BSeq.nat_from_intseq_be_lemma0 (Seq.slice b 1 2);
assert (BSeq.nat_from_intseq_be (Seq.slice b 0 2) == b1 + pow2 64 * (BSeq.nat_from_intseq_be (Seq.slice b 0 1)));
BSeq.nat_from_intseq_be_lemma0 (Seq.slice b 0 1);
assert (res == b3 + pow2 64 * (b2 + pow2 64 * (b1 + pow2 64 * b0)));
ML.lemma_as_nat64_horner b3 b2 b1 b0
val lemma_prime : unit -> Lemma (pow2 256 % S.prime = 0x1000003D1)
let lemma_prime () = ()
val lemma_pow2_256_minus_prime : unit -> Lemma (pow2 256 - S.prime = 0x1000003D1)
let lemma_pow2_256_minus_prime () = ()
val lemma_pow2_260_mod_prime: unit -> Lemma (pow2 260 % S.prime = 0x1000003D10)
let lemma_pow2_260_mod_prime () =
calc (==) {
pow2 260 % S.prime;
(==) { Math.Lemmas.pow2_plus 256 4 }
pow2 256 * pow2 4 % S.prime;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (pow2 256) (pow2 4) S.prime }
(pow2 256 % S.prime) * pow2 4 % S.prime;
(==) { lemma_prime () }
0x1000003D1 * pow2 4 % S.prime;
(==) { assert_norm (0x1000003D1 * pow2 4 = 0x1000003D10) }
0x1000003D10 % S.prime;
(==) { Math.Lemmas.small_mod 0x1000003D10 S.prime }
0x1000003D10;
}
val lemma_as_nat_bound_f4_lt_powa: f:felem5 -> a:nat -> Lemma
(requires (let (f0,f1,f2,f3,f4) = f in
felem_fits5 f (1,1,1,1,1) /\ v f4 < pow2 a))
(ensures as_nat5 f <= pow2 (208 + a) - 1)
let lemma_as_nat_bound_f4_lt_powa f a =
let (f0,f1,f2,f3,f4) = f in
calc (<=) { //as_nat5 f ==
v f0 + v f1 * pow52 + v f2 * pow104 + v f3 * pow156 + v f4 * pow208;
(<=) { }
pow2 52 - 1 + v f1 * pow52 + v f2 * pow104 + v f3 * pow156 + v f4 * pow208;
(<=) {
Math.Lemmas.lemma_mult_le_right pow52 (v f1) (pow2 52 - 1);
Math.Lemmas.distributivity_sub_left (pow2 52) 1 pow52 }
pow2 52 * pow52 + v f2 * pow104 + v f3 * pow156 + v f4 * pow208 - 1;
(<=) {
Math.Lemmas.lemma_mult_le_right pow104 (v f2) (pow2 52 - 1);
Math.Lemmas.distributivity_sub_left (pow2 52) 1 pow104;
Math.Lemmas.pow2_plus 52 52 }
pow2 52 * pow104 + v f3 * pow156 + v f4 * pow208 - 1;
(<=) {
Math.Lemmas.lemma_mult_le_right pow156 (v f3) (pow2 52 - 1);
Math.Lemmas.distributivity_sub_left (pow2 52) 1 pow156;
Math.Lemmas.pow2_plus 52 104 }
pow2 52 * pow156 + v f4 * pow208 - 1;
(<=) {
Math.Lemmas.lemma_mult_le_right pow208 (v f4) (pow2 a - 1);
Math.Lemmas.distributivity_sub_left (pow2 a) 1 pow208;
Math.Lemmas.pow2_plus 52 156;
Math.Lemmas.pow2_plus a 208 }
pow2 (208 + a) - 1;
}
val lemma_as_nat_bound: f:felem5 -> Lemma
(requires felem_fits5 f (1,1,1,1,1))
(ensures as_nat5 f < pow2 256)
let lemma_as_nat_bound f =
lemma_as_nat_bound_f4_lt_powa f 48
val lemma_as_nat_bound_f4_lt_pow12: f:felem5 -> Lemma
(requires (let (f0,f1,f2,f3,f4) = f in
felem_fits5 f (1,1,1,1,1) /\ v f4 < pow2 12))
(ensures as_nat5 f <= pow2 220 - 1)
let lemma_as_nat_bound_f4_lt_pow12 f =
lemma_as_nat_bound_f4_lt_powa f 12
val lemma_as_nat_decompose: f:felem5 -> Lemma
(requires felem_fits5 f (1,1,1,1,1))
(ensures (let (f0,f1,f2,f3,f4) = f in
v f4 = as_nat5 f / pow208 /\
v f3 = as_nat5 f % pow208 / pow156 /\
v f2 = as_nat5 f % pow156 / pow104 /\
v f1 = as_nat5 f % pow104 / pow52 /\
v f0 = as_nat5 f % pow52))
let lemma_as_nat_decompose f =
let (f0,f1,f2,f3,f4) = f in
lemma_as_nat_bound f;
Math.Lemmas.euclidean_division_definition (as_nat5 f) pow208;
assert (v f4 = as_nat5 f / pow208);
Math.Lemmas.euclidean_division_definition (as_nat5 f % pow208) pow156;
assert (v f3 = as_nat5 f % pow208 / pow156);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (as_nat5 f) 156 208;
assert (as_nat5 f % pow208 % pow156 == as_nat5 f % pow156);
Math.Lemmas.euclidean_division_definition (as_nat5 f % pow156) pow104;
assert (v f2 = as_nat5 f % pow156 / pow104);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (as_nat5 f) 104 156;
assert (as_nat5 f % pow156 % pow104 == as_nat5 f % pow104);
Math.Lemmas.euclidean_division_definition (as_nat5 f % pow104) pow52;
assert (v f1 = as_nat5 f % pow104 / pow52);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (as_nat5 f) 52 104;
assert (as_nat5 f % pow104 % pow52 == as_nat5 f % pow52);
assert (v f0 = as_nat5 f % pow52)
#push-options "--ifuel 1"
val as_nat_inj (f1 f2: felem5) : Lemma
(requires
felem_fits5 f1 (1,1,1,1,1) /\ felem_fits5 f2 (1,1,1,1,1) /\
as_nat5 f1 == as_nat5 f2)
(ensures
(let (a0,a1,a2,a3,a4) = f1 in let (b0,b1,b2,b3,b4) = f2 in
a0 == b0 /\ a1 == b1 /\ a2 == b2 /\ a3 == b3 /\ a4 == b4))
let as_nat_inj f1 f2 =
lemma_as_nat_decompose f1;
lemma_as_nat_decompose f2
#pop-options
val lemma_normalize_x_le_1: t4:uint64 -> Lemma
(requires felem_fits_last1 t4 2)
(ensures v t4 / pow2 48 <= 1)
let lemma_normalize_x_le_1 t4 =
calc (==) {
(2 * (pow2 48 - 1)) / pow2 48;
(==) { Math.Lemmas.distributivity_add_right 2 (pow2 48) 1 }
(2 * pow2 48 - 2) / pow2 48;
(==) { Math.Lemmas.division_addition_lemma (-2) (pow2 48) 2 }
(-2) / pow2 48 + 2;
(==) { assert_norm ((-2) / pow2 48 = -1) }
1;
};
assert (v t4 <= 2 * (pow2 48 - 1));
Math.Lemmas.lemma_div_le (v t4) (2 * pow2 48 - 2) (pow2 48);
assert (v t4 / pow2 48 <= 1)
val lemma_div_pow48: t4:uint64 -> Lemma
(requires felem_fits_last1 t4 2)
(ensures v t4 / pow2 48 == (if v t4 < pow2 48 then 0 else 1))
let lemma_div_pow48 t4 =
if v t4 < pow2 48 then
Math.Lemmas.small_div (v t4) (pow2 48)
else begin
lemma_normalize_x_le_1 t4;
assert (v t4 / pow2 48 <= 1);
Math.Lemmas.lemma_div_le (pow2 48) (v t4) (pow2 48);
assert (1 <= v t4 / pow2 48) end
val lemma_mask52: a:uint64 ->
Lemma (let r = a &. mask52 in
v r = v a % pow2 52 /\ felem_fits1 r 1)
let lemma_mask52 a =
let r = a &. mask52 in
assert_norm (v mask52 = pow2 52 - 1);
mod_mask_lemma a 52ul;
assert (v (mod_mask #U64 #SEC 52ul) == v mask52);
assert (v r = v a % pow2 52);
assert (felem_fits1 r 1)
val lemma_mask48: a:uint64 ->
Lemma (let r = a &. mask48 in
v r = v a % pow2 48 /\ felem_fits_last1 r 1)
let lemma_mask48 a =
let r = a &. mask48 in
assert_norm (v mask48 = pow2 48 - 1);
mod_mask_lemma a 48ul;
assert (v (mod_mask #U64 #SEC 48ul) == v mask48);
assert (v r = v a % pow2 48);
assert (felem_fits_last1 r 1)
val lemma_add_rsh52: m1:scale64 -> m2:scale64 -> a:uint64 -> b:uint64 -> Lemma
(requires felem_fits1 a m1 /\ felem_fits1 b m2 /\ m1 + 1 <= 4096)
(ensures (let c = a +. (b >>. 52ul) in
felem_fits1 c (m1 + 1) /\ v c = v a + v b / pow2 52))
let lemma_add_rsh52 m1 m2 a b =
let c = a +. (b >>. 52ul) in
calc (<) {
v a + v b / pow2 52;
(<) { Math.Lemmas.lemma_div_lt (v b) 64 52 }
m1 * max52 + pow2 12;
(<=) { Math.Lemmas.pow2_lt_compat 52 12 }
m1 * max52 + max52;
(==) { Math.Lemmas.distributivity_add_left m1 1 max52 }
(m1 + 1) * max52;
};
Math.Lemmas.lemma_mult_le_right max52 (m1 + 1) 4096;
assert_norm (4096 * max52 < pow2 64);
Math.Lemmas.small_mod (v a + v b / pow2 52) (pow2 64);
assert (v c = v a + v b / pow2 52);
assert (felem_fits1 c (m1 + 1))
val lemma_add_rsh52_last: m1:scale64_last -> m2:scale64 -> a:uint64 -> b:uint64 -> Lemma
(requires felem_fits_last1 a m1 /\ felem_fits1 b m2 /\ m1 + 1 <= 65536)
(ensures (let c = a +. (b >>. 52ul) in
felem_fits_last1 c (m1 + 1) /\ v c = v a + v b / pow2 52))
let lemma_add_rsh52_last m1 m2 a b =
let c = a +. (b >>. 52ul) in
calc (<) {
v a + v b / pow2 52;
(<) { Math.Lemmas.lemma_div_lt (v b) 64 52 }
m1 * max48 + pow2 12;
(<=) { Math.Lemmas.pow2_lt_compat 48 12 }
m1 * max48 + max48;
(==) { Math.Lemmas.distributivity_add_left m1 1 max48 }
(m1 + 1) * max48;
};
Math.Lemmas.lemma_mult_le_right max48 (m1 + 1) 65536;
assert_norm (65536 * max48 < pow2 64);
Math.Lemmas.small_mod (v a + v b / pow2 52) (pow2 64);
assert (v c = v a + v b / pow2 52);
assert (felem_fits_last1 c (m1 + 1))
val lemma_carry52: m1:scale64 -> m2:scale64 -> a:uint64 -> b:uint64 -> Lemma
(requires felem_fits1 a m1 /\ felem_fits1 b m2 /\ m1 + 1 <= 4096)
(ensures
(let c = a +. (b >>. 52ul) in let d = b &. mask52 in
felem_fits1 d 1 /\ felem_fits1 c (m1 + 1) /\
v d = v b % pow2 52 /\ v c = v a + v b / pow2 52))
let lemma_carry52 m1 m2 a b =
lemma_mask52 b;
lemma_add_rsh52 m1 m2 a b
val lemma_carry_last52: m1:scale64_last -> m2:scale64 -> a:uint64 -> b:uint64 -> Lemma
(requires felem_fits_last1 a m1 /\ felem_fits1 b m2 /\ m1 + 1 <= 65536)
(ensures
(let c = a +. (b >>. 52ul) in let d = b &. mask52 in
felem_fits1 d 1 /\ felem_fits_last1 c (m1 + 1) /\
v d = v b % pow2 52 /\ v c = v a + v b / pow2 52))
let lemma_carry_last52 m1 m2 a b =
lemma_mask52 b;
lemma_add_rsh52_last m1 m2 a b
val lemma_small_sub_mod: a:nat -> n:pos -> Lemma
(requires n <= a /\ a < 2 * n)
(ensures a % n = a - n)
let lemma_small_sub_mod a n =
calc (==) {
a % n;
(==) { Math.Lemmas.sub_div_mod_1 a n }
(a - n) % n;
(==) { Math.Lemmas.small_mod (a - n) n }
a - n;
}
val carry_last_small_mod_lemma: t4:uint64 -> t3':uint64 -> Lemma
(requires felem_fits_last1 t4 1 /\
v (t4 +. (t3' >>. 52ul)) == v t4 + v t3' / pow2 52)
(ensures (let r = t4 +. (t3' >>. 52ul) in
felem_fits_last1 r 2 /\
v r < v t4 + pow2 12 /\ (v r >= pow2 48 ==> v r % pow2 48 < pow2 12)))
let carry_last_small_mod_lemma t4 t3' =
let r = t4 +. (t3' >>. 52ul) in
assert (v r = v t4 + v t3' / pow2 52);
Math.Lemmas.lemma_div_lt (v t3') 64 52;
assert (v r < v t4 + pow2 12);
Math.Lemmas.pow2_lt_compat 48 12;
assert (felem_fits_last1 r 2);
if v r >= pow2 48 then begin
lemma_small_sub_mod (v r) (pow2 48);
assert (v r % pow2 48 = v r - pow2 48);
assert (v r % pow2 48 < pow2 12) end
val lemma_a_plus_b_mul_pow256 (a b:int) :
Lemma ((a + b * pow2 256) % S.prime == (a + b * 0x1000003D1) % S.prime) | false | false | Hacl.Spec.K256.Field52.Definitions.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_a_plus_b_mul_pow256 (a b:int) :
Lemma ((a + b * pow2 256) % S.prime == (a + b * 0x1000003D1) % S.prime) | [] | Hacl.Spec.K256.Field52.Definitions.Lemmas.lemma_a_plus_b_mul_pow256 | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Definitions.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Prims.int -> b: Prims.int
-> FStar.Pervasives.Lemma
(ensures
(a + b * Prims.pow2 256) % Spec.K256.PointOps.prime ==
(a + b * 0x1000003D1) % Spec.K256.PointOps.prime) | {
"end_col": 3,
"end_line": 373,
"start_col": 2,
"start_line": 363
} |
FStar.Pervasives.Lemma | val as_nat_mod_prime (t0 t1 t2 t3 t4:int) : Lemma
((t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + t4 * pow208) % S.prime =
(t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + (t4 % pow2 48) * pow208 + t4 / pow2 48 * 0x1000003D1) % S.prime) | [
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.MathLemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let as_nat_mod_prime t0 t1 t2 t3 t4 =
calc (==) {
(t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + t4 * pow208) % S.prime;
(==) { Math.Lemmas.euclidean_division_definition t4 (pow2 48) }
(t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + (t4 / pow2 48 * pow2 48 + t4 % pow2 48) * pow208) % S.prime;
(==) { Math.Lemmas.distributivity_add_left (t4 / pow2 48 * pow2 48) (t4 % pow2 48) pow208 }
(t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + t4 / pow2 48 * pow2 48 * pow208 + t4 % pow2 48 * pow208) % S.prime;
(==) { Math.Lemmas.paren_mul_right (t4 / pow2 48) (pow2 48) pow208; Math.Lemmas.pow2_plus 48 208 }
(t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + t4 / pow2 48 * pow2 256 + t4 % pow2 48 * pow208) % S.prime;
(==) { lemma_a_plus_b_mul_pow256 (t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + t4 % pow2 48 * pow208) (t4 / pow2 48) }
(t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + t4 % pow2 48 * pow208 + t4 / pow2 48 * 0x1000003D1) % S.prime;
} | val as_nat_mod_prime (t0 t1 t2 t3 t4:int) : Lemma
((t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + t4 * pow208) % S.prime =
(t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + (t4 % pow2 48) * pow208 + t4 / pow2 48 * 0x1000003D1) % S.prime)
let as_nat_mod_prime t0 t1 t2 t3 t4 = | false | null | true | calc ( == ) {
(t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + t4 * pow208) % S.prime;
( == ) { Math.Lemmas.euclidean_division_definition t4 (pow2 48) }
(t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + ((t4 / pow2 48) * pow2 48 + t4 % pow2 48) * pow208) %
S.prime;
( == ) { Math.Lemmas.distributivity_add_left ((t4 / pow2 48) * pow2 48) (t4 % pow2 48) pow208 }
(t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + ((t4 / pow2 48) * pow2 48) * pow208 +
(t4 % pow2 48) * pow208) %
S.prime;
( == ) { (Math.Lemmas.paren_mul_right (t4 / pow2 48) (pow2 48) pow208;
Math.Lemmas.pow2_plus 48 208) }
(t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + (t4 / pow2 48) * pow2 256 + (t4 % pow2 48) * pow208
) %
S.prime;
( == ) { lemma_a_plus_b_mul_pow256 (t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 +
(t4 % pow2 48) * pow208)
(t4 / pow2 48) }
(t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + (t4 % pow2 48) * pow208 +
(t4 / pow2 48) * 0x1000003D1) %
S.prime;
} | {
"checked_file": "Hacl.Spec.K256.Field52.Definitions.Lemmas.fst.checked",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.K256.MathLemmas.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.Field52.Definitions.Lemmas.fst"
} | [
"lemma"
] | [
"Prims.int",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Prims.op_Modulus",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Hacl.Spec.K256.Field52.Definitions.pow52",
"Hacl.Spec.K256.Field52.Definitions.pow104",
"Hacl.Spec.K256.Field52.Definitions.pow156",
"Hacl.Spec.K256.Field52.Definitions.pow208",
"Spec.K256.PointOps.prime",
"Prims.pow2",
"Prims.op_Division",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.euclidean_division_definition",
"Prims.squash",
"FStar.Math.Lemmas.distributivity_add_left",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.paren_mul_right",
"Hacl.Spec.K256.Field52.Definitions.Lemmas.lemma_a_plus_b_mul_pow256"
] | [] | module Hacl.Spec.K256.Field52.Definitions.Lemmas
open FStar.Mul
open Lib.IntTypes
open Hacl.Spec.K256.Field52.Definitions
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.K256
module ML = Hacl.Spec.K256.MathLemmas
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
val lemma_as_nat_mod2: x:felem5 ->
Lemma (let (x0,x1,x2,x3,x4) = x in as_nat5 x % 2 = v x0 % 2)
let lemma_as_nat_mod2 x =
let (x0,x1,x2,x3,x4) = x in
assert (as_nat5 x = v x0 + v x1 * pow52 + v x2 * pow104 + v x3 * pow156 + v x4 * pow208);
assert (as_nat5 x % 2 = (v x0 + v x1 * pow52 + v x2 * pow104 + v x3 * pow156 + v x4 * pow208) % 2);
ML.lemma_a_plus_b_pow2_mod2 (v x0 + v x1 * pow52 + v x2 * pow104 + v x3 * pow156) (v x4) 208;
ML.lemma_a_plus_b_pow2_mod2 (v x0 + v x1 * pow52 + v x2 * pow104) (v x3) 156;
ML.lemma_a_plus_b_pow2_mod2 (v x0 + v x1 * pow52) (v x2) 104;
ML.lemma_a_plus_b_pow2_mod2 (v x0) (v x1) 52;
assert (as_nat5 x % 2 = v x0 % 2)
val lemma_nat_from_bytes_be_mod2: f:LSeq.lseq uint8 32 ->
Lemma (BSeq.nat_from_bytes_be f % 2 = v (LSeq.index f 31) % 2)
let lemma_nat_from_bytes_be_mod2 f =
let x0 = LSeq.index f 31 in
BSeq.nat_from_intseq_be_slice_lemma f 31;
BSeq.nat_from_intseq_be_lemma0 (LSeq.slice f 31 32);
assert (BSeq.nat_from_intseq_be f == v x0 + pow2 8 * BSeq.nat_from_intseq_be (LSeq.slice f 0 31));
ML.lemma_a_plus_b_pow2_mod2 (v x0) (BSeq.nat_from_intseq_be (LSeq.slice f 0 31)) 8
val unfold_nat_from_uint64_four: b:LSeq.lseq uint64 4 ->
Lemma (BSeq.nat_from_intseq_be b ==
v (LSeq.index b 3) + v (LSeq.index b 2) * pow2 64 +
v (LSeq.index b 1) * pow2 128 + v (LSeq.index b 0) * pow2 192)
let unfold_nat_from_uint64_four b =
let b0 = v (LSeq.index b 0) in
let b1 = v (LSeq.index b 1) in
let b2 = v (LSeq.index b 2) in
let b3 = v (LSeq.index b 3) in
let res = BSeq.nat_from_intseq_be b in
BSeq.nat_from_intseq_be_slice_lemma b 3;
BSeq.nat_from_intseq_be_lemma0 (Seq.slice b 3 4);
assert (res == b3 + pow2 64 * (BSeq.nat_from_intseq_be (Seq.slice b 0 3)));
BSeq.nat_from_intseq_be_slice_lemma #U64 #SEC #3 (Seq.slice b 0 3) 2;
BSeq.nat_from_intseq_be_lemma0 (Seq.slice b 2 3);
assert (BSeq.nat_from_intseq_be (Seq.slice b 0 3) == b2 + pow2 64 * (BSeq.nat_from_intseq_be (Seq.slice b 0 2)));
BSeq.nat_from_intseq_be_slice_lemma #U64 #SEC #2 (Seq.slice b 0 2) 1;
BSeq.nat_from_intseq_be_lemma0 (Seq.slice b 1 2);
assert (BSeq.nat_from_intseq_be (Seq.slice b 0 2) == b1 + pow2 64 * (BSeq.nat_from_intseq_be (Seq.slice b 0 1)));
BSeq.nat_from_intseq_be_lemma0 (Seq.slice b 0 1);
assert (res == b3 + pow2 64 * (b2 + pow2 64 * (b1 + pow2 64 * b0)));
ML.lemma_as_nat64_horner b3 b2 b1 b0
val lemma_prime : unit -> Lemma (pow2 256 % S.prime = 0x1000003D1)
let lemma_prime () = ()
val lemma_pow2_256_minus_prime : unit -> Lemma (pow2 256 - S.prime = 0x1000003D1)
let lemma_pow2_256_minus_prime () = ()
val lemma_pow2_260_mod_prime: unit -> Lemma (pow2 260 % S.prime = 0x1000003D10)
let lemma_pow2_260_mod_prime () =
calc (==) {
pow2 260 % S.prime;
(==) { Math.Lemmas.pow2_plus 256 4 }
pow2 256 * pow2 4 % S.prime;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (pow2 256) (pow2 4) S.prime }
(pow2 256 % S.prime) * pow2 4 % S.prime;
(==) { lemma_prime () }
0x1000003D1 * pow2 4 % S.prime;
(==) { assert_norm (0x1000003D1 * pow2 4 = 0x1000003D10) }
0x1000003D10 % S.prime;
(==) { Math.Lemmas.small_mod 0x1000003D10 S.prime }
0x1000003D10;
}
val lemma_as_nat_bound_f4_lt_powa: f:felem5 -> a:nat -> Lemma
(requires (let (f0,f1,f2,f3,f4) = f in
felem_fits5 f (1,1,1,1,1) /\ v f4 < pow2 a))
(ensures as_nat5 f <= pow2 (208 + a) - 1)
let lemma_as_nat_bound_f4_lt_powa f a =
let (f0,f1,f2,f3,f4) = f in
calc (<=) { //as_nat5 f ==
v f0 + v f1 * pow52 + v f2 * pow104 + v f3 * pow156 + v f4 * pow208;
(<=) { }
pow2 52 - 1 + v f1 * pow52 + v f2 * pow104 + v f3 * pow156 + v f4 * pow208;
(<=) {
Math.Lemmas.lemma_mult_le_right pow52 (v f1) (pow2 52 - 1);
Math.Lemmas.distributivity_sub_left (pow2 52) 1 pow52 }
pow2 52 * pow52 + v f2 * pow104 + v f3 * pow156 + v f4 * pow208 - 1;
(<=) {
Math.Lemmas.lemma_mult_le_right pow104 (v f2) (pow2 52 - 1);
Math.Lemmas.distributivity_sub_left (pow2 52) 1 pow104;
Math.Lemmas.pow2_plus 52 52 }
pow2 52 * pow104 + v f3 * pow156 + v f4 * pow208 - 1;
(<=) {
Math.Lemmas.lemma_mult_le_right pow156 (v f3) (pow2 52 - 1);
Math.Lemmas.distributivity_sub_left (pow2 52) 1 pow156;
Math.Lemmas.pow2_plus 52 104 }
pow2 52 * pow156 + v f4 * pow208 - 1;
(<=) {
Math.Lemmas.lemma_mult_le_right pow208 (v f4) (pow2 a - 1);
Math.Lemmas.distributivity_sub_left (pow2 a) 1 pow208;
Math.Lemmas.pow2_plus 52 156;
Math.Lemmas.pow2_plus a 208 }
pow2 (208 + a) - 1;
}
val lemma_as_nat_bound: f:felem5 -> Lemma
(requires felem_fits5 f (1,1,1,1,1))
(ensures as_nat5 f < pow2 256)
let lemma_as_nat_bound f =
lemma_as_nat_bound_f4_lt_powa f 48
val lemma_as_nat_bound_f4_lt_pow12: f:felem5 -> Lemma
(requires (let (f0,f1,f2,f3,f4) = f in
felem_fits5 f (1,1,1,1,1) /\ v f4 < pow2 12))
(ensures as_nat5 f <= pow2 220 - 1)
let lemma_as_nat_bound_f4_lt_pow12 f =
lemma_as_nat_bound_f4_lt_powa f 12
val lemma_as_nat_decompose: f:felem5 -> Lemma
(requires felem_fits5 f (1,1,1,1,1))
(ensures (let (f0,f1,f2,f3,f4) = f in
v f4 = as_nat5 f / pow208 /\
v f3 = as_nat5 f % pow208 / pow156 /\
v f2 = as_nat5 f % pow156 / pow104 /\
v f1 = as_nat5 f % pow104 / pow52 /\
v f0 = as_nat5 f % pow52))
let lemma_as_nat_decompose f =
let (f0,f1,f2,f3,f4) = f in
lemma_as_nat_bound f;
Math.Lemmas.euclidean_division_definition (as_nat5 f) pow208;
assert (v f4 = as_nat5 f / pow208);
Math.Lemmas.euclidean_division_definition (as_nat5 f % pow208) pow156;
assert (v f3 = as_nat5 f % pow208 / pow156);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (as_nat5 f) 156 208;
assert (as_nat5 f % pow208 % pow156 == as_nat5 f % pow156);
Math.Lemmas.euclidean_division_definition (as_nat5 f % pow156) pow104;
assert (v f2 = as_nat5 f % pow156 / pow104);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (as_nat5 f) 104 156;
assert (as_nat5 f % pow156 % pow104 == as_nat5 f % pow104);
Math.Lemmas.euclidean_division_definition (as_nat5 f % pow104) pow52;
assert (v f1 = as_nat5 f % pow104 / pow52);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (as_nat5 f) 52 104;
assert (as_nat5 f % pow104 % pow52 == as_nat5 f % pow52);
assert (v f0 = as_nat5 f % pow52)
#push-options "--ifuel 1"
val as_nat_inj (f1 f2: felem5) : Lemma
(requires
felem_fits5 f1 (1,1,1,1,1) /\ felem_fits5 f2 (1,1,1,1,1) /\
as_nat5 f1 == as_nat5 f2)
(ensures
(let (a0,a1,a2,a3,a4) = f1 in let (b0,b1,b2,b3,b4) = f2 in
a0 == b0 /\ a1 == b1 /\ a2 == b2 /\ a3 == b3 /\ a4 == b4))
let as_nat_inj f1 f2 =
lemma_as_nat_decompose f1;
lemma_as_nat_decompose f2
#pop-options
val lemma_normalize_x_le_1: t4:uint64 -> Lemma
(requires felem_fits_last1 t4 2)
(ensures v t4 / pow2 48 <= 1)
let lemma_normalize_x_le_1 t4 =
calc (==) {
(2 * (pow2 48 - 1)) / pow2 48;
(==) { Math.Lemmas.distributivity_add_right 2 (pow2 48) 1 }
(2 * pow2 48 - 2) / pow2 48;
(==) { Math.Lemmas.division_addition_lemma (-2) (pow2 48) 2 }
(-2) / pow2 48 + 2;
(==) { assert_norm ((-2) / pow2 48 = -1) }
1;
};
assert (v t4 <= 2 * (pow2 48 - 1));
Math.Lemmas.lemma_div_le (v t4) (2 * pow2 48 - 2) (pow2 48);
assert (v t4 / pow2 48 <= 1)
val lemma_div_pow48: t4:uint64 -> Lemma
(requires felem_fits_last1 t4 2)
(ensures v t4 / pow2 48 == (if v t4 < pow2 48 then 0 else 1))
let lemma_div_pow48 t4 =
if v t4 < pow2 48 then
Math.Lemmas.small_div (v t4) (pow2 48)
else begin
lemma_normalize_x_le_1 t4;
assert (v t4 / pow2 48 <= 1);
Math.Lemmas.lemma_div_le (pow2 48) (v t4) (pow2 48);
assert (1 <= v t4 / pow2 48) end
val lemma_mask52: a:uint64 ->
Lemma (let r = a &. mask52 in
v r = v a % pow2 52 /\ felem_fits1 r 1)
let lemma_mask52 a =
let r = a &. mask52 in
assert_norm (v mask52 = pow2 52 - 1);
mod_mask_lemma a 52ul;
assert (v (mod_mask #U64 #SEC 52ul) == v mask52);
assert (v r = v a % pow2 52);
assert (felem_fits1 r 1)
val lemma_mask48: a:uint64 ->
Lemma (let r = a &. mask48 in
v r = v a % pow2 48 /\ felem_fits_last1 r 1)
let lemma_mask48 a =
let r = a &. mask48 in
assert_norm (v mask48 = pow2 48 - 1);
mod_mask_lemma a 48ul;
assert (v (mod_mask #U64 #SEC 48ul) == v mask48);
assert (v r = v a % pow2 48);
assert (felem_fits_last1 r 1)
val lemma_add_rsh52: m1:scale64 -> m2:scale64 -> a:uint64 -> b:uint64 -> Lemma
(requires felem_fits1 a m1 /\ felem_fits1 b m2 /\ m1 + 1 <= 4096)
(ensures (let c = a +. (b >>. 52ul) in
felem_fits1 c (m1 + 1) /\ v c = v a + v b / pow2 52))
let lemma_add_rsh52 m1 m2 a b =
let c = a +. (b >>. 52ul) in
calc (<) {
v a + v b / pow2 52;
(<) { Math.Lemmas.lemma_div_lt (v b) 64 52 }
m1 * max52 + pow2 12;
(<=) { Math.Lemmas.pow2_lt_compat 52 12 }
m1 * max52 + max52;
(==) { Math.Lemmas.distributivity_add_left m1 1 max52 }
(m1 + 1) * max52;
};
Math.Lemmas.lemma_mult_le_right max52 (m1 + 1) 4096;
assert_norm (4096 * max52 < pow2 64);
Math.Lemmas.small_mod (v a + v b / pow2 52) (pow2 64);
assert (v c = v a + v b / pow2 52);
assert (felem_fits1 c (m1 + 1))
val lemma_add_rsh52_last: m1:scale64_last -> m2:scale64 -> a:uint64 -> b:uint64 -> Lemma
(requires felem_fits_last1 a m1 /\ felem_fits1 b m2 /\ m1 + 1 <= 65536)
(ensures (let c = a +. (b >>. 52ul) in
felem_fits_last1 c (m1 + 1) /\ v c = v a + v b / pow2 52))
let lemma_add_rsh52_last m1 m2 a b =
let c = a +. (b >>. 52ul) in
calc (<) {
v a + v b / pow2 52;
(<) { Math.Lemmas.lemma_div_lt (v b) 64 52 }
m1 * max48 + pow2 12;
(<=) { Math.Lemmas.pow2_lt_compat 48 12 }
m1 * max48 + max48;
(==) { Math.Lemmas.distributivity_add_left m1 1 max48 }
(m1 + 1) * max48;
};
Math.Lemmas.lemma_mult_le_right max48 (m1 + 1) 65536;
assert_norm (65536 * max48 < pow2 64);
Math.Lemmas.small_mod (v a + v b / pow2 52) (pow2 64);
assert (v c = v a + v b / pow2 52);
assert (felem_fits_last1 c (m1 + 1))
val lemma_carry52: m1:scale64 -> m2:scale64 -> a:uint64 -> b:uint64 -> Lemma
(requires felem_fits1 a m1 /\ felem_fits1 b m2 /\ m1 + 1 <= 4096)
(ensures
(let c = a +. (b >>. 52ul) in let d = b &. mask52 in
felem_fits1 d 1 /\ felem_fits1 c (m1 + 1) /\
v d = v b % pow2 52 /\ v c = v a + v b / pow2 52))
let lemma_carry52 m1 m2 a b =
lemma_mask52 b;
lemma_add_rsh52 m1 m2 a b
val lemma_carry_last52: m1:scale64_last -> m2:scale64 -> a:uint64 -> b:uint64 -> Lemma
(requires felem_fits_last1 a m1 /\ felem_fits1 b m2 /\ m1 + 1 <= 65536)
(ensures
(let c = a +. (b >>. 52ul) in let d = b &. mask52 in
felem_fits1 d 1 /\ felem_fits_last1 c (m1 + 1) /\
v d = v b % pow2 52 /\ v c = v a + v b / pow2 52))
let lemma_carry_last52 m1 m2 a b =
lemma_mask52 b;
lemma_add_rsh52_last m1 m2 a b
val lemma_small_sub_mod: a:nat -> n:pos -> Lemma
(requires n <= a /\ a < 2 * n)
(ensures a % n = a - n)
let lemma_small_sub_mod a n =
calc (==) {
a % n;
(==) { Math.Lemmas.sub_div_mod_1 a n }
(a - n) % n;
(==) { Math.Lemmas.small_mod (a - n) n }
a - n;
}
val carry_last_small_mod_lemma: t4:uint64 -> t3':uint64 -> Lemma
(requires felem_fits_last1 t4 1 /\
v (t4 +. (t3' >>. 52ul)) == v t4 + v t3' / pow2 52)
(ensures (let r = t4 +. (t3' >>. 52ul) in
felem_fits_last1 r 2 /\
v r < v t4 + pow2 12 /\ (v r >= pow2 48 ==> v r % pow2 48 < pow2 12)))
let carry_last_small_mod_lemma t4 t3' =
let r = t4 +. (t3' >>. 52ul) in
assert (v r = v t4 + v t3' / pow2 52);
Math.Lemmas.lemma_div_lt (v t3') 64 52;
assert (v r < v t4 + pow2 12);
Math.Lemmas.pow2_lt_compat 48 12;
assert (felem_fits_last1 r 2);
if v r >= pow2 48 then begin
lemma_small_sub_mod (v r) (pow2 48);
assert (v r % pow2 48 = v r - pow2 48);
assert (v r % pow2 48 < pow2 12) end
val lemma_a_plus_b_mul_pow256 (a b:int) :
Lemma ((a + b * pow2 256) % S.prime == (a + b * 0x1000003D1) % S.prime)
let lemma_a_plus_b_mul_pow256 a b =
calc (==) {
(a + b * pow2 256) % S.prime;
(==) { Math.Lemmas.lemma_mod_plus_distr_r a (b * pow2 256) S.prime }
(a + b * pow2 256 % S.prime) % S.prime;
(==) { Math.Lemmas.lemma_mod_mul_distr_r b (pow2 256) S.prime }
(a + b * (pow2 256 % S.prime) % S.prime) % S.prime;
(==) { lemma_prime () }
(a + b * 0x1000003D1 % S.prime) % S.prime;
(==) { Math.Lemmas.lemma_mod_plus_distr_r a (b * 0x1000003D1) S.prime }
(a + b * 0x1000003D1) % S.prime;
}
val as_nat_mod_prime (t0 t1 t2 t3 t4:int) : Lemma
((t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + t4 * pow208) % S.prime =
(t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + (t4 % pow2 48) * pow208 + t4 / pow2 48 * 0x1000003D1) % S.prime) | false | false | Hacl.Spec.K256.Field52.Definitions.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val as_nat_mod_prime (t0 t1 t2 t3 t4:int) : Lemma
((t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + t4 * pow208) % S.prime =
(t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + (t4 % pow2 48) * pow208 + t4 / pow2 48 * 0x1000003D1) % S.prime) | [] | Hacl.Spec.K256.Field52.Definitions.Lemmas.as_nat_mod_prime | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Definitions.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | t0: Prims.int -> t1: Prims.int -> t2: Prims.int -> t3: Prims.int -> t4: Prims.int
-> FStar.Pervasives.Lemma
(ensures
(t0 + t1 * Hacl.Spec.K256.Field52.Definitions.pow52 +
t2 * Hacl.Spec.K256.Field52.Definitions.pow104 +
t3 * Hacl.Spec.K256.Field52.Definitions.pow156 +
t4 * Hacl.Spec.K256.Field52.Definitions.pow208) %
Spec.K256.PointOps.prime =
(t0 + t1 * Hacl.Spec.K256.Field52.Definitions.pow52 +
t2 * Hacl.Spec.K256.Field52.Definitions.pow104 +
t3 * Hacl.Spec.K256.Field52.Definitions.pow156 +
(t4 % Prims.pow2 48) * Hacl.Spec.K256.Field52.Definitions.pow208 +
(t4 / Prims.pow2 48) * 0x1000003D1) %
Spec.K256.PointOps.prime) | {
"end_col": 3,
"end_line": 391,
"start_col": 2,
"start_line": 381
} |
Prims.Tot | val const_on (#key: eqtype) (#value: Type) (dom: S.set key) (v: value) : t key value | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.Set",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Set",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Set",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let const_on (#key:eqtype) (#value:Type) (dom:S.set key) (v:value)
: t key value
= restrict dom (const v) | val const_on (#key: eqtype) (#value: Type) (dom: S.set key) (v: value) : t key value
let const_on (#key: eqtype) (#value: Type) (dom: S.set key) (v: value) : t key value = | false | null | false | restrict dom (const v) | {
"checked_file": "FStar.Map.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Map.fsti"
} | [
"total"
] | [
"Prims.eqtype",
"FStar.Set.set",
"FStar.Map.restrict",
"FStar.Map.const",
"FStar.Map.t"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
@summary FStar.Map provides a polymorphic, partial map from keys to
values, where keys support decidable equality.
`m:Map.t key value` is a partial map from `key` to `value`
A distinctive feature of the library is in its model of partiality.
A map can be seen as a pair of:
1. a total map `key -> Tot value`
2. a set of keys that record the domain of the map
*)
module FStar.Map
module S = FStar.Set
(* Map.t key value: The main type provided by this module *)
val t (key:eqtype) ([@@@strictly_positive] value:Type u#a)
: Type u#a
(* sel m k : Look up key `k` in map `m` *)
val sel: #key:eqtype -> #value:Type -> t key value -> key -> Tot value
(* upd m k v : A map identical to `m` except mapping `k` to `v` *)
val upd: #key:eqtype -> #value:Type -> t key value -> key -> value -> Tot (t key value)
(* const v : A constant map mapping all keys to `v` *)
val const: #key:eqtype -> #value:Type -> value -> Tot (t key value)
(* domain m : The set of keys on which this partial map is defined *)
val domain: #key:eqtype -> #value:Type -> t key value -> Tot (S.set key)
(* contains m k: Decides if key `k` is in the map `m` *)
val contains: #key:eqtype -> #value:Type -> t key value -> key -> Tot bool
(* concat m1 m2 :
A map whose domain is the union of the domains of `m1` and `m2`.
Maps every key `k` in the domain of `m1` to `sel m1 k`
and all other keys to `sel m2 k`.
*)
val concat: #key:eqtype -> #value:Type -> t key value -> t key value -> Tot (t key value)
(* map_val f m:
A map whose domain is the same as `m` but all values have
`f` applied to them.
*)
val map_val: #val1:Type -> #val2:Type -> f:(val1 -> val2) -> #key:eqtype -> t key val1 -> Tot (t key val2)
(* restrict s m:
Restricts the domain of `m` to (domain m `intersect` s)
*)
val restrict: #key:eqtype -> #value:Type -> S.set key -> t key value -> Tot (t key value)
(* const_on dom v: A defined notion, for convenience
A partial constant map on dom
*)
let const_on (#key:eqtype) (#value:Type) (dom:S.set key) (v:value) | false | false | FStar.Map.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val const_on (#key: eqtype) (#value: Type) (dom: S.set key) (v: value) : t key value | [] | FStar.Map.const_on | {
"file_name": "ulib/FStar.Map.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | dom: FStar.Set.set key -> v: value -> FStar.Map.t key value | {
"end_col": 26,
"end_line": 77,
"start_col": 4,
"start_line": 77
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.Set",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Set",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Set",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let has_dom (#key:eqtype) (#value:Type) (m:t key value) (dom:S.set key)
= forall x. contains m x <==> S.mem x dom | let has_dom (#key: eqtype) (#value: Type) (m: t key value) (dom: S.set key) = | false | null | false | forall x. contains m x <==> S.mem x dom | {
"checked_file": "FStar.Map.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Map.fsti"
} | [
"total"
] | [
"Prims.eqtype",
"FStar.Map.t",
"FStar.Set.set",
"Prims.l_Forall",
"Prims.l_iff",
"Prims.b2t",
"FStar.Map.contains",
"FStar.Set.mem",
"Prims.logical"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
@summary FStar.Map provides a polymorphic, partial map from keys to
values, where keys support decidable equality.
`m:Map.t key value` is a partial map from `key` to `value`
A distinctive feature of the library is in its model of partiality.
A map can be seen as a pair of:
1. a total map `key -> Tot value`
2. a set of keys that record the domain of the map
*)
module FStar.Map
module S = FStar.Set
(* Map.t key value: The main type provided by this module *)
val t (key:eqtype) ([@@@strictly_positive] value:Type u#a)
: Type u#a
(* sel m k : Look up key `k` in map `m` *)
val sel: #key:eqtype -> #value:Type -> t key value -> key -> Tot value
(* upd m k v : A map identical to `m` except mapping `k` to `v` *)
val upd: #key:eqtype -> #value:Type -> t key value -> key -> value -> Tot (t key value)
(* const v : A constant map mapping all keys to `v` *)
val const: #key:eqtype -> #value:Type -> value -> Tot (t key value)
(* domain m : The set of keys on which this partial map is defined *)
val domain: #key:eqtype -> #value:Type -> t key value -> Tot (S.set key)
(* contains m k: Decides if key `k` is in the map `m` *)
val contains: #key:eqtype -> #value:Type -> t key value -> key -> Tot bool
(* concat m1 m2 :
A map whose domain is the union of the domains of `m1` and `m2`.
Maps every key `k` in the domain of `m1` to `sel m1 k`
and all other keys to `sel m2 k`.
*)
val concat: #key:eqtype -> #value:Type -> t key value -> t key value -> Tot (t key value)
(* map_val f m:
A map whose domain is the same as `m` but all values have
`f` applied to them.
*)
val map_val: #val1:Type -> #val2:Type -> f:(val1 -> val2) -> #key:eqtype -> t key val1 -> Tot (t key val2)
(* restrict s m:
Restricts the domain of `m` to (domain m `intersect` s)
*)
val restrict: #key:eqtype -> #value:Type -> S.set key -> t key value -> Tot (t key value)
(* const_on dom v: A defined notion, for convenience
A partial constant map on dom
*)
let const_on (#key:eqtype) (#value:Type) (dom:S.set key) (v:value)
: t key value
= restrict dom (const v)
(* map_literal f: A map that is extensionally equal to the function [f] *)
val map_literal (#k:eqtype) (#v:Type) (f: k -> Tot v)
: t k v
(* disjoint_dom m1 m2:
Disjoint domains. TODO: its pattern is biased towards `m1`. Why?
*)
let disjoint_dom (#key:eqtype) (#value:Type) (m1:t key value) (m2:t key value)
= forall x.{:pattern (contains m1 x)(* ; (contains m2 x) *)} contains m1 x ==> not (contains m2 x)
(* has_dom m dom: A relational version of the `domain m` function *) | false | false | FStar.Map.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val has_dom : m: FStar.Map.t key value -> dom: FStar.Set.set key -> Prims.logical | [] | FStar.Map.has_dom | {
"file_name": "ulib/FStar.Map.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | m: FStar.Map.t key value -> dom: FStar.Set.set key -> Prims.logical | {
"end_col": 43,
"end_line": 92,
"start_col": 4,
"start_line": 92
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "FStar.Set",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Set",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Set",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let disjoint_dom (#key:eqtype) (#value:Type) (m1:t key value) (m2:t key value)
= forall x.{:pattern (contains m1 x)(* ; (contains m2 x) *)} contains m1 x ==> not (contains m2 x) | let disjoint_dom (#key: eqtype) (#value: Type) (m1 m2: t key value) = | false | null | false | forall x. {:pattern (contains m1 x)} contains m1 x ==> not (contains m2 x) | {
"checked_file": "FStar.Map.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Map.fsti"
} | [
"total"
] | [
"Prims.eqtype",
"FStar.Map.t",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.b2t",
"FStar.Map.contains",
"Prims.op_Negation",
"Prims.logical"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
(**
@summary FStar.Map provides a polymorphic, partial map from keys to
values, where keys support decidable equality.
`m:Map.t key value` is a partial map from `key` to `value`
A distinctive feature of the library is in its model of partiality.
A map can be seen as a pair of:
1. a total map `key -> Tot value`
2. a set of keys that record the domain of the map
*)
module FStar.Map
module S = FStar.Set
(* Map.t key value: The main type provided by this module *)
val t (key:eqtype) ([@@@strictly_positive] value:Type u#a)
: Type u#a
(* sel m k : Look up key `k` in map `m` *)
val sel: #key:eqtype -> #value:Type -> t key value -> key -> Tot value
(* upd m k v : A map identical to `m` except mapping `k` to `v` *)
val upd: #key:eqtype -> #value:Type -> t key value -> key -> value -> Tot (t key value)
(* const v : A constant map mapping all keys to `v` *)
val const: #key:eqtype -> #value:Type -> value -> Tot (t key value)
(* domain m : The set of keys on which this partial map is defined *)
val domain: #key:eqtype -> #value:Type -> t key value -> Tot (S.set key)
(* contains m k: Decides if key `k` is in the map `m` *)
val contains: #key:eqtype -> #value:Type -> t key value -> key -> Tot bool
(* concat m1 m2 :
A map whose domain is the union of the domains of `m1` and `m2`.
Maps every key `k` in the domain of `m1` to `sel m1 k`
and all other keys to `sel m2 k`.
*)
val concat: #key:eqtype -> #value:Type -> t key value -> t key value -> Tot (t key value)
(* map_val f m:
A map whose domain is the same as `m` but all values have
`f` applied to them.
*)
val map_val: #val1:Type -> #val2:Type -> f:(val1 -> val2) -> #key:eqtype -> t key val1 -> Tot (t key val2)
(* restrict s m:
Restricts the domain of `m` to (domain m `intersect` s)
*)
val restrict: #key:eqtype -> #value:Type -> S.set key -> t key value -> Tot (t key value)
(* const_on dom v: A defined notion, for convenience
A partial constant map on dom
*)
let const_on (#key:eqtype) (#value:Type) (dom:S.set key) (v:value)
: t key value
= restrict dom (const v)
(* map_literal f: A map that is extensionally equal to the function [f] *)
val map_literal (#k:eqtype) (#v:Type) (f: k -> Tot v)
: t k v
(* disjoint_dom m1 m2:
Disjoint domains. TODO: its pattern is biased towards `m1`. Why?
*) | false | false | FStar.Map.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val disjoint_dom : m1: FStar.Map.t key value -> m2: FStar.Map.t key value -> Prims.logical | [] | FStar.Map.disjoint_dom | {
"file_name": "ulib/FStar.Map.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | m1: FStar.Map.t key value -> m2: FStar.Map.t key value -> Prims.logical | {
"end_col": 100,
"end_line": 88,
"start_col": 4,
"start_line": 88
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lbignum = Hacl.Bignum.Definitions.lbignum | let lbignum = | false | null | false | Hacl.Bignum.Definitions.lbignum | {
"checked_file": "Hacl.Bignum64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Bignum.SafeAPI.fst.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum64.fsti"
} | [
"total"
] | [
"Hacl.Bignum.Definitions.lbignum"
] | [] | module Hacl.Bignum64
open FStar.Mul
module BN = Hacl.Bignum
module BS = Hacl.Bignum.SafeAPI
module MA = Hacl.Bignum.MontArithmetic
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let t_limbs: Hacl.Bignum.Definitions.limb_t = Lib.IntTypes.U64 | false | true | Hacl.Bignum64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lbignum : t: Hacl.Bignum.Definitions.limb_t -> len: Lib.IntTypes.size_t -> Type0 | [] | Hacl.Bignum64.lbignum | {
"file_name": "code/bignum/Hacl.Bignum64.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | t: Hacl.Bignum.Definitions.limb_t -> len: Lib.IntTypes.size_t -> Type0 | {
"end_col": 45,
"end_line": 15,
"start_col": 14,
"start_line": 15
} |
|
Prims.Tot | val t_limbs:Hacl.Bignum.Definitions.limb_t | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let t_limbs: Hacl.Bignum.Definitions.limb_t = Lib.IntTypes.U64 | val t_limbs:Hacl.Bignum.Definitions.limb_t
let t_limbs:Hacl.Bignum.Definitions.limb_t = | false | null | false | Lib.IntTypes.U64 | {
"checked_file": "Hacl.Bignum64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Bignum.SafeAPI.fst.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum64.fsti"
} | [
"total"
] | [
"Lib.IntTypes.U64"
] | [] | module Hacl.Bignum64
open FStar.Mul
module BN = Hacl.Bignum
module BS = Hacl.Bignum.SafeAPI
module MA = Hacl.Bignum.MontArithmetic
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0" | false | true | Hacl.Bignum64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val t_limbs:Hacl.Bignum.Definitions.limb_t | [] | Hacl.Bignum64.t_limbs | {
"file_name": "code/bignum/Hacl.Bignum64.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Bignum.Definitions.limb_t | {
"end_col": 62,
"end_line": 12,
"start_col": 46,
"start_line": 12
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.MontArithmetic",
"short_module": "MA"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.SafeAPI",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let pbn_mont_ctx_u64 = MA.pbn_mont_ctx_u64 | let pbn_mont_ctx_u64 = | false | null | false | MA.pbn_mont_ctx_u64 | {
"checked_file": "Hacl.Bignum64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Bignum.SafeAPI.fst.checked",
"Hacl.Bignum.MontArithmetic.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.Convert.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum64.fsti"
} | [
"total"
] | [
"Hacl.Bignum.MontArithmetic.pbn_mont_ctx_u64"
] | [] | module Hacl.Bignum64
open FStar.Mul
module BN = Hacl.Bignum
module BS = Hacl.Bignum.SafeAPI
module MA = Hacl.Bignum.MontArithmetic
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let t_limbs: Hacl.Bignum.Definitions.limb_t = Lib.IntTypes.U64
inline_for_extraction noextract
let lbignum = Hacl.Bignum.Definitions.lbignum | false | true | Hacl.Bignum64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val pbn_mont_ctx_u64 : Type0 | [] | Hacl.Bignum64.pbn_mont_ctx_u64 | {
"file_name": "code/bignum/Hacl.Bignum64.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 42,
"end_line": 17,
"start_col": 23,
"start_line": 17
} |
|
FStar.HyperStack.ST.St | val init_hash (hsz: hash_size_t) (r: HST.erid) : HST.St (hash #hsz) | [
{
"abbrev": false,
"full_module": "MerkleTree.Low.Datastructures",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "MerkleTree.Spec",
"short_module": "MTS"
},
{
"abbrev": true,
"full_module": "MerkleTree.New.High",
"short_module": "MTH"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Regional.Instances",
"short_module": "RVI"
},
{
"abbrev": true,
"full_module": "LowStar.RVector",
"short_module": "RV"
},
{
"abbrev": true,
"full_module": "LowStar.Vector",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "LowStar.ConstBuffer",
"short_module": "CB"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.HyperHeap",
"short_module": "HH"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.HyperStack",
"short_module": "MHS"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.Regional.Instances",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.RVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Regional",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Vector",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt.Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let init_hash (hsz:hash_size_t) (r:HST.erid): HST.St (hash #hsz)
= rg_alloc (hreg hsz) r | val init_hash (hsz: hash_size_t) (r: HST.erid) : HST.St (hash #hsz)
let init_hash (hsz: hash_size_t) (r: HST.erid) : HST.St (hash #hsz) = | true | null | false | rg_alloc (hreg hsz) r | {
"checked_file": "MerkleTree.Low.Hashfunctions.fst.checked",
"dependencies": [
"prims.fst.checked",
"MerkleTree.Spec.fst.checked",
"MerkleTree.New.High.fst.checked",
"MerkleTree.Low.Datastructures.fst.checked",
"LowStar.Vector.fst.checked",
"LowStar.RVector.fst.checked",
"LowStar.Regional.Instances.fst.checked",
"LowStar.Regional.fst.checked",
"LowStar.ConstBuffer.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Monotonic.HyperStack.fsti.checked",
"FStar.Monotonic.HyperHeap.fsti.checked",
"FStar.Integers.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.All.fst.checked",
"EverCrypt.Helpers.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Low.Hashfunctions.fst"
} | [] | [
"MerkleTree.Low.Datastructures.hash_size_t",
"FStar.HyperStack.ST.erid",
"LowStar.Regional.rg_alloc",
"MerkleTree.Low.Datastructures.hash",
"MerkleTree.Low.Datastructures.hreg"
] | [] | module MerkleTree.Low.Hashfunctions
open EverCrypt.Helpers
open FStar.All
open FStar.Integers
open FStar.Mul
open LowStar.Buffer
open LowStar.BufferOps
open LowStar.Vector
open LowStar.Regional
open LowStar.RVector
open LowStar.Regional.Instances
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module MHS = FStar.Monotonic.HyperStack
module HH = FStar.Monotonic.HyperHeap
module B = LowStar.Buffer
module CB = LowStar.ConstBuffer
module V = LowStar.Vector
module RV = LowStar.RVector
module RVI = LowStar.Regional.Instances
module S = FStar.Seq
module U32 = FStar.UInt32
module MTH = MerkleTree.New.High
module MTS = MerkleTree.Spec
open Lib.IntTypes
open MerkleTree.Low.Datastructures
#set-options "--z3rlimit 10 --initial_fuel 0 --max_fuel 0 --initial_ifuel 0 --max_ifuel 0" | false | false | MerkleTree.Low.Hashfunctions.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val init_hash (hsz: hash_size_t) (r: HST.erid) : HST.St (hash #hsz) | [] | MerkleTree.Low.Hashfunctions.init_hash | {
"file_name": "src/MerkleTree.Low.Hashfunctions.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | hsz: MerkleTree.Low.Datastructures.hash_size_t -> r: FStar.HyperStack.ST.erid
-> FStar.HyperStack.ST.St MerkleTree.Low.Datastructures.hash | {
"end_col": 23,
"end_line": 40,
"start_col": 2,
"start_line": 40
} |
FStar.HyperStack.ST.ST | val free_hash (#hsz: Ghost.erased hash_size_t) (h: hash #hsz)
: HST.ST unit (requires (fun h0 -> (Rgl?.r_inv (hreg hsz)) h0 h)) (ensures (fun _ _ _ -> True)) | [
{
"abbrev": false,
"full_module": "MerkleTree.Low.Datastructures",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "MerkleTree.Spec",
"short_module": "MTS"
},
{
"abbrev": true,
"full_module": "MerkleTree.New.High",
"short_module": "MTH"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Regional.Instances",
"short_module": "RVI"
},
{
"abbrev": true,
"full_module": "LowStar.RVector",
"short_module": "RV"
},
{
"abbrev": true,
"full_module": "LowStar.Vector",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "LowStar.ConstBuffer",
"short_module": "CB"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.HyperHeap",
"short_module": "HH"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.HyperStack",
"short_module": "MHS"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.Regional.Instances",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.RVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Regional",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Vector",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverCrypt.Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "MerkleTree.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let free_hash
(#hsz:Ghost.erased hash_size_t)
(h:hash #hsz): HST.ST unit
(requires (fun h0 -> (Rgl?.r_inv (hreg hsz)) h0 h))
(ensures (fun _ _ _ -> True))
= B.free h | val free_hash (#hsz: Ghost.erased hash_size_t) (h: hash #hsz)
: HST.ST unit (requires (fun h0 -> (Rgl?.r_inv (hreg hsz)) h0 h)) (ensures (fun _ _ _ -> True))
let free_hash (#hsz: Ghost.erased hash_size_t) (h: hash #hsz)
: HST.ST unit (requires (fun h0 -> (Rgl?.r_inv (hreg hsz)) h0 h)) (ensures (fun _ _ _ -> True)) = | true | null | false | B.free h | {
"checked_file": "MerkleTree.Low.Hashfunctions.fst.checked",
"dependencies": [
"prims.fst.checked",
"MerkleTree.Spec.fst.checked",
"MerkleTree.New.High.fst.checked",
"MerkleTree.Low.Datastructures.fst.checked",
"LowStar.Vector.fst.checked",
"LowStar.RVector.fst.checked",
"LowStar.Regional.Instances.fst.checked",
"LowStar.Regional.fst.checked",
"LowStar.ConstBuffer.fsti.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Monotonic.HyperStack.fsti.checked",
"FStar.Monotonic.HyperHeap.fsti.checked",
"FStar.Integers.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.All.fst.checked",
"EverCrypt.Helpers.fsti.checked"
],
"interface_file": false,
"source_file": "MerkleTree.Low.Hashfunctions.fst"
} | [] | [
"FStar.Ghost.erased",
"MerkleTree.Low.Datastructures.hash_size_t",
"MerkleTree.Low.Datastructures.hash",
"FStar.Ghost.reveal",
"LowStar.Monotonic.Buffer.free",
"Lib.IntTypes.uint8",
"LowStar.Buffer.trivial_preorder",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Regional.__proj__Rgl__item__r_inv",
"MerkleTree.Low.Datastructures.hreg",
"Prims.l_True"
] | [] | module MerkleTree.Low.Hashfunctions
open EverCrypt.Helpers
open FStar.All
open FStar.Integers
open FStar.Mul
open LowStar.Buffer
open LowStar.BufferOps
open LowStar.Vector
open LowStar.Regional
open LowStar.RVector
open LowStar.Regional.Instances
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module MHS = FStar.Monotonic.HyperStack
module HH = FStar.Monotonic.HyperHeap
module B = LowStar.Buffer
module CB = LowStar.ConstBuffer
module V = LowStar.Vector
module RV = LowStar.RVector
module RVI = LowStar.Regional.Instances
module S = FStar.Seq
module U32 = FStar.UInt32
module MTH = MerkleTree.New.High
module MTS = MerkleTree.Spec
open Lib.IntTypes
open MerkleTree.Low.Datastructures
#set-options "--z3rlimit 10 --initial_fuel 0 --max_fuel 0 --initial_ifuel 0 --max_ifuel 0"
let init_hash (hsz:hash_size_t) (r:HST.erid): HST.St (hash #hsz)
= rg_alloc (hreg hsz) r
#set-options "--z3rlimit 200 --initial_fuel 2 --max_fuel 2 --initial_ifuel 2 --max_ifuel 2"
let free_hash
(#hsz:Ghost.erased hash_size_t)
(h:hash #hsz): HST.ST unit
(requires (fun h0 -> (Rgl?.r_inv (hreg hsz)) h0 h)) | false | false | MerkleTree.Low.Hashfunctions.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 2,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 200,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val free_hash (#hsz: Ghost.erased hash_size_t) (h: hash #hsz)
: HST.ST unit (requires (fun h0 -> (Rgl?.r_inv (hreg hsz)) h0 h)) (ensures (fun _ _ _ -> True)) | [] | MerkleTree.Low.Hashfunctions.free_hash | {
"file_name": "src/MerkleTree.Low.Hashfunctions.fst",
"git_rev": "3b0f086655c145aa23f58a97259ebf4cf112a4a3",
"git_url": "https://github.com/hacl-star/merkle-tree.git",
"project_name": "merkle-tree"
} | h: MerkleTree.Low.Datastructures.hash -> FStar.HyperStack.ST.ST Prims.unit | {
"end_col": 10,
"end_line": 49,
"start_col": 2,
"start_line": 49
} |
Prims.Tot | val is_fodd (x: nat) : bool | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let is_fodd (x:nat) : bool = x % 2 = 1 | val is_fodd (x: nat) : bool
let is_fodd (x: nat) : bool = | false | null | false | x % 2 = 1 | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Prims.bool"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2) | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val is_fodd (x: nat) : bool | [] | Spec.P256.PointOps.is_fodd | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Prims.nat -> Prims.bool | {
"end_col": 38,
"end_line": 29,
"start_col": 29,
"start_line": 29
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ( /% ) (x y:felem) = x *% finv y | let op_Slash_Percent (x y: felem) = | false | null | false | x *% finv y | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Spec.P256.PointOps.felem",
"Spec.P256.PointOps.op_Star_Percent",
"Spec.P256.PointOps.finv"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val op_Slash_Percent : x: Spec.P256.PointOps.felem -> y: Spec.P256.PointOps.felem -> Spec.P256.PointOps.felem | [] | Spec.P256.PointOps.op_Slash_Percent | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Spec.P256.PointOps.felem -> y: Spec.P256.PointOps.felem -> Spec.P256.PointOps.felem | {
"end_col": 36,
"end_line": 34,
"start_col": 25,
"start_line": 34
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let felem = x:nat{x < prime} | let felem = | false | null | false | x: nat{x < prime} | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Spec.P256.PointOps.prime"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val felem : Type0 | [] | Spec.P256.PointOps.felem | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 28,
"end_line": 20,
"start_col": 12,
"start_line": 20
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let is_point_at_inf (p:proj_point) =
let (_, _, z) = p in z = 0 | let is_point_at_inf (p: proj_point) = | false | null | false | let _, _, z = p in
z = 0 | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Spec.P256.PointOps.proj_point",
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"Prims.bool"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o
let qelem = x:nat{x < order}
let qadd (x y:qelem) : qelem = (x + y) % order
let qmul (x y:qelem) : qelem = (x * y) % order
let qinv (x:qelem) : qelem = M.pow_mod #order x (order - 2)
let ( +^ ) = qadd
let ( *^ ) = qmul
/// Elliptic curve `y^2 = x^3 + a * x + b`
let aff_point = p:tuple2 nat nat{let (px, py) = p in px < prime /\ py < prime}
let proj_point = p:tuple3 nat nat nat{let (px, py, pz) = p in px < prime /\ py < prime /\ pz < prime}
// let aff_point = felem & felem // Affine point
// let proj_point = felem & felem & felem // Projective coordinates
let a_coeff : felem = (-3) % prime
let b_coeff : felem =
let b = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b in
assert_norm (b < prime); b
// Base point
let g_x : felem =
let x = 0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296 in
assert_norm (x < prime); x
let g_y : felem =
let y = 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5 in
assert_norm (y < prime); y
let base_point : proj_point = (g_x, g_y, one)
let is_on_curve (p:aff_point) : bool =
let (x, y) = p in y *% y = x *% x *% x +% a_coeff *% x +% b_coeff
let aff_point_at_inf : aff_point = (zero, zero) // not on the curve!
let point_at_inf : proj_point = (zero, one, zero)
let is_aff_point_at_inf (p:aff_point) : bool =
let (x, y) = p in x = zero && y = zero | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val is_point_at_inf : p: Spec.P256.PointOps.proj_point -> Prims.bool | [] | Spec.P256.PointOps.is_point_at_inf | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Spec.P256.PointOps.proj_point -> Prims.bool | {
"end_col": 28,
"end_line": 88,
"start_col": 36,
"start_line": 87
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let qelem = x:nat{x < order} | let qelem = | false | null | false | x: nat{x < order} | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Spec.P256.PointOps.order"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val qelem : Type0 | [] | Spec.P256.PointOps.qelem | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 28,
"end_line": 43,
"start_col": 12,
"start_line": 43
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let aff_point = p:tuple2 nat nat{let (px, py) = p in px < prime /\ py < prime} | let aff_point = | false | null | false | p:
tuple2 nat nat
{ let px, py = p in
px < prime /\ py < prime } | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"FStar.Pervasives.Native.tuple2",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Spec.P256.PointOps.prime"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o
let qelem = x:nat{x < order}
let qadd (x y:qelem) : qelem = (x + y) % order
let qmul (x y:qelem) : qelem = (x * y) % order
let qinv (x:qelem) : qelem = M.pow_mod #order x (order - 2)
let ( +^ ) = qadd
let ( *^ ) = qmul
/// Elliptic curve `y^2 = x^3 + a * x + b` | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val aff_point : Type0 | [] | Spec.P256.PointOps.aff_point | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 78,
"end_line": 54,
"start_col": 16,
"start_line": 54
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let proj_point = p:tuple3 nat nat nat{let (px, py, pz) = p in px < prime /\ py < prime /\ pz < prime} | let proj_point = | false | null | false | p:
tuple3 nat nat nat
{ let px, py, pz = p in
px < prime /\ py < prime /\ pz < prime } | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"FStar.Pervasives.Native.tuple3",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Spec.P256.PointOps.prime"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o
let qelem = x:nat{x < order}
let qadd (x y:qelem) : qelem = (x + y) % order
let qmul (x y:qelem) : qelem = (x * y) % order
let qinv (x:qelem) : qelem = M.pow_mod #order x (order - 2)
let ( +^ ) = qadd
let ( *^ ) = qmul
/// Elliptic curve `y^2 = x^3 + a * x + b` | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val proj_point : Type0 | [] | Spec.P256.PointOps.proj_point | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 101,
"end_line": 55,
"start_col": 17,
"start_line": 55
} |
|
Prims.Tot | val order:(a: pos{a < pow2 256}) | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o | val order:(a: pos{a < pow2 256})
let order:(a: pos{a < pow2 256}) = | false | null | false | let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256);
o | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.int"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field | false | false | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val order:(a: pos{a < pow2 256}) | [] | Spec.P256.PointOps.order | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Prims.pos{a < Prims.pow2 256} | {
"end_col": 31,
"end_line": 41,
"start_col": 34,
"start_line": 39
} |
Prims.Tot | val g_y:felem | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let g_y : felem =
let y = 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5 in
assert_norm (y < prime); y | val g_y:felem
let g_y:felem = | false | null | false | let y = 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5 in
assert_norm (y < prime);
y | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_LessThan",
"Spec.P256.PointOps.prime",
"Prims.int"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o
let qelem = x:nat{x < order}
let qadd (x y:qelem) : qelem = (x + y) % order
let qmul (x y:qelem) : qelem = (x * y) % order
let qinv (x:qelem) : qelem = M.pow_mod #order x (order - 2)
let ( +^ ) = qadd
let ( *^ ) = qmul
/// Elliptic curve `y^2 = x^3 + a * x + b`
let aff_point = p:tuple2 nat nat{let (px, py) = p in px < prime /\ py < prime}
let proj_point = p:tuple3 nat nat nat{let (px, py, pz) = p in px < prime /\ py < prime /\ pz < prime}
// let aff_point = felem & felem // Affine point
// let proj_point = felem & felem & felem // Projective coordinates
let a_coeff : felem = (-3) % prime
let b_coeff : felem =
let b = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b in
assert_norm (b < prime); b
// Base point
let g_x : felem =
let x = 0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296 in | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val g_y:felem | [] | Spec.P256.PointOps.g_y | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Spec.P256.PointOps.felem | {
"end_col": 28,
"end_line": 72,
"start_col": 17,
"start_line": 70
} |
Prims.Tot | val b_coeff:felem | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let b_coeff : felem =
let b = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b in
assert_norm (b < prime); b | val b_coeff:felem
let b_coeff:felem = | false | null | false | let b = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b in
assert_norm (b < prime);
b | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_LessThan",
"Spec.P256.PointOps.prime",
"Prims.int"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o
let qelem = x:nat{x < order}
let qadd (x y:qelem) : qelem = (x + y) % order
let qmul (x y:qelem) : qelem = (x * y) % order
let qinv (x:qelem) : qelem = M.pow_mod #order x (order - 2)
let ( +^ ) = qadd
let ( *^ ) = qmul
/// Elliptic curve `y^2 = x^3 + a * x + b`
let aff_point = p:tuple2 nat nat{let (px, py) = p in px < prime /\ py < prime}
let proj_point = p:tuple3 nat nat nat{let (px, py, pz) = p in px < prime /\ py < prime /\ pz < prime}
// let aff_point = felem & felem // Affine point
// let proj_point = felem & felem & felem // Projective coordinates | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val b_coeff:felem | [] | Spec.P256.PointOps.b_coeff | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Spec.P256.PointOps.felem | {
"end_col": 28,
"end_line": 63,
"start_col": 21,
"start_line": 61
} |
Prims.Tot | val g_x:felem | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let g_x : felem =
let x = 0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296 in
assert_norm (x < prime); x | val g_x:felem
let g_x:felem = | false | null | false | let x = 0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296 in
assert_norm (x < prime);
x | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_LessThan",
"Spec.P256.PointOps.prime",
"Prims.int"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o
let qelem = x:nat{x < order}
let qadd (x y:qelem) : qelem = (x + y) % order
let qmul (x y:qelem) : qelem = (x * y) % order
let qinv (x:qelem) : qelem = M.pow_mod #order x (order - 2)
let ( +^ ) = qadd
let ( *^ ) = qmul
/// Elliptic curve `y^2 = x^3 + a * x + b`
let aff_point = p:tuple2 nat nat{let (px, py) = p in px < prime /\ py < prime}
let proj_point = p:tuple3 nat nat nat{let (px, py, pz) = p in px < prime /\ py < prime /\ pz < prime}
// let aff_point = felem & felem // Affine point
// let proj_point = felem & felem & felem // Projective coordinates
let a_coeff : felem = (-3) % prime
let b_coeff : felem =
let b = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b in
assert_norm (b < prime); b | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val g_x:felem | [] | Spec.P256.PointOps.g_x | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Spec.P256.PointOps.felem | {
"end_col": 28,
"end_line": 69,
"start_col": 17,
"start_line": 67
} |
Prims.Tot | val fsub (x y: felem) : felem | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fsub (x y:felem) : felem = (x - y) % prime | val fsub (x y: felem) : felem
let fsub (x y: felem) : felem = | false | null | false | (x - y) % prime | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Spec.P256.PointOps.felem",
"Prims.op_Modulus",
"Prims.op_Subtraction",
"Spec.P256.PointOps.prime"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1 | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fsub (x y: felem) : felem | [] | Spec.P256.PointOps.fsub | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Spec.P256.PointOps.felem -> y: Spec.P256.PointOps.felem -> Spec.P256.PointOps.felem | {
"end_col": 46,
"end_line": 25,
"start_col": 31,
"start_line": 25
} |
Prims.Tot | val to_aff_point (p: proj_point) : aff_point | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let to_aff_point (p:proj_point) : aff_point =
// if is_proj_point_at_inf p then aff_point_at_inf
let (px, py, pz) = p in
let zinv = finv pz in
let x = px *% zinv in
let y = py *% zinv in
(x, y) | val to_aff_point (p: proj_point) : aff_point
let to_aff_point (p: proj_point) : aff_point = | false | null | false | let px, py, pz = p in
let zinv = finv pz in
let x = px *% zinv in
let y = py *% zinv in
(x, y) | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Spec.P256.PointOps.proj_point",
"Prims.nat",
"FStar.Pervasives.Native.Mktuple2",
"Spec.P256.PointOps.felem",
"Spec.P256.PointOps.op_Star_Percent",
"Spec.P256.PointOps.finv",
"Spec.P256.PointOps.aff_point"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o
let qelem = x:nat{x < order}
let qadd (x y:qelem) : qelem = (x + y) % order
let qmul (x y:qelem) : qelem = (x * y) % order
let qinv (x:qelem) : qelem = M.pow_mod #order x (order - 2)
let ( +^ ) = qadd
let ( *^ ) = qmul
/// Elliptic curve `y^2 = x^3 + a * x + b`
let aff_point = p:tuple2 nat nat{let (px, py) = p in px < prime /\ py < prime}
let proj_point = p:tuple3 nat nat nat{let (px, py, pz) = p in px < prime /\ py < prime /\ pz < prime}
// let aff_point = felem & felem // Affine point
// let proj_point = felem & felem & felem // Projective coordinates
let a_coeff : felem = (-3) % prime
let b_coeff : felem =
let b = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b in
assert_norm (b < prime); b
// Base point
let g_x : felem =
let x = 0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296 in
assert_norm (x < prime); x
let g_y : felem =
let y = 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5 in
assert_norm (y < prime); y
let base_point : proj_point = (g_x, g_y, one)
let is_on_curve (p:aff_point) : bool =
let (x, y) = p in y *% y = x *% x *% x +% a_coeff *% x +% b_coeff
let aff_point_at_inf : aff_point = (zero, zero) // not on the curve!
let point_at_inf : proj_point = (zero, one, zero)
let is_aff_point_at_inf (p:aff_point) : bool =
let (x, y) = p in x = zero && y = zero
let is_point_at_inf (p:proj_point) =
let (_, _, z) = p in z = 0
let to_proj_point (p:aff_point) : proj_point =
let (x, y) = p in (x, y, one) | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val to_aff_point (p: proj_point) : aff_point | [] | Spec.P256.PointOps.to_aff_point | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Spec.P256.PointOps.proj_point -> Spec.P256.PointOps.aff_point | {
"end_col": 8,
"end_line": 100,
"start_col": 45,
"start_line": 94
} |
Prims.Tot | val one:felem | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let one : felem = 1 | val one:felem
let one:felem = | false | null | false | 1 | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime} | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val one:felem | [] | Spec.P256.PointOps.one | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Spec.P256.PointOps.felem | {
"end_col": 20,
"end_line": 22,
"start_col": 19,
"start_line": 22
} |
Prims.Tot | val aff_point_at_inf:aff_point | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let aff_point_at_inf : aff_point = (zero, zero) | val aff_point_at_inf:aff_point
let aff_point_at_inf:aff_point = | false | null | false | (zero, zero) | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"FStar.Pervasives.Native.Mktuple2",
"Prims.nat",
"Spec.P256.PointOps.zero"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o
let qelem = x:nat{x < order}
let qadd (x y:qelem) : qelem = (x + y) % order
let qmul (x y:qelem) : qelem = (x * y) % order
let qinv (x:qelem) : qelem = M.pow_mod #order x (order - 2)
let ( +^ ) = qadd
let ( *^ ) = qmul
/// Elliptic curve `y^2 = x^3 + a * x + b`
let aff_point = p:tuple2 nat nat{let (px, py) = p in px < prime /\ py < prime}
let proj_point = p:tuple3 nat nat nat{let (px, py, pz) = p in px < prime /\ py < prime /\ pz < prime}
// let aff_point = felem & felem // Affine point
// let proj_point = felem & felem & felem // Projective coordinates
let a_coeff : felem = (-3) % prime
let b_coeff : felem =
let b = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b in
assert_norm (b < prime); b
// Base point
let g_x : felem =
let x = 0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296 in
assert_norm (x < prime); x
let g_y : felem =
let y = 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5 in
assert_norm (y < prime); y
let base_point : proj_point = (g_x, g_y, one)
let is_on_curve (p:aff_point) : bool =
let (x, y) = p in y *% y = x *% x *% x +% a_coeff *% x +% b_coeff | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val aff_point_at_inf:aff_point | [] | Spec.P256.PointOps.aff_point_at_inf | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Spec.P256.PointOps.aff_point | {
"end_col": 47,
"end_line": 81,
"start_col": 35,
"start_line": 81
} |
Prims.Tot | val point_at_inf:proj_point | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let point_at_inf : proj_point = (zero, one, zero) | val point_at_inf:proj_point
let point_at_inf:proj_point = | false | null | false | (zero, one, zero) | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"FStar.Pervasives.Native.Mktuple3",
"Prims.nat",
"Spec.P256.PointOps.zero",
"Spec.P256.PointOps.one"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o
let qelem = x:nat{x < order}
let qadd (x y:qelem) : qelem = (x + y) % order
let qmul (x y:qelem) : qelem = (x * y) % order
let qinv (x:qelem) : qelem = M.pow_mod #order x (order - 2)
let ( +^ ) = qadd
let ( *^ ) = qmul
/// Elliptic curve `y^2 = x^3 + a * x + b`
let aff_point = p:tuple2 nat nat{let (px, py) = p in px < prime /\ py < prime}
let proj_point = p:tuple3 nat nat nat{let (px, py, pz) = p in px < prime /\ py < prime /\ pz < prime}
// let aff_point = felem & felem // Affine point
// let proj_point = felem & felem & felem // Projective coordinates
let a_coeff : felem = (-3) % prime
let b_coeff : felem =
let b = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b in
assert_norm (b < prime); b
// Base point
let g_x : felem =
let x = 0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296 in
assert_norm (x < prime); x
let g_y : felem =
let y = 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5 in
assert_norm (y < prime); y
let base_point : proj_point = (g_x, g_y, one)
let is_on_curve (p:aff_point) : bool =
let (x, y) = p in y *% y = x *% x *% x +% a_coeff *% x +% b_coeff | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val point_at_inf:proj_point | [] | Spec.P256.PointOps.point_at_inf | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Spec.P256.PointOps.proj_point | {
"end_col": 49,
"end_line": 82,
"start_col": 32,
"start_line": 82
} |
Prims.Tot | val finv (a: felem) : felem | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2) | val finv (a: felem) : felem
let finv (a: felem) : felem = | false | null | false | M.pow_mod #prime a (prime - 2) | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Spec.P256.PointOps.felem",
"Lib.NatMod.pow_mod",
"Spec.P256.PointOps.prime",
"Prims.op_Subtraction"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val finv (a: felem) : felem | [] | Spec.P256.PointOps.finv | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Spec.P256.PointOps.felem -> Spec.P256.PointOps.felem | {
"end_col": 59,
"end_line": 27,
"start_col": 29,
"start_line": 27
} |
Prims.Tot | val is_on_curve (p: aff_point) : bool | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let is_on_curve (p:aff_point) : bool =
let (x, y) = p in y *% y = x *% x *% x +% a_coeff *% x +% b_coeff | val is_on_curve (p: aff_point) : bool
let is_on_curve (p: aff_point) : bool = | false | null | false | let x, y = p in
y *% y = x *% x *% x +% a_coeff *% x +% b_coeff | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Spec.P256.PointOps.aff_point",
"Prims.nat",
"Prims.op_Equality",
"Spec.P256.PointOps.felem",
"Spec.P256.PointOps.op_Star_Percent",
"Spec.P256.PointOps.op_Plus_Percent",
"Spec.P256.PointOps.a_coeff",
"Spec.P256.PointOps.b_coeff",
"Prims.bool"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o
let qelem = x:nat{x < order}
let qadd (x y:qelem) : qelem = (x + y) % order
let qmul (x y:qelem) : qelem = (x * y) % order
let qinv (x:qelem) : qelem = M.pow_mod #order x (order - 2)
let ( +^ ) = qadd
let ( *^ ) = qmul
/// Elliptic curve `y^2 = x^3 + a * x + b`
let aff_point = p:tuple2 nat nat{let (px, py) = p in px < prime /\ py < prime}
let proj_point = p:tuple3 nat nat nat{let (px, py, pz) = p in px < prime /\ py < prime /\ pz < prime}
// let aff_point = felem & felem // Affine point
// let proj_point = felem & felem & felem // Projective coordinates
let a_coeff : felem = (-3) % prime
let b_coeff : felem =
let b = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b in
assert_norm (b < prime); b
// Base point
let g_x : felem =
let x = 0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296 in
assert_norm (x < prime); x
let g_y : felem =
let y = 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5 in
assert_norm (y < prime); y
let base_point : proj_point = (g_x, g_y, one) | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val is_on_curve (p: aff_point) : bool | [] | Spec.P256.PointOps.is_on_curve | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Spec.P256.PointOps.aff_point -> Prims.bool | {
"end_col": 67,
"end_line": 78,
"start_col": 38,
"start_line": 77
} |
Prims.Tot | val base_point:proj_point | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let base_point : proj_point = (g_x, g_y, one) | val base_point:proj_point
let base_point:proj_point = | false | null | false | (g_x, g_y, one) | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"FStar.Pervasives.Native.Mktuple3",
"Prims.nat",
"Spec.P256.PointOps.g_x",
"Spec.P256.PointOps.g_y",
"Spec.P256.PointOps.one"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o
let qelem = x:nat{x < order}
let qadd (x y:qelem) : qelem = (x + y) % order
let qmul (x y:qelem) : qelem = (x * y) % order
let qinv (x:qelem) : qelem = M.pow_mod #order x (order - 2)
let ( +^ ) = qadd
let ( *^ ) = qmul
/// Elliptic curve `y^2 = x^3 + a * x + b`
let aff_point = p:tuple2 nat nat{let (px, py) = p in px < prime /\ py < prime}
let proj_point = p:tuple3 nat nat nat{let (px, py, pz) = p in px < prime /\ py < prime /\ pz < prime}
// let aff_point = felem & felem // Affine point
// let proj_point = felem & felem & felem // Projective coordinates
let a_coeff : felem = (-3) % prime
let b_coeff : felem =
let b = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b in
assert_norm (b < prime); b
// Base point
let g_x : felem =
let x = 0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296 in
assert_norm (x < prime); x
let g_y : felem =
let y = 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5 in
assert_norm (y < prime); y | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val base_point:proj_point | [] | Spec.P256.PointOps.base_point | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Spec.P256.PointOps.proj_point | {
"end_col": 45,
"end_line": 74,
"start_col": 30,
"start_line": 74
} |
Prims.Tot | val fadd (x y: felem) : felem | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fadd (x y:felem) : felem = (x + y) % prime | val fadd (x y: felem) : felem
let fadd (x y: felem) : felem = | false | null | false | (x + y) % prime | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Spec.P256.PointOps.felem",
"Prims.op_Modulus",
"Prims.op_Addition",
"Spec.P256.PointOps.prime"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1 | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fadd (x y: felem) : felem | [] | Spec.P256.PointOps.fadd | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Spec.P256.PointOps.felem -> y: Spec.P256.PointOps.felem -> Spec.P256.PointOps.felem | {
"end_col": 46,
"end_line": 24,
"start_col": 31,
"start_line": 24
} |
Prims.Tot | val qmul (x y: qelem) : qelem | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let qmul (x y:qelem) : qelem = (x * y) % order | val qmul (x y: qelem) : qelem
let qmul (x y: qelem) : qelem = | false | null | false | (x * y) % order | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Spec.P256.PointOps.qelem",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Spec.P256.PointOps.order"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o
let qelem = x:nat{x < order} | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val qmul (x y: qelem) : qelem | [] | Spec.P256.PointOps.qmul | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Spec.P256.PointOps.qelem -> y: Spec.P256.PointOps.qelem -> Spec.P256.PointOps.qelem | {
"end_col": 46,
"end_line": 45,
"start_col": 31,
"start_line": 45
} |
Prims.Tot | val zero:felem | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let zero : felem = 0 | val zero:felem
let zero:felem = | false | null | false | 0 | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val zero:felem | [] | Spec.P256.PointOps.zero | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Spec.P256.PointOps.felem | {
"end_col": 20,
"end_line": 21,
"start_col": 19,
"start_line": 21
} |
Prims.Tot | val qinv (x: qelem) : qelem | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let qinv (x:qelem) : qelem = M.pow_mod #order x (order - 2) | val qinv (x: qelem) : qelem
let qinv (x: qelem) : qelem = | false | null | false | M.pow_mod #order x (order - 2) | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Spec.P256.PointOps.qelem",
"Lib.NatMod.pow_mod",
"Spec.P256.PointOps.order",
"Prims.op_Subtraction"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o
let qelem = x:nat{x < order}
let qadd (x y:qelem) : qelem = (x + y) % order | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val qinv (x: qelem) : qelem | [] | Spec.P256.PointOps.qinv | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Spec.P256.PointOps.qelem -> Spec.P256.PointOps.qelem | {
"end_col": 59,
"end_line": 46,
"start_col": 29,
"start_line": 46
} |
Prims.Tot | val fsqrt (a: felem) : felem | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4) | val fsqrt (a: felem) : felem
let fsqrt (a: felem) : felem = | false | null | false | M.pow_mod #prime a ((prime + 1) / 4) | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Spec.P256.PointOps.felem",
"Lib.NatMod.pow_mod",
"Spec.P256.PointOps.prime",
"Prims.op_Division",
"Prims.op_Addition"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fsqrt (a: felem) : felem | [] | Spec.P256.PointOps.fsqrt | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Spec.P256.PointOps.felem -> Spec.P256.PointOps.felem | {
"end_col": 66,
"end_line": 28,
"start_col": 30,
"start_line": 28
} |
Prims.Tot | val aff_point_double (p: aff_point) : aff_point | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let aff_point_double (p:aff_point) : aff_point =
let (px, py) = p in
if is_aff_point_at_inf p then p
else begin
if py = 0 then aff_point_at_inf
else begin
let lambda = (3 *% px *% px +% a_coeff) /% (2 *% py) in
let rx = lambda *% lambda -% px -% px in
let ry = lambda *% (px -% rx) -% py in
(rx, ry) end
end | val aff_point_double (p: aff_point) : aff_point
let aff_point_double (p: aff_point) : aff_point = | false | null | false | let px, py = p in
if is_aff_point_at_inf p
then p
else
if py = 0
then aff_point_at_inf
else
let lambda = (3 *% px *% px +% a_coeff) /% (2 *% py) in
let rx = lambda *% lambda -% px -% px in
let ry = lambda *% (px -% rx) -% py in
(rx, ry) | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Spec.P256.PointOps.aff_point",
"Prims.nat",
"Spec.P256.PointOps.is_aff_point_at_inf",
"Prims.bool",
"Prims.op_Equality",
"Prims.int",
"Spec.P256.PointOps.aff_point_at_inf",
"FStar.Pervasives.Native.Mktuple2",
"Spec.P256.PointOps.felem",
"Spec.P256.PointOps.op_Subtraction_Percent",
"Spec.P256.PointOps.op_Star_Percent",
"Spec.P256.PointOps.op_Slash_Percent",
"Spec.P256.PointOps.op_Plus_Percent",
"Spec.P256.PointOps.a_coeff"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o
let qelem = x:nat{x < order}
let qadd (x y:qelem) : qelem = (x + y) % order
let qmul (x y:qelem) : qelem = (x * y) % order
let qinv (x:qelem) : qelem = M.pow_mod #order x (order - 2)
let ( +^ ) = qadd
let ( *^ ) = qmul
/// Elliptic curve `y^2 = x^3 + a * x + b`
let aff_point = p:tuple2 nat nat{let (px, py) = p in px < prime /\ py < prime}
let proj_point = p:tuple3 nat nat nat{let (px, py, pz) = p in px < prime /\ py < prime /\ pz < prime}
// let aff_point = felem & felem // Affine point
// let proj_point = felem & felem & felem // Projective coordinates
let a_coeff : felem = (-3) % prime
let b_coeff : felem =
let b = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b in
assert_norm (b < prime); b
// Base point
let g_x : felem =
let x = 0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296 in
assert_norm (x < prime); x
let g_y : felem =
let y = 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5 in
assert_norm (y < prime); y
let base_point : proj_point = (g_x, g_y, one)
let is_on_curve (p:aff_point) : bool =
let (x, y) = p in y *% y = x *% x *% x +% a_coeff *% x +% b_coeff
let aff_point_at_inf : aff_point = (zero, zero) // not on the curve!
let point_at_inf : proj_point = (zero, one, zero)
let is_aff_point_at_inf (p:aff_point) : bool =
let (x, y) = p in x = zero && y = zero
let is_point_at_inf (p:proj_point) =
let (_, _, z) = p in z = 0
let to_proj_point (p:aff_point) : proj_point =
let (x, y) = p in (x, y, one)
let to_aff_point (p:proj_point) : aff_point =
// if is_proj_point_at_inf p then aff_point_at_inf
let (px, py, pz) = p in
let zinv = finv pz in
let x = px *% zinv in
let y = py *% zinv in
(x, y)
/// Point addition in affine coordinates | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val aff_point_double (p: aff_point) : aff_point | [] | Spec.P256.PointOps.aff_point_double | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Spec.P256.PointOps.aff_point -> Spec.P256.PointOps.aff_point | {
"end_col": 5,
"end_line": 115,
"start_col": 48,
"start_line": 105
} |
Prims.Tot | val qadd (x y: qelem) : qelem | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let qadd (x y:qelem) : qelem = (x + y) % order | val qadd (x y: qelem) : qelem
let qadd (x y: qelem) : qelem = | false | null | false | (x + y) % order | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Spec.P256.PointOps.qelem",
"Prims.op_Modulus",
"Prims.op_Addition",
"Spec.P256.PointOps.order"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val qadd (x y: qelem) : qelem | [] | Spec.P256.PointOps.qadd | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Spec.P256.PointOps.qelem -> y: Spec.P256.PointOps.qelem -> Spec.P256.PointOps.qelem | {
"end_col": 46,
"end_line": 44,
"start_col": 31,
"start_line": 44
} |
Prims.Tot | val fmul (x y: felem) : felem | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fmul (x y:felem) : felem = (x * y) % prime | val fmul (x y: felem) : felem
let fmul (x y: felem) : felem = | false | null | false | (x * y) % prime | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Spec.P256.PointOps.felem",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Spec.P256.PointOps.prime"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fmul (x y: felem) : felem | [] | Spec.P256.PointOps.fmul | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Spec.P256.PointOps.felem -> y: Spec.P256.PointOps.felem -> Spec.P256.PointOps.felem | {
"end_col": 46,
"end_line": 26,
"start_col": 31,
"start_line": 26
} |
Prims.Tot | val to_proj_point (p: aff_point) : proj_point | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let to_proj_point (p:aff_point) : proj_point =
let (x, y) = p in (x, y, one) | val to_proj_point (p: aff_point) : proj_point
let to_proj_point (p: aff_point) : proj_point = | false | null | false | let x, y = p in
(x, y, one) | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Spec.P256.PointOps.aff_point",
"Prims.nat",
"FStar.Pervasives.Native.Mktuple3",
"Spec.P256.PointOps.one",
"Spec.P256.PointOps.proj_point"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o
let qelem = x:nat{x < order}
let qadd (x y:qelem) : qelem = (x + y) % order
let qmul (x y:qelem) : qelem = (x * y) % order
let qinv (x:qelem) : qelem = M.pow_mod #order x (order - 2)
let ( +^ ) = qadd
let ( *^ ) = qmul
/// Elliptic curve `y^2 = x^3 + a * x + b`
let aff_point = p:tuple2 nat nat{let (px, py) = p in px < prime /\ py < prime}
let proj_point = p:tuple3 nat nat nat{let (px, py, pz) = p in px < prime /\ py < prime /\ pz < prime}
// let aff_point = felem & felem // Affine point
// let proj_point = felem & felem & felem // Projective coordinates
let a_coeff : felem = (-3) % prime
let b_coeff : felem =
let b = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b in
assert_norm (b < prime); b
// Base point
let g_x : felem =
let x = 0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296 in
assert_norm (x < prime); x
let g_y : felem =
let y = 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5 in
assert_norm (y < prime); y
let base_point : proj_point = (g_x, g_y, one)
let is_on_curve (p:aff_point) : bool =
let (x, y) = p in y *% y = x *% x *% x +% a_coeff *% x +% b_coeff
let aff_point_at_inf : aff_point = (zero, zero) // not on the curve!
let point_at_inf : proj_point = (zero, one, zero)
let is_aff_point_at_inf (p:aff_point) : bool =
let (x, y) = p in x = zero && y = zero
let is_point_at_inf (p:proj_point) =
let (_, _, z) = p in z = 0 | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val to_proj_point (p: aff_point) : proj_point | [] | Spec.P256.PointOps.to_proj_point | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Spec.P256.PointOps.aff_point -> Spec.P256.PointOps.proj_point | {
"end_col": 31,
"end_line": 92,
"start_col": 46,
"start_line": 91
} |
Prims.Tot | val is_aff_point_at_inf (p: aff_point) : bool | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let is_aff_point_at_inf (p:aff_point) : bool =
let (x, y) = p in x = zero && y = zero | val is_aff_point_at_inf (p: aff_point) : bool
let is_aff_point_at_inf (p: aff_point) : bool = | false | null | false | let x, y = p in
x = zero && y = zero | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Spec.P256.PointOps.aff_point",
"Prims.nat",
"Prims.op_AmpAmp",
"Prims.op_Equality",
"Spec.P256.PointOps.zero",
"Prims.bool"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o
let qelem = x:nat{x < order}
let qadd (x y:qelem) : qelem = (x + y) % order
let qmul (x y:qelem) : qelem = (x * y) % order
let qinv (x:qelem) : qelem = M.pow_mod #order x (order - 2)
let ( +^ ) = qadd
let ( *^ ) = qmul
/// Elliptic curve `y^2 = x^3 + a * x + b`
let aff_point = p:tuple2 nat nat{let (px, py) = p in px < prime /\ py < prime}
let proj_point = p:tuple3 nat nat nat{let (px, py, pz) = p in px < prime /\ py < prime /\ pz < prime}
// let aff_point = felem & felem // Affine point
// let proj_point = felem & felem & felem // Projective coordinates
let a_coeff : felem = (-3) % prime
let b_coeff : felem =
let b = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b in
assert_norm (b < prime); b
// Base point
let g_x : felem =
let x = 0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296 in
assert_norm (x < prime); x
let g_y : felem =
let y = 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5 in
assert_norm (y < prime); y
let base_point : proj_point = (g_x, g_y, one)
let is_on_curve (p:aff_point) : bool =
let (x, y) = p in y *% y = x *% x *% x +% a_coeff *% x +% b_coeff
let aff_point_at_inf : aff_point = (zero, zero) // not on the curve!
let point_at_inf : proj_point = (zero, one, zero) | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val is_aff_point_at_inf (p: aff_point) : bool | [] | Spec.P256.PointOps.is_aff_point_at_inf | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Spec.P256.PointOps.aff_point -> Prims.bool | {
"end_col": 40,
"end_line": 85,
"start_col": 46,
"start_line": 84
} |
Prims.Tot | val a_coeff:felem | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let a_coeff : felem = (-3) % prime | val a_coeff:felem
let a_coeff:felem = | false | null | false | (- 3) % prime | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Prims.op_Modulus",
"Prims.op_Minus",
"Spec.P256.PointOps.prime"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o
let qelem = x:nat{x < order}
let qadd (x y:qelem) : qelem = (x + y) % order
let qmul (x y:qelem) : qelem = (x * y) % order
let qinv (x:qelem) : qelem = M.pow_mod #order x (order - 2)
let ( +^ ) = qadd
let ( *^ ) = qmul
/// Elliptic curve `y^2 = x^3 + a * x + b`
let aff_point = p:tuple2 nat nat{let (px, py) = p in px < prime /\ py < prime}
let proj_point = p:tuple3 nat nat nat{let (px, py, pz) = p in px < prime /\ py < prime /\ pz < prime}
// let aff_point = felem & felem // Affine point
// let proj_point = felem & felem & felem // Projective coordinates | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val a_coeff:felem | [] | Spec.P256.PointOps.a_coeff | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Spec.P256.PointOps.felem | {
"end_col": 34,
"end_line": 60,
"start_col": 22,
"start_line": 60
} |
Prims.Tot | val point_double (p: proj_point) : proj_point | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let point_double (p:proj_point) : proj_point =
let (x, y, z) = p in
let t0 = x *% x in
let t1 = y *% y in
let t2 = z *% z in
let t3 = x *% y in
let t3 = t3 +% t3 in
let t4 = y *% z in
let z3 = x *% z in
let z3 = z3 +% z3 in
let y3 = b_coeff *% t2 in
let y3 = y3 -% z3 in
let x3 = y3 +% y3 in
let y3 = x3 +% y3 in
let x3 = t1 -% y3 in
let y3 = t1 +% y3 in
let y3 = x3 *% y3 in
let x3 = x3 *% t3 in
let t3 = t2 +% t2 in
let t2 = t2 +% t3 in
let z3 = b_coeff *% z3 in
let z3 = z3 -% t2 in
let z3 = z3 -% t0 in
let t3 = z3 +% z3 in
let z3 = z3 +% t3 in
let t3 = t0 +% t0 in
let t0 = t3 +% t0 in
let t0 = t0 -% t2 in
let t0 = t0 *% z3 in
let y3 = y3 +% t0 in
let t0 = t4 +% t4 in
let z3 = t0 *% z3 in
let x3 = x3 -% z3 in
let z3 = t0 *% t1 in
let z3 = z3 +% z3 in
let z3 = z3 +% z3 in
(x3, y3, z3) | val point_double (p: proj_point) : proj_point
let point_double (p: proj_point) : proj_point = | false | null | false | let x, y, z = p in
let t0 = x *% x in
let t1 = y *% y in
let t2 = z *% z in
let t3 = x *% y in
let t3 = t3 +% t3 in
let t4 = y *% z in
let z3 = x *% z in
let z3 = z3 +% z3 in
let y3 = b_coeff *% t2 in
let y3 = y3 -% z3 in
let x3 = y3 +% y3 in
let y3 = x3 +% y3 in
let x3 = t1 -% y3 in
let y3 = t1 +% y3 in
let y3 = x3 *% y3 in
let x3 = x3 *% t3 in
let t3 = t2 +% t2 in
let t2 = t2 +% t3 in
let z3 = b_coeff *% z3 in
let z3 = z3 -% t2 in
let z3 = z3 -% t0 in
let t3 = z3 +% z3 in
let z3 = z3 +% t3 in
let t3 = t0 +% t0 in
let t0 = t3 +% t0 in
let t0 = t0 -% t2 in
let t0 = t0 *% z3 in
let y3 = y3 +% t0 in
let t0 = t4 +% t4 in
let z3 = t0 *% z3 in
let x3 = x3 -% z3 in
let z3 = t0 *% t1 in
let z3 = z3 +% z3 in
let z3 = z3 +% z3 in
(x3, y3, z3) | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Spec.P256.PointOps.proj_point",
"Prims.nat",
"FStar.Pervasives.Native.Mktuple3",
"Spec.P256.PointOps.felem",
"Spec.P256.PointOps.op_Plus_Percent",
"Spec.P256.PointOps.op_Star_Percent",
"Spec.P256.PointOps.op_Subtraction_Percent",
"Spec.P256.PointOps.b_coeff"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o
let qelem = x:nat{x < order}
let qadd (x y:qelem) : qelem = (x + y) % order
let qmul (x y:qelem) : qelem = (x * y) % order
let qinv (x:qelem) : qelem = M.pow_mod #order x (order - 2)
let ( +^ ) = qadd
let ( *^ ) = qmul
/// Elliptic curve `y^2 = x^3 + a * x + b`
let aff_point = p:tuple2 nat nat{let (px, py) = p in px < prime /\ py < prime}
let proj_point = p:tuple3 nat nat nat{let (px, py, pz) = p in px < prime /\ py < prime /\ pz < prime}
// let aff_point = felem & felem // Affine point
// let proj_point = felem & felem & felem // Projective coordinates
let a_coeff : felem = (-3) % prime
let b_coeff : felem =
let b = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b in
assert_norm (b < prime); b
// Base point
let g_x : felem =
let x = 0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296 in
assert_norm (x < prime); x
let g_y : felem =
let y = 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5 in
assert_norm (y < prime); y
let base_point : proj_point = (g_x, g_y, one)
let is_on_curve (p:aff_point) : bool =
let (x, y) = p in y *% y = x *% x *% x +% a_coeff *% x +% b_coeff
let aff_point_at_inf : aff_point = (zero, zero) // not on the curve!
let point_at_inf : proj_point = (zero, one, zero)
let is_aff_point_at_inf (p:aff_point) : bool =
let (x, y) = p in x = zero && y = zero
let is_point_at_inf (p:proj_point) =
let (_, _, z) = p in z = 0
let to_proj_point (p:aff_point) : proj_point =
let (x, y) = p in (x, y, one)
let to_aff_point (p:proj_point) : aff_point =
// if is_proj_point_at_inf p then aff_point_at_inf
let (px, py, pz) = p in
let zinv = finv pz in
let x = px *% zinv in
let y = py *% zinv in
(x, y)
/// Point addition in affine coordinates
let aff_point_double (p:aff_point) : aff_point =
let (px, py) = p in
if is_aff_point_at_inf p then p
else begin
if py = 0 then aff_point_at_inf
else begin
let lambda = (3 *% px *% px +% a_coeff) /% (2 *% py) in
let rx = lambda *% lambda -% px -% px in
let ry = lambda *% (px -% rx) -% py in
(rx, ry) end
end
let aff_point_add (p:aff_point) (q:aff_point) : aff_point =
let (px, py) = p in let (qx, qy) = q in
if is_aff_point_at_inf p then q
else begin
if is_aff_point_at_inf q then p
else begin
if p = q then aff_point_double p
else begin
if qx = px then aff_point_at_inf
else begin
let lambda = (qy -% py) /% (qx -% px) in
let rx = lambda *% lambda -% px -% qx in
let ry = lambda *% (px -% rx) -% py in
(rx, ry)
end
end
end
end
/// Point addition and doubling in projective coordinates
// Alg 4 from https://eprint.iacr.org/2015/1060.pdf
let point_add (p q:proj_point) : proj_point =
let x1, y1, z1 = p in
let x2, y2, z2 = q in
let t0 = x1 *% x2 in
let t1 = y1 *% y2 in
let t2 = z1 *% z2 in
let t3 = x1 +% y1 in
let t4 = x2 +% y2 in
let t3 = t3 *% t4 in
let t4 = t0 +% t1 in
let t3 = t3 -% t4 in
let t4 = y1 +% z1 in
let t5 = y2 +% z2 in
let t4 = t4 *% t5 in
let t5 = t1 +% t2 in
let t4 = t4 -% t5 in
let x3 = x1 +% z1 in
let y3 = x2 +% z2 in
let x3 = x3 *% y3 in
let y3 = t0 +% t2 in
let y3 = x3 -% y3 in
let z3 = b_coeff *% t2 in
let x3 = y3 -% z3 in
let z3 = x3 +% x3 in
let x3 = x3 +% z3 in
let z3 = t1 -% x3 in
let x3 = t1 +% x3 in
let y3 = b_coeff *% y3 in
let t1 = t2 +% t2 in
let t2 = t1 +% t2 in
let y3 = y3 -% t2 in
let y3 = y3 -% t0 in
let t1 = y3 +% y3 in
let y3 = t1 +% y3 in
let t1 = t0 +% t0 in
let t0 = t1 +% t0 in
let t0 = t0 -% t2 in
let t1 = t4 *% y3 in
let t2 = t0 *% y3 in
let y3 = x3 *% z3 in
let y3 = y3 +% t2 in
let x3 = t3 *% x3 in
let x3 = x3 -% t1 in
let z3 = t4 *% z3 in
let t1 = t3 *% t0 in
let z3 = z3 +% t1 in
(x3, y3, z3) | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val point_double (p: proj_point) : proj_point | [] | Spec.P256.PointOps.point_double | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Spec.P256.PointOps.proj_point -> Spec.P256.PointOps.proj_point | {
"end_col": 14,
"end_line": 226,
"start_col": 46,
"start_line": 190
} |
Prims.Tot | val aff_point_add (p q: aff_point) : aff_point | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let aff_point_add (p:aff_point) (q:aff_point) : aff_point =
let (px, py) = p in let (qx, qy) = q in
if is_aff_point_at_inf p then q
else begin
if is_aff_point_at_inf q then p
else begin
if p = q then aff_point_double p
else begin
if qx = px then aff_point_at_inf
else begin
let lambda = (qy -% py) /% (qx -% px) in
let rx = lambda *% lambda -% px -% qx in
let ry = lambda *% (px -% rx) -% py in
(rx, ry)
end
end
end
end | val aff_point_add (p q: aff_point) : aff_point
let aff_point_add (p q: aff_point) : aff_point = | false | null | false | let px, py = p in
let qx, qy = q in
if is_aff_point_at_inf p
then q
else
if is_aff_point_at_inf q
then p
else
if p = q
then aff_point_double p
else
if qx = px
then aff_point_at_inf
else
let lambda = (qy -% py) /% (qx -% px) in
let rx = lambda *% lambda -% px -% qx in
let ry = lambda *% (px -% rx) -% py in
(rx, ry) | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Spec.P256.PointOps.aff_point",
"Prims.nat",
"Spec.P256.PointOps.is_aff_point_at_inf",
"Prims.bool",
"Prims.op_Equality",
"Spec.P256.PointOps.aff_point_double",
"Spec.P256.PointOps.aff_point_at_inf",
"FStar.Pervasives.Native.Mktuple2",
"Spec.P256.PointOps.felem",
"Spec.P256.PointOps.op_Subtraction_Percent",
"Spec.P256.PointOps.op_Star_Percent",
"Spec.P256.PointOps.op_Slash_Percent"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o
let qelem = x:nat{x < order}
let qadd (x y:qelem) : qelem = (x + y) % order
let qmul (x y:qelem) : qelem = (x * y) % order
let qinv (x:qelem) : qelem = M.pow_mod #order x (order - 2)
let ( +^ ) = qadd
let ( *^ ) = qmul
/// Elliptic curve `y^2 = x^3 + a * x + b`
let aff_point = p:tuple2 nat nat{let (px, py) = p in px < prime /\ py < prime}
let proj_point = p:tuple3 nat nat nat{let (px, py, pz) = p in px < prime /\ py < prime /\ pz < prime}
// let aff_point = felem & felem // Affine point
// let proj_point = felem & felem & felem // Projective coordinates
let a_coeff : felem = (-3) % prime
let b_coeff : felem =
let b = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b in
assert_norm (b < prime); b
// Base point
let g_x : felem =
let x = 0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296 in
assert_norm (x < prime); x
let g_y : felem =
let y = 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5 in
assert_norm (y < prime); y
let base_point : proj_point = (g_x, g_y, one)
let is_on_curve (p:aff_point) : bool =
let (x, y) = p in y *% y = x *% x *% x +% a_coeff *% x +% b_coeff
let aff_point_at_inf : aff_point = (zero, zero) // not on the curve!
let point_at_inf : proj_point = (zero, one, zero)
let is_aff_point_at_inf (p:aff_point) : bool =
let (x, y) = p in x = zero && y = zero
let is_point_at_inf (p:proj_point) =
let (_, _, z) = p in z = 0
let to_proj_point (p:aff_point) : proj_point =
let (x, y) = p in (x, y, one)
let to_aff_point (p:proj_point) : aff_point =
// if is_proj_point_at_inf p then aff_point_at_inf
let (px, py, pz) = p in
let zinv = finv pz in
let x = px *% zinv in
let y = py *% zinv in
(x, y)
/// Point addition in affine coordinates
let aff_point_double (p:aff_point) : aff_point =
let (px, py) = p in
if is_aff_point_at_inf p then p
else begin
if py = 0 then aff_point_at_inf
else begin
let lambda = (3 *% px *% px +% a_coeff) /% (2 *% py) in
let rx = lambda *% lambda -% px -% px in
let ry = lambda *% (px -% rx) -% py in
(rx, ry) end
end | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val aff_point_add (p q: aff_point) : aff_point | [] | Spec.P256.PointOps.aff_point_add | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Spec.P256.PointOps.aff_point -> q: Spec.P256.PointOps.aff_point -> Spec.P256.PointOps.aff_point | {
"end_col": 5,
"end_line": 134,
"start_col": 59,
"start_line": 117
} |
Prims.Tot | val point_add (p q: proj_point) : proj_point | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let point_add (p q:proj_point) : proj_point =
let x1, y1, z1 = p in
let x2, y2, z2 = q in
let t0 = x1 *% x2 in
let t1 = y1 *% y2 in
let t2 = z1 *% z2 in
let t3 = x1 +% y1 in
let t4 = x2 +% y2 in
let t3 = t3 *% t4 in
let t4 = t0 +% t1 in
let t3 = t3 -% t4 in
let t4 = y1 +% z1 in
let t5 = y2 +% z2 in
let t4 = t4 *% t5 in
let t5 = t1 +% t2 in
let t4 = t4 -% t5 in
let x3 = x1 +% z1 in
let y3 = x2 +% z2 in
let x3 = x3 *% y3 in
let y3 = t0 +% t2 in
let y3 = x3 -% y3 in
let z3 = b_coeff *% t2 in
let x3 = y3 -% z3 in
let z3 = x3 +% x3 in
let x3 = x3 +% z3 in
let z3 = t1 -% x3 in
let x3 = t1 +% x3 in
let y3 = b_coeff *% y3 in
let t1 = t2 +% t2 in
let t2 = t1 +% t2 in
let y3 = y3 -% t2 in
let y3 = y3 -% t0 in
let t1 = y3 +% y3 in
let y3 = t1 +% y3 in
let t1 = t0 +% t0 in
let t0 = t1 +% t0 in
let t0 = t0 -% t2 in
let t1 = t4 *% y3 in
let t2 = t0 *% y3 in
let y3 = x3 *% z3 in
let y3 = y3 +% t2 in
let x3 = t3 *% x3 in
let x3 = x3 -% t1 in
let z3 = t4 *% z3 in
let t1 = t3 *% t0 in
let z3 = z3 +% t1 in
(x3, y3, z3) | val point_add (p q: proj_point) : proj_point
let point_add (p q: proj_point) : proj_point = | false | null | false | let x1, y1, z1 = p in
let x2, y2, z2 = q in
let t0 = x1 *% x2 in
let t1 = y1 *% y2 in
let t2 = z1 *% z2 in
let t3 = x1 +% y1 in
let t4 = x2 +% y2 in
let t3 = t3 *% t4 in
let t4 = t0 +% t1 in
let t3 = t3 -% t4 in
let t4 = y1 +% z1 in
let t5 = y2 +% z2 in
let t4 = t4 *% t5 in
let t5 = t1 +% t2 in
let t4 = t4 -% t5 in
let x3 = x1 +% z1 in
let y3 = x2 +% z2 in
let x3 = x3 *% y3 in
let y3 = t0 +% t2 in
let y3 = x3 -% y3 in
let z3 = b_coeff *% t2 in
let x3 = y3 -% z3 in
let z3 = x3 +% x3 in
let x3 = x3 +% z3 in
let z3 = t1 -% x3 in
let x3 = t1 +% x3 in
let y3 = b_coeff *% y3 in
let t1 = t2 +% t2 in
let t2 = t1 +% t2 in
let y3 = y3 -% t2 in
let y3 = y3 -% t0 in
let t1 = y3 +% y3 in
let y3 = t1 +% y3 in
let t1 = t0 +% t0 in
let t0 = t1 +% t0 in
let t0 = t0 -% t2 in
let t1 = t4 *% y3 in
let t2 = t0 *% y3 in
let y3 = x3 *% z3 in
let y3 = y3 +% t2 in
let x3 = t3 *% x3 in
let x3 = x3 -% t1 in
let z3 = t4 *% z3 in
let t1 = t3 *% t0 in
let z3 = z3 +% t1 in
(x3, y3, z3) | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Spec.P256.PointOps.proj_point",
"Prims.nat",
"FStar.Pervasives.Native.Mktuple3",
"Spec.P256.PointOps.felem",
"Spec.P256.PointOps.op_Plus_Percent",
"Spec.P256.PointOps.op_Star_Percent",
"Spec.P256.PointOps.op_Subtraction_Percent",
"Spec.P256.PointOps.b_coeff"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o
let qelem = x:nat{x < order}
let qadd (x y:qelem) : qelem = (x + y) % order
let qmul (x y:qelem) : qelem = (x * y) % order
let qinv (x:qelem) : qelem = M.pow_mod #order x (order - 2)
let ( +^ ) = qadd
let ( *^ ) = qmul
/// Elliptic curve `y^2 = x^3 + a * x + b`
let aff_point = p:tuple2 nat nat{let (px, py) = p in px < prime /\ py < prime}
let proj_point = p:tuple3 nat nat nat{let (px, py, pz) = p in px < prime /\ py < prime /\ pz < prime}
// let aff_point = felem & felem // Affine point
// let proj_point = felem & felem & felem // Projective coordinates
let a_coeff : felem = (-3) % prime
let b_coeff : felem =
let b = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b in
assert_norm (b < prime); b
// Base point
let g_x : felem =
let x = 0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296 in
assert_norm (x < prime); x
let g_y : felem =
let y = 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5 in
assert_norm (y < prime); y
let base_point : proj_point = (g_x, g_y, one)
let is_on_curve (p:aff_point) : bool =
let (x, y) = p in y *% y = x *% x *% x +% a_coeff *% x +% b_coeff
let aff_point_at_inf : aff_point = (zero, zero) // not on the curve!
let point_at_inf : proj_point = (zero, one, zero)
let is_aff_point_at_inf (p:aff_point) : bool =
let (x, y) = p in x = zero && y = zero
let is_point_at_inf (p:proj_point) =
let (_, _, z) = p in z = 0
let to_proj_point (p:aff_point) : proj_point =
let (x, y) = p in (x, y, one)
let to_aff_point (p:proj_point) : aff_point =
// if is_proj_point_at_inf p then aff_point_at_inf
let (px, py, pz) = p in
let zinv = finv pz in
let x = px *% zinv in
let y = py *% zinv in
(x, y)
/// Point addition in affine coordinates
let aff_point_double (p:aff_point) : aff_point =
let (px, py) = p in
if is_aff_point_at_inf p then p
else begin
if py = 0 then aff_point_at_inf
else begin
let lambda = (3 *% px *% px +% a_coeff) /% (2 *% py) in
let rx = lambda *% lambda -% px -% px in
let ry = lambda *% (px -% rx) -% py in
(rx, ry) end
end
let aff_point_add (p:aff_point) (q:aff_point) : aff_point =
let (px, py) = p in let (qx, qy) = q in
if is_aff_point_at_inf p then q
else begin
if is_aff_point_at_inf q then p
else begin
if p = q then aff_point_double p
else begin
if qx = px then aff_point_at_inf
else begin
let lambda = (qy -% py) /% (qx -% px) in
let rx = lambda *% lambda -% px -% qx in
let ry = lambda *% (px -% rx) -% py in
(rx, ry)
end
end
end
end
/// Point addition and doubling in projective coordinates | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val point_add (p q: proj_point) : proj_point | [] | Spec.P256.PointOps.point_add | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Spec.P256.PointOps.proj_point -> q: Spec.P256.PointOps.proj_point
-> Spec.P256.PointOps.proj_point | {
"end_col": 14,
"end_line": 186,
"start_col": 45,
"start_line": 140
} |
Prims.Tot | val recover_y (x: felem) (is_odd: bool) : option felem | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let recover_y (x:felem) (is_odd:bool) : option felem =
let y2 = x *% x *% x +% a_coeff *% x +% b_coeff in
let y = fsqrt y2 in
if y *% y <> y2 then None
else begin
let y = if is_fodd y <> is_odd then (prime - y) % prime else y in
Some y end | val recover_y (x: felem) (is_odd: bool) : option felem
let recover_y (x: felem) (is_odd: bool) : option felem = | false | null | false | let y2 = x *% x *% x +% a_coeff *% x +% b_coeff in
let y = fsqrt y2 in
if y *% y <> y2
then None
else
let y = if is_fodd y <> is_odd then (prime - y) % prime else y in
Some y | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Spec.P256.PointOps.felem",
"Prims.bool",
"Prims.op_disEquality",
"Spec.P256.PointOps.op_Star_Percent",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.Some",
"Spec.P256.PointOps.is_fodd",
"Prims.op_Modulus",
"Prims.op_Subtraction",
"Spec.P256.PointOps.prime",
"FStar.Pervasives.Native.option",
"Spec.P256.PointOps.fsqrt",
"Spec.P256.PointOps.op_Plus_Percent",
"Spec.P256.PointOps.a_coeff",
"Spec.P256.PointOps.b_coeff"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o
let qelem = x:nat{x < order}
let qadd (x y:qelem) : qelem = (x + y) % order
let qmul (x y:qelem) : qelem = (x * y) % order
let qinv (x:qelem) : qelem = M.pow_mod #order x (order - 2)
let ( +^ ) = qadd
let ( *^ ) = qmul
/// Elliptic curve `y^2 = x^3 + a * x + b`
let aff_point = p:tuple2 nat nat{let (px, py) = p in px < prime /\ py < prime}
let proj_point = p:tuple3 nat nat nat{let (px, py, pz) = p in px < prime /\ py < prime /\ pz < prime}
// let aff_point = felem & felem // Affine point
// let proj_point = felem & felem & felem // Projective coordinates
let a_coeff : felem = (-3) % prime
let b_coeff : felem =
let b = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b in
assert_norm (b < prime); b
// Base point
let g_x : felem =
let x = 0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296 in
assert_norm (x < prime); x
let g_y : felem =
let y = 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5 in
assert_norm (y < prime); y
let base_point : proj_point = (g_x, g_y, one)
let is_on_curve (p:aff_point) : bool =
let (x, y) = p in y *% y = x *% x *% x +% a_coeff *% x +% b_coeff
let aff_point_at_inf : aff_point = (zero, zero) // not on the curve!
let point_at_inf : proj_point = (zero, one, zero)
let is_aff_point_at_inf (p:aff_point) : bool =
let (x, y) = p in x = zero && y = zero
let is_point_at_inf (p:proj_point) =
let (_, _, z) = p in z = 0
let to_proj_point (p:aff_point) : proj_point =
let (x, y) = p in (x, y, one)
let to_aff_point (p:proj_point) : aff_point =
// if is_proj_point_at_inf p then aff_point_at_inf
let (px, py, pz) = p in
let zinv = finv pz in
let x = px *% zinv in
let y = py *% zinv in
(x, y)
/// Point addition in affine coordinates
let aff_point_double (p:aff_point) : aff_point =
let (px, py) = p in
if is_aff_point_at_inf p then p
else begin
if py = 0 then aff_point_at_inf
else begin
let lambda = (3 *% px *% px +% a_coeff) /% (2 *% py) in
let rx = lambda *% lambda -% px -% px in
let ry = lambda *% (px -% rx) -% py in
(rx, ry) end
end
let aff_point_add (p:aff_point) (q:aff_point) : aff_point =
let (px, py) = p in let (qx, qy) = q in
if is_aff_point_at_inf p then q
else begin
if is_aff_point_at_inf q then p
else begin
if p = q then aff_point_double p
else begin
if qx = px then aff_point_at_inf
else begin
let lambda = (qy -% py) /% (qx -% px) in
let rx = lambda *% lambda -% px -% qx in
let ry = lambda *% (px -% rx) -% py in
(rx, ry)
end
end
end
end
/// Point addition and doubling in projective coordinates
// Alg 4 from https://eprint.iacr.org/2015/1060.pdf
let point_add (p q:proj_point) : proj_point =
let x1, y1, z1 = p in
let x2, y2, z2 = q in
let t0 = x1 *% x2 in
let t1 = y1 *% y2 in
let t2 = z1 *% z2 in
let t3 = x1 +% y1 in
let t4 = x2 +% y2 in
let t3 = t3 *% t4 in
let t4 = t0 +% t1 in
let t3 = t3 -% t4 in
let t4 = y1 +% z1 in
let t5 = y2 +% z2 in
let t4 = t4 *% t5 in
let t5 = t1 +% t2 in
let t4 = t4 -% t5 in
let x3 = x1 +% z1 in
let y3 = x2 +% z2 in
let x3 = x3 *% y3 in
let y3 = t0 +% t2 in
let y3 = x3 -% y3 in
let z3 = b_coeff *% t2 in
let x3 = y3 -% z3 in
let z3 = x3 +% x3 in
let x3 = x3 +% z3 in
let z3 = t1 -% x3 in
let x3 = t1 +% x3 in
let y3 = b_coeff *% y3 in
let t1 = t2 +% t2 in
let t2 = t1 +% t2 in
let y3 = y3 -% t2 in
let y3 = y3 -% t0 in
let t1 = y3 +% y3 in
let y3 = t1 +% y3 in
let t1 = t0 +% t0 in
let t0 = t1 +% t0 in
let t0 = t0 -% t2 in
let t1 = t4 *% y3 in
let t2 = t0 *% y3 in
let y3 = x3 *% z3 in
let y3 = y3 +% t2 in
let x3 = t3 *% x3 in
let x3 = x3 -% t1 in
let z3 = t4 *% z3 in
let t1 = t3 *% t0 in
let z3 = z3 +% t1 in
(x3, y3, z3)
// Alg 6 from https://eprint.iacr.org/2015/1060.pdf
let point_double (p:proj_point) : proj_point =
let (x, y, z) = p in
let t0 = x *% x in
let t1 = y *% y in
let t2 = z *% z in
let t3 = x *% y in
let t3 = t3 +% t3 in
let t4 = y *% z in
let z3 = x *% z in
let z3 = z3 +% z3 in
let y3 = b_coeff *% t2 in
let y3 = y3 -% z3 in
let x3 = y3 +% y3 in
let y3 = x3 +% y3 in
let x3 = t1 -% y3 in
let y3 = t1 +% y3 in
let y3 = x3 *% y3 in
let x3 = x3 *% t3 in
let t3 = t2 +% t2 in
let t2 = t2 +% t3 in
let z3 = b_coeff *% z3 in
let z3 = z3 -% t2 in
let z3 = z3 -% t0 in
let t3 = z3 +% z3 in
let z3 = z3 +% t3 in
let t3 = t0 +% t0 in
let t0 = t3 +% t0 in
let t0 = t0 -% t2 in
let t0 = t0 *% z3 in
let y3 = y3 +% t0 in
let t0 = t4 +% t4 in
let z3 = t0 *% z3 in
let x3 = x3 -% z3 in
let z3 = t0 *% t1 in
let z3 = z3 +% z3 in
let z3 = z3 +% z3 in
(x3, y3, z3)
/// Point conversion between affine, projective and bytes representation
let aff_point_load (b:BSeq.lbytes 64) : option aff_point =
let pk_x = BSeq.nat_from_bytes_be (sub b 0 32) in
let pk_y = BSeq.nat_from_bytes_be (sub b 32 32) in
let is_x_valid = pk_x < prime in
let is_y_valid = pk_y < prime in
let is_xy_on_curve =
if is_x_valid && is_y_valid then is_on_curve (pk_x, pk_y) else false in
if is_xy_on_curve then Some (pk_x, pk_y) else None
let load_point (b:BSeq.lbytes 64) : option proj_point =
match (aff_point_load b) with
| Some p -> Some (to_proj_point p)
| None -> None
let aff_point_store (p:aff_point) : BSeq.lbytes 64 =
let (px, py) = p in
let pxb = BSeq.nat_to_bytes_be 32 px in
let pxy = BSeq.nat_to_bytes_be 32 py in
concat #uint8 #32 #32 pxb pxy
let point_store (p:proj_point) : BSeq.lbytes 64 =
aff_point_store (to_aff_point p) | false | true | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val recover_y (x: felem) (is_odd: bool) : option felem | [] | Spec.P256.PointOps.recover_y | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Spec.P256.PointOps.felem -> is_odd: Prims.bool
-> FStar.Pervasives.Native.option Spec.P256.PointOps.felem | {
"end_col": 14,
"end_line": 264,
"start_col": 54,
"start_line": 258
} |
Prims.Tot | val prime:(a:
pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p | val prime:(a:
pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256})
let prime:(a:
pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) = | false | null | false | let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256);
p | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Subtraction",
"Prims.op_Addition"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field | false | false | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val prime:(a:
pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) | [] | Spec.P256.PointOps.prime | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a:
Prims.pos
{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < Prims.pow2 256} | {
"end_col": 31,
"end_line": 18,
"start_col": 108,
"start_line": 15
} |
Prims.Tot | val load_point (b: BSeq.lbytes 64) : option proj_point | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let load_point (b:BSeq.lbytes 64) : option proj_point =
match (aff_point_load b) with
| Some p -> Some (to_proj_point p)
| None -> None | val load_point (b: BSeq.lbytes 64) : option proj_point
let load_point (b: BSeq.lbytes 64) : option proj_point = | false | null | false | match (aff_point_load b) with
| Some p -> Some (to_proj_point p)
| None -> None | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Lib.ByteSequence.lbytes",
"Spec.P256.PointOps.aff_point_load",
"Spec.P256.PointOps.aff_point",
"FStar.Pervasives.Native.Some",
"Spec.P256.PointOps.proj_point",
"Spec.P256.PointOps.to_proj_point",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.option"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o
let qelem = x:nat{x < order}
let qadd (x y:qelem) : qelem = (x + y) % order
let qmul (x y:qelem) : qelem = (x * y) % order
let qinv (x:qelem) : qelem = M.pow_mod #order x (order - 2)
let ( +^ ) = qadd
let ( *^ ) = qmul
/// Elliptic curve `y^2 = x^3 + a * x + b`
let aff_point = p:tuple2 nat nat{let (px, py) = p in px < prime /\ py < prime}
let proj_point = p:tuple3 nat nat nat{let (px, py, pz) = p in px < prime /\ py < prime /\ pz < prime}
// let aff_point = felem & felem // Affine point
// let proj_point = felem & felem & felem // Projective coordinates
let a_coeff : felem = (-3) % prime
let b_coeff : felem =
let b = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b in
assert_norm (b < prime); b
// Base point
let g_x : felem =
let x = 0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296 in
assert_norm (x < prime); x
let g_y : felem =
let y = 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5 in
assert_norm (y < prime); y
let base_point : proj_point = (g_x, g_y, one)
let is_on_curve (p:aff_point) : bool =
let (x, y) = p in y *% y = x *% x *% x +% a_coeff *% x +% b_coeff
let aff_point_at_inf : aff_point = (zero, zero) // not on the curve!
let point_at_inf : proj_point = (zero, one, zero)
let is_aff_point_at_inf (p:aff_point) : bool =
let (x, y) = p in x = zero && y = zero
let is_point_at_inf (p:proj_point) =
let (_, _, z) = p in z = 0
let to_proj_point (p:aff_point) : proj_point =
let (x, y) = p in (x, y, one)
let to_aff_point (p:proj_point) : aff_point =
// if is_proj_point_at_inf p then aff_point_at_inf
let (px, py, pz) = p in
let zinv = finv pz in
let x = px *% zinv in
let y = py *% zinv in
(x, y)
/// Point addition in affine coordinates
let aff_point_double (p:aff_point) : aff_point =
let (px, py) = p in
if is_aff_point_at_inf p then p
else begin
if py = 0 then aff_point_at_inf
else begin
let lambda = (3 *% px *% px +% a_coeff) /% (2 *% py) in
let rx = lambda *% lambda -% px -% px in
let ry = lambda *% (px -% rx) -% py in
(rx, ry) end
end
let aff_point_add (p:aff_point) (q:aff_point) : aff_point =
let (px, py) = p in let (qx, qy) = q in
if is_aff_point_at_inf p then q
else begin
if is_aff_point_at_inf q then p
else begin
if p = q then aff_point_double p
else begin
if qx = px then aff_point_at_inf
else begin
let lambda = (qy -% py) /% (qx -% px) in
let rx = lambda *% lambda -% px -% qx in
let ry = lambda *% (px -% rx) -% py in
(rx, ry)
end
end
end
end
/// Point addition and doubling in projective coordinates
// Alg 4 from https://eprint.iacr.org/2015/1060.pdf
let point_add (p q:proj_point) : proj_point =
let x1, y1, z1 = p in
let x2, y2, z2 = q in
let t0 = x1 *% x2 in
let t1 = y1 *% y2 in
let t2 = z1 *% z2 in
let t3 = x1 +% y1 in
let t4 = x2 +% y2 in
let t3 = t3 *% t4 in
let t4 = t0 +% t1 in
let t3 = t3 -% t4 in
let t4 = y1 +% z1 in
let t5 = y2 +% z2 in
let t4 = t4 *% t5 in
let t5 = t1 +% t2 in
let t4 = t4 -% t5 in
let x3 = x1 +% z1 in
let y3 = x2 +% z2 in
let x3 = x3 *% y3 in
let y3 = t0 +% t2 in
let y3 = x3 -% y3 in
let z3 = b_coeff *% t2 in
let x3 = y3 -% z3 in
let z3 = x3 +% x3 in
let x3 = x3 +% z3 in
let z3 = t1 -% x3 in
let x3 = t1 +% x3 in
let y3 = b_coeff *% y3 in
let t1 = t2 +% t2 in
let t2 = t1 +% t2 in
let y3 = y3 -% t2 in
let y3 = y3 -% t0 in
let t1 = y3 +% y3 in
let y3 = t1 +% y3 in
let t1 = t0 +% t0 in
let t0 = t1 +% t0 in
let t0 = t0 -% t2 in
let t1 = t4 *% y3 in
let t2 = t0 *% y3 in
let y3 = x3 *% z3 in
let y3 = y3 +% t2 in
let x3 = t3 *% x3 in
let x3 = x3 -% t1 in
let z3 = t4 *% z3 in
let t1 = t3 *% t0 in
let z3 = z3 +% t1 in
(x3, y3, z3)
// Alg 6 from https://eprint.iacr.org/2015/1060.pdf
let point_double (p:proj_point) : proj_point =
let (x, y, z) = p in
let t0 = x *% x in
let t1 = y *% y in
let t2 = z *% z in
let t3 = x *% y in
let t3 = t3 +% t3 in
let t4 = y *% z in
let z3 = x *% z in
let z3 = z3 +% z3 in
let y3 = b_coeff *% t2 in
let y3 = y3 -% z3 in
let x3 = y3 +% y3 in
let y3 = x3 +% y3 in
let x3 = t1 -% y3 in
let y3 = t1 +% y3 in
let y3 = x3 *% y3 in
let x3 = x3 *% t3 in
let t3 = t2 +% t2 in
let t2 = t2 +% t3 in
let z3 = b_coeff *% z3 in
let z3 = z3 -% t2 in
let z3 = z3 -% t0 in
let t3 = z3 +% z3 in
let z3 = z3 +% t3 in
let t3 = t0 +% t0 in
let t0 = t3 +% t0 in
let t0 = t0 -% t2 in
let t0 = t0 *% z3 in
let y3 = y3 +% t0 in
let t0 = t4 +% t4 in
let z3 = t0 *% z3 in
let x3 = x3 -% z3 in
let z3 = t0 *% t1 in
let z3 = z3 +% z3 in
let z3 = z3 +% z3 in
(x3, y3, z3)
/// Point conversion between affine, projective and bytes representation
let aff_point_load (b:BSeq.lbytes 64) : option aff_point =
let pk_x = BSeq.nat_from_bytes_be (sub b 0 32) in
let pk_y = BSeq.nat_from_bytes_be (sub b 32 32) in
let is_x_valid = pk_x < prime in
let is_y_valid = pk_y < prime in
let is_xy_on_curve =
if is_x_valid && is_y_valid then is_on_curve (pk_x, pk_y) else false in
if is_xy_on_curve then Some (pk_x, pk_y) else None | false | false | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val load_point (b: BSeq.lbytes 64) : option proj_point | [] | Spec.P256.PointOps.load_point | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b: Lib.ByteSequence.lbytes 64 -> FStar.Pervasives.Native.option Spec.P256.PointOps.proj_point | {
"end_col": 16,
"end_line": 244,
"start_col": 2,
"start_line": 242
} |
Prims.Tot | val point_store (p: proj_point) : BSeq.lbytes 64 | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let point_store (p:proj_point) : BSeq.lbytes 64 =
aff_point_store (to_aff_point p) | val point_store (p: proj_point) : BSeq.lbytes 64
let point_store (p: proj_point) : BSeq.lbytes 64 = | false | null | false | aff_point_store (to_aff_point p) | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Spec.P256.PointOps.proj_point",
"Spec.P256.PointOps.aff_point_store",
"Spec.P256.PointOps.to_aff_point",
"Lib.ByteSequence.lbytes"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o
let qelem = x:nat{x < order}
let qadd (x y:qelem) : qelem = (x + y) % order
let qmul (x y:qelem) : qelem = (x * y) % order
let qinv (x:qelem) : qelem = M.pow_mod #order x (order - 2)
let ( +^ ) = qadd
let ( *^ ) = qmul
/// Elliptic curve `y^2 = x^3 + a * x + b`
let aff_point = p:tuple2 nat nat{let (px, py) = p in px < prime /\ py < prime}
let proj_point = p:tuple3 nat nat nat{let (px, py, pz) = p in px < prime /\ py < prime /\ pz < prime}
// let aff_point = felem & felem // Affine point
// let proj_point = felem & felem & felem // Projective coordinates
let a_coeff : felem = (-3) % prime
let b_coeff : felem =
let b = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b in
assert_norm (b < prime); b
// Base point
let g_x : felem =
let x = 0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296 in
assert_norm (x < prime); x
let g_y : felem =
let y = 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5 in
assert_norm (y < prime); y
let base_point : proj_point = (g_x, g_y, one)
let is_on_curve (p:aff_point) : bool =
let (x, y) = p in y *% y = x *% x *% x +% a_coeff *% x +% b_coeff
let aff_point_at_inf : aff_point = (zero, zero) // not on the curve!
let point_at_inf : proj_point = (zero, one, zero)
let is_aff_point_at_inf (p:aff_point) : bool =
let (x, y) = p in x = zero && y = zero
let is_point_at_inf (p:proj_point) =
let (_, _, z) = p in z = 0
let to_proj_point (p:aff_point) : proj_point =
let (x, y) = p in (x, y, one)
let to_aff_point (p:proj_point) : aff_point =
// if is_proj_point_at_inf p then aff_point_at_inf
let (px, py, pz) = p in
let zinv = finv pz in
let x = px *% zinv in
let y = py *% zinv in
(x, y)
/// Point addition in affine coordinates
let aff_point_double (p:aff_point) : aff_point =
let (px, py) = p in
if is_aff_point_at_inf p then p
else begin
if py = 0 then aff_point_at_inf
else begin
let lambda = (3 *% px *% px +% a_coeff) /% (2 *% py) in
let rx = lambda *% lambda -% px -% px in
let ry = lambda *% (px -% rx) -% py in
(rx, ry) end
end
let aff_point_add (p:aff_point) (q:aff_point) : aff_point =
let (px, py) = p in let (qx, qy) = q in
if is_aff_point_at_inf p then q
else begin
if is_aff_point_at_inf q then p
else begin
if p = q then aff_point_double p
else begin
if qx = px then aff_point_at_inf
else begin
let lambda = (qy -% py) /% (qx -% px) in
let rx = lambda *% lambda -% px -% qx in
let ry = lambda *% (px -% rx) -% py in
(rx, ry)
end
end
end
end
/// Point addition and doubling in projective coordinates
// Alg 4 from https://eprint.iacr.org/2015/1060.pdf
let point_add (p q:proj_point) : proj_point =
let x1, y1, z1 = p in
let x2, y2, z2 = q in
let t0 = x1 *% x2 in
let t1 = y1 *% y2 in
let t2 = z1 *% z2 in
let t3 = x1 +% y1 in
let t4 = x2 +% y2 in
let t3 = t3 *% t4 in
let t4 = t0 +% t1 in
let t3 = t3 -% t4 in
let t4 = y1 +% z1 in
let t5 = y2 +% z2 in
let t4 = t4 *% t5 in
let t5 = t1 +% t2 in
let t4 = t4 -% t5 in
let x3 = x1 +% z1 in
let y3 = x2 +% z2 in
let x3 = x3 *% y3 in
let y3 = t0 +% t2 in
let y3 = x3 -% y3 in
let z3 = b_coeff *% t2 in
let x3 = y3 -% z3 in
let z3 = x3 +% x3 in
let x3 = x3 +% z3 in
let z3 = t1 -% x3 in
let x3 = t1 +% x3 in
let y3 = b_coeff *% y3 in
let t1 = t2 +% t2 in
let t2 = t1 +% t2 in
let y3 = y3 -% t2 in
let y3 = y3 -% t0 in
let t1 = y3 +% y3 in
let y3 = t1 +% y3 in
let t1 = t0 +% t0 in
let t0 = t1 +% t0 in
let t0 = t0 -% t2 in
let t1 = t4 *% y3 in
let t2 = t0 *% y3 in
let y3 = x3 *% z3 in
let y3 = y3 +% t2 in
let x3 = t3 *% x3 in
let x3 = x3 -% t1 in
let z3 = t4 *% z3 in
let t1 = t3 *% t0 in
let z3 = z3 +% t1 in
(x3, y3, z3)
// Alg 6 from https://eprint.iacr.org/2015/1060.pdf
let point_double (p:proj_point) : proj_point =
let (x, y, z) = p in
let t0 = x *% x in
let t1 = y *% y in
let t2 = z *% z in
let t3 = x *% y in
let t3 = t3 +% t3 in
let t4 = y *% z in
let z3 = x *% z in
let z3 = z3 +% z3 in
let y3 = b_coeff *% t2 in
let y3 = y3 -% z3 in
let x3 = y3 +% y3 in
let y3 = x3 +% y3 in
let x3 = t1 -% y3 in
let y3 = t1 +% y3 in
let y3 = x3 *% y3 in
let x3 = x3 *% t3 in
let t3 = t2 +% t2 in
let t2 = t2 +% t3 in
let z3 = b_coeff *% z3 in
let z3 = z3 -% t2 in
let z3 = z3 -% t0 in
let t3 = z3 +% z3 in
let z3 = z3 +% t3 in
let t3 = t0 +% t0 in
let t0 = t3 +% t0 in
let t0 = t0 -% t2 in
let t0 = t0 *% z3 in
let y3 = y3 +% t0 in
let t0 = t4 +% t4 in
let z3 = t0 *% z3 in
let x3 = x3 -% z3 in
let z3 = t0 *% t1 in
let z3 = z3 +% z3 in
let z3 = z3 +% z3 in
(x3, y3, z3)
/// Point conversion between affine, projective and bytes representation
let aff_point_load (b:BSeq.lbytes 64) : option aff_point =
let pk_x = BSeq.nat_from_bytes_be (sub b 0 32) in
let pk_y = BSeq.nat_from_bytes_be (sub b 32 32) in
let is_x_valid = pk_x < prime in
let is_y_valid = pk_y < prime in
let is_xy_on_curve =
if is_x_valid && is_y_valid then is_on_curve (pk_x, pk_y) else false in
if is_xy_on_curve then Some (pk_x, pk_y) else None
let load_point (b:BSeq.lbytes 64) : option proj_point =
match (aff_point_load b) with
| Some p -> Some (to_proj_point p)
| None -> None
let aff_point_store (p:aff_point) : BSeq.lbytes 64 =
let (px, py) = p in
let pxb = BSeq.nat_to_bytes_be 32 px in
let pxy = BSeq.nat_to_bytes_be 32 py in
concat #uint8 #32 #32 pxb pxy | false | false | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val point_store (p: proj_point) : BSeq.lbytes 64 | [] | Spec.P256.PointOps.point_store | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Spec.P256.PointOps.proj_point -> Lib.ByteSequence.lbytes 64 | {
"end_col": 34,
"end_line": 255,
"start_col": 2,
"start_line": 255
} |
Prims.Tot | val aff_point_store (p: aff_point) : BSeq.lbytes 64 | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let aff_point_store (p:aff_point) : BSeq.lbytes 64 =
let (px, py) = p in
let pxb = BSeq.nat_to_bytes_be 32 px in
let pxy = BSeq.nat_to_bytes_be 32 py in
concat #uint8 #32 #32 pxb pxy | val aff_point_store (p: aff_point) : BSeq.lbytes 64
let aff_point_store (p: aff_point) : BSeq.lbytes 64 = | false | null | false | let px, py = p in
let pxb = BSeq.nat_to_bytes_be 32 px in
let pxy = BSeq.nat_to_bytes_be 32 py in
concat #uint8 #32 #32 pxb pxy | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Spec.P256.PointOps.aff_point",
"Prims.nat",
"Lib.Sequence.concat",
"Lib.IntTypes.uint8",
"Lib.Sequence.seq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.l_and",
"Prims.eq2",
"Lib.Sequence.length",
"Prims.l_or",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_Multiply",
"Lib.ByteSequence.nat_from_intseq_be",
"Lib.ByteSequence.nat_to_bytes_be",
"Lib.ByteSequence.lbytes"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o
let qelem = x:nat{x < order}
let qadd (x y:qelem) : qelem = (x + y) % order
let qmul (x y:qelem) : qelem = (x * y) % order
let qinv (x:qelem) : qelem = M.pow_mod #order x (order - 2)
let ( +^ ) = qadd
let ( *^ ) = qmul
/// Elliptic curve `y^2 = x^3 + a * x + b`
let aff_point = p:tuple2 nat nat{let (px, py) = p in px < prime /\ py < prime}
let proj_point = p:tuple3 nat nat nat{let (px, py, pz) = p in px < prime /\ py < prime /\ pz < prime}
// let aff_point = felem & felem // Affine point
// let proj_point = felem & felem & felem // Projective coordinates
let a_coeff : felem = (-3) % prime
let b_coeff : felem =
let b = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b in
assert_norm (b < prime); b
// Base point
let g_x : felem =
let x = 0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296 in
assert_norm (x < prime); x
let g_y : felem =
let y = 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5 in
assert_norm (y < prime); y
let base_point : proj_point = (g_x, g_y, one)
let is_on_curve (p:aff_point) : bool =
let (x, y) = p in y *% y = x *% x *% x +% a_coeff *% x +% b_coeff
let aff_point_at_inf : aff_point = (zero, zero) // not on the curve!
let point_at_inf : proj_point = (zero, one, zero)
let is_aff_point_at_inf (p:aff_point) : bool =
let (x, y) = p in x = zero && y = zero
let is_point_at_inf (p:proj_point) =
let (_, _, z) = p in z = 0
let to_proj_point (p:aff_point) : proj_point =
let (x, y) = p in (x, y, one)
let to_aff_point (p:proj_point) : aff_point =
// if is_proj_point_at_inf p then aff_point_at_inf
let (px, py, pz) = p in
let zinv = finv pz in
let x = px *% zinv in
let y = py *% zinv in
(x, y)
/// Point addition in affine coordinates
let aff_point_double (p:aff_point) : aff_point =
let (px, py) = p in
if is_aff_point_at_inf p then p
else begin
if py = 0 then aff_point_at_inf
else begin
let lambda = (3 *% px *% px +% a_coeff) /% (2 *% py) in
let rx = lambda *% lambda -% px -% px in
let ry = lambda *% (px -% rx) -% py in
(rx, ry) end
end
let aff_point_add (p:aff_point) (q:aff_point) : aff_point =
let (px, py) = p in let (qx, qy) = q in
if is_aff_point_at_inf p then q
else begin
if is_aff_point_at_inf q then p
else begin
if p = q then aff_point_double p
else begin
if qx = px then aff_point_at_inf
else begin
let lambda = (qy -% py) /% (qx -% px) in
let rx = lambda *% lambda -% px -% qx in
let ry = lambda *% (px -% rx) -% py in
(rx, ry)
end
end
end
end
/// Point addition and doubling in projective coordinates
// Alg 4 from https://eprint.iacr.org/2015/1060.pdf
let point_add (p q:proj_point) : proj_point =
let x1, y1, z1 = p in
let x2, y2, z2 = q in
let t0 = x1 *% x2 in
let t1 = y1 *% y2 in
let t2 = z1 *% z2 in
let t3 = x1 +% y1 in
let t4 = x2 +% y2 in
let t3 = t3 *% t4 in
let t4 = t0 +% t1 in
let t3 = t3 -% t4 in
let t4 = y1 +% z1 in
let t5 = y2 +% z2 in
let t4 = t4 *% t5 in
let t5 = t1 +% t2 in
let t4 = t4 -% t5 in
let x3 = x1 +% z1 in
let y3 = x2 +% z2 in
let x3 = x3 *% y3 in
let y3 = t0 +% t2 in
let y3 = x3 -% y3 in
let z3 = b_coeff *% t2 in
let x3 = y3 -% z3 in
let z3 = x3 +% x3 in
let x3 = x3 +% z3 in
let z3 = t1 -% x3 in
let x3 = t1 +% x3 in
let y3 = b_coeff *% y3 in
let t1 = t2 +% t2 in
let t2 = t1 +% t2 in
let y3 = y3 -% t2 in
let y3 = y3 -% t0 in
let t1 = y3 +% y3 in
let y3 = t1 +% y3 in
let t1 = t0 +% t0 in
let t0 = t1 +% t0 in
let t0 = t0 -% t2 in
let t1 = t4 *% y3 in
let t2 = t0 *% y3 in
let y3 = x3 *% z3 in
let y3 = y3 +% t2 in
let x3 = t3 *% x3 in
let x3 = x3 -% t1 in
let z3 = t4 *% z3 in
let t1 = t3 *% t0 in
let z3 = z3 +% t1 in
(x3, y3, z3)
// Alg 6 from https://eprint.iacr.org/2015/1060.pdf
let point_double (p:proj_point) : proj_point =
let (x, y, z) = p in
let t0 = x *% x in
let t1 = y *% y in
let t2 = z *% z in
let t3 = x *% y in
let t3 = t3 +% t3 in
let t4 = y *% z in
let z3 = x *% z in
let z3 = z3 +% z3 in
let y3 = b_coeff *% t2 in
let y3 = y3 -% z3 in
let x3 = y3 +% y3 in
let y3 = x3 +% y3 in
let x3 = t1 -% y3 in
let y3 = t1 +% y3 in
let y3 = x3 *% y3 in
let x3 = x3 *% t3 in
let t3 = t2 +% t2 in
let t2 = t2 +% t3 in
let z3 = b_coeff *% z3 in
let z3 = z3 -% t2 in
let z3 = z3 -% t0 in
let t3 = z3 +% z3 in
let z3 = z3 +% t3 in
let t3 = t0 +% t0 in
let t0 = t3 +% t0 in
let t0 = t0 -% t2 in
let t0 = t0 *% z3 in
let y3 = y3 +% t0 in
let t0 = t4 +% t4 in
let z3 = t0 *% z3 in
let x3 = x3 -% z3 in
let z3 = t0 *% t1 in
let z3 = z3 +% z3 in
let z3 = z3 +% z3 in
(x3, y3, z3)
/// Point conversion between affine, projective and bytes representation
let aff_point_load (b:BSeq.lbytes 64) : option aff_point =
let pk_x = BSeq.nat_from_bytes_be (sub b 0 32) in
let pk_y = BSeq.nat_from_bytes_be (sub b 32 32) in
let is_x_valid = pk_x < prime in
let is_y_valid = pk_y < prime in
let is_xy_on_curve =
if is_x_valid && is_y_valid then is_on_curve (pk_x, pk_y) else false in
if is_xy_on_curve then Some (pk_x, pk_y) else None
let load_point (b:BSeq.lbytes 64) : option proj_point =
match (aff_point_load b) with
| Some p -> Some (to_proj_point p)
| None -> None | false | false | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val aff_point_store (p: aff_point) : BSeq.lbytes 64 | [] | Spec.P256.PointOps.aff_point_store | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Spec.P256.PointOps.aff_point -> Lib.ByteSequence.lbytes 64 | {
"end_col": 31,
"end_line": 251,
"start_col": 52,
"start_line": 247
} |
Prims.Tot | val aff_point_load (b: BSeq.lbytes 64) : option aff_point | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let aff_point_load (b:BSeq.lbytes 64) : option aff_point =
let pk_x = BSeq.nat_from_bytes_be (sub b 0 32) in
let pk_y = BSeq.nat_from_bytes_be (sub b 32 32) in
let is_x_valid = pk_x < prime in
let is_y_valid = pk_y < prime in
let is_xy_on_curve =
if is_x_valid && is_y_valid then is_on_curve (pk_x, pk_y) else false in
if is_xy_on_curve then Some (pk_x, pk_y) else None | val aff_point_load (b: BSeq.lbytes 64) : option aff_point
let aff_point_load (b: BSeq.lbytes 64) : option aff_point = | false | null | false | let pk_x = BSeq.nat_from_bytes_be (sub b 0 32) in
let pk_y = BSeq.nat_from_bytes_be (sub b 32 32) in
let is_x_valid = pk_x < prime in
let is_y_valid = pk_y < prime in
let is_xy_on_curve = if is_x_valid && is_y_valid then is_on_curve (pk_x, pk_y) else false in
if is_xy_on_curve then Some (pk_x, pk_y) else None | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Lib.ByteSequence.lbytes",
"FStar.Pervasives.Native.Some",
"Spec.P256.PointOps.aff_point",
"FStar.Pervasives.Native.Mktuple2",
"Prims.nat",
"Prims.bool",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.option",
"Prims.op_AmpAmp",
"Spec.P256.PointOps.is_on_curve",
"Prims.op_LessThan",
"Spec.P256.PointOps.prime",
"Prims.b2t",
"Prims.pow2",
"Prims.op_Multiply",
"Lib.Sequence.length",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.Sequence.sub",
"Lib.ByteSequence.nat_from_bytes_be",
"Lib.IntTypes.uint_t"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o
let qelem = x:nat{x < order}
let qadd (x y:qelem) : qelem = (x + y) % order
let qmul (x y:qelem) : qelem = (x * y) % order
let qinv (x:qelem) : qelem = M.pow_mod #order x (order - 2)
let ( +^ ) = qadd
let ( *^ ) = qmul
/// Elliptic curve `y^2 = x^3 + a * x + b`
let aff_point = p:tuple2 nat nat{let (px, py) = p in px < prime /\ py < prime}
let proj_point = p:tuple3 nat nat nat{let (px, py, pz) = p in px < prime /\ py < prime /\ pz < prime}
// let aff_point = felem & felem // Affine point
// let proj_point = felem & felem & felem // Projective coordinates
let a_coeff : felem = (-3) % prime
let b_coeff : felem =
let b = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b in
assert_norm (b < prime); b
// Base point
let g_x : felem =
let x = 0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296 in
assert_norm (x < prime); x
let g_y : felem =
let y = 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5 in
assert_norm (y < prime); y
let base_point : proj_point = (g_x, g_y, one)
let is_on_curve (p:aff_point) : bool =
let (x, y) = p in y *% y = x *% x *% x +% a_coeff *% x +% b_coeff
let aff_point_at_inf : aff_point = (zero, zero) // not on the curve!
let point_at_inf : proj_point = (zero, one, zero)
let is_aff_point_at_inf (p:aff_point) : bool =
let (x, y) = p in x = zero && y = zero
let is_point_at_inf (p:proj_point) =
let (_, _, z) = p in z = 0
let to_proj_point (p:aff_point) : proj_point =
let (x, y) = p in (x, y, one)
let to_aff_point (p:proj_point) : aff_point =
// if is_proj_point_at_inf p then aff_point_at_inf
let (px, py, pz) = p in
let zinv = finv pz in
let x = px *% zinv in
let y = py *% zinv in
(x, y)
/// Point addition in affine coordinates
let aff_point_double (p:aff_point) : aff_point =
let (px, py) = p in
if is_aff_point_at_inf p then p
else begin
if py = 0 then aff_point_at_inf
else begin
let lambda = (3 *% px *% px +% a_coeff) /% (2 *% py) in
let rx = lambda *% lambda -% px -% px in
let ry = lambda *% (px -% rx) -% py in
(rx, ry) end
end
let aff_point_add (p:aff_point) (q:aff_point) : aff_point =
let (px, py) = p in let (qx, qy) = q in
if is_aff_point_at_inf p then q
else begin
if is_aff_point_at_inf q then p
else begin
if p = q then aff_point_double p
else begin
if qx = px then aff_point_at_inf
else begin
let lambda = (qy -% py) /% (qx -% px) in
let rx = lambda *% lambda -% px -% qx in
let ry = lambda *% (px -% rx) -% py in
(rx, ry)
end
end
end
end
/// Point addition and doubling in projective coordinates
// Alg 4 from https://eprint.iacr.org/2015/1060.pdf
let point_add (p q:proj_point) : proj_point =
let x1, y1, z1 = p in
let x2, y2, z2 = q in
let t0 = x1 *% x2 in
let t1 = y1 *% y2 in
let t2 = z1 *% z2 in
let t3 = x1 +% y1 in
let t4 = x2 +% y2 in
let t3 = t3 *% t4 in
let t4 = t0 +% t1 in
let t3 = t3 -% t4 in
let t4 = y1 +% z1 in
let t5 = y2 +% z2 in
let t4 = t4 *% t5 in
let t5 = t1 +% t2 in
let t4 = t4 -% t5 in
let x3 = x1 +% z1 in
let y3 = x2 +% z2 in
let x3 = x3 *% y3 in
let y3 = t0 +% t2 in
let y3 = x3 -% y3 in
let z3 = b_coeff *% t2 in
let x3 = y3 -% z3 in
let z3 = x3 +% x3 in
let x3 = x3 +% z3 in
let z3 = t1 -% x3 in
let x3 = t1 +% x3 in
let y3 = b_coeff *% y3 in
let t1 = t2 +% t2 in
let t2 = t1 +% t2 in
let y3 = y3 -% t2 in
let y3 = y3 -% t0 in
let t1 = y3 +% y3 in
let y3 = t1 +% y3 in
let t1 = t0 +% t0 in
let t0 = t1 +% t0 in
let t0 = t0 -% t2 in
let t1 = t4 *% y3 in
let t2 = t0 *% y3 in
let y3 = x3 *% z3 in
let y3 = y3 +% t2 in
let x3 = t3 *% x3 in
let x3 = x3 -% t1 in
let z3 = t4 *% z3 in
let t1 = t3 *% t0 in
let z3 = z3 +% t1 in
(x3, y3, z3)
// Alg 6 from https://eprint.iacr.org/2015/1060.pdf
let point_double (p:proj_point) : proj_point =
let (x, y, z) = p in
let t0 = x *% x in
let t1 = y *% y in
let t2 = z *% z in
let t3 = x *% y in
let t3 = t3 +% t3 in
let t4 = y *% z in
let z3 = x *% z in
let z3 = z3 +% z3 in
let y3 = b_coeff *% t2 in
let y3 = y3 -% z3 in
let x3 = y3 +% y3 in
let y3 = x3 +% y3 in
let x3 = t1 -% y3 in
let y3 = t1 +% y3 in
let y3 = x3 *% y3 in
let x3 = x3 *% t3 in
let t3 = t2 +% t2 in
let t2 = t2 +% t3 in
let z3 = b_coeff *% z3 in
let z3 = z3 -% t2 in
let z3 = z3 -% t0 in
let t3 = z3 +% z3 in
let z3 = z3 +% t3 in
let t3 = t0 +% t0 in
let t0 = t3 +% t0 in
let t0 = t0 -% t2 in
let t0 = t0 *% z3 in
let y3 = y3 +% t0 in
let t0 = t4 +% t4 in
let z3 = t0 *% z3 in
let x3 = x3 -% z3 in
let z3 = t0 *% t1 in
let z3 = z3 +% z3 in
let z3 = z3 +% z3 in
(x3, y3, z3)
/// Point conversion between affine, projective and bytes representation | false | false | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val aff_point_load (b: BSeq.lbytes 64) : option aff_point | [] | Spec.P256.PointOps.aff_point_load | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b: Lib.ByteSequence.lbytes 64 -> FStar.Pervasives.Native.option Spec.P256.PointOps.aff_point | {
"end_col": 52,
"end_line": 238,
"start_col": 58,
"start_line": 231
} |
Prims.Tot | val aff_point_decompress (s: BSeq.lbytes 33) : option aff_point | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.NatMod",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let aff_point_decompress (s:BSeq.lbytes 33) : option aff_point =
let s0 = Lib.RawIntTypes.u8_to_UInt8 s.[0] in
if not (s0 = 0x02uy || s0 = 0x03uy) then None
else begin
let x = BSeq.nat_from_bytes_be (sub s 1 32) in
let is_x_valid = x < prime in
let is_y_odd = s0 = 0x03uy in
if not is_x_valid then None
else
match (recover_y x is_y_odd) with
| Some y -> Some (x, y)
| None -> None end | val aff_point_decompress (s: BSeq.lbytes 33) : option aff_point
let aff_point_decompress (s: BSeq.lbytes 33) : option aff_point = | false | null | false | let s0 = Lib.RawIntTypes.u8_to_UInt8 s.[ 0 ] in
if not (s0 = 0x02uy || s0 = 0x03uy)
then None
else
let x = BSeq.nat_from_bytes_be (sub s 1 32) in
let is_x_valid = x < prime in
let is_y_odd = s0 = 0x03uy in
if not is_x_valid
then None
else
match (recover_y x is_y_odd) with
| Some y -> Some (x, y)
| None -> None | {
"checked_file": "Spec.P256.PointOps.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.P256.PointOps.fst"
} | [
"total"
] | [
"Lib.ByteSequence.lbytes",
"Prims.op_Negation",
"Prims.op_BarBar",
"Prims.op_Equality",
"FStar.UInt8.t",
"FStar.UInt8.__uint_to_t",
"FStar.Pervasives.Native.None",
"Spec.P256.PointOps.aff_point",
"Prims.bool",
"Spec.P256.PointOps.recover_y",
"Spec.P256.PointOps.felem",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.Mktuple2",
"Prims.nat",
"FStar.Pervasives.Native.option",
"Prims.op_LessThan",
"Spec.P256.PointOps.prime",
"Prims.b2t",
"Prims.pow2",
"Prims.op_Multiply",
"Lib.Sequence.length",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.Sequence.sub",
"Lib.ByteSequence.nat_from_bytes_be",
"Lib.IntTypes.uint_t",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"FStar.UInt.size",
"Lib.IntTypes.v",
"Lib.Sequence.index",
"FStar.UInt8.v",
"Lib.RawIntTypes.u8_to_UInt8",
"Lib.Sequence.op_String_Access"
] | [] | module Spec.P256.PointOps
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
module M = Lib.NatMod
module BSeq = Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Base field
// 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
let prime: (a:pos{a = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff /\ a < pow2 256}) =
let p = pow2 256 - pow2 224 + pow2 192 + pow2 96 - 1 in
assert_norm (0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff = p);
assert_norm (p < pow2 256); p
let felem = x:nat{x < prime}
let zero : felem = 0
let one : felem = 1
let fadd (x y:felem) : felem = (x + y) % prime
let fsub (x y:felem) : felem = (x - y) % prime
let fmul (x y:felem) : felem = (x * y) % prime
let finv (a:felem) : felem = M.pow_mod #prime a (prime - 2)
let fsqrt (a:felem) : felem = M.pow_mod #prime a ((prime + 1) / 4)
let is_fodd (x:nat) : bool = x % 2 = 1
let ( +% ) = fadd
let ( -% ) = fsub
let ( *% ) = fmul
let ( /% ) (x y:felem) = x *% finv y
/// Scalar field
// Group order
let order: (a:pos{a < pow2 256}) =
let o = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 in
assert_norm (o < pow2 256); o
let qelem = x:nat{x < order}
let qadd (x y:qelem) : qelem = (x + y) % order
let qmul (x y:qelem) : qelem = (x * y) % order
let qinv (x:qelem) : qelem = M.pow_mod #order x (order - 2)
let ( +^ ) = qadd
let ( *^ ) = qmul
/// Elliptic curve `y^2 = x^3 + a * x + b`
let aff_point = p:tuple2 nat nat{let (px, py) = p in px < prime /\ py < prime}
let proj_point = p:tuple3 nat nat nat{let (px, py, pz) = p in px < prime /\ py < prime /\ pz < prime}
// let aff_point = felem & felem // Affine point
// let proj_point = felem & felem & felem // Projective coordinates
let a_coeff : felem = (-3) % prime
let b_coeff : felem =
let b = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b in
assert_norm (b < prime); b
// Base point
let g_x : felem =
let x = 0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296 in
assert_norm (x < prime); x
let g_y : felem =
let y = 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5 in
assert_norm (y < prime); y
let base_point : proj_point = (g_x, g_y, one)
let is_on_curve (p:aff_point) : bool =
let (x, y) = p in y *% y = x *% x *% x +% a_coeff *% x +% b_coeff
let aff_point_at_inf : aff_point = (zero, zero) // not on the curve!
let point_at_inf : proj_point = (zero, one, zero)
let is_aff_point_at_inf (p:aff_point) : bool =
let (x, y) = p in x = zero && y = zero
let is_point_at_inf (p:proj_point) =
let (_, _, z) = p in z = 0
let to_proj_point (p:aff_point) : proj_point =
let (x, y) = p in (x, y, one)
let to_aff_point (p:proj_point) : aff_point =
// if is_proj_point_at_inf p then aff_point_at_inf
let (px, py, pz) = p in
let zinv = finv pz in
let x = px *% zinv in
let y = py *% zinv in
(x, y)
/// Point addition in affine coordinates
let aff_point_double (p:aff_point) : aff_point =
let (px, py) = p in
if is_aff_point_at_inf p then p
else begin
if py = 0 then aff_point_at_inf
else begin
let lambda = (3 *% px *% px +% a_coeff) /% (2 *% py) in
let rx = lambda *% lambda -% px -% px in
let ry = lambda *% (px -% rx) -% py in
(rx, ry) end
end
let aff_point_add (p:aff_point) (q:aff_point) : aff_point =
let (px, py) = p in let (qx, qy) = q in
if is_aff_point_at_inf p then q
else begin
if is_aff_point_at_inf q then p
else begin
if p = q then aff_point_double p
else begin
if qx = px then aff_point_at_inf
else begin
let lambda = (qy -% py) /% (qx -% px) in
let rx = lambda *% lambda -% px -% qx in
let ry = lambda *% (px -% rx) -% py in
(rx, ry)
end
end
end
end
/// Point addition and doubling in projective coordinates
// Alg 4 from https://eprint.iacr.org/2015/1060.pdf
let point_add (p q:proj_point) : proj_point =
let x1, y1, z1 = p in
let x2, y2, z2 = q in
let t0 = x1 *% x2 in
let t1 = y1 *% y2 in
let t2 = z1 *% z2 in
let t3 = x1 +% y1 in
let t4 = x2 +% y2 in
let t3 = t3 *% t4 in
let t4 = t0 +% t1 in
let t3 = t3 -% t4 in
let t4 = y1 +% z1 in
let t5 = y2 +% z2 in
let t4 = t4 *% t5 in
let t5 = t1 +% t2 in
let t4 = t4 -% t5 in
let x3 = x1 +% z1 in
let y3 = x2 +% z2 in
let x3 = x3 *% y3 in
let y3 = t0 +% t2 in
let y3 = x3 -% y3 in
let z3 = b_coeff *% t2 in
let x3 = y3 -% z3 in
let z3 = x3 +% x3 in
let x3 = x3 +% z3 in
let z3 = t1 -% x3 in
let x3 = t1 +% x3 in
let y3 = b_coeff *% y3 in
let t1 = t2 +% t2 in
let t2 = t1 +% t2 in
let y3 = y3 -% t2 in
let y3 = y3 -% t0 in
let t1 = y3 +% y3 in
let y3 = t1 +% y3 in
let t1 = t0 +% t0 in
let t0 = t1 +% t0 in
let t0 = t0 -% t2 in
let t1 = t4 *% y3 in
let t2 = t0 *% y3 in
let y3 = x3 *% z3 in
let y3 = y3 +% t2 in
let x3 = t3 *% x3 in
let x3 = x3 -% t1 in
let z3 = t4 *% z3 in
let t1 = t3 *% t0 in
let z3 = z3 +% t1 in
(x3, y3, z3)
// Alg 6 from https://eprint.iacr.org/2015/1060.pdf
let point_double (p:proj_point) : proj_point =
let (x, y, z) = p in
let t0 = x *% x in
let t1 = y *% y in
let t2 = z *% z in
let t3 = x *% y in
let t3 = t3 +% t3 in
let t4 = y *% z in
let z3 = x *% z in
let z3 = z3 +% z3 in
let y3 = b_coeff *% t2 in
let y3 = y3 -% z3 in
let x3 = y3 +% y3 in
let y3 = x3 +% y3 in
let x3 = t1 -% y3 in
let y3 = t1 +% y3 in
let y3 = x3 *% y3 in
let x3 = x3 *% t3 in
let t3 = t2 +% t2 in
let t2 = t2 +% t3 in
let z3 = b_coeff *% z3 in
let z3 = z3 -% t2 in
let z3 = z3 -% t0 in
let t3 = z3 +% z3 in
let z3 = z3 +% t3 in
let t3 = t0 +% t0 in
let t0 = t3 +% t0 in
let t0 = t0 -% t2 in
let t0 = t0 *% z3 in
let y3 = y3 +% t0 in
let t0 = t4 +% t4 in
let z3 = t0 *% z3 in
let x3 = x3 -% z3 in
let z3 = t0 *% t1 in
let z3 = z3 +% z3 in
let z3 = z3 +% z3 in
(x3, y3, z3)
/// Point conversion between affine, projective and bytes representation
let aff_point_load (b:BSeq.lbytes 64) : option aff_point =
let pk_x = BSeq.nat_from_bytes_be (sub b 0 32) in
let pk_y = BSeq.nat_from_bytes_be (sub b 32 32) in
let is_x_valid = pk_x < prime in
let is_y_valid = pk_y < prime in
let is_xy_on_curve =
if is_x_valid && is_y_valid then is_on_curve (pk_x, pk_y) else false in
if is_xy_on_curve then Some (pk_x, pk_y) else None
let load_point (b:BSeq.lbytes 64) : option proj_point =
match (aff_point_load b) with
| Some p -> Some (to_proj_point p)
| None -> None
let aff_point_store (p:aff_point) : BSeq.lbytes 64 =
let (px, py) = p in
let pxb = BSeq.nat_to_bytes_be 32 px in
let pxy = BSeq.nat_to_bytes_be 32 py in
concat #uint8 #32 #32 pxb pxy
let point_store (p:proj_point) : BSeq.lbytes 64 =
aff_point_store (to_aff_point p)
let recover_y (x:felem) (is_odd:bool) : option felem =
let y2 = x *% x *% x +% a_coeff *% x +% b_coeff in
let y = fsqrt y2 in
if y *% y <> y2 then None
else begin
let y = if is_fodd y <> is_odd then (prime - y) % prime else y in
Some y end | false | false | Spec.P256.PointOps.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val aff_point_decompress (s: BSeq.lbytes 33) : option aff_point | [] | Spec.P256.PointOps.aff_point_decompress | {
"file_name": "specs/Spec.P256.PointOps.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Lib.ByteSequence.lbytes 33 -> FStar.Pervasives.Native.option Spec.P256.PointOps.aff_point | {
"end_col": 24,
"end_line": 279,
"start_col": 64,
"start_line": 267
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s) | let felem_wide (s: field_spec) = | false | null | false | lbuffer (wide s) (nwide s) | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"Lib.Buffer.lbuffer",
"Hacl.Impl.Curve25519.Fields.Core.wide",
"Hacl.Impl.Curve25519.Fields.Core.nwide"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s) | false | true | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val felem_wide : s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.felem_wide | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> Type0 | {
"end_col": 58,
"end_line": 67,
"start_col": 32,
"start_line": 67
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s) | let felem2 (s: field_spec) = | false | null | false | lbuffer (limb s) (nlimb s +. nlimb s) | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"Lib.Buffer.lbuffer",
"Hacl.Impl.Curve25519.Fields.Core.limb",
"Lib.IntTypes.op_Plus_Dot",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Impl.Curve25519.Fields.Core.nlimb"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s) | false | true | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val felem2 : s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.felem2 | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> Type0 | {
"end_col": 65,
"end_line": 65,
"start_col": 28,
"start_line": 65
} |
|
Prims.Tot | val f51_felem_fits (h: mem) (f: felem M51) (m: Hacl.Spec.Curve25519.Field51.Definition.scale64_5)
: Type0 | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m | val f51_felem_fits (h: mem) (f: felem M51) (m: Hacl.Spec.Curve25519.Field51.Definition.scale64_5)
: Type0
let f51_felem_fits (h: mem) (f: felem M51) (m: Hacl.Spec.Curve25519.Field51.Definition.scale64_5)
: Type0 = | false | null | false | Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Curve25519.Fields.Core.felem",
"Hacl.Impl.Curve25519.Fields.Core.M51",
"Hacl.Spec.Curve25519.Field51.Definition.scale64_5",
"Hacl.Spec.Curve25519.Field51.Definition.felem_fits5",
"Hacl.Impl.Curve25519.Fields.Core.f51_as_felem"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract | false | true | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val f51_felem_fits (h: mem) (f: felem M51) (m: Hacl.Spec.Curve25519.Field51.Definition.scale64_5)
: Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.f51_felem_fits | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
h: FStar.Monotonic.HyperStack.mem ->
f: Hacl.Impl.Curve25519.Fields.Core.felem Hacl.Impl.Curve25519.Fields.Core.M51 ->
m: Hacl.Spec.Curve25519.Field51.Definition.scale64_5
-> Type0 | {
"end_col": 74,
"end_line": 89,
"start_col": 2,
"start_line": 89
} |
Prims.GTot | val f51_mul_inv_t (h: mem) (f: felem M51) : GTot Type0 | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f | val f51_mul_inv_t (h: mem) (f: felem M51) : GTot Type0
let f51_mul_inv_t (h: mem) (f: felem M51) : GTot Type0 = | false | null | false | let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"sometrivial"
] | [
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Curve25519.Fields.Core.felem",
"Hacl.Impl.Curve25519.Fields.Core.M51",
"Hacl.Spec.Curve25519.Field51.mul_inv_t",
"Hacl.Spec.Curve25519.Field51.Definition.felem5",
"Hacl.Impl.Curve25519.Fields.Core.f51_as_felem"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1 | false | false | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val f51_mul_inv_t (h: mem) (f: felem M51) : GTot Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.f51_mul_inv_t | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
h: FStar.Monotonic.HyperStack.mem ->
f: Hacl.Impl.Curve25519.Fields.Core.felem Hacl.Impl.Curve25519.Fields.Core.M51
-> Prims.GTot Type0 | {
"end_col": 42,
"end_line": 97,
"start_col": 54,
"start_line": 95
} |
Prims.GTot | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e) | let f51_as_nat h e = | false | null | false | Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e) | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"sometrivial"
] | [
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Curve25519.Fields.Core.felem",
"Hacl.Impl.Curve25519.Fields.Core.M51",
"Hacl.Spec.Curve25519.Field51.Definition.as_nat5",
"Hacl.Impl.Curve25519.Fields.Core.f51_as_felem",
"Prims.nat"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4) | false | false | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val f51_as_nat : h: FStar.Monotonic.HyperStack.mem ->
e: Hacl.Impl.Curve25519.Fields.Core.felem Hacl.Impl.Curve25519.Fields.Core.M51
-> Prims.GTot Prims.nat | [] | Hacl.Impl.Curve25519.Fields.Core.f51_as_nat | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
h: FStar.Monotonic.HyperStack.mem ->
e: Hacl.Impl.Curve25519.Fields.Core.felem Hacl.Impl.Curve25519.Fields.Core.M51
-> Prims.GTot Prims.nat | {
"end_col": 87,
"end_line": 85,
"start_col": 21,
"start_line": 85
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fsqr_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> tmp:felem_wide s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h tmp /\
fsqr_disjoint out f1 tmp /\
fsqr_pre h f1)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\
state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (feval h0 f1)) | let fsqr_t (s: field_spec) (p: Type0) = | false | null | false | out: felem s -> f1: felem s -> tmp: felem_wide s
-> Stack unit
(requires
fun h ->
p /\ live h out /\ live h f1 /\ live h tmp /\ fsqr_disjoint out f1 tmp /\ fsqr_pre h f1)
(ensures
fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (feval h0 f1)) | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"Hacl.Impl.Curve25519.Fields.Core.felem",
"Hacl.Impl.Curve25519.Fields.Core.felem_wide",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Hacl.Impl.Curve25519.Fields.Core.limb",
"Hacl.Impl.Curve25519.Fields.Core.wide",
"Hacl.Impl.Curve25519.Fields.Core.fsqr_disjoint",
"Hacl.Impl.Curve25519.Fields.Core.fsqr_pre",
"Lib.Buffer.modifies",
"Lib.Buffer.op_Bar_Plus_Bar",
"Lib.Buffer.loc",
"Hacl.Impl.Curve25519.Fields.Core.state_inv_t",
"Prims.eq2",
"Spec.Curve25519.elem",
"Hacl.Impl.Curve25519.Fields.Core.feval",
"Spec.Curve25519.fmul"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1
noextract
let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f
noextract
let f64_as_nat (h:mem) (e: felem M64) : GTot nat =
let s = as_seq h e in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3)
noextract
let as_nat (#s:field_spec) (h:mem) (e:felem s): GTot nat =
match s with
| M51 -> f51_as_nat h e
| M64 -> f64_as_nat h e
noextract
let feval (#s:field_spec) (h:mem) (e:felem s): GTot P.elem =
(as_nat h e) % P.prime
/// Start of core combinators
/// -------------------------
let fadd_fsub_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (1, 2, 1, 1, 1) /\
f51_felem_fits h f2 (1, 2, 1, 1, 1)
| M64 -> True
let fadd_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (2, 4, 2, 2, 2)
| M64 -> True
inline_for_extraction
let fadd_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fadd_post h1 out /\
feval h1 out == P.fadd (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize]
val fadd: #s:field_spec -> fadd_t s True
let fsub_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (9, 10, 9, 9, 9)
| M64 -> True
inline_for_extraction
let fsub_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fsub_post h1 out /\
feval h1 out == P.fsub (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fsub: #s:field_spec -> fsub_t s True
let fmul_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (9, 10, 9, 9, 9) /\
f51_felem_fits h f2 (9, 10, 9, 9, 9)
| M64 -> True
let fmul_disjoint (#s:field_spec) (out f1 f2:felem s) (tmp:felem_wide2 s): Type0 =
match s with
| M51 -> True
| M64 ->
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp \/ out == tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp
let state_inv_t (#s:field_spec) (h:mem) (f:felem s): Type0 =
match s with
| M51 -> f51_mul_inv_t h f
| M64 -> True
inline_for_extraction
let fmul_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
fmul_disjoint out f1 f2 tmp /\
fmul_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fmul: #s:field_spec -> fmul_t s True
let fmul2_pre (#s:field_spec) (h:mem) (f1:felem2 s) (f2:felem2 s): Type0 =
match s with
| M51 ->
let f10 = gsub f1 0ul 5ul in
let f11 = gsub f1 5ul 5ul in
let f20 = gsub f2 0ul 5ul in
let f21 = gsub f2 5ul 5ul in
f51_felem_fits h f10 (9, 10, 9, 9, 9) /\
f51_felem_fits h f11 (9, 10, 9, 9, 9) /\
f51_felem_fits h f20 (9, 10, 9, 9, 9) /\
f51_felem_fits h f21 (9, 10, 9, 9, 9)
| M64 -> True
let fmul2_fsqr2_post (#s:field_spec) (h:mem) (out:felem2 s): Type0 =
match s with
| M51 ->
let out0 = gsub out 0ul 5ul in
let out1 = gsub out 5ul 5ul in
f51_mul_inv_t h out0 /\
f51_mul_inv_t h out1
| M64 -> True
inline_for_extraction
let fmul2_t (s:field_spec) (p: Type0) =
out:felem2 s
-> f1:felem2 s
-> f2:felem2 s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp /\
fmul2_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ fmul2_fsqr2_post h1 out /\
(let out0 = gsub out 0ul (nlimb s) in
let out1 = gsub out (nlimb s) (nlimb s) in
let f10 = gsub f1 0ul (nlimb s) in
let f11 = gsub f1 (nlimb s) (nlimb s) in
let f20 = gsub f2 0ul (nlimb s) in
let f21 = gsub f2 (nlimb s) (nlimb s) in
feval h1 out0 == P.fmul (feval h0 f10) (feval h0 f20) /\
feval h1 out1 == P.fmul (feval h0 f11) (feval h0 f21)))
[@ Meta.Attribute.specialize ]
val fmul2: #s:field_spec -> fmul2_t s True
let fmul1_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:uint64): Type0 =
match s with
| M51 -> f51_felem_fits h f1 (9, 10, 9, 9, 9) /\ f51_felem_fits1 f2 1
| M64 -> v f2 < pow2 17
inline_for_extraction
let fmul1_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:uint64
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\
(disjoint out f1 \/ out == f1) /\
fmul1_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (v f2))
// feval h1 out == (feval h0 f1 * v f2) % P.prime)
[@ Meta.Attribute.specialize ]
val fmul1: #s:field_spec -> fmul1_t s True
let fsqr_pre (#s:field_spec) (h:mem) (f:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h f (9, 10, 9, 9, 9)
| M64 -> True
let fsqr_disjoint (#s:field_spec) (out f1:felem s) (tmp:felem_wide s): Type0 =
match s with
| M51 -> True
| M64 ->
(disjoint out f1 \/ out == f1) /\
(disjoint out tmp \/ out == tmp) /\
disjoint tmp f1
inline_for_extraction | false | true | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fsqr_t : s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> p: Type0 -> Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.fsqr_t | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> p: Type0 -> Type0 | {
"end_col": 57,
"end_line": 323,
"start_col": 4,
"start_line": 311
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fadd_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fadd_post h1 out /\
feval h1 out == P.fadd (feval h0 f1) (feval h0 f2)) | let fadd_t (s: field_spec) (p: Type0) = | false | null | false | out: felem s -> f1: felem s -> f2: felem s
-> Stack unit
(requires
fun h ->
p /\ live h out /\ live h f1 /\ live h f2 /\ (disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\ (disjoint f1 f2 \/ f1 == f2) /\ fadd_fsub_pre h f1 f2)
(ensures
fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fadd_post h1 out /\
feval h1 out == P.fadd (feval h0 f1) (feval h0 f2)) | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"Hacl.Impl.Curve25519.Fields.Core.felem",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Hacl.Impl.Curve25519.Fields.Core.limb",
"Prims.l_or",
"Lib.Buffer.disjoint",
"Prims.eq2",
"Hacl.Impl.Curve25519.Fields.Core.fadd_fsub_pre",
"Lib.Buffer.modifies",
"Lib.Buffer.loc",
"Hacl.Impl.Curve25519.Fields.Core.fadd_post",
"Spec.Curve25519.elem",
"Hacl.Impl.Curve25519.Fields.Core.feval",
"Spec.Curve25519.fadd"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1
noextract
let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f
noextract
let f64_as_nat (h:mem) (e: felem M64) : GTot nat =
let s = as_seq h e in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3)
noextract
let as_nat (#s:field_spec) (h:mem) (e:felem s): GTot nat =
match s with
| M51 -> f51_as_nat h e
| M64 -> f64_as_nat h e
noextract
let feval (#s:field_spec) (h:mem) (e:felem s): GTot P.elem =
(as_nat h e) % P.prime
/// Start of core combinators
/// -------------------------
let fadd_fsub_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (1, 2, 1, 1, 1) /\
f51_felem_fits h f2 (1, 2, 1, 1, 1)
| M64 -> True
let fadd_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (2, 4, 2, 2, 2)
| M64 -> True
inline_for_extraction | false | true | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fadd_t : s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> p: Type0 -> Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.fadd_t | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> p: Type0 -> Type0 | {
"end_col": 57,
"end_line": 149,
"start_col": 4,
"start_line": 136
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let felem (s:field_spec) = lbuffer (limb s) (nlimb s) | let felem (s: field_spec) = | false | null | false | lbuffer (limb s) (nlimb s) | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"Lib.Buffer.lbuffer",
"Hacl.Impl.Curve25519.Fields.Core.limb",
"Hacl.Impl.Curve25519.Fields.Core.nlimb"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul | false | true | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val felem : s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.felem | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> Type0 | {
"end_col": 53,
"end_line": 63,
"start_col": 27,
"start_line": 63
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s) | let felem_wide2 (s: field_spec) = | false | null | false | lbuffer (wide s) (nwide s +. nwide s) | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"Lib.Buffer.lbuffer",
"Hacl.Impl.Curve25519.Fields.Core.wide",
"Lib.IntTypes.op_Plus_Dot",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Impl.Curve25519.Fields.Core.nwide"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s) | false | true | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val felem_wide2 : s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.felem_wide2 | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> Type0 | {
"end_col": 70,
"end_line": 69,
"start_col": 33,
"start_line": 69
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1 | let f51_felem_fits1 = | false | null | false | Hacl.Spec.Curve25519.Field51.Definition.felem_fits1 | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Spec.Curve25519.Field51.Definition.felem_fits1"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m | false | true | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val f51_felem_fits1 : x: Lib.IntTypes.uint64 -> m: Hacl.Spec.Curve25519.Field51.Definition.scale64 -> Prims.bool | [] | Hacl.Impl.Curve25519.Fields.Core.f51_felem_fits1 | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Lib.IntTypes.uint64 -> m: Hacl.Spec.Curve25519.Field51.Definition.scale64 -> Prims.bool | {
"end_col": 73,
"end_line": 92,
"start_col": 22,
"start_line": 92
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fmul_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
fmul_disjoint out f1 f2 tmp /\
fmul_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (feval h0 f2)) | let fmul_t (s: field_spec) (p: Type0) = | false | null | false | out: felem s -> f1: felem s -> f2: felem s -> tmp: felem_wide2 s
-> Stack unit
(requires
fun h ->
p /\ live h out /\ live h f1 /\ live h f2 /\ live h tmp /\ fmul_disjoint out f1 f2 tmp /\
fmul_pre h f1 f2)
(ensures
fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (feval h0 f2)) | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"Hacl.Impl.Curve25519.Fields.Core.felem",
"Hacl.Impl.Curve25519.Fields.Core.felem_wide2",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Hacl.Impl.Curve25519.Fields.Core.limb",
"Hacl.Impl.Curve25519.Fields.Core.wide",
"Hacl.Impl.Curve25519.Fields.Core.fmul_disjoint",
"Hacl.Impl.Curve25519.Fields.Core.fmul_pre",
"Lib.Buffer.modifies",
"Lib.Buffer.op_Bar_Plus_Bar",
"Lib.Buffer.loc",
"Hacl.Impl.Curve25519.Fields.Core.state_inv_t",
"Prims.eq2",
"Spec.Curve25519.elem",
"Hacl.Impl.Curve25519.Fields.Core.feval",
"Spec.Curve25519.fmul"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1
noextract
let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f
noextract
let f64_as_nat (h:mem) (e: felem M64) : GTot nat =
let s = as_seq h e in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3)
noextract
let as_nat (#s:field_spec) (h:mem) (e:felem s): GTot nat =
match s with
| M51 -> f51_as_nat h e
| M64 -> f64_as_nat h e
noextract
let feval (#s:field_spec) (h:mem) (e:felem s): GTot P.elem =
(as_nat h e) % P.prime
/// Start of core combinators
/// -------------------------
let fadd_fsub_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (1, 2, 1, 1, 1) /\
f51_felem_fits h f2 (1, 2, 1, 1, 1)
| M64 -> True
let fadd_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (2, 4, 2, 2, 2)
| M64 -> True
inline_for_extraction
let fadd_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fadd_post h1 out /\
feval h1 out == P.fadd (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize]
val fadd: #s:field_spec -> fadd_t s True
let fsub_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (9, 10, 9, 9, 9)
| M64 -> True
inline_for_extraction
let fsub_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fsub_post h1 out /\
feval h1 out == P.fsub (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fsub: #s:field_spec -> fsub_t s True
let fmul_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (9, 10, 9, 9, 9) /\
f51_felem_fits h f2 (9, 10, 9, 9, 9)
| M64 -> True
let fmul_disjoint (#s:field_spec) (out f1 f2:felem s) (tmp:felem_wide2 s): Type0 =
match s with
| M51 -> True
| M64 ->
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp \/ out == tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp
let state_inv_t (#s:field_spec) (h:mem) (f:felem s): Type0 =
match s with
| M51 -> f51_mul_inv_t h f
| M64 -> True
inline_for_extraction | false | true | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fmul_t : s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> p: Type0 -> Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.fmul_t | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> p: Type0 -> Type0 | {
"end_col": 57,
"end_line": 215,
"start_col": 4,
"start_line": 203
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fsub_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fsub_post h1 out /\
feval h1 out == P.fsub (feval h0 f1) (feval h0 f2)) | let fsub_t (s: field_spec) (p: Type0) = | false | null | false | out: felem s -> f1: felem s -> f2: felem s
-> Stack unit
(requires
fun h ->
p /\ live h out /\ live h f1 /\ live h f2 /\ (disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\ (disjoint f1 f2 \/ f1 == f2) /\ fadd_fsub_pre h f1 f2)
(ensures
fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fsub_post h1 out /\
feval h1 out == P.fsub (feval h0 f1) (feval h0 f2)) | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"Hacl.Impl.Curve25519.Fields.Core.felem",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Hacl.Impl.Curve25519.Fields.Core.limb",
"Prims.l_or",
"Lib.Buffer.disjoint",
"Prims.eq2",
"Hacl.Impl.Curve25519.Fields.Core.fadd_fsub_pre",
"Lib.Buffer.modifies",
"Lib.Buffer.loc",
"Hacl.Impl.Curve25519.Fields.Core.fsub_post",
"Spec.Curve25519.elem",
"Hacl.Impl.Curve25519.Fields.Core.feval",
"Spec.Curve25519.fsub"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1
noextract
let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f
noextract
let f64_as_nat (h:mem) (e: felem M64) : GTot nat =
let s = as_seq h e in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3)
noextract
let as_nat (#s:field_spec) (h:mem) (e:felem s): GTot nat =
match s with
| M51 -> f51_as_nat h e
| M64 -> f64_as_nat h e
noextract
let feval (#s:field_spec) (h:mem) (e:felem s): GTot P.elem =
(as_nat h e) % P.prime
/// Start of core combinators
/// -------------------------
let fadd_fsub_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (1, 2, 1, 1, 1) /\
f51_felem_fits h f2 (1, 2, 1, 1, 1)
| M64 -> True
let fadd_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (2, 4, 2, 2, 2)
| M64 -> True
inline_for_extraction
let fadd_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fadd_post h1 out /\
feval h1 out == P.fadd (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize]
val fadd: #s:field_spec -> fadd_t s True
let fsub_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (9, 10, 9, 9, 9)
| M64 -> True
inline_for_extraction | false | true | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fsub_t : s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> p: Type0 -> Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.fsub_t | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> p: Type0 -> Type0 | {
"end_col": 57,
"end_line": 173,
"start_col": 4,
"start_line": 160
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let add1_t (p: Type0) = out:felem M64 -> f1:felem M64 -> f2:uint64
-> Stack (Ghost.erased uint64)
(requires fun h ->
p /\
live h f1 /\ live h out /\
(disjoint out f1 \/ out == f1))
(ensures fun h0 c h1 ->
modifies (loc out) h0 h1 /\
as_nat h1 out + v c * pow2 256 == as_nat h0 f1 + v f2) | let add1_t (p: Type0) = | false | null | false | out: felem M64 -> f1: felem M64 -> f2: uint64
-> Stack (Ghost.erased uint64)
(requires fun h -> p /\ live h f1 /\ live h out /\ (disjoint out f1 \/ out == f1))
(ensures
fun h0 c h1 ->
modifies (loc out) h0 h1 /\ as_nat h1 out + v c * pow2 256 == as_nat h0 f1 + v f2) | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.felem",
"Hacl.Impl.Curve25519.Fields.Core.M64",
"Lib.IntTypes.uint64",
"FStar.Ghost.erased",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Hacl.Impl.Curve25519.Fields.Core.limb",
"Prims.l_or",
"Lib.Buffer.disjoint",
"Prims.eq2",
"Lib.Buffer.modifies",
"Lib.Buffer.loc",
"Prims.int",
"Prims.op_Addition",
"Hacl.Impl.Curve25519.Fields.Core.as_nat",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.Ghost.reveal",
"Prims.pow2"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1
noextract
let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f
noextract
let f64_as_nat (h:mem) (e: felem M64) : GTot nat =
let s = as_seq h e in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3)
noextract
let as_nat (#s:field_spec) (h:mem) (e:felem s): GTot nat =
match s with
| M51 -> f51_as_nat h e
| M64 -> f64_as_nat h e
noextract
let feval (#s:field_spec) (h:mem) (e:felem s): GTot P.elem =
(as_nat h e) % P.prime
/// Start of core combinators
/// -------------------------
let fadd_fsub_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (1, 2, 1, 1, 1) /\
f51_felem_fits h f2 (1, 2, 1, 1, 1)
| M64 -> True
let fadd_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (2, 4, 2, 2, 2)
| M64 -> True
inline_for_extraction
let fadd_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fadd_post h1 out /\
feval h1 out == P.fadd (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize]
val fadd: #s:field_spec -> fadd_t s True
let fsub_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (9, 10, 9, 9, 9)
| M64 -> True
inline_for_extraction
let fsub_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fsub_post h1 out /\
feval h1 out == P.fsub (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fsub: #s:field_spec -> fsub_t s True
let fmul_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (9, 10, 9, 9, 9) /\
f51_felem_fits h f2 (9, 10, 9, 9, 9)
| M64 -> True
let fmul_disjoint (#s:field_spec) (out f1 f2:felem s) (tmp:felem_wide2 s): Type0 =
match s with
| M51 -> True
| M64 ->
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp \/ out == tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp
let state_inv_t (#s:field_spec) (h:mem) (f:felem s): Type0 =
match s with
| M51 -> f51_mul_inv_t h f
| M64 -> True
inline_for_extraction
let fmul_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
fmul_disjoint out f1 f2 tmp /\
fmul_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fmul: #s:field_spec -> fmul_t s True
let fmul2_pre (#s:field_spec) (h:mem) (f1:felem2 s) (f2:felem2 s): Type0 =
match s with
| M51 ->
let f10 = gsub f1 0ul 5ul in
let f11 = gsub f1 5ul 5ul in
let f20 = gsub f2 0ul 5ul in
let f21 = gsub f2 5ul 5ul in
f51_felem_fits h f10 (9, 10, 9, 9, 9) /\
f51_felem_fits h f11 (9, 10, 9, 9, 9) /\
f51_felem_fits h f20 (9, 10, 9, 9, 9) /\
f51_felem_fits h f21 (9, 10, 9, 9, 9)
| M64 -> True
let fmul2_fsqr2_post (#s:field_spec) (h:mem) (out:felem2 s): Type0 =
match s with
| M51 ->
let out0 = gsub out 0ul 5ul in
let out1 = gsub out 5ul 5ul in
f51_mul_inv_t h out0 /\
f51_mul_inv_t h out1
| M64 -> True
inline_for_extraction
let fmul2_t (s:field_spec) (p: Type0) =
out:felem2 s
-> f1:felem2 s
-> f2:felem2 s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp /\
fmul2_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ fmul2_fsqr2_post h1 out /\
(let out0 = gsub out 0ul (nlimb s) in
let out1 = gsub out (nlimb s) (nlimb s) in
let f10 = gsub f1 0ul (nlimb s) in
let f11 = gsub f1 (nlimb s) (nlimb s) in
let f20 = gsub f2 0ul (nlimb s) in
let f21 = gsub f2 (nlimb s) (nlimb s) in
feval h1 out0 == P.fmul (feval h0 f10) (feval h0 f20) /\
feval h1 out1 == P.fmul (feval h0 f11) (feval h0 f21)))
[@ Meta.Attribute.specialize ]
val fmul2: #s:field_spec -> fmul2_t s True
let fmul1_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:uint64): Type0 =
match s with
| M51 -> f51_felem_fits h f1 (9, 10, 9, 9, 9) /\ f51_felem_fits1 f2 1
| M64 -> v f2 < pow2 17
inline_for_extraction
let fmul1_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:uint64
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\
(disjoint out f1 \/ out == f1) /\
fmul1_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (v f2))
// feval h1 out == (feval h0 f1 * v f2) % P.prime)
[@ Meta.Attribute.specialize ]
val fmul1: #s:field_spec -> fmul1_t s True
let fsqr_pre (#s:field_spec) (h:mem) (f:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h f (9, 10, 9, 9, 9)
| M64 -> True
let fsqr_disjoint (#s:field_spec) (out f1:felem s) (tmp:felem_wide s): Type0 =
match s with
| M51 -> True
| M64 ->
(disjoint out f1 \/ out == f1) /\
(disjoint out tmp \/ out == tmp) /\
disjoint tmp f1
inline_for_extraction
let fsqr_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> tmp:felem_wide s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h tmp /\
fsqr_disjoint out f1 tmp /\
fsqr_pre h f1)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\
state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (feval h0 f1))
[@ Meta.Attribute.specialize ]
val fsqr: #s:field_spec -> fsqr_t s True
let fsqr2_pre (#s:field_spec) (h:mem) (f:felem2 s): Type0 =
match s with
| M51 ->
let f1 = gsub f 0ul 5ul in
let f2 = gsub f 5ul 5ul in
f51_felem_fits h f1 (9, 10, 9, 9, 9) /\
f51_felem_fits h f2 (9, 10, 9, 9, 9)
| M64 -> True
inline_for_extraction
let fsqr2_t (s:field_spec) (p: Type0) =
out:felem2 s
-> f:felem2 s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f /\ live h tmp /\
(disjoint out f \/ out == f) /\
(disjoint out tmp) /\
disjoint tmp f /\
fsqr2_pre h f)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ fmul2_fsqr2_post h1 out /\
(let out1 = gsub out 0ul (nlimb s) in
let out2 = gsub out (nlimb s) (nlimb s) in
let f1 = gsub f 0ul (nlimb s) in
let f2 = gsub f (nlimb s) (nlimb s) in
feval h1 out1 == P.fmul (feval h0 f1) (feval h0 f1) /\
feval h1 out2 == P.fmul (feval h0 f2) (feval h0 f2)))
[@ Meta.Attribute.specialize ]
val fsqr2: #s:field_spec -> fsqr2_t s True
inline_for_extraction
let cswap2_t (s:field_spec) (p: Type0) =
bit:uint64{v bit <= 1}
-> p1:felem2 s
-> p2:felem2 s
-> Stack unit
(requires fun h0 ->
p /\
live h0 p1 /\ live h0 p2 /\
(disjoint p1 p2 \/ p1 == p2))
(ensures fun h0 _ h1 ->
modifies (loc p1 |+| loc p2) h0 h1 /\
(v bit == 1 ==> as_seq h1 p1 == as_seq h0 p2 /\ as_seq h1 p2 == as_seq h0 p1) /\
(v bit == 0 ==> as_seq h1 p1 == as_seq h0 p1 /\ as_seq h1 p2 == as_seq h0 p2))
[@ Meta.Attribute.specialize ]
val cswap2: #s:field_spec -> cswap2_t s True
/// Field64-specific core operations
/// -------------------------------- | false | true | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val add1_t : p: Type0 -> Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.add1_t | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Type0 -> Type0 | {
"end_col": 60,
"end_line": 392,
"start_col": 24,
"start_line": 384
} |
|
Prims.GTot | val as_nat (#s: field_spec) (h: mem) (e: felem s) : GTot nat | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let as_nat (#s:field_spec) (h:mem) (e:felem s): GTot nat =
match s with
| M51 -> f51_as_nat h e
| M64 -> f64_as_nat h e | val as_nat (#s: field_spec) (h: mem) (e: felem s) : GTot nat
let as_nat (#s: field_spec) (h: mem) (e: felem s) : GTot nat = | false | null | false | match s with
| M51 -> f51_as_nat h e
| M64 -> f64_as_nat h e | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"sometrivial"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Curve25519.Fields.Core.felem",
"Hacl.Impl.Curve25519.Fields.Core.f51_as_nat",
"Hacl.Impl.Curve25519.Fields.Core.f64_as_nat",
"Prims.nat"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1
noextract
let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f
noextract
let f64_as_nat (h:mem) (e: felem M64) : GTot nat =
let s = as_seq h e in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3)
noextract | false | false | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val as_nat (#s: field_spec) (h: mem) (e: felem s) : GTot nat | [] | Hacl.Impl.Curve25519.Fields.Core.as_nat | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> e: Hacl.Impl.Curve25519.Fields.Core.felem s
-> Prims.GTot Prims.nat | {
"end_col": 25,
"end_line": 112,
"start_col": 2,
"start_line": 110
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64 | let limb (s: field_spec) = | false | null | false | match s with
| M51 -> uint64
| M64 -> uint64 | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"Lib.IntTypes.uint64"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract | false | true | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val limb : s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.limb | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> Type0 | {
"end_col": 17,
"end_line": 30,
"start_col": 2,
"start_line": 28
} |
|
Prims.Tot | val fmul_pre (#s: field_spec) (h: mem) (f1 f2: felem s) : Type0 | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fmul_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (9, 10, 9, 9, 9) /\
f51_felem_fits h f2 (9, 10, 9, 9, 9)
| M64 -> True | val fmul_pre (#s: field_spec) (h: mem) (f1 f2: felem s) : Type0
let fmul_pre (#s: field_spec) (h: mem) (f1 f2: felem s) : Type0 = | false | null | false | match s with
| M51 -> f51_felem_fits h f1 (9, 10, 9, 9, 9) /\ f51_felem_fits h f2 (9, 10, 9, 9, 9)
| M64 -> True | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Curve25519.Fields.Core.felem",
"Prims.l_and",
"Hacl.Impl.Curve25519.Fields.Core.f51_felem_fits",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Prims.l_True"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1
noextract
let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f
noextract
let f64_as_nat (h:mem) (e: felem M64) : GTot nat =
let s = as_seq h e in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3)
noextract
let as_nat (#s:field_spec) (h:mem) (e:felem s): GTot nat =
match s with
| M51 -> f51_as_nat h e
| M64 -> f64_as_nat h e
noextract
let feval (#s:field_spec) (h:mem) (e:felem s): GTot P.elem =
(as_nat h e) % P.prime
/// Start of core combinators
/// -------------------------
let fadd_fsub_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (1, 2, 1, 1, 1) /\
f51_felem_fits h f2 (1, 2, 1, 1, 1)
| M64 -> True
let fadd_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (2, 4, 2, 2, 2)
| M64 -> True
inline_for_extraction
let fadd_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fadd_post h1 out /\
feval h1 out == P.fadd (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize]
val fadd: #s:field_spec -> fadd_t s True
let fsub_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (9, 10, 9, 9, 9)
| M64 -> True
inline_for_extraction
let fsub_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fsub_post h1 out /\
feval h1 out == P.fsub (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fsub: #s:field_spec -> fsub_t s True | false | false | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fmul_pre (#s: field_spec) (h: mem) (f1 f2: felem s) : Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.fmul_pre | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
h: FStar.Monotonic.HyperStack.mem ->
f1: Hacl.Impl.Curve25519.Fields.Core.felem s ->
f2: Hacl.Impl.Curve25519.Fields.Core.felem s
-> Type0 | {
"end_col": 15,
"end_line": 182,
"start_col": 2,
"start_line": 178
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64 | let wide (s: field_spec) = | false | null | false | match s with
| M51 -> uint128
| M64 -> uint64 | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"Lib.IntTypes.uint128",
"Lib.IntTypes.uint64"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract | false | true | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val wide : s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.wide | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> Type0 | {
"end_col": 17,
"end_line": 48,
"start_col": 2,
"start_line": 46
} |
|
Prims.Tot | val state_inv_t (#s: field_spec) (h: mem) (f: felem s) : Type0 | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let state_inv_t (#s:field_spec) (h:mem) (f:felem s): Type0 =
match s with
| M51 -> f51_mul_inv_t h f
| M64 -> True | val state_inv_t (#s: field_spec) (h: mem) (f: felem s) : Type0
let state_inv_t (#s: field_spec) (h: mem) (f: felem s) : Type0 = | false | null | false | match s with
| M51 -> f51_mul_inv_t h f
| M64 -> True | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Curve25519.Fields.Core.felem",
"Hacl.Impl.Curve25519.Fields.Core.f51_mul_inv_t",
"Prims.l_True"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1
noextract
let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f
noextract
let f64_as_nat (h:mem) (e: felem M64) : GTot nat =
let s = as_seq h e in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3)
noextract
let as_nat (#s:field_spec) (h:mem) (e:felem s): GTot nat =
match s with
| M51 -> f51_as_nat h e
| M64 -> f64_as_nat h e
noextract
let feval (#s:field_spec) (h:mem) (e:felem s): GTot P.elem =
(as_nat h e) % P.prime
/// Start of core combinators
/// -------------------------
let fadd_fsub_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (1, 2, 1, 1, 1) /\
f51_felem_fits h f2 (1, 2, 1, 1, 1)
| M64 -> True
let fadd_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (2, 4, 2, 2, 2)
| M64 -> True
inline_for_extraction
let fadd_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fadd_post h1 out /\
feval h1 out == P.fadd (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize]
val fadd: #s:field_spec -> fadd_t s True
let fsub_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (9, 10, 9, 9, 9)
| M64 -> True
inline_for_extraction
let fsub_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fsub_post h1 out /\
feval h1 out == P.fsub (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fsub: #s:field_spec -> fsub_t s True
let fmul_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (9, 10, 9, 9, 9) /\
f51_felem_fits h f2 (9, 10, 9, 9, 9)
| M64 -> True
let fmul_disjoint (#s:field_spec) (out f1 f2:felem s) (tmp:felem_wide2 s): Type0 =
match s with
| M51 -> True
| M64 ->
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp \/ out == tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp | false | false | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val state_inv_t (#s: field_spec) (h: mem) (f: felem s) : Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.state_inv_t | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> f: Hacl.Impl.Curve25519.Fields.Core.felem s -> Type0 | {
"end_col": 15,
"end_line": 199,
"start_col": 2,
"start_line": 197
} |
Prims.Tot | val nwide (s: field_spec) : size_t | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul | val nwide (s: field_spec) : size_t
let nwide (s: field_spec) : size_t = | false | null | false | match s with
| M51 -> 5ul
| M64 -> 8ul | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.size_t"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract | false | true | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val nwide (s: field_spec) : size_t | [] | Hacl.Impl.Curve25519.Fields.Core.nwide | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> Lib.IntTypes.size_t | {
"end_col": 14,
"end_line": 60,
"start_col": 2,
"start_line": 58
} |
Prims.Tot | val fmul_disjoint (#s: field_spec) (out f1 f2: felem s) (tmp: felem_wide2 s) : Type0 | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fmul_disjoint (#s:field_spec) (out f1 f2:felem s) (tmp:felem_wide2 s): Type0 =
match s with
| M51 -> True
| M64 ->
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp \/ out == tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp | val fmul_disjoint (#s: field_spec) (out f1 f2: felem s) (tmp: felem_wide2 s) : Type0
let fmul_disjoint (#s: field_spec) (out f1 f2: felem s) (tmp: felem_wide2 s) : Type0 = | false | null | false | match s with
| M51 -> True
| M64 ->
(disjoint out f1 \/ out == f1) /\ (disjoint out f2 \/ out == f2) /\
(disjoint out tmp \/ out == tmp) /\ (disjoint f1 f2 \/ f1 == f2) /\ disjoint f1 tmp /\
disjoint f2 tmp | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"Hacl.Impl.Curve25519.Fields.Core.felem",
"Hacl.Impl.Curve25519.Fields.Core.felem_wide2",
"Prims.l_True",
"Prims.l_and",
"Prims.l_or",
"Lib.Buffer.disjoint",
"Lib.Buffer.MUT",
"Hacl.Impl.Curve25519.Fields.Core.limb",
"Prims.eq2",
"Hacl.Impl.Curve25519.Fields.Core.wide",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.int",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Lib.IntTypes.range",
"Lib.IntTypes.U32",
"Lib.Buffer.length",
"Lib.IntTypes.v",
"Lib.IntTypes.PUB",
"Lib.IntTypes.op_Plus_Dot",
"Hacl.Impl.Curve25519.Fields.Core.nwide",
"Hacl.Impl.Curve25519.Fields.Core.nlimb"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1
noextract
let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f
noextract
let f64_as_nat (h:mem) (e: felem M64) : GTot nat =
let s = as_seq h e in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3)
noextract
let as_nat (#s:field_spec) (h:mem) (e:felem s): GTot nat =
match s with
| M51 -> f51_as_nat h e
| M64 -> f64_as_nat h e
noextract
let feval (#s:field_spec) (h:mem) (e:felem s): GTot P.elem =
(as_nat h e) % P.prime
/// Start of core combinators
/// -------------------------
let fadd_fsub_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (1, 2, 1, 1, 1) /\
f51_felem_fits h f2 (1, 2, 1, 1, 1)
| M64 -> True
let fadd_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (2, 4, 2, 2, 2)
| M64 -> True
inline_for_extraction
let fadd_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fadd_post h1 out /\
feval h1 out == P.fadd (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize]
val fadd: #s:field_spec -> fadd_t s True
let fsub_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (9, 10, 9, 9, 9)
| M64 -> True
inline_for_extraction
let fsub_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fsub_post h1 out /\
feval h1 out == P.fsub (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fsub: #s:field_spec -> fsub_t s True
let fmul_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (9, 10, 9, 9, 9) /\
f51_felem_fits h f2 (9, 10, 9, 9, 9)
| M64 -> True | false | false | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fmul_disjoint (#s: field_spec) (out f1 f2: felem s) (tmp: felem_wide2 s) : Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.fmul_disjoint | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
out: Hacl.Impl.Curve25519.Fields.Core.felem s ->
f1: Hacl.Impl.Curve25519.Fields.Core.felem s ->
f2: Hacl.Impl.Curve25519.Fields.Core.felem s ->
tmp: Hacl.Impl.Curve25519.Fields.Core.felem_wide2 s
-> Type0 | {
"end_col": 21,
"end_line": 193,
"start_col": 2,
"start_line": 185
} |
Prims.GTot | val feval (#s: field_spec) (h: mem) (e: felem s) : GTot P.elem | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let feval (#s:field_spec) (h:mem) (e:felem s): GTot P.elem =
(as_nat h e) % P.prime | val feval (#s: field_spec) (h: mem) (e: felem s) : GTot P.elem
let feval (#s: field_spec) (h: mem) (e: felem s) : GTot P.elem = | false | null | false | (as_nat h e) % P.prime | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"sometrivial"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Curve25519.Fields.Core.felem",
"Prims.op_Modulus",
"Hacl.Impl.Curve25519.Fields.Core.as_nat",
"Spec.Curve25519.prime",
"Spec.Curve25519.elem"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1
noextract
let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f
noextract
let f64_as_nat (h:mem) (e: felem M64) : GTot nat =
let s = as_seq h e in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3)
noextract
let as_nat (#s:field_spec) (h:mem) (e:felem s): GTot nat =
match s with
| M51 -> f51_as_nat h e
| M64 -> f64_as_nat h e
noextract | false | false | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val feval (#s: field_spec) (h: mem) (e: felem s) : GTot P.elem | [] | Hacl.Impl.Curve25519.Fields.Core.feval | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> e: Hacl.Impl.Curve25519.Fields.Core.felem s
-> Prims.GTot Spec.Curve25519.elem | {
"end_col": 24,
"end_line": 116,
"start_col": 2,
"start_line": 116
} |
Prims.Tot | val fadd_post (#s: field_spec) (h: mem) (out: felem s) : Type0 | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fadd_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (2, 4, 2, 2, 2)
| M64 -> True | val fadd_post (#s: field_spec) (h: mem) (out: felem s) : Type0
let fadd_post (#s: field_spec) (h: mem) (out: felem s) : Type0 = | false | null | false | match s with
| M51 -> f51_felem_fits h out (2, 4, 2, 2, 2)
| M64 -> True | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Curve25519.Fields.Core.felem",
"Hacl.Impl.Curve25519.Fields.Core.f51_felem_fits",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Prims.l_True"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1
noextract
let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f
noextract
let f64_as_nat (h:mem) (e: felem M64) : GTot nat =
let s = as_seq h e in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3)
noextract
let as_nat (#s:field_spec) (h:mem) (e:felem s): GTot nat =
match s with
| M51 -> f51_as_nat h e
| M64 -> f64_as_nat h e
noextract
let feval (#s:field_spec) (h:mem) (e:felem s): GTot P.elem =
(as_nat h e) % P.prime
/// Start of core combinators
/// -------------------------
let fadd_fsub_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (1, 2, 1, 1, 1) /\
f51_felem_fits h f2 (1, 2, 1, 1, 1)
| M64 -> True | false | false | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fadd_post (#s: field_spec) (h: mem) (out: felem s) : Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.fadd_post | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> out: Hacl.Impl.Curve25519.Fields.Core.felem s -> Type0 | {
"end_col": 15,
"end_line": 132,
"start_col": 2,
"start_line": 130
} |
Prims.Tot | val nlimb (s: field_spec) : size_t | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul | val nlimb (s: field_spec) : size_t
let nlimb (s: field_spec) : size_t = | false | null | false | match s with
| M51 -> 5ul
| M64 -> 4ul | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.size_t"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract | false | true | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val nlimb (s: field_spec) : size_t | [] | Hacl.Impl.Curve25519.Fields.Core.nlimb | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> Lib.IntTypes.size_t | {
"end_col": 14,
"end_line": 42,
"start_col": 2,
"start_line": 40
} |
Prims.Tot | val fadd_fsub_pre (#s: field_spec) (h: mem) (f1 f2: felem s) : Type0 | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fadd_fsub_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (1, 2, 1, 1, 1) /\
f51_felem_fits h f2 (1, 2, 1, 1, 1)
| M64 -> True | val fadd_fsub_pre (#s: field_spec) (h: mem) (f1 f2: felem s) : Type0
let fadd_fsub_pre (#s: field_spec) (h: mem) (f1 f2: felem s) : Type0 = | false | null | false | match s with
| M51 -> f51_felem_fits h f1 (1, 2, 1, 1, 1) /\ f51_felem_fits h f2 (1, 2, 1, 1, 1)
| M64 -> True | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Curve25519.Fields.Core.felem",
"Prims.l_and",
"Hacl.Impl.Curve25519.Fields.Core.f51_felem_fits",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Prims.l_True"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1
noextract
let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f
noextract
let f64_as_nat (h:mem) (e: felem M64) : GTot nat =
let s = as_seq h e in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3)
noextract
let as_nat (#s:field_spec) (h:mem) (e:felem s): GTot nat =
match s with
| M51 -> f51_as_nat h e
| M64 -> f64_as_nat h e
noextract
let feval (#s:field_spec) (h:mem) (e:felem s): GTot P.elem =
(as_nat h e) % P.prime
/// Start of core combinators
/// ------------------------- | false | false | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fadd_fsub_pre (#s: field_spec) (h: mem) (f1 f2: felem s) : Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.fadd_fsub_pre | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
h: FStar.Monotonic.HyperStack.mem ->
f1: Hacl.Impl.Curve25519.Fields.Core.felem s ->
f2: Hacl.Impl.Curve25519.Fields.Core.felem s
-> Type0 | {
"end_col": 15,
"end_line": 127,
"start_col": 2,
"start_line": 123
} |
Prims.Tot | val fsub_post (#s: field_spec) (h: mem) (out: felem s) : Type0 | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fsub_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (9, 10, 9, 9, 9)
| M64 -> True | val fsub_post (#s: field_spec) (h: mem) (out: felem s) : Type0
let fsub_post (#s: field_spec) (h: mem) (out: felem s) : Type0 = | false | null | false | match s with
| M51 -> f51_felem_fits h out (9, 10, 9, 9, 9)
| M64 -> True | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Curve25519.Fields.Core.felem",
"Hacl.Impl.Curve25519.Fields.Core.f51_felem_fits",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Prims.l_True"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1
noextract
let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f
noextract
let f64_as_nat (h:mem) (e: felem M64) : GTot nat =
let s = as_seq h e in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3)
noextract
let as_nat (#s:field_spec) (h:mem) (e:felem s): GTot nat =
match s with
| M51 -> f51_as_nat h e
| M64 -> f64_as_nat h e
noextract
let feval (#s:field_spec) (h:mem) (e:felem s): GTot P.elem =
(as_nat h e) % P.prime
/// Start of core combinators
/// -------------------------
let fadd_fsub_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (1, 2, 1, 1, 1) /\
f51_felem_fits h f2 (1, 2, 1, 1, 1)
| M64 -> True
let fadd_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (2, 4, 2, 2, 2)
| M64 -> True
inline_for_extraction
let fadd_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fadd_post h1 out /\
feval h1 out == P.fadd (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize]
val fadd: #s:field_spec -> fadd_t s True | false | false | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fsub_post (#s: field_spec) (h: mem) (out: felem s) : Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.fsub_post | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> out: Hacl.Impl.Curve25519.Fields.Core.felem s -> Type0 | {
"end_col": 15,
"end_line": 156,
"start_col": 2,
"start_line": 154
} |
Prims.Tot | val fmul1_pre (#s: field_spec) (h: mem) (f1: felem s) (f2: uint64) : Type0 | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fmul1_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:uint64): Type0 =
match s with
| M51 -> f51_felem_fits h f1 (9, 10, 9, 9, 9) /\ f51_felem_fits1 f2 1
| M64 -> v f2 < pow2 17 | val fmul1_pre (#s: field_spec) (h: mem) (f1: felem s) (f2: uint64) : Type0
let fmul1_pre (#s: field_spec) (h: mem) (f1: felem s) (f2: uint64) : Type0 = | false | null | false | match s with
| M51 -> f51_felem_fits h f1 (9, 10, 9, 9, 9) /\ f51_felem_fits1 f2 1
| M64 -> v f2 < pow2 17 | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Curve25519.Fields.Core.felem",
"Lib.IntTypes.uint64",
"Prims.l_and",
"Hacl.Impl.Curve25519.Fields.Core.f51_felem_fits",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Prims.b2t",
"Hacl.Impl.Curve25519.Fields.Core.f51_felem_fits1",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.pow2"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1
noextract
let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f
noextract
let f64_as_nat (h:mem) (e: felem M64) : GTot nat =
let s = as_seq h e in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3)
noextract
let as_nat (#s:field_spec) (h:mem) (e:felem s): GTot nat =
match s with
| M51 -> f51_as_nat h e
| M64 -> f64_as_nat h e
noextract
let feval (#s:field_spec) (h:mem) (e:felem s): GTot P.elem =
(as_nat h e) % P.prime
/// Start of core combinators
/// -------------------------
let fadd_fsub_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (1, 2, 1, 1, 1) /\
f51_felem_fits h f2 (1, 2, 1, 1, 1)
| M64 -> True
let fadd_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (2, 4, 2, 2, 2)
| M64 -> True
inline_for_extraction
let fadd_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fadd_post h1 out /\
feval h1 out == P.fadd (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize]
val fadd: #s:field_spec -> fadd_t s True
let fsub_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (9, 10, 9, 9, 9)
| M64 -> True
inline_for_extraction
let fsub_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fsub_post h1 out /\
feval h1 out == P.fsub (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fsub: #s:field_spec -> fsub_t s True
let fmul_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (9, 10, 9, 9, 9) /\
f51_felem_fits h f2 (9, 10, 9, 9, 9)
| M64 -> True
let fmul_disjoint (#s:field_spec) (out f1 f2:felem s) (tmp:felem_wide2 s): Type0 =
match s with
| M51 -> True
| M64 ->
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp \/ out == tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp
let state_inv_t (#s:field_spec) (h:mem) (f:felem s): Type0 =
match s with
| M51 -> f51_mul_inv_t h f
| M64 -> True
inline_for_extraction
let fmul_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
fmul_disjoint out f1 f2 tmp /\
fmul_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fmul: #s:field_spec -> fmul_t s True
let fmul2_pre (#s:field_spec) (h:mem) (f1:felem2 s) (f2:felem2 s): Type0 =
match s with
| M51 ->
let f10 = gsub f1 0ul 5ul in
let f11 = gsub f1 5ul 5ul in
let f20 = gsub f2 0ul 5ul in
let f21 = gsub f2 5ul 5ul in
f51_felem_fits h f10 (9, 10, 9, 9, 9) /\
f51_felem_fits h f11 (9, 10, 9, 9, 9) /\
f51_felem_fits h f20 (9, 10, 9, 9, 9) /\
f51_felem_fits h f21 (9, 10, 9, 9, 9)
| M64 -> True
let fmul2_fsqr2_post (#s:field_spec) (h:mem) (out:felem2 s): Type0 =
match s with
| M51 ->
let out0 = gsub out 0ul 5ul in
let out1 = gsub out 5ul 5ul in
f51_mul_inv_t h out0 /\
f51_mul_inv_t h out1
| M64 -> True
inline_for_extraction
let fmul2_t (s:field_spec) (p: Type0) =
out:felem2 s
-> f1:felem2 s
-> f2:felem2 s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp /\
fmul2_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ fmul2_fsqr2_post h1 out /\
(let out0 = gsub out 0ul (nlimb s) in
let out1 = gsub out (nlimb s) (nlimb s) in
let f10 = gsub f1 0ul (nlimb s) in
let f11 = gsub f1 (nlimb s) (nlimb s) in
let f20 = gsub f2 0ul (nlimb s) in
let f21 = gsub f2 (nlimb s) (nlimb s) in
feval h1 out0 == P.fmul (feval h0 f10) (feval h0 f20) /\
feval h1 out1 == P.fmul (feval h0 f11) (feval h0 f21)))
[@ Meta.Attribute.specialize ]
val fmul2: #s:field_spec -> fmul2_t s True | false | false | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fmul1_pre (#s: field_spec) (h: mem) (f1: felem s) (f2: uint64) : Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.fmul1_pre | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
h: FStar.Monotonic.HyperStack.mem ->
f1: Hacl.Impl.Curve25519.Fields.Core.felem s ->
f2: Lib.IntTypes.uint64
-> Type0 | {
"end_col": 25,
"end_line": 275,
"start_col": 2,
"start_line": 273
} |
Prims.Tot | val fsqr_pre (#s: field_spec) (h: mem) (f: felem s) : Type0 | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fsqr_pre (#s:field_spec) (h:mem) (f:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h f (9, 10, 9, 9, 9)
| M64 -> True | val fsqr_pre (#s: field_spec) (h: mem) (f: felem s) : Type0
let fsqr_pre (#s: field_spec) (h: mem) (f: felem s) : Type0 = | false | null | false | match s with
| M51 -> f51_felem_fits h f (9, 10, 9, 9, 9)
| M64 -> True | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Curve25519.Fields.Core.felem",
"Hacl.Impl.Curve25519.Fields.Core.f51_felem_fits",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Prims.l_True"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1
noextract
let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f
noextract
let f64_as_nat (h:mem) (e: felem M64) : GTot nat =
let s = as_seq h e in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3)
noextract
let as_nat (#s:field_spec) (h:mem) (e:felem s): GTot nat =
match s with
| M51 -> f51_as_nat h e
| M64 -> f64_as_nat h e
noextract
let feval (#s:field_spec) (h:mem) (e:felem s): GTot P.elem =
(as_nat h e) % P.prime
/// Start of core combinators
/// -------------------------
let fadd_fsub_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (1, 2, 1, 1, 1) /\
f51_felem_fits h f2 (1, 2, 1, 1, 1)
| M64 -> True
let fadd_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (2, 4, 2, 2, 2)
| M64 -> True
inline_for_extraction
let fadd_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fadd_post h1 out /\
feval h1 out == P.fadd (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize]
val fadd: #s:field_spec -> fadd_t s True
let fsub_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (9, 10, 9, 9, 9)
| M64 -> True
inline_for_extraction
let fsub_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fsub_post h1 out /\
feval h1 out == P.fsub (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fsub: #s:field_spec -> fsub_t s True
let fmul_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (9, 10, 9, 9, 9) /\
f51_felem_fits h f2 (9, 10, 9, 9, 9)
| M64 -> True
let fmul_disjoint (#s:field_spec) (out f1 f2:felem s) (tmp:felem_wide2 s): Type0 =
match s with
| M51 -> True
| M64 ->
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp \/ out == tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp
let state_inv_t (#s:field_spec) (h:mem) (f:felem s): Type0 =
match s with
| M51 -> f51_mul_inv_t h f
| M64 -> True
inline_for_extraction
let fmul_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
fmul_disjoint out f1 f2 tmp /\
fmul_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fmul: #s:field_spec -> fmul_t s True
let fmul2_pre (#s:field_spec) (h:mem) (f1:felem2 s) (f2:felem2 s): Type0 =
match s with
| M51 ->
let f10 = gsub f1 0ul 5ul in
let f11 = gsub f1 5ul 5ul in
let f20 = gsub f2 0ul 5ul in
let f21 = gsub f2 5ul 5ul in
f51_felem_fits h f10 (9, 10, 9, 9, 9) /\
f51_felem_fits h f11 (9, 10, 9, 9, 9) /\
f51_felem_fits h f20 (9, 10, 9, 9, 9) /\
f51_felem_fits h f21 (9, 10, 9, 9, 9)
| M64 -> True
let fmul2_fsqr2_post (#s:field_spec) (h:mem) (out:felem2 s): Type0 =
match s with
| M51 ->
let out0 = gsub out 0ul 5ul in
let out1 = gsub out 5ul 5ul in
f51_mul_inv_t h out0 /\
f51_mul_inv_t h out1
| M64 -> True
inline_for_extraction
let fmul2_t (s:field_spec) (p: Type0) =
out:felem2 s
-> f1:felem2 s
-> f2:felem2 s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp /\
fmul2_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ fmul2_fsqr2_post h1 out /\
(let out0 = gsub out 0ul (nlimb s) in
let out1 = gsub out (nlimb s) (nlimb s) in
let f10 = gsub f1 0ul (nlimb s) in
let f11 = gsub f1 (nlimb s) (nlimb s) in
let f20 = gsub f2 0ul (nlimb s) in
let f21 = gsub f2 (nlimb s) (nlimb s) in
feval h1 out0 == P.fmul (feval h0 f10) (feval h0 f20) /\
feval h1 out1 == P.fmul (feval h0 f11) (feval h0 f21)))
[@ Meta.Attribute.specialize ]
val fmul2: #s:field_spec -> fmul2_t s True
let fmul1_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:uint64): Type0 =
match s with
| M51 -> f51_felem_fits h f1 (9, 10, 9, 9, 9) /\ f51_felem_fits1 f2 1
| M64 -> v f2 < pow2 17
inline_for_extraction
let fmul1_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:uint64
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\
(disjoint out f1 \/ out == f1) /\
fmul1_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (v f2))
// feval h1 out == (feval h0 f1 * v f2) % P.prime)
[@ Meta.Attribute.specialize ]
val fmul1: #s:field_spec -> fmul1_t s True | false | false | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fsqr_pre (#s: field_spec) (h: mem) (f: felem s) : Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.fsqr_pre | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> f: Hacl.Impl.Curve25519.Fields.Core.felem s -> Type0 | {
"end_col": 15,
"end_line": 299,
"start_col": 2,
"start_line": 297
} |
Prims.Tot | val fsqr_disjoint (#s: field_spec) (out f1: felem s) (tmp: felem_wide s) : Type0 | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fsqr_disjoint (#s:field_spec) (out f1:felem s) (tmp:felem_wide s): Type0 =
match s with
| M51 -> True
| M64 ->
(disjoint out f1 \/ out == f1) /\
(disjoint out tmp \/ out == tmp) /\
disjoint tmp f1 | val fsqr_disjoint (#s: field_spec) (out f1: felem s) (tmp: felem_wide s) : Type0
let fsqr_disjoint (#s: field_spec) (out f1: felem s) (tmp: felem_wide s) : Type0 = | false | null | false | match s with
| M51 -> True
| M64 -> (disjoint out f1 \/ out == f1) /\ (disjoint out tmp \/ out == tmp) /\ disjoint tmp f1 | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"Hacl.Impl.Curve25519.Fields.Core.felem",
"Hacl.Impl.Curve25519.Fields.Core.felem_wide",
"Prims.l_True",
"Prims.l_and",
"Prims.l_or",
"Lib.Buffer.disjoint",
"Lib.Buffer.MUT",
"Hacl.Impl.Curve25519.Fields.Core.limb",
"Prims.eq2",
"Hacl.Impl.Curve25519.Fields.Core.wide",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.int",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Lib.IntTypes.range",
"Lib.IntTypes.U32",
"Lib.Buffer.length",
"Lib.IntTypes.v",
"Lib.IntTypes.PUB",
"Hacl.Impl.Curve25519.Fields.Core.nwide",
"Hacl.Impl.Curve25519.Fields.Core.nlimb"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1
noextract
let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f
noextract
let f64_as_nat (h:mem) (e: felem M64) : GTot nat =
let s = as_seq h e in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3)
noextract
let as_nat (#s:field_spec) (h:mem) (e:felem s): GTot nat =
match s with
| M51 -> f51_as_nat h e
| M64 -> f64_as_nat h e
noextract
let feval (#s:field_spec) (h:mem) (e:felem s): GTot P.elem =
(as_nat h e) % P.prime
/// Start of core combinators
/// -------------------------
let fadd_fsub_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (1, 2, 1, 1, 1) /\
f51_felem_fits h f2 (1, 2, 1, 1, 1)
| M64 -> True
let fadd_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (2, 4, 2, 2, 2)
| M64 -> True
inline_for_extraction
let fadd_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fadd_post h1 out /\
feval h1 out == P.fadd (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize]
val fadd: #s:field_spec -> fadd_t s True
let fsub_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (9, 10, 9, 9, 9)
| M64 -> True
inline_for_extraction
let fsub_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fsub_post h1 out /\
feval h1 out == P.fsub (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fsub: #s:field_spec -> fsub_t s True
let fmul_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (9, 10, 9, 9, 9) /\
f51_felem_fits h f2 (9, 10, 9, 9, 9)
| M64 -> True
let fmul_disjoint (#s:field_spec) (out f1 f2:felem s) (tmp:felem_wide2 s): Type0 =
match s with
| M51 -> True
| M64 ->
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp \/ out == tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp
let state_inv_t (#s:field_spec) (h:mem) (f:felem s): Type0 =
match s with
| M51 -> f51_mul_inv_t h f
| M64 -> True
inline_for_extraction
let fmul_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
fmul_disjoint out f1 f2 tmp /\
fmul_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fmul: #s:field_spec -> fmul_t s True
let fmul2_pre (#s:field_spec) (h:mem) (f1:felem2 s) (f2:felem2 s): Type0 =
match s with
| M51 ->
let f10 = gsub f1 0ul 5ul in
let f11 = gsub f1 5ul 5ul in
let f20 = gsub f2 0ul 5ul in
let f21 = gsub f2 5ul 5ul in
f51_felem_fits h f10 (9, 10, 9, 9, 9) /\
f51_felem_fits h f11 (9, 10, 9, 9, 9) /\
f51_felem_fits h f20 (9, 10, 9, 9, 9) /\
f51_felem_fits h f21 (9, 10, 9, 9, 9)
| M64 -> True
let fmul2_fsqr2_post (#s:field_spec) (h:mem) (out:felem2 s): Type0 =
match s with
| M51 ->
let out0 = gsub out 0ul 5ul in
let out1 = gsub out 5ul 5ul in
f51_mul_inv_t h out0 /\
f51_mul_inv_t h out1
| M64 -> True
inline_for_extraction
let fmul2_t (s:field_spec) (p: Type0) =
out:felem2 s
-> f1:felem2 s
-> f2:felem2 s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp /\
fmul2_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ fmul2_fsqr2_post h1 out /\
(let out0 = gsub out 0ul (nlimb s) in
let out1 = gsub out (nlimb s) (nlimb s) in
let f10 = gsub f1 0ul (nlimb s) in
let f11 = gsub f1 (nlimb s) (nlimb s) in
let f20 = gsub f2 0ul (nlimb s) in
let f21 = gsub f2 (nlimb s) (nlimb s) in
feval h1 out0 == P.fmul (feval h0 f10) (feval h0 f20) /\
feval h1 out1 == P.fmul (feval h0 f11) (feval h0 f21)))
[@ Meta.Attribute.specialize ]
val fmul2: #s:field_spec -> fmul2_t s True
let fmul1_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:uint64): Type0 =
match s with
| M51 -> f51_felem_fits h f1 (9, 10, 9, 9, 9) /\ f51_felem_fits1 f2 1
| M64 -> v f2 < pow2 17
inline_for_extraction
let fmul1_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:uint64
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\
(disjoint out f1 \/ out == f1) /\
fmul1_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (v f2))
// feval h1 out == (feval h0 f1 * v f2) % P.prime)
[@ Meta.Attribute.specialize ]
val fmul1: #s:field_spec -> fmul1_t s True
let fsqr_pre (#s:field_spec) (h:mem) (f:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h f (9, 10, 9, 9, 9)
| M64 -> True | false | false | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fsqr_disjoint (#s: field_spec) (out f1: felem s) (tmp: felem_wide s) : Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.fsqr_disjoint | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
out: Hacl.Impl.Curve25519.Fields.Core.felem s ->
f1: Hacl.Impl.Curve25519.Fields.Core.felem s ->
tmp: Hacl.Impl.Curve25519.Fields.Core.felem_wide s
-> Type0 | {
"end_col": 21,
"end_line": 307,
"start_col": 2,
"start_line": 302
} |
Prims.Tot | val limb_zero (s: field_spec) : limb s | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0 | val limb_zero (s: field_spec) : limb s
let limb_zero (s: field_spec) : limb s = | false | null | false | match s with
| M51 -> u64 0
| M64 -> u64 0 | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"Lib.IntTypes.u64",
"Hacl.Impl.Curve25519.Fields.Core.limb"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract | false | false | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val limb_zero (s: field_spec) : limb s | [] | Hacl.Impl.Curve25519.Fields.Core.limb_zero | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> Hacl.Impl.Curve25519.Fields.Core.limb s | {
"end_col": 16,
"end_line": 36,
"start_col": 2,
"start_line": 34
} |
Prims.Tot | val wide_zero (s: field_spec) : wide s | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0 | val wide_zero (s: field_spec) : wide s
let wide_zero (s: field_spec) : wide s = | false | null | false | match s with
| M51 -> u128 0
| M64 -> u64 0 | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"Lib.IntTypes.u128",
"Lib.IntTypes.u64",
"Hacl.Impl.Curve25519.Fields.Core.wide"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract | false | false | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val wide_zero (s: field_spec) : wide s | [] | Hacl.Impl.Curve25519.Fields.Core.wide_zero | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> Hacl.Impl.Curve25519.Fields.Core.wide s | {
"end_col": 16,
"end_line": 54,
"start_col": 2,
"start_line": 52
} |
Prims.Tot | val fmul2_fsqr2_post (#s: field_spec) (h: mem) (out: felem2 s) : Type0 | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fmul2_fsqr2_post (#s:field_spec) (h:mem) (out:felem2 s): Type0 =
match s with
| M51 ->
let out0 = gsub out 0ul 5ul in
let out1 = gsub out 5ul 5ul in
f51_mul_inv_t h out0 /\
f51_mul_inv_t h out1
| M64 -> True | val fmul2_fsqr2_post (#s: field_spec) (h: mem) (out: felem2 s) : Type0
let fmul2_fsqr2_post (#s: field_spec) (h: mem) (out: felem2 s) : Type0 = | false | null | false | match s with
| M51 ->
let out0 = gsub out 0ul 5ul in
let out1 = gsub out 5ul 5ul in
f51_mul_inv_t h out0 /\ f51_mul_inv_t h out1
| M64 -> True | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Curve25519.Fields.Core.felem2",
"Prims.l_and",
"Hacl.Impl.Curve25519.Fields.Core.f51_mul_inv_t",
"Lib.Buffer.lbuffer_t",
"Lib.Buffer.MUT",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.gsub",
"Hacl.Impl.Curve25519.Fields.Core.limb",
"Lib.IntTypes.op_Plus_Dot",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Impl.Curve25519.Fields.Core.nlimb",
"FStar.UInt32.__uint_to_t",
"Prims.l_True"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1
noextract
let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f
noextract
let f64_as_nat (h:mem) (e: felem M64) : GTot nat =
let s = as_seq h e in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3)
noextract
let as_nat (#s:field_spec) (h:mem) (e:felem s): GTot nat =
match s with
| M51 -> f51_as_nat h e
| M64 -> f64_as_nat h e
noextract
let feval (#s:field_spec) (h:mem) (e:felem s): GTot P.elem =
(as_nat h e) % P.prime
/// Start of core combinators
/// -------------------------
let fadd_fsub_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (1, 2, 1, 1, 1) /\
f51_felem_fits h f2 (1, 2, 1, 1, 1)
| M64 -> True
let fadd_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (2, 4, 2, 2, 2)
| M64 -> True
inline_for_extraction
let fadd_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fadd_post h1 out /\
feval h1 out == P.fadd (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize]
val fadd: #s:field_spec -> fadd_t s True
let fsub_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (9, 10, 9, 9, 9)
| M64 -> True
inline_for_extraction
let fsub_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fsub_post h1 out /\
feval h1 out == P.fsub (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fsub: #s:field_spec -> fsub_t s True
let fmul_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (9, 10, 9, 9, 9) /\
f51_felem_fits h f2 (9, 10, 9, 9, 9)
| M64 -> True
let fmul_disjoint (#s:field_spec) (out f1 f2:felem s) (tmp:felem_wide2 s): Type0 =
match s with
| M51 -> True
| M64 ->
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp \/ out == tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp
let state_inv_t (#s:field_spec) (h:mem) (f:felem s): Type0 =
match s with
| M51 -> f51_mul_inv_t h f
| M64 -> True
inline_for_extraction
let fmul_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
fmul_disjoint out f1 f2 tmp /\
fmul_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fmul: #s:field_spec -> fmul_t s True
let fmul2_pre (#s:field_spec) (h:mem) (f1:felem2 s) (f2:felem2 s): Type0 =
match s with
| M51 ->
let f10 = gsub f1 0ul 5ul in
let f11 = gsub f1 5ul 5ul in
let f20 = gsub f2 0ul 5ul in
let f21 = gsub f2 5ul 5ul in
f51_felem_fits h f10 (9, 10, 9, 9, 9) /\
f51_felem_fits h f11 (9, 10, 9, 9, 9) /\
f51_felem_fits h f20 (9, 10, 9, 9, 9) /\
f51_felem_fits h f21 (9, 10, 9, 9, 9)
| M64 -> True | false | false | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fmul2_fsqr2_post (#s: field_spec) (h: mem) (out: felem2 s) : Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.fmul2_fsqr2_post | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> out: Hacl.Impl.Curve25519.Fields.Core.felem2 s -> Type0 | {
"end_col": 15,
"end_line": 239,
"start_col": 2,
"start_line": 233
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let cswap2_t (s:field_spec) (p: Type0) =
bit:uint64{v bit <= 1}
-> p1:felem2 s
-> p2:felem2 s
-> Stack unit
(requires fun h0 ->
p /\
live h0 p1 /\ live h0 p2 /\
(disjoint p1 p2 \/ p1 == p2))
(ensures fun h0 _ h1 ->
modifies (loc p1 |+| loc p2) h0 h1 /\
(v bit == 1 ==> as_seq h1 p1 == as_seq h0 p2 /\ as_seq h1 p2 == as_seq h0 p1) /\
(v bit == 0 ==> as_seq h1 p1 == as_seq h0 p1 /\ as_seq h1 p2 == as_seq h0 p2)) | let cswap2_t (s: field_spec) (p: Type0) = | false | null | false | bit: uint64{v bit <= 1} -> p1: felem2 s -> p2: felem2 s
-> Stack unit
(requires fun h0 -> p /\ live h0 p1 /\ live h0 p2 /\ (disjoint p1 p2 \/ p1 == p2))
(ensures
fun h0 _ h1 ->
modifies (loc p1 |+| loc p2) h0 h1 /\
(v bit == 1 ==> as_seq h1 p1 == as_seq h0 p2 /\ as_seq h1 p2 == as_seq h0 p1) /\
(v bit == 0 ==> as_seq h1 p1 == as_seq h0 p1 /\ as_seq h1 p2 == as_seq h0 p2)) | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"Lib.IntTypes.uint64",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Hacl.Impl.Curve25519.Fields.Core.felem2",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Hacl.Impl.Curve25519.Fields.Core.limb",
"Prims.l_or",
"Lib.Buffer.disjoint",
"Prims.eq2",
"Lib.Buffer.modifies",
"Lib.Buffer.op_Bar_Plus_Bar",
"Lib.Buffer.loc",
"Prims.l_imp",
"Prims.int",
"Lib.Sequence.lseq",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.IntTypes.op_Plus_Dot",
"Hacl.Impl.Curve25519.Fields.Core.nlimb",
"Lib.Buffer.as_seq"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1
noextract
let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f
noextract
let f64_as_nat (h:mem) (e: felem M64) : GTot nat =
let s = as_seq h e in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3)
noextract
let as_nat (#s:field_spec) (h:mem) (e:felem s): GTot nat =
match s with
| M51 -> f51_as_nat h e
| M64 -> f64_as_nat h e
noextract
let feval (#s:field_spec) (h:mem) (e:felem s): GTot P.elem =
(as_nat h e) % P.prime
/// Start of core combinators
/// -------------------------
let fadd_fsub_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (1, 2, 1, 1, 1) /\
f51_felem_fits h f2 (1, 2, 1, 1, 1)
| M64 -> True
let fadd_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (2, 4, 2, 2, 2)
| M64 -> True
inline_for_extraction
let fadd_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fadd_post h1 out /\
feval h1 out == P.fadd (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize]
val fadd: #s:field_spec -> fadd_t s True
let fsub_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (9, 10, 9, 9, 9)
| M64 -> True
inline_for_extraction
let fsub_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fsub_post h1 out /\
feval h1 out == P.fsub (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fsub: #s:field_spec -> fsub_t s True
let fmul_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (9, 10, 9, 9, 9) /\
f51_felem_fits h f2 (9, 10, 9, 9, 9)
| M64 -> True
let fmul_disjoint (#s:field_spec) (out f1 f2:felem s) (tmp:felem_wide2 s): Type0 =
match s with
| M51 -> True
| M64 ->
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp \/ out == tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp
let state_inv_t (#s:field_spec) (h:mem) (f:felem s): Type0 =
match s with
| M51 -> f51_mul_inv_t h f
| M64 -> True
inline_for_extraction
let fmul_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
fmul_disjoint out f1 f2 tmp /\
fmul_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fmul: #s:field_spec -> fmul_t s True
let fmul2_pre (#s:field_spec) (h:mem) (f1:felem2 s) (f2:felem2 s): Type0 =
match s with
| M51 ->
let f10 = gsub f1 0ul 5ul in
let f11 = gsub f1 5ul 5ul in
let f20 = gsub f2 0ul 5ul in
let f21 = gsub f2 5ul 5ul in
f51_felem_fits h f10 (9, 10, 9, 9, 9) /\
f51_felem_fits h f11 (9, 10, 9, 9, 9) /\
f51_felem_fits h f20 (9, 10, 9, 9, 9) /\
f51_felem_fits h f21 (9, 10, 9, 9, 9)
| M64 -> True
let fmul2_fsqr2_post (#s:field_spec) (h:mem) (out:felem2 s): Type0 =
match s with
| M51 ->
let out0 = gsub out 0ul 5ul in
let out1 = gsub out 5ul 5ul in
f51_mul_inv_t h out0 /\
f51_mul_inv_t h out1
| M64 -> True
inline_for_extraction
let fmul2_t (s:field_spec) (p: Type0) =
out:felem2 s
-> f1:felem2 s
-> f2:felem2 s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp /\
fmul2_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ fmul2_fsqr2_post h1 out /\
(let out0 = gsub out 0ul (nlimb s) in
let out1 = gsub out (nlimb s) (nlimb s) in
let f10 = gsub f1 0ul (nlimb s) in
let f11 = gsub f1 (nlimb s) (nlimb s) in
let f20 = gsub f2 0ul (nlimb s) in
let f21 = gsub f2 (nlimb s) (nlimb s) in
feval h1 out0 == P.fmul (feval h0 f10) (feval h0 f20) /\
feval h1 out1 == P.fmul (feval h0 f11) (feval h0 f21)))
[@ Meta.Attribute.specialize ]
val fmul2: #s:field_spec -> fmul2_t s True
let fmul1_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:uint64): Type0 =
match s with
| M51 -> f51_felem_fits h f1 (9, 10, 9, 9, 9) /\ f51_felem_fits1 f2 1
| M64 -> v f2 < pow2 17
inline_for_extraction
let fmul1_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:uint64
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\
(disjoint out f1 \/ out == f1) /\
fmul1_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (v f2))
// feval h1 out == (feval h0 f1 * v f2) % P.prime)
[@ Meta.Attribute.specialize ]
val fmul1: #s:field_spec -> fmul1_t s True
let fsqr_pre (#s:field_spec) (h:mem) (f:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h f (9, 10, 9, 9, 9)
| M64 -> True
let fsqr_disjoint (#s:field_spec) (out f1:felem s) (tmp:felem_wide s): Type0 =
match s with
| M51 -> True
| M64 ->
(disjoint out f1 \/ out == f1) /\
(disjoint out tmp \/ out == tmp) /\
disjoint tmp f1
inline_for_extraction
let fsqr_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> tmp:felem_wide s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h tmp /\
fsqr_disjoint out f1 tmp /\
fsqr_pre h f1)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\
state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (feval h0 f1))
[@ Meta.Attribute.specialize ]
val fsqr: #s:field_spec -> fsqr_t s True
let fsqr2_pre (#s:field_spec) (h:mem) (f:felem2 s): Type0 =
match s with
| M51 ->
let f1 = gsub f 0ul 5ul in
let f2 = gsub f 5ul 5ul in
f51_felem_fits h f1 (9, 10, 9, 9, 9) /\
f51_felem_fits h f2 (9, 10, 9, 9, 9)
| M64 -> True
inline_for_extraction
let fsqr2_t (s:field_spec) (p: Type0) =
out:felem2 s
-> f:felem2 s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f /\ live h tmp /\
(disjoint out f \/ out == f) /\
(disjoint out tmp) /\
disjoint tmp f /\
fsqr2_pre h f)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ fmul2_fsqr2_post h1 out /\
(let out1 = gsub out 0ul (nlimb s) in
let out2 = gsub out (nlimb s) (nlimb s) in
let f1 = gsub f 0ul (nlimb s) in
let f2 = gsub f (nlimb s) (nlimb s) in
feval h1 out1 == P.fmul (feval h0 f1) (feval h0 f1) /\
feval h1 out2 == P.fmul (feval h0 f2) (feval h0 f2)))
[@ Meta.Attribute.specialize ]
val fsqr2: #s:field_spec -> fsqr2_t s True
inline_for_extraction | false | true | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val cswap2_t : s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> p: Type0 -> Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.cswap2_t | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> p: Type0 -> Type0 | {
"end_col": 84,
"end_line": 375,
"start_col": 4,
"start_line": 364
} |
|
Prims.GTot | val f64_as_nat (h: mem) (e: felem M64) : GTot nat | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let f64_as_nat (h:mem) (e: felem M64) : GTot nat =
let s = as_seq h e in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3) | val f64_as_nat (h: mem) (e: felem M64) : GTot nat
let f64_as_nat (h: mem) (e: felem M64) : GTot nat = | false | null | false | let s = as_seq h e in
let s0 = s.[ 0 ] in
let s1 = s.[ 1 ] in
let s2 = s.[ 2 ] in
let s3 = s.[ 3 ] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3) | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"sometrivial"
] | [
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Curve25519.Fields.Core.felem",
"Hacl.Impl.Curve25519.Fields.Core.M64",
"Hacl.Spec.Curve25519.Field64.Definition.as_nat4",
"FStar.Pervasives.Native.Mktuple4",
"Lib.IntTypes.uint64",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.eq2",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Sequence.op_String_Access",
"Hacl.Impl.Curve25519.Fields.Core.limb",
"Hacl.Impl.Curve25519.Fields.Core.nlimb",
"Lib.Sequence.lseq",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Prims.nat"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1
noextract
let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f | false | false | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val f64_as_nat (h: mem) (e: felem M64) : GTot nat | [] | Hacl.Impl.Curve25519.Fields.Core.f64_as_nat | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
h: FStar.Monotonic.HyperStack.mem ->
e: Hacl.Impl.Curve25519.Fields.Core.felem Hacl.Impl.Curve25519.Fields.Core.M64
-> Prims.GTot Prims.nat | {
"end_col": 66,
"end_line": 106,
"start_col": 50,
"start_line": 100
} |
Prims.Tot | val fsqr2_pre (#s: field_spec) (h: mem) (f: felem2 s) : Type0 | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fsqr2_pre (#s:field_spec) (h:mem) (f:felem2 s): Type0 =
match s with
| M51 ->
let f1 = gsub f 0ul 5ul in
let f2 = gsub f 5ul 5ul in
f51_felem_fits h f1 (9, 10, 9, 9, 9) /\
f51_felem_fits h f2 (9, 10, 9, 9, 9)
| M64 -> True | val fsqr2_pre (#s: field_spec) (h: mem) (f: felem2 s) : Type0
let fsqr2_pre (#s: field_spec) (h: mem) (f: felem2 s) : Type0 = | false | null | false | match s with
| M51 ->
let f1 = gsub f 0ul 5ul in
let f2 = gsub f 5ul 5ul in
f51_felem_fits h f1 (9, 10, 9, 9, 9) /\ f51_felem_fits h f2 (9, 10, 9, 9, 9)
| M64 -> True | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Curve25519.Fields.Core.felem2",
"Prims.l_and",
"Hacl.Impl.Curve25519.Fields.Core.f51_felem_fits",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Lib.Buffer.lbuffer_t",
"Lib.Buffer.MUT",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.gsub",
"Hacl.Impl.Curve25519.Fields.Core.limb",
"Lib.IntTypes.op_Plus_Dot",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Impl.Curve25519.Fields.Core.nlimb",
"FStar.UInt32.__uint_to_t",
"Prims.l_True"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1
noextract
let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f
noextract
let f64_as_nat (h:mem) (e: felem M64) : GTot nat =
let s = as_seq h e in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3)
noextract
let as_nat (#s:field_spec) (h:mem) (e:felem s): GTot nat =
match s with
| M51 -> f51_as_nat h e
| M64 -> f64_as_nat h e
noextract
let feval (#s:field_spec) (h:mem) (e:felem s): GTot P.elem =
(as_nat h e) % P.prime
/// Start of core combinators
/// -------------------------
let fadd_fsub_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (1, 2, 1, 1, 1) /\
f51_felem_fits h f2 (1, 2, 1, 1, 1)
| M64 -> True
let fadd_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (2, 4, 2, 2, 2)
| M64 -> True
inline_for_extraction
let fadd_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fadd_post h1 out /\
feval h1 out == P.fadd (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize]
val fadd: #s:field_spec -> fadd_t s True
let fsub_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (9, 10, 9, 9, 9)
| M64 -> True
inline_for_extraction
let fsub_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fsub_post h1 out /\
feval h1 out == P.fsub (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fsub: #s:field_spec -> fsub_t s True
let fmul_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (9, 10, 9, 9, 9) /\
f51_felem_fits h f2 (9, 10, 9, 9, 9)
| M64 -> True
let fmul_disjoint (#s:field_spec) (out f1 f2:felem s) (tmp:felem_wide2 s): Type0 =
match s with
| M51 -> True
| M64 ->
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp \/ out == tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp
let state_inv_t (#s:field_spec) (h:mem) (f:felem s): Type0 =
match s with
| M51 -> f51_mul_inv_t h f
| M64 -> True
inline_for_extraction
let fmul_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
fmul_disjoint out f1 f2 tmp /\
fmul_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fmul: #s:field_spec -> fmul_t s True
let fmul2_pre (#s:field_spec) (h:mem) (f1:felem2 s) (f2:felem2 s): Type0 =
match s with
| M51 ->
let f10 = gsub f1 0ul 5ul in
let f11 = gsub f1 5ul 5ul in
let f20 = gsub f2 0ul 5ul in
let f21 = gsub f2 5ul 5ul in
f51_felem_fits h f10 (9, 10, 9, 9, 9) /\
f51_felem_fits h f11 (9, 10, 9, 9, 9) /\
f51_felem_fits h f20 (9, 10, 9, 9, 9) /\
f51_felem_fits h f21 (9, 10, 9, 9, 9)
| M64 -> True
let fmul2_fsqr2_post (#s:field_spec) (h:mem) (out:felem2 s): Type0 =
match s with
| M51 ->
let out0 = gsub out 0ul 5ul in
let out1 = gsub out 5ul 5ul in
f51_mul_inv_t h out0 /\
f51_mul_inv_t h out1
| M64 -> True
inline_for_extraction
let fmul2_t (s:field_spec) (p: Type0) =
out:felem2 s
-> f1:felem2 s
-> f2:felem2 s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp /\
fmul2_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ fmul2_fsqr2_post h1 out /\
(let out0 = gsub out 0ul (nlimb s) in
let out1 = gsub out (nlimb s) (nlimb s) in
let f10 = gsub f1 0ul (nlimb s) in
let f11 = gsub f1 (nlimb s) (nlimb s) in
let f20 = gsub f2 0ul (nlimb s) in
let f21 = gsub f2 (nlimb s) (nlimb s) in
feval h1 out0 == P.fmul (feval h0 f10) (feval h0 f20) /\
feval h1 out1 == P.fmul (feval h0 f11) (feval h0 f21)))
[@ Meta.Attribute.specialize ]
val fmul2: #s:field_spec -> fmul2_t s True
let fmul1_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:uint64): Type0 =
match s with
| M51 -> f51_felem_fits h f1 (9, 10, 9, 9, 9) /\ f51_felem_fits1 f2 1
| M64 -> v f2 < pow2 17
inline_for_extraction
let fmul1_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:uint64
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\
(disjoint out f1 \/ out == f1) /\
fmul1_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (v f2))
// feval h1 out == (feval h0 f1 * v f2) % P.prime)
[@ Meta.Attribute.specialize ]
val fmul1: #s:field_spec -> fmul1_t s True
let fsqr_pre (#s:field_spec) (h:mem) (f:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h f (9, 10, 9, 9, 9)
| M64 -> True
let fsqr_disjoint (#s:field_spec) (out f1:felem s) (tmp:felem_wide s): Type0 =
match s with
| M51 -> True
| M64 ->
(disjoint out f1 \/ out == f1) /\
(disjoint out tmp \/ out == tmp) /\
disjoint tmp f1
inline_for_extraction
let fsqr_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> tmp:felem_wide s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h tmp /\
fsqr_disjoint out f1 tmp /\
fsqr_pre h f1)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\
state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (feval h0 f1))
[@ Meta.Attribute.specialize ]
val fsqr: #s:field_spec -> fsqr_t s True | false | false | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fsqr2_pre (#s: field_spec) (h: mem) (f: felem2 s) : Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.fsqr2_pre | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> f: Hacl.Impl.Curve25519.Fields.Core.felem2 s -> Type0 | {
"end_col": 15,
"end_line": 335,
"start_col": 2,
"start_line": 329
} |
Prims.GTot | val f51_as_felem (h: mem) (f: felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4) | val f51_as_felem (h: mem) (f: felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5
let f51_as_felem (h: mem) (f: felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 = | false | null | false | let s = as_seq h f in
let s0 = s.[ 0 ] in
let s1 = s.[ 1 ] in
let s2 = s.[ 2 ] in
let s3 = s.[ 3 ] in
let s4 = s.[ 4 ] in
(s0, s1, s2, s3, s4) | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"sometrivial"
] | [
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Curve25519.Fields.Core.felem",
"Hacl.Impl.Curve25519.Fields.Core.M51",
"FStar.Pervasives.Native.Mktuple5",
"Lib.IntTypes.uint64",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.eq2",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Sequence.op_String_Access",
"Hacl.Impl.Curve25519.Fields.Core.limb",
"Hacl.Impl.Curve25519.Fields.Core.nlimb",
"Lib.Sequence.lseq",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Hacl.Spec.Curve25519.Field51.Definition.felem5"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// --------------------------------------------------------------------------------- | false | false | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val f51_as_felem (h: mem) (f: felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 | [] | Hacl.Impl.Curve25519.Fields.Core.f51_as_felem | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
h: FStar.Monotonic.HyperStack.mem ->
f: Hacl.Impl.Curve25519.Fields.Core.felem Hacl.Impl.Curve25519.Fields.Core.M51
-> Prims.GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 | {
"end_col": 22,
"end_line": 83,
"start_col": 94,
"start_line": 76
} |
Prims.Tot | val fmul2_pre (#s: field_spec) (h: mem) (f1 f2: felem2 s) : Type0 | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fmul2_pre (#s:field_spec) (h:mem) (f1:felem2 s) (f2:felem2 s): Type0 =
match s with
| M51 ->
let f10 = gsub f1 0ul 5ul in
let f11 = gsub f1 5ul 5ul in
let f20 = gsub f2 0ul 5ul in
let f21 = gsub f2 5ul 5ul in
f51_felem_fits h f10 (9, 10, 9, 9, 9) /\
f51_felem_fits h f11 (9, 10, 9, 9, 9) /\
f51_felem_fits h f20 (9, 10, 9, 9, 9) /\
f51_felem_fits h f21 (9, 10, 9, 9, 9)
| M64 -> True | val fmul2_pre (#s: field_spec) (h: mem) (f1 f2: felem2 s) : Type0
let fmul2_pre (#s: field_spec) (h: mem) (f1 f2: felem2 s) : Type0 = | false | null | false | match s with
| M51 ->
let f10 = gsub f1 0ul 5ul in
let f11 = gsub f1 5ul 5ul in
let f20 = gsub f2 0ul 5ul in
let f21 = gsub f2 5ul 5ul in
f51_felem_fits h f10 (9, 10, 9, 9, 9) /\ f51_felem_fits h f11 (9, 10, 9, 9, 9) /\
f51_felem_fits h f20 (9, 10, 9, 9, 9) /\ f51_felem_fits h f21 (9, 10, 9, 9, 9)
| M64 -> True | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Curve25519.Fields.Core.felem2",
"Prims.l_and",
"Hacl.Impl.Curve25519.Fields.Core.f51_felem_fits",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Lib.Buffer.lbuffer_t",
"Lib.Buffer.MUT",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.gsub",
"Hacl.Impl.Curve25519.Fields.Core.limb",
"Lib.IntTypes.op_Plus_Dot",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Impl.Curve25519.Fields.Core.nlimb",
"FStar.UInt32.__uint_to_t",
"Prims.l_True"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1
noextract
let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f
noextract
let f64_as_nat (h:mem) (e: felem M64) : GTot nat =
let s = as_seq h e in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3)
noextract
let as_nat (#s:field_spec) (h:mem) (e:felem s): GTot nat =
match s with
| M51 -> f51_as_nat h e
| M64 -> f64_as_nat h e
noextract
let feval (#s:field_spec) (h:mem) (e:felem s): GTot P.elem =
(as_nat h e) % P.prime
/// Start of core combinators
/// -------------------------
let fadd_fsub_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (1, 2, 1, 1, 1) /\
f51_felem_fits h f2 (1, 2, 1, 1, 1)
| M64 -> True
let fadd_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (2, 4, 2, 2, 2)
| M64 -> True
inline_for_extraction
let fadd_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fadd_post h1 out /\
feval h1 out == P.fadd (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize]
val fadd: #s:field_spec -> fadd_t s True
let fsub_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (9, 10, 9, 9, 9)
| M64 -> True
inline_for_extraction
let fsub_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fsub_post h1 out /\
feval h1 out == P.fsub (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fsub: #s:field_spec -> fsub_t s True
let fmul_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (9, 10, 9, 9, 9) /\
f51_felem_fits h f2 (9, 10, 9, 9, 9)
| M64 -> True
let fmul_disjoint (#s:field_spec) (out f1 f2:felem s) (tmp:felem_wide2 s): Type0 =
match s with
| M51 -> True
| M64 ->
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp \/ out == tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp
let state_inv_t (#s:field_spec) (h:mem) (f:felem s): Type0 =
match s with
| M51 -> f51_mul_inv_t h f
| M64 -> True
inline_for_extraction
let fmul_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
fmul_disjoint out f1 f2 tmp /\
fmul_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fmul: #s:field_spec -> fmul_t s True | false | false | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fmul2_pre (#s: field_spec) (h: mem) (f1 f2: felem2 s) : Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.fmul2_pre | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
h: FStar.Monotonic.HyperStack.mem ->
f1: Hacl.Impl.Curve25519.Fields.Core.felem2 s ->
f2: Hacl.Impl.Curve25519.Fields.Core.felem2 s
-> Type0 | {
"end_col": 15,
"end_line": 230,
"start_col": 2,
"start_line": 220
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fmul1_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:uint64
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\
(disjoint out f1 \/ out == f1) /\
fmul1_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (v f2)) | let fmul1_t (s: field_spec) (p: Type0) = | false | null | false | out: felem s -> f1: felem s -> f2: uint64
-> Stack unit
(requires
fun h -> p /\ live h out /\ live h f1 /\ (disjoint out f1 \/ out == f1) /\ fmul1_pre h f1 f2
)
(ensures
fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (v f2)) | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"Hacl.Impl.Curve25519.Fields.Core.felem",
"Lib.IntTypes.uint64",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Hacl.Impl.Curve25519.Fields.Core.limb",
"Prims.l_or",
"Lib.Buffer.disjoint",
"Prims.eq2",
"Hacl.Impl.Curve25519.Fields.Core.fmul1_pre",
"Lib.Buffer.modifies",
"Lib.Buffer.loc",
"Hacl.Impl.Curve25519.Fields.Core.state_inv_t",
"Spec.Curve25519.elem",
"Hacl.Impl.Curve25519.Fields.Core.feval",
"Spec.Curve25519.fmul",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1
noextract
let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f
noextract
let f64_as_nat (h:mem) (e: felem M64) : GTot nat =
let s = as_seq h e in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3)
noextract
let as_nat (#s:field_spec) (h:mem) (e:felem s): GTot nat =
match s with
| M51 -> f51_as_nat h e
| M64 -> f64_as_nat h e
noextract
let feval (#s:field_spec) (h:mem) (e:felem s): GTot P.elem =
(as_nat h e) % P.prime
/// Start of core combinators
/// -------------------------
let fadd_fsub_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (1, 2, 1, 1, 1) /\
f51_felem_fits h f2 (1, 2, 1, 1, 1)
| M64 -> True
let fadd_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (2, 4, 2, 2, 2)
| M64 -> True
inline_for_extraction
let fadd_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fadd_post h1 out /\
feval h1 out == P.fadd (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize]
val fadd: #s:field_spec -> fadd_t s True
let fsub_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (9, 10, 9, 9, 9)
| M64 -> True
inline_for_extraction
let fsub_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fsub_post h1 out /\
feval h1 out == P.fsub (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fsub: #s:field_spec -> fsub_t s True
let fmul_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (9, 10, 9, 9, 9) /\
f51_felem_fits h f2 (9, 10, 9, 9, 9)
| M64 -> True
let fmul_disjoint (#s:field_spec) (out f1 f2:felem s) (tmp:felem_wide2 s): Type0 =
match s with
| M51 -> True
| M64 ->
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp \/ out == tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp
let state_inv_t (#s:field_spec) (h:mem) (f:felem s): Type0 =
match s with
| M51 -> f51_mul_inv_t h f
| M64 -> True
inline_for_extraction
let fmul_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
fmul_disjoint out f1 f2 tmp /\
fmul_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fmul: #s:field_spec -> fmul_t s True
let fmul2_pre (#s:field_spec) (h:mem) (f1:felem2 s) (f2:felem2 s): Type0 =
match s with
| M51 ->
let f10 = gsub f1 0ul 5ul in
let f11 = gsub f1 5ul 5ul in
let f20 = gsub f2 0ul 5ul in
let f21 = gsub f2 5ul 5ul in
f51_felem_fits h f10 (9, 10, 9, 9, 9) /\
f51_felem_fits h f11 (9, 10, 9, 9, 9) /\
f51_felem_fits h f20 (9, 10, 9, 9, 9) /\
f51_felem_fits h f21 (9, 10, 9, 9, 9)
| M64 -> True
let fmul2_fsqr2_post (#s:field_spec) (h:mem) (out:felem2 s): Type0 =
match s with
| M51 ->
let out0 = gsub out 0ul 5ul in
let out1 = gsub out 5ul 5ul in
f51_mul_inv_t h out0 /\
f51_mul_inv_t h out1
| M64 -> True
inline_for_extraction
let fmul2_t (s:field_spec) (p: Type0) =
out:felem2 s
-> f1:felem2 s
-> f2:felem2 s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp /\
fmul2_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ fmul2_fsqr2_post h1 out /\
(let out0 = gsub out 0ul (nlimb s) in
let out1 = gsub out (nlimb s) (nlimb s) in
let f10 = gsub f1 0ul (nlimb s) in
let f11 = gsub f1 (nlimb s) (nlimb s) in
let f20 = gsub f2 0ul (nlimb s) in
let f21 = gsub f2 (nlimb s) (nlimb s) in
feval h1 out0 == P.fmul (feval h0 f10) (feval h0 f20) /\
feval h1 out1 == P.fmul (feval h0 f11) (feval h0 f21)))
[@ Meta.Attribute.specialize ]
val fmul2: #s:field_spec -> fmul2_t s True
let fmul1_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:uint64): Type0 =
match s with
| M51 -> f51_felem_fits h f1 (9, 10, 9, 9, 9) /\ f51_felem_fits1 f2 1
| M64 -> v f2 < pow2 17
inline_for_extraction | false | true | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fmul1_t : s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> p: Type0 -> Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.fmul1_t | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> p: Type0 -> Type0 | {
"end_col": 50,
"end_line": 290,
"start_col": 4,
"start_line": 279
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fsqr2_t (s:field_spec) (p: Type0) =
out:felem2 s
-> f:felem2 s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f /\ live h tmp /\
(disjoint out f \/ out == f) /\
(disjoint out tmp) /\
disjoint tmp f /\
fsqr2_pre h f)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ fmul2_fsqr2_post h1 out /\
(let out1 = gsub out 0ul (nlimb s) in
let out2 = gsub out (nlimb s) (nlimb s) in
let f1 = gsub f 0ul (nlimb s) in
let f2 = gsub f (nlimb s) (nlimb s) in
feval h1 out1 == P.fmul (feval h0 f1) (feval h0 f1) /\
feval h1 out2 == P.fmul (feval h0 f2) (feval h0 f2))) | let fsqr2_t (s: field_spec) (p: Type0) = | false | null | false | out: felem2 s -> f: felem2 s -> tmp: felem_wide2 s
-> Stack unit
(requires
fun h ->
p /\ live h out /\ live h f /\ live h tmp /\ (disjoint out f \/ out == f) /\
(disjoint out tmp) /\ disjoint tmp f /\ fsqr2_pre h f)
(ensures
fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ fmul2_fsqr2_post h1 out /\
(let out1 = gsub out 0ul (nlimb s) in
let out2 = gsub out (nlimb s) (nlimb s) in
let f1 = gsub f 0ul (nlimb s) in
let f2 = gsub f (nlimb s) (nlimb s) in
feval h1 out1 == P.fmul (feval h0 f1) (feval h0 f1) /\
feval h1 out2 == P.fmul (feval h0 f2) (feval h0 f2))) | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"Hacl.Impl.Curve25519.Fields.Core.felem2",
"Hacl.Impl.Curve25519.Fields.Core.felem_wide2",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Hacl.Impl.Curve25519.Fields.Core.limb",
"Hacl.Impl.Curve25519.Fields.Core.wide",
"Prims.l_or",
"Lib.Buffer.disjoint",
"Prims.eq2",
"Hacl.Impl.Curve25519.Fields.Core.fsqr2_pre",
"Lib.Buffer.modifies",
"Lib.Buffer.op_Bar_Plus_Bar",
"Lib.Buffer.loc",
"Hacl.Impl.Curve25519.Fields.Core.fmul2_fsqr2_post",
"Spec.Curve25519.elem",
"Hacl.Impl.Curve25519.Fields.Core.feval",
"Spec.Curve25519.fmul",
"Lib.Buffer.lbuffer_t",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.gsub",
"Lib.IntTypes.op_Plus_Dot",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Impl.Curve25519.Fields.Core.nlimb",
"FStar.UInt32.__uint_to_t"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1
noextract
let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f
noextract
let f64_as_nat (h:mem) (e: felem M64) : GTot nat =
let s = as_seq h e in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3)
noextract
let as_nat (#s:field_spec) (h:mem) (e:felem s): GTot nat =
match s with
| M51 -> f51_as_nat h e
| M64 -> f64_as_nat h e
noextract
let feval (#s:field_spec) (h:mem) (e:felem s): GTot P.elem =
(as_nat h e) % P.prime
/// Start of core combinators
/// -------------------------
let fadd_fsub_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (1, 2, 1, 1, 1) /\
f51_felem_fits h f2 (1, 2, 1, 1, 1)
| M64 -> True
let fadd_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (2, 4, 2, 2, 2)
| M64 -> True
inline_for_extraction
let fadd_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fadd_post h1 out /\
feval h1 out == P.fadd (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize]
val fadd: #s:field_spec -> fadd_t s True
let fsub_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (9, 10, 9, 9, 9)
| M64 -> True
inline_for_extraction
let fsub_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fsub_post h1 out /\
feval h1 out == P.fsub (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fsub: #s:field_spec -> fsub_t s True
let fmul_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (9, 10, 9, 9, 9) /\
f51_felem_fits h f2 (9, 10, 9, 9, 9)
| M64 -> True
let fmul_disjoint (#s:field_spec) (out f1 f2:felem s) (tmp:felem_wide2 s): Type0 =
match s with
| M51 -> True
| M64 ->
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp \/ out == tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp
let state_inv_t (#s:field_spec) (h:mem) (f:felem s): Type0 =
match s with
| M51 -> f51_mul_inv_t h f
| M64 -> True
inline_for_extraction
let fmul_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
fmul_disjoint out f1 f2 tmp /\
fmul_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fmul: #s:field_spec -> fmul_t s True
let fmul2_pre (#s:field_spec) (h:mem) (f1:felem2 s) (f2:felem2 s): Type0 =
match s with
| M51 ->
let f10 = gsub f1 0ul 5ul in
let f11 = gsub f1 5ul 5ul in
let f20 = gsub f2 0ul 5ul in
let f21 = gsub f2 5ul 5ul in
f51_felem_fits h f10 (9, 10, 9, 9, 9) /\
f51_felem_fits h f11 (9, 10, 9, 9, 9) /\
f51_felem_fits h f20 (9, 10, 9, 9, 9) /\
f51_felem_fits h f21 (9, 10, 9, 9, 9)
| M64 -> True
let fmul2_fsqr2_post (#s:field_spec) (h:mem) (out:felem2 s): Type0 =
match s with
| M51 ->
let out0 = gsub out 0ul 5ul in
let out1 = gsub out 5ul 5ul in
f51_mul_inv_t h out0 /\
f51_mul_inv_t h out1
| M64 -> True
inline_for_extraction
let fmul2_t (s:field_spec) (p: Type0) =
out:felem2 s
-> f1:felem2 s
-> f2:felem2 s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp /\
fmul2_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ fmul2_fsqr2_post h1 out /\
(let out0 = gsub out 0ul (nlimb s) in
let out1 = gsub out (nlimb s) (nlimb s) in
let f10 = gsub f1 0ul (nlimb s) in
let f11 = gsub f1 (nlimb s) (nlimb s) in
let f20 = gsub f2 0ul (nlimb s) in
let f21 = gsub f2 (nlimb s) (nlimb s) in
feval h1 out0 == P.fmul (feval h0 f10) (feval h0 f20) /\
feval h1 out1 == P.fmul (feval h0 f11) (feval h0 f21)))
[@ Meta.Attribute.specialize ]
val fmul2: #s:field_spec -> fmul2_t s True
let fmul1_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:uint64): Type0 =
match s with
| M51 -> f51_felem_fits h f1 (9, 10, 9, 9, 9) /\ f51_felem_fits1 f2 1
| M64 -> v f2 < pow2 17
inline_for_extraction
let fmul1_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:uint64
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\
(disjoint out f1 \/ out == f1) /\
fmul1_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (v f2))
// feval h1 out == (feval h0 f1 * v f2) % P.prime)
[@ Meta.Attribute.specialize ]
val fmul1: #s:field_spec -> fmul1_t s True
let fsqr_pre (#s:field_spec) (h:mem) (f:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h f (9, 10, 9, 9, 9)
| M64 -> True
let fsqr_disjoint (#s:field_spec) (out f1:felem s) (tmp:felem_wide s): Type0 =
match s with
| M51 -> True
| M64 ->
(disjoint out f1 \/ out == f1) /\
(disjoint out tmp \/ out == tmp) /\
disjoint tmp f1
inline_for_extraction
let fsqr_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> tmp:felem_wide s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h tmp /\
fsqr_disjoint out f1 tmp /\
fsqr_pre h f1)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\
state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (feval h0 f1))
[@ Meta.Attribute.specialize ]
val fsqr: #s:field_spec -> fsqr_t s True
let fsqr2_pre (#s:field_spec) (h:mem) (f:felem2 s): Type0 =
match s with
| M51 ->
let f1 = gsub f 0ul 5ul in
let f2 = gsub f 5ul 5ul in
f51_felem_fits h f1 (9, 10, 9, 9, 9) /\
f51_felem_fits h f2 (9, 10, 9, 9, 9)
| M64 -> True
inline_for_extraction | false | true | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fsqr2_t : s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> p: Type0 -> Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.fsqr2_t | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> p: Type0 -> Type0 | {
"end_col": 59,
"end_line": 357,
"start_col": 4,
"start_line": 339
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fmul2_t (s:field_spec) (p: Type0) =
out:felem2 s
-> f1:felem2 s
-> f2:felem2 s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp /\
fmul2_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ fmul2_fsqr2_post h1 out /\
(let out0 = gsub out 0ul (nlimb s) in
let out1 = gsub out (nlimb s) (nlimb s) in
let f10 = gsub f1 0ul (nlimb s) in
let f11 = gsub f1 (nlimb s) (nlimb s) in
let f20 = gsub f2 0ul (nlimb s) in
let f21 = gsub f2 (nlimb s) (nlimb s) in
feval h1 out0 == P.fmul (feval h0 f10) (feval h0 f20) /\
feval h1 out1 == P.fmul (feval h0 f11) (feval h0 f21))) | let fmul2_t (s: field_spec) (p: Type0) = | false | null | false | out: felem2 s -> f1: felem2 s -> f2: felem2 s -> tmp: felem_wide2 s
-> Stack unit
(requires
fun h ->
p /\ live h out /\ live h f1 /\ live h f2 /\ live h tmp /\ (disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\ (disjoint out tmp) /\ (disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\ disjoint f2 tmp /\ fmul2_pre h f1 f2)
(ensures
fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ fmul2_fsqr2_post h1 out /\
(let out0 = gsub out 0ul (nlimb s) in
let out1 = gsub out (nlimb s) (nlimb s) in
let f10 = gsub f1 0ul (nlimb s) in
let f11 = gsub f1 (nlimb s) (nlimb s) in
let f20 = gsub f2 0ul (nlimb s) in
let f21 = gsub f2 (nlimb s) (nlimb s) in
feval h1 out0 == P.fmul (feval h0 f10) (feval h0 f20) /\
feval h1 out1 == P.fmul (feval h0 f11) (feval h0 f21))) | {
"checked_file": "Hacl.Impl.Curve25519.Fields.Core.fsti.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
"total"
] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"Hacl.Impl.Curve25519.Fields.Core.felem2",
"Hacl.Impl.Curve25519.Fields.Core.felem_wide2",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Hacl.Impl.Curve25519.Fields.Core.limb",
"Hacl.Impl.Curve25519.Fields.Core.wide",
"Prims.l_or",
"Lib.Buffer.disjoint",
"Prims.eq2",
"Hacl.Impl.Curve25519.Fields.Core.fmul2_pre",
"Lib.Buffer.modifies",
"Lib.Buffer.op_Bar_Plus_Bar",
"Lib.Buffer.loc",
"Hacl.Impl.Curve25519.Fields.Core.fmul2_fsqr2_post",
"Spec.Curve25519.elem",
"Hacl.Impl.Curve25519.Fields.Core.feval",
"Spec.Curve25519.fmul",
"Lib.Buffer.lbuffer_t",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.gsub",
"Lib.IntTypes.op_Plus_Dot",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Impl.Curve25519.Fields.Core.nlimb",
"FStar.UInt32.__uint_to_t"
] | [] | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1
noextract
let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f
noextract
let f64_as_nat (h:mem) (e: felem M64) : GTot nat =
let s = as_seq h e in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3)
noextract
let as_nat (#s:field_spec) (h:mem) (e:felem s): GTot nat =
match s with
| M51 -> f51_as_nat h e
| M64 -> f64_as_nat h e
noextract
let feval (#s:field_spec) (h:mem) (e:felem s): GTot P.elem =
(as_nat h e) % P.prime
/// Start of core combinators
/// -------------------------
let fadd_fsub_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (1, 2, 1, 1, 1) /\
f51_felem_fits h f2 (1, 2, 1, 1, 1)
| M64 -> True
let fadd_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (2, 4, 2, 2, 2)
| M64 -> True
inline_for_extraction
let fadd_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fadd_post h1 out /\
feval h1 out == P.fadd (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize]
val fadd: #s:field_spec -> fadd_t s True
let fsub_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (9, 10, 9, 9, 9)
| M64 -> True
inline_for_extraction
let fsub_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fsub_post h1 out /\
feval h1 out == P.fsub (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fsub: #s:field_spec -> fsub_t s True
let fmul_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (9, 10, 9, 9, 9) /\
f51_felem_fits h f2 (9, 10, 9, 9, 9)
| M64 -> True
let fmul_disjoint (#s:field_spec) (out f1 f2:felem s) (tmp:felem_wide2 s): Type0 =
match s with
| M51 -> True
| M64 ->
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp \/ out == tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp
let state_inv_t (#s:field_spec) (h:mem) (f:felem s): Type0 =
match s with
| M51 -> f51_mul_inv_t h f
| M64 -> True
inline_for_extraction
let fmul_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
fmul_disjoint out f1 f2 tmp /\
fmul_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fmul: #s:field_spec -> fmul_t s True
let fmul2_pre (#s:field_spec) (h:mem) (f1:felem2 s) (f2:felem2 s): Type0 =
match s with
| M51 ->
let f10 = gsub f1 0ul 5ul in
let f11 = gsub f1 5ul 5ul in
let f20 = gsub f2 0ul 5ul in
let f21 = gsub f2 5ul 5ul in
f51_felem_fits h f10 (9, 10, 9, 9, 9) /\
f51_felem_fits h f11 (9, 10, 9, 9, 9) /\
f51_felem_fits h f20 (9, 10, 9, 9, 9) /\
f51_felem_fits h f21 (9, 10, 9, 9, 9)
| M64 -> True
let fmul2_fsqr2_post (#s:field_spec) (h:mem) (out:felem2 s): Type0 =
match s with
| M51 ->
let out0 = gsub out 0ul 5ul in
let out1 = gsub out 5ul 5ul in
f51_mul_inv_t h out0 /\
f51_mul_inv_t h out1
| M64 -> True
inline_for_extraction | false | true | Hacl.Impl.Curve25519.Fields.Core.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fmul2_t : s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> p: Type0 -> Type0 | [] | Hacl.Impl.Curve25519.Fields.Core.fmul2_t | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> p: Type0 -> Type0 | {
"end_col": 61,
"end_line": 267,
"start_col": 4,
"start_line": 243
} |
|
Prims.GTot | val as_nat (h: mem) (f: felem) : GTot nat | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field51",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let as_nat (h:mem) (f:felem) : GTot nat = P.as_nat h f | val as_nat (h: mem) (f: felem) : GTot nat
let as_nat (h: mem) (f: felem) : GTot nat = | false | null | false | P.as_nat h f | {
"checked_file": "Hacl.Impl.Ed25519.Field51.fst.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"Hacl.Impl.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.Field51.fst"
} | [
"sometrivial"
] | [
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Ed25519.Field51.felem",
"Hacl.Impl.Curve25519.Field51.as_nat",
"Prims.nat"
] | [] | module Hacl.Impl.Ed25519.Field51
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open FStar.Mul
module LSeq = Lib.Sequence
module P = Hacl.Impl.Curve25519.Field51
module S = Spec.Curve25519
let felem = lbuffer uint64 5ul
let point = lbuffer uint64 20ul | false | false | Hacl.Impl.Ed25519.Field51.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val as_nat (h: mem) (f: felem) : GTot nat | [] | Hacl.Impl.Ed25519.Field51.as_nat | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Field51.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> f: Hacl.Impl.Ed25519.Field51.felem -> Prims.GTot Prims.nat | {
"end_col": 54,
"end_line": 17,
"start_col": 42,
"start_line": 17
} |
Prims.Tot | val felem_fits: h:mem -> f:felem -> m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5 -> Type0 | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field51",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let felem_fits h f m = P.felem_fits h f m | val felem_fits: h:mem -> f:felem -> m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5 -> Type0
let felem_fits h f m = | false | null | false | P.felem_fits h f m | {
"checked_file": "Hacl.Impl.Ed25519.Field51.fst.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"Hacl.Impl.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.Field51.fst"
} | [
"total"
] | [
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Ed25519.Field51.felem",
"Hacl.Spec.Curve25519.Field51.Definition.scale64_5",
"Hacl.Impl.Curve25519.Field51.felem_fits"
] | [] | module Hacl.Impl.Ed25519.Field51
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open FStar.Mul
module LSeq = Lib.Sequence
module P = Hacl.Impl.Curve25519.Field51
module S = Spec.Curve25519
let felem = lbuffer uint64 5ul
let point = lbuffer uint64 20ul
let as_nat (h:mem) (f:felem) : GTot nat = P.as_nat h f
let fevalh (h:mem) (f:felem) : GTot S.elem = P.fevalh h f
noextract
val point_eval:h:mem -> p:point -> GTot Spec.Ed25519.ext_point
let point_eval h p =
let x = gsub p 0ul 5ul in
let y = gsub p 5ul 5ul in
let z = gsub p 10ul 5ul in
let t = gsub p 15ul 5ul in
(fevalh h x, fevalh h y, fevalh h z, fevalh h t)
noextract | false | true | Hacl.Impl.Ed25519.Field51.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val felem_fits: h:mem -> f:felem -> m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5 -> Type0 | [] | Hacl.Impl.Ed25519.Field51.felem_fits | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Field51.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
h: FStar.Monotonic.HyperStack.mem ->
f: Hacl.Impl.Ed25519.Field51.felem ->
m: Hacl.Spec.Curve25519.Field51.Definition.scale64_5
-> Type0 | {
"end_col": 41,
"end_line": 32,
"start_col": 23,
"start_line": 32
} |
Prims.GTot | val mul_inv_t (h: mem) (f: felem) : GTot Type0 | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field51",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let mul_inv_t (h:mem) (f:felem) : GTot Type0 =
P.mul_inv_t h f | val mul_inv_t (h: mem) (f: felem) : GTot Type0
let mul_inv_t (h: mem) (f: felem) : GTot Type0 = | false | null | false | P.mul_inv_t h f | {
"checked_file": "Hacl.Impl.Ed25519.Field51.fst.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"Hacl.Impl.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.Field51.fst"
} | [
"sometrivial"
] | [
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Ed25519.Field51.felem",
"Hacl.Impl.Curve25519.Field51.mul_inv_t"
] | [] | module Hacl.Impl.Ed25519.Field51
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open FStar.Mul
module LSeq = Lib.Sequence
module P = Hacl.Impl.Curve25519.Field51
module S = Spec.Curve25519
let felem = lbuffer uint64 5ul
let point = lbuffer uint64 20ul
let as_nat (h:mem) (f:felem) : GTot nat = P.as_nat h f
let fevalh (h:mem) (f:felem) : GTot S.elem = P.fevalh h f
noextract
val point_eval:h:mem -> p:point -> GTot Spec.Ed25519.ext_point
let point_eval h p =
let x = gsub p 0ul 5ul in
let y = gsub p 5ul 5ul in
let z = gsub p 10ul 5ul in
let t = gsub p 15ul 5ul in
(fevalh h x, fevalh h y, fevalh h z, fevalh h t)
noextract
val felem_fits: h:mem -> f:felem -> m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5 -> Type0
let felem_fits h f m = P.felem_fits h f m
noextract
let as_felem (h:mem) (f:felem) =
P.as_felem h f
noextract | false | false | Hacl.Impl.Ed25519.Field51.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mul_inv_t (h: mem) (f: felem) : GTot Type0 | [] | Hacl.Impl.Ed25519.Field51.mul_inv_t | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Field51.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> f: Hacl.Impl.Ed25519.Field51.felem -> Prims.GTot Type0 | {
"end_col": 17,
"end_line": 40,
"start_col": 2,
"start_line": 40
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field51",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let felem = lbuffer uint64 5ul | let felem = | false | null | false | lbuffer uint64 5ul | {
"checked_file": "Hacl.Impl.Ed25519.Field51.fst.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"Hacl.Impl.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.Field51.fst"
} | [
"total"
] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t"
] | [] | module Hacl.Impl.Ed25519.Field51
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open FStar.Mul
module LSeq = Lib.Sequence
module P = Hacl.Impl.Curve25519.Field51
module S = Spec.Curve25519 | false | true | Hacl.Impl.Ed25519.Field51.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val felem : Type0 | [] | Hacl.Impl.Ed25519.Field51.felem | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Field51.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 30,
"end_line": 14,
"start_col": 12,
"start_line": 14
} |
|
Prims.GTot | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field51",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let as_felem (h:mem) (f:felem) =
P.as_felem h f | let as_felem (h: mem) (f: felem) = | false | null | false | P.as_felem h f | {
"checked_file": "Hacl.Impl.Ed25519.Field51.fst.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"Hacl.Impl.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.Field51.fst"
} | [
"sometrivial"
] | [
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Ed25519.Field51.felem",
"Hacl.Impl.Curve25519.Field51.as_felem",
"Hacl.Spec.Curve25519.Field51.Definition.felem5"
] | [] | module Hacl.Impl.Ed25519.Field51
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open FStar.Mul
module LSeq = Lib.Sequence
module P = Hacl.Impl.Curve25519.Field51
module S = Spec.Curve25519
let felem = lbuffer uint64 5ul
let point = lbuffer uint64 20ul
let as_nat (h:mem) (f:felem) : GTot nat = P.as_nat h f
let fevalh (h:mem) (f:felem) : GTot S.elem = P.fevalh h f
noextract
val point_eval:h:mem -> p:point -> GTot Spec.Ed25519.ext_point
let point_eval h p =
let x = gsub p 0ul 5ul in
let y = gsub p 5ul 5ul in
let z = gsub p 10ul 5ul in
let t = gsub p 15ul 5ul in
(fevalh h x, fevalh h y, fevalh h z, fevalh h t)
noextract
val felem_fits: h:mem -> f:felem -> m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5 -> Type0
let felem_fits h f m = P.felem_fits h f m
noextract | false | false | Hacl.Impl.Ed25519.Field51.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val as_felem : h: FStar.Monotonic.HyperStack.mem -> f: Hacl.Impl.Ed25519.Field51.felem
-> Prims.GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 | [] | Hacl.Impl.Ed25519.Field51.as_felem | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Field51.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> f: Hacl.Impl.Ed25519.Field51.felem
-> Prims.GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 | {
"end_col": 16,
"end_line": 36,
"start_col": 2,
"start_line": 36
} |
|
Prims.GTot | val fevalh (h: mem) (f: felem) : GTot S.elem | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field51",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fevalh (h:mem) (f:felem) : GTot S.elem = P.fevalh h f | val fevalh (h: mem) (f: felem) : GTot S.elem
let fevalh (h: mem) (f: felem) : GTot S.elem = | false | null | false | P.fevalh h f | {
"checked_file": "Hacl.Impl.Ed25519.Field51.fst.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"Hacl.Impl.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.Field51.fst"
} | [
"sometrivial"
] | [
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Ed25519.Field51.felem",
"Hacl.Impl.Curve25519.Field51.fevalh",
"Spec.Curve25519.elem"
] | [] | module Hacl.Impl.Ed25519.Field51
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open FStar.Mul
module LSeq = Lib.Sequence
module P = Hacl.Impl.Curve25519.Field51
module S = Spec.Curve25519
let felem = lbuffer uint64 5ul
let point = lbuffer uint64 20ul
let as_nat (h:mem) (f:felem) : GTot nat = P.as_nat h f | false | false | Hacl.Impl.Ed25519.Field51.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fevalh (h: mem) (f: felem) : GTot S.elem | [] | Hacl.Impl.Ed25519.Field51.fevalh | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Field51.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> f: Hacl.Impl.Ed25519.Field51.felem
-> Prims.GTot Spec.Curve25519.elem | {
"end_col": 57,
"end_line": 19,
"start_col": 45,
"start_line": 19
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field51",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let point = lbuffer uint64 20ul | let point = | false | null | false | lbuffer uint64 20ul | {
"checked_file": "Hacl.Impl.Ed25519.Field51.fst.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"Hacl.Impl.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.Field51.fst"
} | [
"total"
] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t"
] | [] | module Hacl.Impl.Ed25519.Field51
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open FStar.Mul
module LSeq = Lib.Sequence
module P = Hacl.Impl.Curve25519.Field51
module S = Spec.Curve25519 | false | true | Hacl.Impl.Ed25519.Field51.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val point : Type0 | [] | Hacl.Impl.Ed25519.Field51.point | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Field51.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 31,
"end_line": 15,
"start_col": 12,
"start_line": 15
} |
|
Prims.GTot | val point_eval:h:mem -> p:point -> GTot Spec.Ed25519.ext_point | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field51",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let point_eval h p =
let x = gsub p 0ul 5ul in
let y = gsub p 5ul 5ul in
let z = gsub p 10ul 5ul in
let t = gsub p 15ul 5ul in
(fevalh h x, fevalh h y, fevalh h z, fevalh h t) | val point_eval:h:mem -> p:point -> GTot Spec.Ed25519.ext_point
let point_eval h p = | false | null | false | let x = gsub p 0ul 5ul in
let y = gsub p 5ul 5ul in
let z = gsub p 10ul 5ul in
let t = gsub p 15ul 5ul in
(fevalh h x, fevalh h y, fevalh h z, fevalh h t) | {
"checked_file": "Hacl.Impl.Ed25519.Field51.fst.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"Hacl.Impl.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.Field51.fst"
} | [
"sometrivial"
] | [
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Ed25519.Field51.point",
"FStar.Pervasives.Native.Mktuple4",
"Spec.Curve25519.elem",
"Hacl.Impl.Ed25519.Field51.fevalh",
"Lib.Buffer.lbuffer_t",
"Lib.Buffer.MUT",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.gsub",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Spec.Ed25519.PointOps.ext_point"
] | [] | module Hacl.Impl.Ed25519.Field51
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open FStar.Mul
module LSeq = Lib.Sequence
module P = Hacl.Impl.Curve25519.Field51
module S = Spec.Curve25519
let felem = lbuffer uint64 5ul
let point = lbuffer uint64 20ul
let as_nat (h:mem) (f:felem) : GTot nat = P.as_nat h f
let fevalh (h:mem) (f:felem) : GTot S.elem = P.fevalh h f
noextract | false | false | Hacl.Impl.Ed25519.Field51.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val point_eval:h:mem -> p:point -> GTot Spec.Ed25519.ext_point | [] | Hacl.Impl.Ed25519.Field51.point_eval | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Field51.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> p: Hacl.Impl.Ed25519.Field51.point
-> Prims.GTot Spec.Ed25519.PointOps.ext_point | {
"end_col": 50,
"end_line": 28,
"start_col": 20,
"start_line": 23
} |
Prims.GTot | val point_inv_t (h: mem) (p: point) : GTot Type0 | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field51",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let point_inv_t (h:mem) (p:point) : GTot Type0 =
mul_inv_t h (gsub p 0ul 5ul) /\
mul_inv_t h (gsub p 5ul 5ul) /\
mul_inv_t h (gsub p 10ul 5ul) /\
mul_inv_t h (gsub p 15ul 5ul) | val point_inv_t (h: mem) (p: point) : GTot Type0
let point_inv_t (h: mem) (p: point) : GTot Type0 = | false | null | false | mul_inv_t h (gsub p 0ul 5ul) /\ mul_inv_t h (gsub p 5ul 5ul) /\ mul_inv_t h (gsub p 10ul 5ul) /\
mul_inv_t h (gsub p 15ul 5ul) | {
"checked_file": "Hacl.Impl.Ed25519.Field51.fst.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"Hacl.Impl.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.Field51.fst"
} | [
"sometrivial"
] | [
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Ed25519.Field51.point",
"Prims.l_and",
"Hacl.Impl.Ed25519.Field51.mul_inv_t",
"Lib.Buffer.gsub",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t"
] | [] | module Hacl.Impl.Ed25519.Field51
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open FStar.Mul
module LSeq = Lib.Sequence
module P = Hacl.Impl.Curve25519.Field51
module S = Spec.Curve25519
let felem = lbuffer uint64 5ul
let point = lbuffer uint64 20ul
let as_nat (h:mem) (f:felem) : GTot nat = P.as_nat h f
let fevalh (h:mem) (f:felem) : GTot S.elem = P.fevalh h f
noextract
val point_eval:h:mem -> p:point -> GTot Spec.Ed25519.ext_point
let point_eval h p =
let x = gsub p 0ul 5ul in
let y = gsub p 5ul 5ul in
let z = gsub p 10ul 5ul in
let t = gsub p 15ul 5ul in
(fevalh h x, fevalh h y, fevalh h z, fevalh h t)
noextract
val felem_fits: h:mem -> f:felem -> m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5 -> Type0
let felem_fits h f m = P.felem_fits h f m
noextract
let as_felem (h:mem) (f:felem) =
P.as_felem h f
noextract
let mul_inv_t (h:mem) (f:felem) : GTot Type0 =
P.mul_inv_t h f
noextract | false | false | Hacl.Impl.Ed25519.Field51.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val point_inv_t (h: mem) (p: point) : GTot Type0 | [] | Hacl.Impl.Ed25519.Field51.point_inv_t | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Field51.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> p: Hacl.Impl.Ed25519.Field51.point -> Prims.GTot Type0 | {
"end_col": 31,
"end_line": 47,
"start_col": 2,
"start_line": 44
} |
Prims.Tot | val inv_ext_point (a: LSeq.lseq uint64 20) : Type0 | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field51",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let inv_ext_point (a:LSeq.lseq uint64 20) : Type0 =
Spec.Ed25519.point_inv (refl_ext_point a) | val inv_ext_point (a: LSeq.lseq uint64 20) : Type0
let inv_ext_point (a: LSeq.lseq uint64 20) : Type0 = | false | null | false | Spec.Ed25519.point_inv (refl_ext_point a) | {
"checked_file": "Hacl.Impl.Ed25519.Field51.fst.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"Hacl.Impl.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.Field51.fst"
} | [
"total"
] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Spec.Ed25519.PointOps.point_inv",
"Hacl.Impl.Ed25519.Field51.refl_ext_point"
] | [] | module Hacl.Impl.Ed25519.Field51
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open FStar.Mul
module LSeq = Lib.Sequence
module P = Hacl.Impl.Curve25519.Field51
module S = Spec.Curve25519
let felem = lbuffer uint64 5ul
let point = lbuffer uint64 20ul
let as_nat (h:mem) (f:felem) : GTot nat = P.as_nat h f
let fevalh (h:mem) (f:felem) : GTot S.elem = P.fevalh h f
noextract
val point_eval:h:mem -> p:point -> GTot Spec.Ed25519.ext_point
let point_eval h p =
let x = gsub p 0ul 5ul in
let y = gsub p 5ul 5ul in
let z = gsub p 10ul 5ul in
let t = gsub p 15ul 5ul in
(fevalh h x, fevalh h y, fevalh h z, fevalh h t)
noextract
val felem_fits: h:mem -> f:felem -> m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5 -> Type0
let felem_fits h f m = P.felem_fits h f m
noextract
let as_felem (h:mem) (f:felem) =
P.as_felem h f
noextract
let mul_inv_t (h:mem) (f:felem) : GTot Type0 =
P.mul_inv_t h f
noextract
let point_inv_t (h:mem) (p:point) : GTot Type0 =
mul_inv_t h (gsub p 0ul 5ul) /\
mul_inv_t h (gsub p 5ul 5ul) /\
mul_inv_t h (gsub p 10ul 5ul) /\
mul_inv_t h (gsub p 15ul 5ul)
unfold
let lseq_as_felem (a:LSeq.lseq uint64 5) : Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let open Lib.Sequence in
(a.[0], a.[1], a.[2], a.[3], a.[4])
unfold
let refl_ext_point (a:LSeq.lseq uint64 20) : GTot Spec.Ed25519.ext_point =
let open Hacl.Spec.Curve25519.Field51.Definition in
let x = feval (lseq_as_felem (LSeq.sub a 0 5)) in
let y = feval (lseq_as_felem (LSeq.sub a 5 5)) in
let z = feval (lseq_as_felem (LSeq.sub a 10 5)) in
let t = feval (lseq_as_felem (LSeq.sub a 15 5)) in
(x, y, z, t)
unfold | false | false | Hacl.Impl.Ed25519.Field51.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val inv_ext_point (a: LSeq.lseq uint64 20) : Type0 | [] | Hacl.Impl.Ed25519.Field51.inv_ext_point | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Field51.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Lib.Sequence.lseq Lib.IntTypes.uint64 20 -> Type0 | {
"end_col": 43,
"end_line": 66,
"start_col": 2,
"start_line": 66
} |
Prims.Tot | val lseq_as_felem (a: LSeq.lseq uint64 5) : Hacl.Spec.Curve25519.Field51.Definition.felem5 | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field51",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lseq_as_felem (a:LSeq.lseq uint64 5) : Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let open Lib.Sequence in
(a.[0], a.[1], a.[2], a.[3], a.[4]) | val lseq_as_felem (a: LSeq.lseq uint64 5) : Hacl.Spec.Curve25519.Field51.Definition.felem5
let lseq_as_felem (a: LSeq.lseq uint64 5) : Hacl.Spec.Curve25519.Field51.Definition.felem5 = | false | null | false | let open Lib.Sequence in (a.[ 0 ], a.[ 1 ], a.[ 2 ], a.[ 3 ], a.[ 4 ]) | {
"checked_file": "Hacl.Impl.Ed25519.Field51.fst.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"Hacl.Impl.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.Field51.fst"
} | [
"total"
] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"FStar.Pervasives.Native.Mktuple5",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Curve25519.Field51.Definition.felem5"
] | [] | module Hacl.Impl.Ed25519.Field51
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open FStar.Mul
module LSeq = Lib.Sequence
module P = Hacl.Impl.Curve25519.Field51
module S = Spec.Curve25519
let felem = lbuffer uint64 5ul
let point = lbuffer uint64 20ul
let as_nat (h:mem) (f:felem) : GTot nat = P.as_nat h f
let fevalh (h:mem) (f:felem) : GTot S.elem = P.fevalh h f
noextract
val point_eval:h:mem -> p:point -> GTot Spec.Ed25519.ext_point
let point_eval h p =
let x = gsub p 0ul 5ul in
let y = gsub p 5ul 5ul in
let z = gsub p 10ul 5ul in
let t = gsub p 15ul 5ul in
(fevalh h x, fevalh h y, fevalh h z, fevalh h t)
noextract
val felem_fits: h:mem -> f:felem -> m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5 -> Type0
let felem_fits h f m = P.felem_fits h f m
noextract
let as_felem (h:mem) (f:felem) =
P.as_felem h f
noextract
let mul_inv_t (h:mem) (f:felem) : GTot Type0 =
P.mul_inv_t h f
noextract
let point_inv_t (h:mem) (p:point) : GTot Type0 =
mul_inv_t h (gsub p 0ul 5ul) /\
mul_inv_t h (gsub p 5ul 5ul) /\
mul_inv_t h (gsub p 10ul 5ul) /\
mul_inv_t h (gsub p 15ul 5ul)
unfold | false | false | Hacl.Impl.Ed25519.Field51.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lseq_as_felem (a: LSeq.lseq uint64 5) : Hacl.Spec.Curve25519.Field51.Definition.felem5 | [] | Hacl.Impl.Ed25519.Field51.lseq_as_felem | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Field51.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Lib.Sequence.lseq Lib.IntTypes.uint64 5 -> Hacl.Spec.Curve25519.Field51.Definition.felem5 | {
"end_col": 37,
"end_line": 53,
"start_col": 2,
"start_line": 52
} |
Subsets and Splits